From 08827265399f3f69f7f25512e991f67da5bbac63 Mon Sep 17 00:00:00 2001 From: Bent Bisballe Nyeng Date: Fri, 4 Jan 2013 11:30:22 +0100 Subject: Change function prefixes according to projet namechange. --- Makefile | 16 +++--- hugin.c | 166 ++++++++++++++++++++++++++++---------------------------- hugin.h | 88 +++++++++++++++--------------- hugin_filter.c | 8 +-- hugin_filter.h | 4 +- hugin_syslog.c | 42 +++++++------- hugin_syslog.h | 6 +- hugin_util.h | 2 +- main_complete.c | 32 +++++------ main_filter.c | 12 ++-- main_mutex.c | 10 ++-- main_simple.c | 20 +++---- main_simple.cc | 20 +++---- main_syslog.c | 12 ++-- 14 files changed, 219 insertions(+), 219 deletions(-) diff --git a/Makefile b/Makefile index 9e8d4c3..7e35afa 100644 --- a/Makefile +++ b/Makefile @@ -6,8 +6,8 @@ CXXFLAGS=$(CFLAGS) all: complete obj simple syslog filter mutex minimal complete: - gcc ${CFLAGS} ${HUGIN_SOURCES} main_complete.c -o hugin-complete -DWITH_DBG_SYSLOG -DWITH_DBG_FILTER -DWITH_DBG_MUTEX - g++ ${CXXFLAGS} ${HUGIN_SOURCES} main_complete.c -o hugin-complete -DWITH_DBG_SYSLOG -DWITH_DBG_FILTER -DWITH_DBG_MUTEX + gcc ${CFLAGS} ${HUGIN_SOURCES} main_complete.c -o hugin-complete -DWITH_HUG_SYSLOG -DWITH_HUG_FILTER -DWITH_HUG_MUTEX + g++ ${CXXFLAGS} ${HUGIN_SOURCES} main_complete.c -o hugin-complete -DWITH_HUG_SYSLOG -DWITH_HUG_FILTER -DWITH_HUG_MUTEX obj: # Compile hugin as c prog and link with c++ program (use hugin.hpp) @@ -29,16 +29,16 @@ minimal: g++ ${CXXFLAGS} hugin.c main_minimal.c -o hugin-minimal syslog: - gcc ${CFLAGS} hugin.c hugin_syslog.c main_syslog.c -o hugin-syslog -DWITH_DBG_SYSLOG - g++ ${CXXFLAGS} hugin.c hugin_syslog.c main_syslog.c -o hugin-syslog -DWITH_DBG_SYSLOG + gcc ${CFLAGS} hugin.c hugin_syslog.c main_syslog.c -o hugin-syslog -DWITH_HUG_SYSLOG + g++ ${CXXFLAGS} hugin.c hugin_syslog.c main_syslog.c -o hugin-syslog -DWITH_HUG_SYSLOG filter: - gcc ${CFLAGS} hugin.c hugin_filter.c main_filter.c -o hugin-filter -DWITH_DBG_FILTER - g++ ${CXXFLAGS} hugin.c hugin_filter.c main_filter.c -o hugin-filter -DWITH_DBG_FILTER + gcc ${CFLAGS} hugin.c hugin_filter.c main_filter.c -o hugin-filter -DWITH_HUG_FILTER + g++ ${CXXFLAGS} hugin.c hugin_filter.c main_filter.c -o hugin-filter -DWITH_HUG_FILTER mutex: - gcc ${CFLAGS} hugin.c main_mutex.c -o hugin-mutex -DWITH_DBG_MUTEX - g++ ${CXXFLAGS} hugin.c main_mutex.c -o hugin-mutex -DWITH_DBG_MUTEX + gcc ${CFLAGS} hugin.c main_mutex.c -o hugin-mutex -DWITH_HUG_MUTEX + g++ ${CXXFLAGS} hugin.c main_mutex.c -o hugin-mutex -DWITH_HUG_MUTEX clean: rm -f hugin_{complete,complete-cpp,simple,syslog,filter,mutex,minimal} \ No newline at end of file diff --git a/hugin.c b/hugin.c index aebfd08..6aff5b8 100644 --- a/hugin.c +++ b/hugin.c @@ -37,58 +37,58 @@ #include #include -#ifdef WITH_DBG_MUTEX +#ifdef WITH_HUG_MUTEX #include #endif -#ifdef WITH_DBG_FILTER +#ifdef WITH_HUG_FILTER #include "hugin_filter.h" #endif -#ifdef WITH_DBG_SYSLOG +#ifdef WITH_HUG_SYSLOG #include "hugin_syslog.h" #endif -struct dbg_config_t { +struct hug_config_t { unsigned int flags; int fd; int file_fd; int stdout_no_date; -#ifdef WITH_DBG_MUTEX +#ifdef WITH_HUG_MUTEX pthread_mutex_t mutex; #endif -#ifdef WITH_DBG_SYSLOG +#ifdef WITH_HUG_SYSLOG const char* syslog_host; int syslog_port; #endif -} dbg_config = { - DBG_FLAG_DEFAULT, // flags +} hug_config = { + HUG_FLAG_DEFAULT, // flags -1, // fd -1, // file_fd 0, //stdout_no_date -#ifdef WITH_DBG_MUTEX +#ifdef WITH_HUG_MUTEX {}, // mutex; #endif -#ifdef WITH_DBG_SYSLOG +#ifdef WITH_HUG_SYSLOG "", // syslog_host; -1, // syslog_port; #endif /* // This doesn't work in C++ - .flags = DBG_FLAG_DEFAULT, + .flags = HUG_FLAG_DEFAULT, .fd = -1, .file_fd = -1, .stdout_no_date = 0 */ }; -#ifdef WITH_DBG_MUTEX +#ifdef WITH_HUG_MUTEX pthread_mutex_t localtime_mutex; #endif -struct tm *dbg_localtime(const time_t *timep, struct tm *result) +struct tm *hug_localtime(const time_t *timep, struct tm *result) { struct tm *res = NULL; -#ifdef WITH_DBG_MUTEX +#ifdef WITH_HUG_MUTEX pthread_mutex_lock(&localtime_mutex); #endif @@ -97,7 +97,7 @@ struct tm *dbg_localtime(const time_t *timep, struct tm *result) res = result; } -#ifdef WITH_DBG_MUTEX +#ifdef WITH_HUG_MUTEX pthread_mutex_unlock(&localtime_mutex); #endif @@ -105,54 +105,54 @@ struct tm *dbg_localtime(const time_t *timep, struct tm *result) } -static void dbg_mutex_init() +static void hug_mutex_init() { -#ifdef WITH_DBG_MUTEX - if(dbg_config.flags & DBG_FLAG_USE_MUTEX) { - pthread_mutex_init(&dbg_config.mutex, NULL); +#ifdef WITH_HUG_MUTEX + if(hug_config.flags & HUG_FLAG_USE_MUTEX) { + pthread_mutex_init(&hug_config.mutex, NULL); } pthread_mutex_init(&localtime_mutex, NULL); #endif } -static void dbg_mutex_lock() +static void hug_mutex_lock() { -#ifdef WITH_DBG_MUTEX - if(dbg_config.flags & DBG_FLAG_USE_MUTEX) { - pthread_mutex_lock(&dbg_config.mutex); +#ifdef WITH_HUG_MUTEX + if(hug_config.flags & HUG_FLAG_USE_MUTEX) { + pthread_mutex_lock(&hug_config.mutex); } #endif } -static void dbg_mutex_unlock() +static void hug_mutex_unlock() { -#ifdef WITH_DBG_MUTEX - if(dbg_config.flags & DBG_FLAG_USE_MUTEX) { - pthread_mutex_unlock(&dbg_config.mutex); +#ifdef WITH_HUG_MUTEX + if(hug_config.flags & HUG_FLAG_USE_MUTEX) { + pthread_mutex_unlock(&hug_config.mutex); } #endif } -static void dbg_mutex_close() +static void hug_mutex_close() { -#ifdef WITH_DBG_MUTEX - if(dbg_config.flags & DBG_FLAG_USE_MUTEX) { +#ifdef WITH_HUG_MUTEX + if(hug_config.flags & HUG_FLAG_USE_MUTEX) { // Make sure we don't destroy the mutex while another thread is using it. - dbg_mutex_lock(); - dbg_mutex_unlock(); - pthread_mutex_destroy(&dbg_config.mutex); + hug_mutex_lock(); + hug_mutex_unlock(); + pthread_mutex_destroy(&hug_config.mutex); } pthread_mutex_destroy(&localtime_mutex); #endif } -dbg_status_t dbg_init(unsigned int flags, ...) +hug_status_t hug_init(unsigned int flags, ...) { - dbg_status_t status = DBG_STATUS_OK; + hug_status_t status = HUG_STATUS_OK; - dbg_config.flags = flags; + hug_config.flags = flags; int end = 0; @@ -161,46 +161,46 @@ dbg_status_t dbg_init(unsigned int flags, ...) while(!end) { int option = va_arg(vl, int); switch(option) { - case DBG_OPTION_END: + case HUG_OPTION_END: end = 1; break; - case DBG_OPTION_FD: - dbg_config.fd = va_arg(vl, int); + case HUG_OPTION_FD: + hug_config.fd = va_arg(vl, int); break; - case DBG_OPTION_STDOUT_NO_DATE: - dbg_config.stdout_no_date = va_arg(vl, int); + case HUG_OPTION_STDOUT_NO_DATE: + hug_config.stdout_no_date = va_arg(vl, int); break; - case DBG_OPTION_FILENAME: - if(dbg_config.flags & DBG_FLAG_OUTPUT_TO_FILE) { + case HUG_OPTION_FILENAME: + if(hug_config.flags & HUG_FLAG_OUTPUT_TO_FILE) { const char *filename = (const char*)va_arg(vl, char*); - dbg_config.file_fd = open(filename, O_CREAT | O_RDWR, 0777); + hug_config.file_fd = open(filename, O_CREAT | O_RDWR, 0777); } break; -#ifdef WITH_DBG_SYSLOG - case DBG_OPTION_SYSLOG_PORT: - dbg_config.syslog_port = va_arg(vl, int); +#ifdef WITH_HUG_SYSLOG + case HUG_OPTION_SYSLOG_PORT: + hug_config.syslog_port = va_arg(vl, int); break; - case DBG_OPTION_SYSLOG_HOST: - dbg_config.syslog_host = (const char*)va_arg(vl, char*); + case HUG_OPTION_SYSLOG_HOST: + hug_config.syslog_host = (const char*)va_arg(vl, char*); break; #endif -#ifdef WITH_DBG_FILTER - case DBG_OPTION_FILTER: - dbg_filter_parse((const char*)va_arg(vl, char*)); +#ifdef WITH_HUG_FILTER + case HUG_OPTION_FILTER: + hug_filter_parse((const char*)va_arg(vl, char*)); break; #endif default: - status = DBG_STATUS_UNKNOWN_OPTION; + status = HUG_STATUS_UNKNOWN_OPTION; printf("option: %x\n", option); goto err; } } - dbg_mutex_init(); + hug_mutex_init(); -#ifdef WITH_DBG_SYSLOG - if(dbg_config.flags & DBG_FLAG_OUTPUT_TO_SYSLOG) { - dbg_syslog_init(dbg_config.syslog_host, dbg_config.syslog_port); +#ifdef WITH_HUG_SYSLOG + if(hug_config.flags & HUG_FLAG_OUTPUT_TO_SYSLOG) { + hug_syslog_init(hug_config.syslog_host, hug_config.syslog_port); } #endif @@ -210,17 +210,17 @@ dbg_status_t dbg_init(unsigned int flags, ...) return status; } -void dbg_close() +void hug_close() { - if(dbg_config.flags & DBG_FLAG_OUTPUT_TO_FILE) { - if(dbg_config.file_fd != -1) close(dbg_config.file_fd); + if(hug_config.flags & HUG_FLAG_OUTPUT_TO_FILE) { + if(hug_config.file_fd != -1) close(hug_config.file_fd); } -#ifdef WITH_DBG_SYSLOG - dbg_syslog_close(); +#ifdef WITH_HUG_SYSLOG + hug_syslog_close(); #endif - dbg_mutex_close(); + hug_mutex_close(); } /* @@ -230,11 +230,11 @@ static unsigned int gettid() } */ -static int dbg_create_header(char *hdr, size_t size) +static int hug_create_header(char *hdr, size_t size) { time_t rawtime = time(NULL); struct tm t; - dbg_localtime(&rawtime, &t); + hug_localtime(&rawtime, &t); return snprintf(hdr, size, "%d-%02d-%02d %02d:%02d:%02d", @@ -246,7 +246,7 @@ static int dbg_create_header(char *hdr, size_t size) t.tm_sec); } -static int dbg_output_fd(int fd, const char *msg, int withdate) +static int hug_output_fd(int fd, const char *msg, int withdate) { int s; @@ -254,7 +254,7 @@ static int dbg_output_fd(int fd, const char *msg, int withdate) if(withdate) { char hdr[32]; - dbg_create_header(hdr, sizeof(hdr)); + hug_create_header(hdr, sizeof(hdr)); s = write(fd, hdr, strlen(hdr)); s = write(fd, " ", 1); @@ -278,10 +278,10 @@ int __debug(const char *func, const int line, const char * const debug_class_str[] = { "fixme", "err", "warn", "info", "debug" }; - dbg_mutex_lock(); + hug_mutex_lock(); -#ifdef WITH_DBG_FILTER - if(!dbg_filter_enabled(cl, ch)) goto done; +#ifdef WITH_HUG_FILTER + if(!hug_filter_enabled(cl, ch)) goto done; #endif // @@ -301,32 +301,32 @@ int __debug(const char *func, const int line, // Send message to output // - if(dbg_config.flags & DBG_FLAG_OUTPUT_TO_STDOUT) { - dbg_output_fd(STDOUT_FILENO, buf, dbg_config.stdout_no_date == 0); + if(hug_config.flags & HUG_FLAG_OUTPUT_TO_STDOUT) { + hug_output_fd(STDOUT_FILENO, buf, hug_config.stdout_no_date == 0); } - if(dbg_config.flags & DBG_FLAG_OUTPUT_TO_STDERR) { - dbg_output_fd(STDERR_FILENO, buf, 1); + if(hug_config.flags & HUG_FLAG_OUTPUT_TO_STDERR) { + hug_output_fd(STDERR_FILENO, buf, 1); } - if(dbg_config.flags & DBG_FLAG_OUTPUT_TO_FD) { - dbg_output_fd(dbg_config.fd, buf, 1); + if(hug_config.flags & HUG_FLAG_OUTPUT_TO_FD) { + hug_output_fd(hug_config.fd, buf, 1); } - if(dbg_config.flags & DBG_FLAG_OUTPUT_TO_FILE) { - dbg_output_fd(dbg_config.file_fd, buf, 1); + if(hug_config.flags & HUG_FLAG_OUTPUT_TO_FILE) { + hug_output_fd(hug_config.file_fd, buf, 1); } -#ifdef WITH_DBG_SYSLOG - if(dbg_config.flags & DBG_FLAG_OUTPUT_TO_SYSLOG) { - dbg_syslog_output(buf); +#ifdef WITH_HUG_SYSLOG + if(hug_config.flags & HUG_FLAG_OUTPUT_TO_SYSLOG) { + hug_syslog_output(buf); } #endif -#ifdef WITH_DBG_FILTER +#ifdef WITH_HUG_FILTER done: #endif - dbg_mutex_unlock(); + hug_mutex_unlock(); return result; } diff --git a/hugin.h b/hugin.h index 6d46b19..1effcd7 100644 --- a/hugin.h +++ b/hugin.h @@ -28,49 +28,49 @@ #ifndef __HUGIN_HUGIN_H__ #define __HUGIN_HUGIN_H__ -enum DBG_FLAG { +enum HUG_FLAG { // Features -#ifdef WITH_DBG_THREAD - DBG_FLAG_USE_THREAD = 0x00000001, +#ifdef WITH_HUG_THREAD + HUG_FLAG_USE_THREAD = 0x00000001, #endif -#ifdef WITH_DBG_MUTEX - DBG_FLAG_USE_MUTEX = 0x00000002, +#ifdef WITH_HUG_MUTEX + HUG_FLAG_USE_MUTEX = 0x00000002, #endif -#ifdef WITH_DBG_FILTER - DBG_FLAG_USE_FILTER = 0x00000004, +#ifdef WITH_HUG_FILTER + HUG_FLAG_USE_FILTER = 0x00000004, #endif // Outputs - DBG_FLAG_OUTPUT_TO_STDOUT = 0x00010000, - DBG_FLAG_OUTPUT_TO_STDERR = 0x00020000, - DBG_FLAG_OUTPUT_TO_FD = 0x00040000, - DBG_FLAG_OUTPUT_TO_FILE = 0x00080000, -#ifdef WITH_DBG_SYSLOG - DBG_FLAG_OUTPUT_TO_SYSLOG = 0x00100000, + HUG_FLAG_OUTPUT_TO_STDOUT = 0x00010000, + HUG_FLAG_OUTPUT_TO_STDERR = 0x00020000, + HUG_FLAG_OUTPUT_TO_FD = 0x00040000, + HUG_FLAG_OUTPUT_TO_FILE = 0x00080000, +#ifdef WITH_HUG_SYSLOG + HUG_FLAG_OUTPUT_TO_SYSLOG = 0x00100000, #endif // Default value of flags - DBG_FLAG_DEFAULT = DBG_FLAG_OUTPUT_TO_STDOUT, // Output to stdout + HUG_FLAG_DEFAULT = HUG_FLAG_OUTPUT_TO_STDOUT, // Output to stdout }; -enum DBG_OPTION { +enum HUG_OPTION { /** * No more options / last option. This is used * to terminate the VARARGs list. */ - DBG_OPTION_END, + HUG_OPTION_END, /** * const char* argument containing a filename which will be used for log - * output. To be used with the DBG_FLAG_OUTPUT_TO_FILE flag. + * output. To be used with the HUG_FLAG_OUTPUT_TO_FILE flag. */ - DBG_OPTION_FILENAME, + HUG_OPTION_FILENAME, /** * Integer argument describing a file descriptor which will be used for log - * output. To be used with the DBG_FLAG_OUTPUT_TO_FD flag. + * output. To be used with the HUG_FLAG_OUTPUT_TO_FD flag. */ - DBG_OPTION_FD, + HUG_OPTION_FD, /** * Set this option to make the stdout output to be printed without any date @@ -80,22 +80,22 @@ enum DBG_OPTION { * 0 := use date * 1 := do not use date. */ - DBG_OPTION_STDOUT_NO_DATE, + HUG_OPTION_STDOUT_NO_DATE, /** * Host and port to use when logging on an external server. * Host is a const char* argument, port is an integer. - * To be used with the DBG_FLAG_USE_SYSLOG flag. - * Linux: If DBG_OPTION_SYSLOG_HOST is not supplied, the local syslog will be + * To be used with the HUG_FLAG_USE_SYSLOG flag. + * Linux: If HUG_OPTION_SYSLOG_HOST is not supplied, the local syslog will be * used. - * Windows: If DBG_OPTION_SYSLOG_HOST is not supplied an error will be + * Windows: If HUG_OPTION_SYSLOG_HOST is not supplied an error will be * returned by hugin_init. - * If DBG_OPTION_SYSLOG_PORT is not supplied, the default syslogd port will + * If HUG_OPTION_SYSLOG_PORT is not supplied, the default syslogd port will * be used (port 514). */ -#ifdef WITH_DBG_SYSLOG - DBG_OPTION_SYSLOG_HOST, - DBG_OPTION_SYSLOG_PORT, +#ifdef WITH_HUG_SYSLOG + HUG_OPTION_SYSLOG_HOST, + HUG_OPTION_SYSLOG_PORT, #endif /** @@ -105,36 +105,36 @@ enum DBG_OPTION { * | class[+-]channel * | [+-]all */ -#ifdef WITH_DBG_FILTER - DBG_OPTION_FILTER, +#ifdef WITH_HUG_FILTER + HUG_OPTION_FILTER, #endif }; typedef enum { - DBG_STATUS_OK = 0, - DBG_STATUS_UNKNOWN_OPTION, - DBG_STATUS_ERROR, -} dbg_status_t; + HUG_STATUS_OK = 0, + HUG_STATUS_UNKNOWN_OPTION, + HUG_STATUS_ERROR, +} hug_status_t; /** - * @param flags combination of DBG_FLAG values + * @param flags combination of HUG_FLAG values * @param ... list of options (type-value pairs, - * terminated with DBG_OPTION_END). + * terminated with HUG_OPTION_END). * @return 0 on success, 1 on error. */ -dbg_status_t dbg_init(unsigned int flags, ...); -void dbg_close(); +hug_status_t hug_init(unsigned int flags, ...); +void hug_close(); /** * Example of usage (use mutex protected calls, send output to file): * - * dbg_status_t status; - * status = hugin_init(DBG_FLAG_OUTPUT_TO_FILE | DBG_FLAG_USE_MUTEX, - * DBG_OPTION_FILENAME, "/tmp/my.log", - DBG_OPTION_END); - * if(status != DBG_STATUS_OK) exit(1); + * hug_status_t status; + * status = hugin_init(HUG_FLAG_OUTPUT_TO_FILE | HUG_FLAG_USE_MUTEX, + * HUG_OPTION_FILENAME, "/tmp/my.log", + HUG_OPTION_END); + * if(status != HUG_STATUS_OK) exit(1); * INFO(example, "We are up and running\n"); - * dbg_close(); + * hug_close(); */ /** diff --git a/hugin_filter.c b/hugin_filter.c index dfd541f..f817145 100644 --- a/hugin_filter.c +++ b/hugin_filter.c @@ -30,8 +30,8 @@ #include #include -#ifndef WITH_DBG_FILTER -#warning hugin_filter.c compiled but WITH_DBG_FILTER not defined +#ifndef WITH_HUG_FILTER +#warning hugin_filter.c compiled but WITH_HUG_FILTER not defined #endif #define NELEM(x) (sizeof(x)/sizeof((x)[0])) @@ -49,7 +49,7 @@ static unsigned n_debug_channel = 0; // Default is to enable everything... static unsigned debug_flags = 0xffffffff;//(1<<__class_err)|(1<<__class_fixme); -int dbg_filter_enabled(const enum __debug_class cl, const char *ch) +int hug_filter_enabled(const enum __debug_class cl, const char *ch) { unsigned i; for(i = 0; i < n_debug_channel; i++) { @@ -66,7 +66,7 @@ int dbg_filter_enabled(const enum __debug_class cl, const char *ch) * | class[+-]channel * | [+-]all */ -int dbg_filter_parse(const char *filter) +int hug_filter_parse(const char *filter) { char *s; char *next; diff --git a/hugin_filter.h b/hugin_filter.h index 5ddd07b..7d2a09a 100644 --- a/hugin_filter.h +++ b/hugin_filter.h @@ -30,7 +30,7 @@ #include "hugin.h" -int dbg_filter_enabled(const enum __debug_class cl, const char *ch); -int dbg_filter_parse(const char *filter); +int hug_filter_enabled(const enum __debug_class cl, const char *ch); +int hug_filter_parse(const char *filter); #endif/*__HUGIN_HUGIN_FILTER_H__*/ diff --git a/hugin_syslog.c b/hugin_syslog.c index de93edb..75e2559 100644 --- a/hugin_syslog.c +++ b/hugin_syslog.c @@ -48,8 +48,8 @@ typedef int socket_t; #include "hugin_util.h" -#ifndef WITH_DBG_SYSLOG -#warning hugin_syslog.c compiled but WITH_DBG_SYSLOG not defined +#ifndef WITH_HUG_SYSLOG +#warning hugin_syslog.c compiled but WITH_HUG_SYSLOG not defined #endif #define SYSLOG_MSGLEN 1024 @@ -61,8 +61,8 @@ typedef int socket_t; #define SYSLOG_LENOFEXECNAME 256 -static int dbg_syslog_sock; -static struct sockaddr_in dbg_syslog_sockaddr; +static int hug_syslog_sock; +static struct sockaddr_in hug_syslog_sockaddr; static pid_t pid; static char execname[SYSLOG_LENOFEXECNAME]; @@ -79,7 +79,7 @@ static void wsastartup() } #endif -void dbg_syslog_init(const char* host, int port) +void hug_syslog_init(const char* host, int port) { #ifdef WIN32 @@ -87,16 +87,16 @@ void dbg_syslog_init(const char* host, int port) #endif printf("Initializing syslog module remote %s:%d\n", host, port); - if ( (dbg_syslog_sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) { + if ( (hug_syslog_sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) { fprintf(stderr, "Failed to create socket\n"); return; } - memset(&dbg_syslog_sockaddr, 0, sizeof(dbg_syslog_sockaddr)); - dbg_syslog_sockaddr.sin_family = AF_INET; -// dbg_syslog_sockaddr.sin_addr.s_addr = inet_addr(host); + memset(&hug_syslog_sockaddr, 0, sizeof(hug_syslog_sockaddr)); + hug_syslog_sockaddr.sin_family = AF_INET; +// hug_syslog_sockaddr.sin_addr.s_addr = inet_addr(host); struct hostent *hp = gethostbyname(host); - memcpy(&(dbg_syslog_sockaddr.sin_addr),*(hp->h_addr_list),sizeof(struct in_addr)); - dbg_syslog_sockaddr.sin_port = htons(port); + memcpy(&(hug_syslog_sockaddr.sin_addr),*(hp->h_addr_list),sizeof(struct in_addr)); + hug_syslog_sockaddr.sin_port = htons(port); // This implementation has all kind of possible errors: // * It is Linux only @@ -124,7 +124,7 @@ void dbg_syslog_init(const char* host, int port) } /* -void dbg_syslog_createheader() { +void hug_syslog_createheader() { const time_t rawtime = time(NULL); struct tm time; localtime_r(&rawtime, &time); @@ -209,13 +209,13 @@ void dbg_syslog_createheader() { * * */ -void dbg_syslog_output(char* msg) +void hug_syslog_output(char* msg) { - if(dbg_syslog_sock < 0) return; + if(hug_syslog_sock < 0) return; const time_t rawtime = time(NULL); struct tm time; - dbg_localtime(&rawtime, &time); + hug_localtime(&rawtime, &time); char buftime[SYSLOG_TIMELEN]; strftime(buftime, SYSLOG_TIMELEN, "%b %e %H:%M:%S ", &time); @@ -237,21 +237,21 @@ void dbg_syslog_output(char* msg) // printf("Sending to syslog: %s\n", buf); int buf_len = strlen(buf); - if((sendto(dbg_syslog_sock, buf, buf_len, 0, (struct sockaddr *) &dbg_syslog_sockaddr, - sizeof(dbg_syslog_sockaddr))) != buf_len) { + if((sendto(hug_syslog_sock, buf, buf_len, 0, (struct sockaddr *) &hug_syslog_sockaddr, + sizeof(hug_syslog_sockaddr))) != buf_len) { fprintf(stderr, "Failed to send message successfully: %s\n", strerror(errno)); } } -void dbg_syslog_close() { +void hug_syslog_close() { printf("Closing syslog module\n"); - if(dbg_syslog_sock < 0) return; + if(hug_syslog_sock < 0) return; #ifdef WIN32 - closesocket(dbg_syslog_sock); + closesocket(hug_syslog_sock); WSACleanup(); #else - close(dbg_syslog_sock); + close(hug_syslog_sock); #endif } diff --git a/hugin_syslog.h b/hugin_syslog.h index 12d1479..c3c05fd 100644 --- a/hugin_syslog.h +++ b/hugin_syslog.h @@ -28,10 +28,10 @@ #ifndef __HUGIN_HUGIN_SYSLOG_H__ #define __HUGIN_HUGIN_SYSLOG_H__ -void dbg_syslog_init(const char* host, int port); +void hug_syslog_init(const char* host, int port); -void dbg_syslog_output(char* msg); +void hug_syslog_output(char* msg); -void dbg_syslog_close(); +void hug_syslog_close(); #endif/*__HUGIN_HUGIN_SYSLOG_H__*/ diff --git a/hugin_util.h b/hugin_util.h index 5a23e7e..9cf48ba 100644 --- a/hugin_util.h +++ b/hugin_util.h @@ -34,6 +34,6 @@ * Threadsafe version of localtime (if compiled with mutex support). * See man page for the posix localtime_r function. */ -struct tm *dbg_localtime(const time_t *timep, struct tm *result); +struct tm *hug_localtime(const time_t *timep, struct tm *result); #endif/*__HUGIN_HUGIN_UTIL_H__*/ diff --git a/main_complete.c b/main_complete.c index c7796fa..a649078 100644 --- a/main_complete.c +++ b/main_complete.c @@ -39,23 +39,23 @@ int main(int argc, char *argv[]) if(fd == -1) { return 1; } - dbg_status_t status = dbg_init(DBG_FLAG_USE_MUTEX | - DBG_FLAG_OUTPUT_TO_FILE | - DBG_FLAG_OUTPUT_TO_FD | - DBG_FLAG_OUTPUT_TO_STDOUT | - DBG_FLAG_OUTPUT_TO_SYSLOG | - DBG_FLAG_OUTPUT_TO_STDERR | - DBG_FLAG_USE_FILTER | + hug_status_t status = hug_init(HUG_FLAG_USE_MUTEX | + HUG_FLAG_OUTPUT_TO_FILE | + HUG_FLAG_OUTPUT_TO_FD | + HUG_FLAG_OUTPUT_TO_STDOUT | + HUG_FLAG_OUTPUT_TO_SYSLOG | + HUG_FLAG_OUTPUT_TO_STDERR | + HUG_FLAG_USE_FILTER | 0, - DBG_OPTION_FD, fd, - DBG_OPTION_FILENAME, "/tmp/my2.log", - DBG_OPTION_STDOUT_NO_DATE, 1, - DBG_OPTION_SYSLOG_HOST, "127.0.0.1", - DBG_OPTION_SYSLOG_PORT, 514, - DBG_OPTION_FILTER, "+all", - DBG_OPTION_END); + HUG_OPTION_FD, fd, + HUG_OPTION_FILENAME, "/tmp/my2.log", + HUG_OPTION_STDOUT_NO_DATE, 1, + HUG_OPTION_SYSLOG_HOST, "127.0.0.1", + HUG_OPTION_SYSLOG_PORT, 514, + HUG_OPTION_FILTER, "+all", + HUG_OPTION_END); - if(status != DBG_STATUS_OK) { + if(status != HUG_STATUS_OK) { printf("Error: %d\n", status); return 1; } @@ -66,7 +66,7 @@ int main(int argc, char *argv[]) DEBUG(foo, "Or are we %d?", 42); - dbg_close(); + hug_close(); return 0; } diff --git a/main_filter.c b/main_filter.c index b2df29f..211e122 100644 --- a/main_filter.c +++ b/main_filter.c @@ -35,13 +35,13 @@ int main(int argc, char *argv[]) { - dbg_status_t status = dbg_init(DBG_FLAG_OUTPUT_TO_STDOUT | - DBG_FLAG_USE_FILTER | + hug_status_t status = hug_init(HUG_FLAG_OUTPUT_TO_STDOUT | + HUG_FLAG_USE_FILTER | 0, - DBG_OPTION_FILTER, "-all,+example", - DBG_OPTION_END); + HUG_OPTION_FILTER, "-all,+example", + HUG_OPTION_END); - if(status != DBG_STATUS_OK) { + if(status != HUG_STATUS_OK) { printf("Error: %d\n", status); return 1; } @@ -52,7 +52,7 @@ int main(int argc, char *argv[]) DEBUG(foo, "Or are we %d?", 42); - dbg_close(); + hug_close(); return 0; } diff --git a/main_mutex.c b/main_mutex.c index 410e9ca..d3f16fb 100644 --- a/main_mutex.c +++ b/main_mutex.c @@ -35,12 +35,12 @@ int main(int argc, char *argv[]) { - dbg_status_t status = dbg_init(DBG_FLAG_USE_MUTEX | - DBG_FLAG_OUTPUT_TO_STDOUT | + hug_status_t status = hug_init(HUG_FLAG_USE_MUTEX | + HUG_FLAG_OUTPUT_TO_STDOUT | 0, - DBG_OPTION_END); + HUG_OPTION_END); - if(status != DBG_STATUS_OK) { + if(status != HUG_STATUS_OK) { printf("Error: %d\n", status); return 1; } @@ -51,7 +51,7 @@ int main(int argc, char *argv[]) DEBUG(foo, "Or are we %d?", 42); - dbg_close(); + hug_close(); return 0; } diff --git a/main_simple.c b/main_simple.c index caad5f8..07b577d 100644 --- a/main_simple.c +++ b/main_simple.c @@ -40,17 +40,17 @@ int main(int argc, char *argv[]) return 1; } - dbg_status_t status = dbg_init(DBG_FLAG_OUTPUT_TO_FILE | - DBG_FLAG_OUTPUT_TO_FD | - DBG_FLAG_OUTPUT_TO_STDOUT | - DBG_FLAG_OUTPUT_TO_STDERR | + hug_status_t status = hug_init(HUG_FLAG_OUTPUT_TO_FILE | + HUG_FLAG_OUTPUT_TO_FD | + HUG_FLAG_OUTPUT_TO_STDOUT | + HUG_FLAG_OUTPUT_TO_STDERR | 0, - DBG_OPTION_FD, fd, - DBG_OPTION_FILENAME, "/tmp/my2.log", - DBG_OPTION_STDOUT_NO_DATE, 0, - DBG_OPTION_END); + HUG_OPTION_FD, fd, + HUG_OPTION_FILENAME, "/tmp/my2.log", + HUG_OPTION_STDOUT_NO_DATE, 0, + HUG_OPTION_END); - if(status != DBG_STATUS_OK) { + if(status != HUG_STATUS_OK) { printf("Error: %d\n", status); return 1; } @@ -61,7 +61,7 @@ int main(int argc, char *argv[]) DEBUG(foo, "Or are we %d?", 42); - dbg_close(); + hug_close(); return 0; } diff --git a/main_simple.cc b/main_simple.cc index c83cc05..c555fde 100644 --- a/main_simple.cc +++ b/main_simple.cc @@ -40,17 +40,17 @@ int main(int argc, char *argv[]) return 1; } - dbg_status_t status = dbg_init(DBG_FLAG_OUTPUT_TO_FILE | - DBG_FLAG_OUTPUT_TO_FD | - DBG_FLAG_OUTPUT_TO_STDOUT | - DBG_FLAG_OUTPUT_TO_STDERR | + hug_status_t status = hug_init(HUG_FLAG_OUTPUT_TO_FILE | + HUG_FLAG_OUTPUT_TO_FD | + HUG_FLAG_OUTPUT_TO_STDOUT | + HUG_FLAG_OUTPUT_TO_STDERR | 0, - DBG_OPTION_FD, fd, - DBG_OPTION_FILENAME, "/tmp/my2.log", - DBG_OPTION_STDOUT_NO_DATE, 0, - DBG_OPTION_END); + HUG_OPTION_FD, fd, + HUG_OPTION_FILENAME, "/tmp/my2.log", + HUG_OPTION_STDOUT_NO_DATE, 0, + HUG_OPTION_END); - if(status != DBG_STATUS_OK) { + if(status != HUG_STATUS_OK) { printf("Error: %d\n", status); return 1; } @@ -61,7 +61,7 @@ int main(int argc, char *argv[]) DEBUG(foo, "Or are we %d?", 42); - dbg_close(); + hug_close(); return 0; } diff --git a/main_syslog.c b/main_syslog.c index 29df99c..2ac99be 100644 --- a/main_syslog.c +++ b/main_syslog.c @@ -35,12 +35,12 @@ int main(int argc, char *argv[]) { - dbg_status_t status = dbg_init(DBG_FLAG_OUTPUT_TO_SYSLOG, - DBG_OPTION_SYSLOG_HOST, "localhost", - DBG_OPTION_SYSLOG_PORT, 514, - DBG_OPTION_END); + hug_status_t status = hug_init(HUG_FLAG_OUTPUT_TO_SYSLOG, + HUG_OPTION_SYSLOG_HOST, "localhost", + HUG_OPTION_SYSLOG_PORT, 514, + HUG_OPTION_END); - if(status != DBG_STATUS_OK) { + if(status != HUG_STATUS_OK) { printf("Error: %d\n", status); return 1; } @@ -51,7 +51,7 @@ int main(int argc, char *argv[]) DEBUG(foo, "Or are we %d?", 42); - dbg_close(); + hug_close(); return 0; } -- cgit v1.2.3