Browse code
autoformat to fix indentation issues throughout the code. converted to tabs to make the multiline definition for ARGLEN render nicely
Micah Snyder authored on 2018/03/07 05:27:14Showing 1 changed files
| ... | ... |
@@ -71,13 +71,13 @@ pthread_mutex_t mdprintf_mutex = PTHREAD_MUTEX_INITIALIZER; |
| 71 | 71 |
#include <locale.h> |
| 72 | 72 |
|
| 73 | 73 |
#define gettext_noop(s) s |
| 74 |
-#define _(s) gettext(s) |
|
| 75 |
-#define N_(s) gettext_noop(s) |
|
| 74 |
+#define _(s) gettext(s) |
|
| 75 |
+#define N_(s) gettext_noop(s) |
|
| 76 | 76 |
|
| 77 | 77 |
#else |
| 78 | 78 |
|
| 79 |
-#define _(s) s |
|
| 80 |
-#define N_(s) s |
|
| 79 |
+#define _(s) s |
|
| 80 |
+#define N_(s) s |
|
| 81 | 81 |
|
| 82 | 82 |
#endif |
| 83 | 83 |
|
| ... | ... |
@@ -91,73 +91,83 @@ short logg_syslog; |
| 91 | 91 |
#endif |
| 92 | 92 |
|
| 93 | 93 |
short int mprintf_disabled = 0, mprintf_verbose = 0, mprintf_quiet = 0, |
| 94 |
- mprintf_stdout = 0, mprintf_nowarn = 0, mprintf_send_timeout = 100, mprintf_progress = 0; |
|
| 95 |
- |
|
| 96 |
-#define ARGLEN(args, str, len) \ |
|
| 97 |
-{ \
|
|
| 98 |
- size_t arglen = 1, i; \ |
|
| 99 |
- char *pt; \ |
|
| 100 |
- va_start(args, str); \ |
|
| 101 |
- len = strlen(str); \ |
|
| 102 |
- for(i = 0; i < len - 1; i++) { \
|
|
| 103 |
- if(str[i] == '%') { \
|
|
| 104 |
- switch(str[++i]) { \
|
|
| 105 |
- case 's': \ |
|
| 106 |
- pt = va_arg(args, char *); \ |
|
| 107 |
- if(pt) \ |
|
| 108 |
- arglen += strlen(pt); \ |
|
| 109 |
- break; \ |
|
| 110 |
- case 'f': \ |
|
| 111 |
- va_arg(args, double); \ |
|
| 112 |
- arglen += 25; \ |
|
| 113 |
- break; \ |
|
| 114 |
- case 'l': \ |
|
| 115 |
- va_arg(args, long); \ |
|
| 116 |
- arglen += 20; \ |
|
| 117 |
- break; \ |
|
| 118 |
- default: \ |
|
| 119 |
- va_arg(args, int); \ |
|
| 120 |
- arglen += 10; \ |
|
| 121 |
- break; \ |
|
| 122 |
- } \ |
|
| 123 |
- } \ |
|
| 124 |
- } \ |
|
| 125 |
- va_end(args); \ |
|
| 126 |
- len += arglen; \ |
|
| 127 |
-} |
|
| 94 |
+ mprintf_stdout = 0, mprintf_nowarn = 0, mprintf_send_timeout = 100, mprintf_progress = 0; |
|
| 95 |
+ |
|
| 96 |
+#define ARGLEN(args, str, len) \ |
|
| 97 |
+ { \
|
|
| 98 |
+ size_t arglen = 1, i; \ |
|
| 99 |
+ char *pt; \ |
|
| 100 |
+ va_start(args, str); \ |
|
| 101 |
+ len = strlen(str); \ |
|
| 102 |
+ for (i = 0; i < len - 1; i++) \ |
|
| 103 |
+ { \
|
|
| 104 |
+ if (str[i] == '%') \ |
|
| 105 |
+ { \
|
|
| 106 |
+ switch (str[++i]) \ |
|
| 107 |
+ { \
|
|
| 108 |
+ case 's': \ |
|
| 109 |
+ pt = va_arg(args, char *); \ |
|
| 110 |
+ if (pt) \ |
|
| 111 |
+ arglen += strlen(pt); \ |
|
| 112 |
+ break; \ |
|
| 113 |
+ case 'f': \ |
|
| 114 |
+ va_arg(args, double); \ |
|
| 115 |
+ arglen += 25; \ |
|
| 116 |
+ break; \ |
|
| 117 |
+ case 'l': \ |
|
| 118 |
+ va_arg(args, long); \ |
|
| 119 |
+ arglen += 20; \ |
|
| 120 |
+ break; \ |
|
| 121 |
+ default: \ |
|
| 122 |
+ va_arg(args, int); \ |
|
| 123 |
+ arglen += 10; \ |
|
| 124 |
+ break; \ |
|
| 125 |
+ } \ |
|
| 126 |
+ } \ |
|
| 127 |
+ } \ |
|
| 128 |
+ va_end(args); \ |
|
| 129 |
+ len += arglen; \ |
|
| 130 |
+ } |
|
| 128 | 131 |
|
| 129 | 132 |
int mdprintf(int desc, const char *str, ...) |
| 130 | 133 |
{
|
| 131 |
- va_list args; |
|
| 132 |
- char buffer[512], *abuffer = NULL, *buff; |
|
| 133 |
- int bytes, todo, ret=0; |
|
| 134 |
- size_t len; |
|
| 134 |
+ va_list args; |
|
| 135 |
+ char buffer[512], *abuffer = NULL, *buff; |
|
| 136 |
+ int bytes, todo, ret = 0; |
|
| 137 |
+ size_t len; |
|
| 135 | 138 |
|
| 136 | 139 |
ARGLEN(args, str, len); |
| 137 |
- if(len <= sizeof(buffer)) {
|
|
| 138 |
- len = sizeof(buffer); |
|
| 139 |
- buff = buffer; |
|
| 140 |
- } else {
|
|
| 141 |
- abuffer = malloc(len); |
|
| 142 |
- if(!abuffer) {
|
|
| 143 |
- len = sizeof(buffer); |
|
| 144 |
- buff = buffer; |
|
| 145 |
- } else {
|
|
| 146 |
- buff = abuffer; |
|
| 147 |
- } |
|
| 140 |
+ if (len <= sizeof(buffer)) |
|
| 141 |
+ {
|
|
| 142 |
+ len = sizeof(buffer); |
|
| 143 |
+ buff = buffer; |
|
| 144 |
+ } |
|
| 145 |
+ else |
|
| 146 |
+ {
|
|
| 147 |
+ abuffer = malloc(len); |
|
| 148 |
+ if (!abuffer) |
|
| 149 |
+ {
|
|
| 150 |
+ len = sizeof(buffer); |
|
| 151 |
+ buff = buffer; |
|
| 152 |
+ } |
|
| 153 |
+ else |
|
| 154 |
+ {
|
|
| 155 |
+ buff = abuffer; |
|
| 156 |
+ } |
|
| 148 | 157 |
} |
| 149 | 158 |
va_start(args, str); |
| 150 | 159 |
bytes = vsnprintf(buff, len, str, args); |
| 151 | 160 |
va_end(args); |
| 152 | 161 |
buff[len - 1] = 0; |
| 153 | 162 |
|
| 154 |
- if(bytes < 0) {
|
|
| 155 |
- if(len > sizeof(buffer)) |
|
| 156 |
- free(abuffer); |
|
| 157 |
- return bytes; |
|
| 163 |
+ if (bytes < 0) |
|
| 164 |
+ {
|
|
| 165 |
+ if (len > sizeof(buffer)) |
|
| 166 |
+ free(abuffer); |
|
| 167 |
+ return bytes; |
|
| 158 | 168 |
} |
| 159 |
- if((size_t) bytes >= len) |
|
| 160 |
- bytes = len - 1; |
|
| 169 |
+ if ((size_t)bytes >= len) |
|
| 170 |
+ bytes = len - 1; |
|
| 161 | 171 |
|
| 162 | 172 |
todo = bytes; |
| 163 | 173 |
#ifdef CL_THREAD_SAFE |
| ... | ... |
@@ -165,43 +175,49 @@ int mdprintf(int desc, const char *str, ...) |
| 165 | 165 |
* important for IDSESSION */ |
| 166 | 166 |
pthread_mutex_lock(&mdprintf_mutex); |
| 167 | 167 |
#endif |
| 168 |
- while (todo > 0) {
|
|
| 169 |
- ret = send(desc, buff, bytes, 0); |
|
| 170 |
- if (ret < 0) {
|
|
| 171 |
- struct timeval tv; |
|
| 172 |
- if (errno != EWOULDBLOCK) |
|
| 173 |
- break; |
|
| 174 |
- /* didn't send anything yet */ |
|
| 168 |
+ while (todo > 0) |
|
| 169 |
+ {
|
|
| 170 |
+ ret = send(desc, buff, bytes, 0); |
|
| 171 |
+ if (ret < 0) |
|
| 172 |
+ {
|
|
| 173 |
+ struct timeval tv; |
|
| 174 |
+ if (errno != EWOULDBLOCK) |
|
| 175 |
+ break; |
|
| 176 |
+ /* didn't send anything yet */ |
|
| 175 | 177 |
#ifdef CL_THREAD_SAFE |
| 176 |
- pthread_mutex_unlock(&mdprintf_mutex); |
|
| 177 |
-#endif |
|
| 178 |
- tv.tv_sec = 0; |
|
| 179 |
- tv.tv_usec = mprintf_send_timeout*1000; |
|
| 180 |
- do {
|
|
| 181 |
- fd_set wfds; |
|
| 182 |
- FD_ZERO(&wfds); |
|
| 183 |
- FD_SET(desc, &wfds); |
|
| 184 |
- ret = select(desc+1, NULL, &wfds, NULL, &tv); |
|
| 185 |
- } while (ret < 0 && errno == EINTR); |
|
| 178 |
+ pthread_mutex_unlock(&mdprintf_mutex); |
|
| 179 |
+#endif |
|
| 180 |
+ tv.tv_sec = 0; |
|
| 181 |
+ tv.tv_usec = mprintf_send_timeout * 1000; |
|
| 182 |
+ do |
|
| 183 |
+ {
|
|
| 184 |
+ fd_set wfds; |
|
| 185 |
+ FD_ZERO(&wfds); |
|
| 186 |
+ FD_SET(desc, &wfds); |
|
| 187 |
+ ret = select(desc + 1, NULL, &wfds, NULL, &tv); |
|
| 188 |
+ } while (ret < 0 && errno == EINTR); |
|
| 186 | 189 |
#ifdef CL_THREAD_SAFE |
| 187 |
- pthread_mutex_lock(&mdprintf_mutex); |
|
| 188 |
-#endif |
|
| 189 |
- if (!ret) {
|
|
| 190 |
- /* timed out */ |
|
| 191 |
- ret = -1; |
|
| 192 |
- break; |
|
| 193 |
- } |
|
| 194 |
- } else {
|
|
| 195 |
- todo -= ret; |
|
| 196 |
- buff += ret; |
|
| 197 |
- } |
|
| 190 |
+ pthread_mutex_lock(&mdprintf_mutex); |
|
| 191 |
+#endif |
|
| 192 |
+ if (!ret) |
|
| 193 |
+ {
|
|
| 194 |
+ /* timed out */ |
|
| 195 |
+ ret = -1; |
|
| 196 |
+ break; |
|
| 197 |
+ } |
|
| 198 |
+ } |
|
| 199 |
+ else |
|
| 200 |
+ {
|
|
| 201 |
+ todo -= ret; |
|
| 202 |
+ buff += ret; |
|
| 203 |
+ } |
|
| 198 | 204 |
} |
| 199 | 205 |
#ifdef CL_THREAD_SAFE |
| 200 | 206 |
pthread_mutex_unlock(&mdprintf_mutex); |
| 201 | 207 |
#endif |
| 202 | 208 |
|
| 203 |
- if(len > sizeof(buffer)) |
|
| 204 |
- free(abuffer); |
|
| 209 |
+ if (len > sizeof(buffer)) |
|
| 210 |
+ free(abuffer); |
|
| 205 | 211 |
|
| 206 | 212 |
return ret < 0 ? -1 : bytes; |
| 207 | 213 |
} |
| ... | ... |
@@ -213,8 +229,10 @@ static int rename_logg(STATBUF *sb) |
| 213 | 213 |
time_t t; |
| 214 | 214 |
struct tm tmp; |
| 215 | 215 |
|
| 216 |
- if (!logg_rotate) {
|
|
| 217 |
- if (logg_fp) {
|
|
| 216 |
+ if (!logg_rotate) |
|
| 217 |
+ {
|
|
| 218 |
+ if (logg_fp) |
|
| 219 |
+ {
|
|
| 218 | 220 |
fprintf(logg_fp, "Log size = %lld, max = %lld\n", (long long int)sb->st_size, (long long int)logg_size); |
| 219 | 221 |
fprintf(logg_fp, "WARNING: Log size limit met but log file rotation turned off. Forcing log file rotation anyways.\n"); |
| 220 | 222 |
} |
| ... | ... |
@@ -224,7 +242,8 @@ static int rename_logg(STATBUF *sb) |
| 224 | 224 |
|
| 225 | 225 |
rotate_file_len = strlen(logg_file) + sizeof("-YYYY-MM-DD_HH:MM:SS");
|
| 226 | 226 |
rotate_file = calloc(1, rotate_file_len + 1); |
| 227 |
- if (!rotate_file) {
|
|
| 227 |
+ if (!rotate_file) |
|
| 228 |
+ {
|
|
| 228 | 229 |
if (logg_fp) |
| 229 | 230 |
fprintf(logg_fp, "Need to rotate log file due to size but ran out of memory.\n"); |
| 230 | 231 |
|
| ... | ... |
@@ -232,7 +251,8 @@ static int rename_logg(STATBUF *sb) |
| 232 | 232 |
} |
| 233 | 233 |
|
| 234 | 234 |
t = time(NULL); |
| 235 |
- if (!localtime_r(&t, &tmp)) {
|
|
| 235 |
+ if (!localtime_r(&t, &tmp)) |
|
| 236 |
+ {
|
|
| 236 | 237 |
if (logg_fp) |
| 237 | 238 |
fprintf(logg_fp, "Need to rotate log file due to size but could not get local time.\n"); |
| 238 | 239 |
|
| ... | ... |
@@ -241,14 +261,16 @@ static int rename_logg(STATBUF *sb) |
| 241 | 241 |
} |
| 242 | 242 |
|
| 243 | 243 |
strcpy(rotate_file, logg_file); |
| 244 |
- strftime(rotate_file+strlen(rotate_file), rotate_file_len-strlen(rotate_file), "-%Y%m%d_%H%M%S", &tmp); |
|
| 244 |
+ strftime(rotate_file + strlen(rotate_file), rotate_file_len - strlen(rotate_file), "-%Y%m%d_%H%M%S", &tmp); |
|
| 245 | 245 |
|
| 246 |
- if (logg_fp) {
|
|
| 246 |
+ if (logg_fp) |
|
| 247 |
+ {
|
|
| 247 | 248 |
fclose(logg_fp); |
| 248 | 249 |
logg_fp = NULL; |
| 249 | 250 |
} |
| 250 | 251 |
|
| 251 |
- if (rename(logg_file, rotate_file)) {
|
|
| 252 |
+ if (rename(logg_file, rotate_file)) |
|
| 253 |
+ {
|
|
| 252 | 254 |
free(rotate_file); |
| 253 | 255 |
return -1; |
| 254 | 256 |
} |
| ... | ... |
@@ -261,30 +283,30 @@ static int logg_open(void) |
| 261 | 261 |
{
|
| 262 | 262 |
STATBUF sb; |
| 263 | 263 |
|
| 264 |
- if(logg_file) |
|
| 265 |
- if(logg_size > 0) |
|
| 266 |
- if(CLAMSTAT(logg_file, &sb) != -1) |
|
| 267 |
- if(sb.st_size > logg_size) |
|
| 268 |
- if (rename_logg(&sb)) |
|
| 264 |
+ if (logg_file) |
|
| 265 |
+ if (logg_size > 0) |
|
| 266 |
+ if (CLAMSTAT(logg_file, &sb) != -1) |
|
| 267 |
+ if (sb.st_size > logg_size) |
|
| 268 |
+ if (rename_logg(&sb)) |
|
| 269 | 269 |
return -1; |
| 270 | 270 |
|
| 271 |
- |
|
| 272 | 271 |
return 0; |
| 273 | 272 |
} |
| 274 | 273 |
|
| 275 | 274 |
void logg_close(void) |
| 276 | 275 |
{
|
| 277 | 276 |
#if defined(USE_SYSLOG) && !defined(C_AIX) |
| 278 |
- if(logg_syslog) |
|
| 279 |
- closelog(); |
|
| 277 |
+ if (logg_syslog) |
|
| 278 |
+ closelog(); |
|
| 280 | 279 |
#endif |
| 281 | 280 |
|
| 282 | 281 |
#ifdef CL_THREAD_SAFE |
| 283 | 282 |
pthread_mutex_lock(&logg_mutex); |
| 284 | 283 |
#endif |
| 285 |
- if(logg_fp) {
|
|
| 286 |
- fclose(logg_fp); |
|
| 287 |
- logg_fp = NULL; |
|
| 284 |
+ if (logg_fp) |
|
| 285 |
+ {
|
|
| 286 |
+ fclose(logg_fp); |
|
| 287 |
+ logg_fp = NULL; |
|
| 288 | 288 |
} |
| 289 | 289 |
#ifdef CL_THREAD_SAFE |
| 290 | 290 |
pthread_mutex_unlock(&logg_mutex); |
| ... | ... |
@@ -312,31 +334,37 @@ void logg_close(void) |
| 312 | 312 |
*/ |
| 313 | 313 |
int logg(const char *str, ...) |
| 314 | 314 |
{
|
| 315 |
- va_list args; |
|
| 316 |
- char buffer[1025], *abuffer = NULL, *buff; |
|
| 317 |
- time_t currtime; |
|
| 318 |
- size_t len; |
|
| 319 |
- mode_t old_umask; |
|
| 315 |
+ va_list args; |
|
| 316 |
+ char buffer[1025], *abuffer = NULL, *buff; |
|
| 317 |
+ time_t currtime; |
|
| 318 |
+ size_t len; |
|
| 319 |
+ mode_t old_umask; |
|
| 320 | 320 |
#ifdef F_WRLCK |
| 321 |
- struct flock fl; |
|
| 321 |
+ struct flock fl; |
|
| 322 | 322 |
#endif |
| 323 | 323 |
|
| 324 | 324 |
if ((*str == '$' && logg_verbose < 2) || |
| 325 |
- (*str == '*' && !logg_verbose)) |
|
| 326 |
- return 0; |
|
| 325 |
+ (*str == '*' && !logg_verbose)) |
|
| 326 |
+ return 0; |
|
| 327 | 327 |
|
| 328 | 328 |
ARGLEN(args, str, len); |
| 329 |
- if(len <= sizeof(buffer)) {
|
|
| 330 |
- len = sizeof(buffer); |
|
| 331 |
- buff = buffer; |
|
| 332 |
- } else {
|
|
| 333 |
- abuffer = malloc(len); |
|
| 334 |
- if(!abuffer) {
|
|
| 335 |
- len = sizeof(buffer); |
|
| 336 |
- buff = buffer; |
|
| 337 |
- } else {
|
|
| 338 |
- buff = abuffer; |
|
| 339 |
- } |
|
| 329 |
+ if (len <= sizeof(buffer)) |
|
| 330 |
+ {
|
|
| 331 |
+ len = sizeof(buffer); |
|
| 332 |
+ buff = buffer; |
|
| 333 |
+ } |
|
| 334 |
+ else |
|
| 335 |
+ {
|
|
| 336 |
+ abuffer = malloc(len); |
|
| 337 |
+ if (!abuffer) |
|
| 338 |
+ {
|
|
| 339 |
+ len = sizeof(buffer); |
|
| 340 |
+ buff = buffer; |
|
| 341 |
+ } |
|
| 342 |
+ else |
|
| 343 |
+ {
|
|
| 344 |
+ buff = abuffer; |
|
| 345 |
+ } |
|
| 340 | 346 |
} |
| 341 | 347 |
va_start(args, str); |
| 342 | 348 |
vsnprintf(buff, len, str, args); |
| ... | ... |
@@ -349,26 +377,32 @@ int logg(const char *str, ...) |
| 349 | 349 |
|
| 350 | 350 |
logg_open(); |
| 351 | 351 |
|
| 352 |
- if(!logg_fp && logg_file) {
|
|
| 352 |
+ if (!logg_fp && logg_file) |
|
| 353 |
+ {
|
|
| 353 | 354 |
old_umask = umask(0037); |
| 354 |
- if((logg_fp = fopen(logg_file, "at")) == NULL) {
|
|
| 355 |
+ if ((logg_fp = fopen(logg_file, "at")) == NULL) |
|
| 356 |
+ {
|
|
| 355 | 357 |
umask(old_umask); |
| 356 | 358 |
#ifdef CL_THREAD_SAFE |
| 357 | 359 |
pthread_mutex_unlock(&logg_mutex); |
| 358 | 360 |
#endif |
| 359 | 361 |
printf("ERROR: Can't open %s in append mode (check permissions!).\n", logg_file);
|
| 360 |
- if(len > sizeof(buffer)) |
|
| 362 |
+ if (len > sizeof(buffer)) |
|
| 361 | 363 |
free(abuffer); |
| 362 | 364 |
return -1; |
| 363 |
- } else umask(old_umask); |
|
| 365 |
+ } |
|
| 366 |
+ else |
|
| 367 |
+ umask(old_umask); |
|
| 364 | 368 |
|
| 365 | 369 |
#ifdef F_WRLCK |
| 366 |
- if(logg_lock) {
|
|
| 370 |
+ if (logg_lock) |
|
| 371 |
+ {
|
|
| 367 | 372 |
memset(&fl, 0, sizeof(fl)); |
| 368 | 373 |
fl.l_type = F_WRLCK; |
| 369 |
- if(fcntl(fileno(logg_fp), F_SETLK, &fl) == -1) {
|
|
| 374 |
+ if (fcntl(fileno(logg_fp), F_SETLK, &fl) == -1) |
|
| 375 |
+ {
|
|
| 370 | 376 |
#ifdef EOPNOTSUPP |
| 371 |
- if(errno == EOPNOTSUPP) |
|
| 377 |
+ if (errno == EOPNOTSUPP) |
|
| 372 | 378 |
printf("WARNING: File locking not supported (NFS?)\n");
|
| 373 | 379 |
else |
| 374 | 380 |
#endif |
| ... | ... |
@@ -377,8 +411,8 @@ int logg(const char *str, ...) |
| 377 | 377 |
pthread_mutex_unlock(&logg_mutex); |
| 378 | 378 |
#endif |
| 379 | 379 |
printf("ERROR: %s is locked by another process\n", logg_file);
|
| 380 |
- if(len > sizeof(buffer)) |
|
| 381 |
- free(abuffer); |
|
| 380 |
+ if (len > sizeof(buffer)) |
|
| 381 |
+ free(abuffer); |
|
| 382 | 382 |
return -1; |
| 383 | 383 |
} |
| 384 | 384 |
} |
| ... | ... |
@@ -386,73 +420,91 @@ int logg(const char *str, ...) |
| 386 | 386 |
#endif |
| 387 | 387 |
} |
| 388 | 388 |
|
| 389 |
- if(logg_fp) {
|
|
| 390 |
- char flush = !logg_noflush; |
|
| 391 |
- /* Need to avoid logging time for verbose messages when logverbose |
|
| 389 |
+ if (logg_fp) |
|
| 390 |
+ {
|
|
| 391 |
+ char flush = !logg_noflush; |
|
| 392 |
+ /* Need to avoid logging time for verbose messages when logverbose |
|
| 392 | 393 |
is not set or we get a bunch of timestamps in the log without |
| 393 | 394 |
newlines... */ |
| 394 |
- if (logg_time && ((*buff != '*') || logg_verbose)) |
|
| 395 |
- {
|
|
| 396 |
- char timestr[32]; |
|
| 397 |
- time(&currtime); |
|
| 398 |
- cli_ctime(&currtime, timestr, sizeof(timestr)); |
|
| 399 |
- /* cut trailing \n */ |
|
| 400 |
- timestr[strlen(timestr) - 1] = '\0'; |
|
| 401 |
- fprintf(logg_fp, "%s -> ", timestr); |
|
| 402 |
- } |
|
| 403 |
- |
|
| 404 |
- if(*buff == '!') {
|
|
| 405 |
- fprintf(logg_fp, "ERROR: %s", buff + 1); |
|
| 406 |
- flush = 1; |
|
| 407 |
- } else if(*buff == '^') {
|
|
| 408 |
- if(!logg_nowarn) |
|
| 409 |
- fprintf(logg_fp, "WARNING: %s", buff + 1); |
|
| 410 |
- flush = 1; |
|
| 411 |
- } else if(*buff == '*' || *buff == '$') {
|
|
| 412 |
- fprintf(logg_fp, "%s", buff + 1); |
|
| 413 |
- } else if(*buff == '#' || *buff == '~') {
|
|
| 414 |
- fprintf(logg_fp, "%s", buff + 1); |
|
| 415 |
- } else |
|
| 416 |
- fprintf(logg_fp, "%s", buff); |
|
| 417 |
- |
|
| 418 |
- if (flush) |
|
| 419 |
- fflush(logg_fp); |
|
| 420 |
- } |
|
| 421 |
- |
|
| 422 |
- if (logg_foreground) |
|
| 423 |
- {
|
|
| 424 |
- if (buff[0] != '#') |
|
| 425 |
- {
|
|
| 426 |
- if (logg_time) |
|
| 427 |
- {
|
|
| 428 |
- char timestr[32]; |
|
| 429 |
- time(&currtime); |
|
| 430 |
- cli_ctime(&currtime, timestr, sizeof(timestr)); |
|
| 431 |
- /* cut trailing \n */ |
|
| 432 |
- timestr[strlen(timestr) - 1] = '\0'; |
|
| 433 |
- mprintf("%s -> %s", timestr, buff);
|
|
| 434 |
- } |
|
| 435 |
- else |
|
| 436 |
- {
|
|
| 437 |
- mprintf("%s", buff);
|
|
| 438 |
- } |
|
| 439 |
- } |
|
| 440 |
- } |
|
| 395 |
+ if (logg_time && ((*buff != '*') || logg_verbose)) |
|
| 396 |
+ {
|
|
| 397 |
+ char timestr[32]; |
|
| 398 |
+ time(&currtime); |
|
| 399 |
+ cli_ctime(&currtime, timestr, sizeof(timestr)); |
|
| 400 |
+ /* cut trailing \n */ |
|
| 401 |
+ timestr[strlen(timestr) - 1] = '\0'; |
|
| 402 |
+ fprintf(logg_fp, "%s -> ", timestr); |
|
| 403 |
+ } |
|
| 441 | 404 |
|
| 442 |
-#if defined(USE_SYSLOG) && !defined(C_AIX) |
|
| 443 |
- if(logg_syslog) {
|
|
| 444 |
- cli_chomp(buff); |
|
| 445 |
- if(buff[0] == '!') {
|
|
| 446 |
- syslog(LOG_ERR, "%s", buff + 1); |
|
| 447 |
- } else if(buff[0] == '^') {
|
|
| 448 |
- if(!logg_nowarn) |
|
| 449 |
- syslog(LOG_WARNING, "%s", buff + 1); |
|
| 450 |
- } else if(buff[0] == '*' || buff[0] == '$') {
|
|
| 451 |
- syslog(LOG_DEBUG, "%s", buff + 1); |
|
| 452 |
- } else if(buff[0] == '#' || buff[0] == '~') {
|
|
| 453 |
- syslog(LOG_INFO, "%s", buff + 1); |
|
| 454 |
- } else syslog(LOG_INFO, "%s", buff); |
|
| 405 |
+ if (*buff == '!') |
|
| 406 |
+ {
|
|
| 407 |
+ fprintf(logg_fp, "ERROR: %s", buff + 1); |
|
| 408 |
+ flush = 1; |
|
| 409 |
+ } |
|
| 410 |
+ else if (*buff == '^') |
|
| 411 |
+ {
|
|
| 412 |
+ if (!logg_nowarn) |
|
| 413 |
+ fprintf(logg_fp, "WARNING: %s", buff + 1); |
|
| 414 |
+ flush = 1; |
|
| 415 |
+ } |
|
| 416 |
+ else if (*buff == '*' || *buff == '$') |
|
| 417 |
+ {
|
|
| 418 |
+ fprintf(logg_fp, "%s", buff + 1); |
|
| 419 |
+ } |
|
| 420 |
+ else if (*buff == '#' || *buff == '~') |
|
| 421 |
+ {
|
|
| 422 |
+ fprintf(logg_fp, "%s", buff + 1); |
|
| 423 |
+ } |
|
| 424 |
+ else |
|
| 425 |
+ fprintf(logg_fp, "%s", buff); |
|
| 455 | 426 |
|
| 427 |
+ if (flush) |
|
| 428 |
+ fflush(logg_fp); |
|
| 429 |
+ } |
|
| 430 |
+ |
|
| 431 |
+ if (logg_foreground) |
|
| 432 |
+ {
|
|
| 433 |
+ if (buff[0] != '#') |
|
| 434 |
+ {
|
|
| 435 |
+ if (logg_time) |
|
| 436 |
+ {
|
|
| 437 |
+ char timestr[32]; |
|
| 438 |
+ time(&currtime); |
|
| 439 |
+ cli_ctime(&currtime, timestr, sizeof(timestr)); |
|
| 440 |
+ /* cut trailing \n */ |
|
| 441 |
+ timestr[strlen(timestr) - 1] = '\0'; |
|
| 442 |
+ mprintf("%s -> %s", timestr, buff);
|
|
| 443 |
+ } |
|
| 444 |
+ else |
|
| 445 |
+ {
|
|
| 446 |
+ mprintf("%s", buff);
|
|
| 447 |
+ } |
|
| 448 |
+ } |
|
| 449 |
+ } |
|
| 450 |
+ |
|
| 451 |
+#if defined(USE_SYSLOG) && !defined(C_AIX) |
|
| 452 |
+ if (logg_syslog) |
|
| 453 |
+ {
|
|
| 454 |
+ cli_chomp(buff); |
|
| 455 |
+ if (buff[0] == '!') |
|
| 456 |
+ {
|
|
| 457 |
+ syslog(LOG_ERR, "%s", buff + 1); |
|
| 458 |
+ } |
|
| 459 |
+ else if (buff[0] == '^') |
|
| 460 |
+ {
|
|
| 461 |
+ if (!logg_nowarn) |
|
| 462 |
+ syslog(LOG_WARNING, "%s", buff + 1); |
|
| 463 |
+ } |
|
| 464 |
+ else if (buff[0] == '*' || buff[0] == '$') |
|
| 465 |
+ {
|
|
| 466 |
+ syslog(LOG_DEBUG, "%s", buff + 1); |
|
| 467 |
+ } |
|
| 468 |
+ else if (buff[0] == '#' || buff[0] == '~') |
|
| 469 |
+ {
|
|
| 470 |
+ syslog(LOG_INFO, "%s", buff + 1); |
|
| 471 |
+ } |
|
| 472 |
+ else |
|
| 473 |
+ syslog(LOG_INFO, "%s", buff); |
|
| 456 | 474 |
} |
| 457 | 475 |
#endif |
| 458 | 476 |
|
| ... | ... |
@@ -460,31 +512,30 @@ int logg(const char *str, ...) |
| 460 | 460 |
pthread_mutex_unlock(&logg_mutex); |
| 461 | 461 |
#endif |
| 462 | 462 |
|
| 463 |
- if(len > sizeof(buffer)) |
|
| 464 |
- free(abuffer); |
|
| 463 |
+ if (len > sizeof(buffer)) |
|
| 464 |
+ free(abuffer); |
|
| 465 | 465 |
return 0; |
| 466 | 466 |
} |
| 467 | 467 |
|
| 468 | 468 |
void mprintf(const char *str, ...) |
| 469 | 469 |
{
|
| 470 |
- va_list args; |
|
| 471 |
- FILE *fd; |
|
| 472 |
- char buffer[512], *abuffer = NULL, *buff; |
|
| 473 |
- size_t len; |
|
| 474 |
- |
|
| 470 |
+ va_list args; |
|
| 471 |
+ FILE *fd; |
|
| 472 |
+ char buffer[512], *abuffer = NULL, *buff; |
|
| 473 |
+ size_t len; |
|
| 475 | 474 |
|
| 476 |
- if(mprintf_disabled) |
|
| 477 |
- return; |
|
| 475 |
+ if (mprintf_disabled) |
|
| 476 |
+ return; |
|
| 478 | 477 |
|
| 479 | 478 |
fd = stdout; |
| 480 | 479 |
|
| 481 |
-/* legend: |
|
| 480 |
+ /* legend: |
|
| 482 | 481 |
* ! - error |
| 483 | 482 |
* @ - error with logging |
| 484 | 483 |
* ... |
| 485 | 484 |
*/ |
| 486 | 485 |
|
| 487 |
-/* |
|
| 486 |
+ /* |
|
| 488 | 487 |
* ERROR WARNING STANDARD |
| 489 | 488 |
* normal stderr stderr stdout |
| 490 | 489 |
* |
| ... | ... |
@@ -494,17 +545,23 @@ void mprintf(const char *str, ...) |
| 494 | 494 |
*/ |
| 495 | 495 |
|
| 496 | 496 |
ARGLEN(args, str, len); |
| 497 |
- if(len <= sizeof(buffer)) {
|
|
| 498 |
- len = sizeof(buffer); |
|
| 499 |
- buff = buffer; |
|
| 500 |
- } else {
|
|
| 501 |
- abuffer = malloc(len); |
|
| 502 |
- if(!abuffer) {
|
|
| 503 |
- len = sizeof(buffer); |
|
| 504 |
- buff = buffer; |
|
| 505 |
- } else {
|
|
| 506 |
- buff = abuffer; |
|
| 507 |
- } |
|
| 497 |
+ if (len <= sizeof(buffer)) |
|
| 498 |
+ {
|
|
| 499 |
+ len = sizeof(buffer); |
|
| 500 |
+ buff = buffer; |
|
| 501 |
+ } |
|
| 502 |
+ else |
|
| 503 |
+ {
|
|
| 504 |
+ abuffer = malloc(len); |
|
| 505 |
+ if (!abuffer) |
|
| 506 |
+ {
|
|
| 507 |
+ len = sizeof(buffer); |
|
| 508 |
+ buff = buffer; |
|
| 509 |
+ } |
|
| 510 |
+ else |
|
| 511 |
+ {
|
|
| 512 |
+ buff = abuffer; |
|
| 513 |
+ } |
|
| 508 | 514 |
} |
| 509 | 515 |
va_start(args, str); |
| 510 | 516 |
vsnprintf(buff, len, str, args); |
| ... | ... |
@@ -512,64 +569,83 @@ void mprintf(const char *str, ...) |
| 512 | 512 |
buff[len - 1] = 0; |
| 513 | 513 |
|
| 514 | 514 |
#ifdef _WIN32 |
| 515 |
- do {
|
|
| 516 |
- int tmplen = len + 1; |
|
| 517 |
- wchar_t *tmpw = malloc(tmplen*sizeof(wchar_t)); |
|
| 518 |
- char *nubuff; |
|
| 519 |
- if(!tmpw) break; |
|
| 520 |
- if(!MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, buff, -1, tmpw, tmplen)) {
|
|
| 521 |
- free(tmpw); |
|
| 522 |
- break; |
|
| 523 |
- } |
|
| 524 |
- /* FIXME CHECK IT'S REALLY UTF8 */ |
|
| 525 |
- nubuff = (char *)malloc(tmplen); |
|
| 526 |
- if(!nubuff) {
|
|
| 527 |
- free(tmpw); |
|
| 528 |
- break; |
|
| 529 |
- } |
|
| 530 |
- if(!WideCharToMultiByte(CP_OEMCP, 0, tmpw, -1, nubuff, tmplen, NULL, NULL)) {
|
|
| 531 |
- free(nubuff); |
|
| 532 |
- free(tmpw); |
|
| 533 |
- break; |
|
| 534 |
- } |
|
| 535 |
- free(tmpw); |
|
| 536 |
- if(len > sizeof(buffer)) |
|
| 537 |
- free(abuffer); |
|
| 538 |
- abuffer = buff = nubuff; |
|
| 539 |
- len = sizeof(buffer) + 1; |
|
| 540 |
- } while(0); |
|
| 541 |
-#endif |
|
| 542 |
- if(buff[0] == '!') {
|
|
| 543 |
- if(!mprintf_stdout) |
|
| 544 |
- fd = stderr; |
|
| 545 |
- fprintf(fd, "ERROR: %s", &buff[1]); |
|
| 546 |
- } else if(buff[0] == '@') {
|
|
| 547 |
- if(!mprintf_stdout) |
|
| 548 |
- fd = stderr; |
|
| 549 |
- fprintf(fd, "ERROR: %s", &buff[1]); |
|
| 550 |
- } else if(!mprintf_quiet) {
|
|
| 551 |
- if(buff[0] == '^') {
|
|
| 552 |
- if(!mprintf_nowarn) {
|
|
| 553 |
- if(!mprintf_stdout) |
|
| 554 |
- fd = stderr; |
|
| 555 |
- fprintf(fd, "WARNING: %s", &buff[1]); |
|
| 556 |
- } |
|
| 557 |
- } else if(buff[0] == '*') {
|
|
| 558 |
- if(mprintf_verbose) |
|
| 559 |
- fprintf(fd, "%s", &buff[1]); |
|
| 560 |
- } else if(buff[0] == '~') {
|
|
| 561 |
- fprintf(fd, "%s", &buff[1]); |
|
| 562 |
- } else fprintf(fd, "%s", buff); |
|
| 515 |
+ do |
|
| 516 |
+ {
|
|
| 517 |
+ int tmplen = len + 1; |
|
| 518 |
+ wchar_t *tmpw = malloc(tmplen * sizeof(wchar_t)); |
|
| 519 |
+ char *nubuff; |
|
| 520 |
+ if (!tmpw) |
|
| 521 |
+ break; |
|
| 522 |
+ if (!MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, buff, -1, tmpw, tmplen)) |
|
| 523 |
+ {
|
|
| 524 |
+ free(tmpw); |
|
| 525 |
+ break; |
|
| 526 |
+ } |
|
| 527 |
+ /* FIXME CHECK IT'S REALLY UTF8 */ |
|
| 528 |
+ nubuff = (char *)malloc(tmplen); |
|
| 529 |
+ if (!nubuff) |
|
| 530 |
+ {
|
|
| 531 |
+ free(tmpw); |
|
| 532 |
+ break; |
|
| 533 |
+ } |
|
| 534 |
+ if (!WideCharToMultiByte(CP_OEMCP, 0, tmpw, -1, nubuff, tmplen, NULL, NULL)) |
|
| 535 |
+ {
|
|
| 536 |
+ free(nubuff); |
|
| 537 |
+ free(tmpw); |
|
| 538 |
+ break; |
|
| 539 |
+ } |
|
| 540 |
+ free(tmpw); |
|
| 541 |
+ if (len > sizeof(buffer)) |
|
| 542 |
+ free(abuffer); |
|
| 543 |
+ abuffer = buff = nubuff; |
|
| 544 |
+ len = sizeof(buffer) + 1; |
|
| 545 |
+ } while (0); |
|
| 546 |
+#endif |
|
| 547 |
+ if (buff[0] == '!') |
|
| 548 |
+ {
|
|
| 549 |
+ if (!mprintf_stdout) |
|
| 550 |
+ fd = stderr; |
|
| 551 |
+ fprintf(fd, "ERROR: %s", &buff[1]); |
|
| 552 |
+ } |
|
| 553 |
+ else if (buff[0] == '@') |
|
| 554 |
+ {
|
|
| 555 |
+ if (!mprintf_stdout) |
|
| 556 |
+ fd = stderr; |
|
| 557 |
+ fprintf(fd, "ERROR: %s", &buff[1]); |
|
| 558 |
+ } |
|
| 559 |
+ else if (!mprintf_quiet) |
|
| 560 |
+ {
|
|
| 561 |
+ if (buff[0] == '^') |
|
| 562 |
+ {
|
|
| 563 |
+ if (!mprintf_nowarn) |
|
| 564 |
+ {
|
|
| 565 |
+ if (!mprintf_stdout) |
|
| 566 |
+ fd = stderr; |
|
| 567 |
+ fprintf(fd, "WARNING: %s", &buff[1]); |
|
| 568 |
+ } |
|
| 569 |
+ } |
|
| 570 |
+ else if (buff[0] == '*') |
|
| 571 |
+ {
|
|
| 572 |
+ if (mprintf_verbose) |
|
| 573 |
+ fprintf(fd, "%s", &buff[1]); |
|
| 574 |
+ } |
|
| 575 |
+ else if (buff[0] == '~') |
|
| 576 |
+ {
|
|
| 577 |
+ fprintf(fd, "%s", &buff[1]); |
|
| 578 |
+ } |
|
| 579 |
+ else |
|
| 580 |
+ fprintf(fd, "%s", buff); |
|
| 563 | 581 |
} |
| 564 | 582 |
|
| 565 |
- if(fd == stdout) |
|
| 566 |
- fflush(stdout); |
|
| 583 |
+ if (fd == stdout) |
|
| 584 |
+ fflush(stdout); |
|
| 567 | 585 |
|
| 568 |
- if(len > sizeof(buffer)) |
|
| 569 |
- free(abuffer); |
|
| 586 |
+ if (len > sizeof(buffer)) |
|
| 587 |
+ free(abuffer); |
|
| 570 | 588 |
} |
| 571 | 589 |
|
| 572 |
-struct facstruct {
|
|
| 590 |
+struct facstruct |
|
| 591 |
+{
|
|
| 573 | 592 |
const char *name; |
| 574 | 593 |
int code; |
| 575 | 594 |
}; |
| ... | ... |
@@ -577,78 +653,77 @@ struct facstruct {
|
| 577 | 577 |
#if defined(USE_SYSLOG) && !defined(C_AIX) |
| 578 | 578 |
static const struct facstruct facilitymap[] = {
|
| 579 | 579 |
#ifdef LOG_AUTH |
| 580 |
- { "LOG_AUTH", LOG_AUTH },
|
|
| 580 |
+ {"LOG_AUTH", LOG_AUTH},
|
|
| 581 | 581 |
#endif |
| 582 | 582 |
#ifdef LOG_AUTHPRIV |
| 583 |
- { "LOG_AUTHPRIV", LOG_AUTHPRIV },
|
|
| 583 |
+ {"LOG_AUTHPRIV", LOG_AUTHPRIV},
|
|
| 584 | 584 |
#endif |
| 585 | 585 |
#ifdef LOG_CRON |
| 586 |
- { "LOG_CRON", LOG_CRON },
|
|
| 586 |
+ {"LOG_CRON", LOG_CRON},
|
|
| 587 | 587 |
#endif |
| 588 | 588 |
#ifdef LOG_DAEMON |
| 589 |
- { "LOG_DAEMON", LOG_DAEMON },
|
|
| 589 |
+ {"LOG_DAEMON", LOG_DAEMON},
|
|
| 590 | 590 |
#endif |
| 591 | 591 |
#ifdef LOG_FTP |
| 592 |
- { "LOG_FTP", LOG_FTP },
|
|
| 592 |
+ {"LOG_FTP", LOG_FTP},
|
|
| 593 | 593 |
#endif |
| 594 | 594 |
#ifdef LOG_KERN |
| 595 |
- { "LOG_KERN", LOG_KERN },
|
|
| 595 |
+ {"LOG_KERN", LOG_KERN},
|
|
| 596 | 596 |
#endif |
| 597 | 597 |
#ifdef LOG_LPR |
| 598 |
- { "LOG_LPR", LOG_LPR },
|
|
| 598 |
+ {"LOG_LPR", LOG_LPR},
|
|
| 599 | 599 |
#endif |
| 600 | 600 |
#ifdef LOG_MAIL |
| 601 |
- { "LOG_MAIL", LOG_MAIL },
|
|
| 601 |
+ {"LOG_MAIL", LOG_MAIL},
|
|
| 602 | 602 |
#endif |
| 603 | 603 |
#ifdef LOG_NEWS |
| 604 |
- { "LOG_NEWS", LOG_NEWS },
|
|
| 604 |
+ {"LOG_NEWS", LOG_NEWS},
|
|
| 605 | 605 |
#endif |
| 606 | 606 |
#ifdef LOG_AUTH |
| 607 |
- { "LOG_AUTH", LOG_AUTH },
|
|
| 607 |
+ {"LOG_AUTH", LOG_AUTH},
|
|
| 608 | 608 |
#endif |
| 609 | 609 |
#ifdef LOG_SYSLOG |
| 610 |
- { "LOG_SYSLOG", LOG_SYSLOG },
|
|
| 610 |
+ {"LOG_SYSLOG", LOG_SYSLOG},
|
|
| 611 | 611 |
#endif |
| 612 | 612 |
#ifdef LOG_USER |
| 613 |
- { "LOG_USER", LOG_USER },
|
|
| 613 |
+ {"LOG_USER", LOG_USER},
|
|
| 614 | 614 |
#endif |
| 615 | 615 |
#ifdef LOG_UUCP |
| 616 |
- { "LOG_UUCP", LOG_UUCP },
|
|
| 616 |
+ {"LOG_UUCP", LOG_UUCP},
|
|
| 617 | 617 |
#endif |
| 618 | 618 |
#ifdef LOG_LOCAL0 |
| 619 |
- { "LOG_LOCAL0", LOG_LOCAL0 },
|
|
| 619 |
+ {"LOG_LOCAL0", LOG_LOCAL0},
|
|
| 620 | 620 |
#endif |
| 621 | 621 |
#ifdef LOG_LOCAL1 |
| 622 |
- { "LOG_LOCAL1", LOG_LOCAL1 },
|
|
| 622 |
+ {"LOG_LOCAL1", LOG_LOCAL1},
|
|
| 623 | 623 |
#endif |
| 624 | 624 |
#ifdef LOG_LOCAL2 |
| 625 |
- { "LOG_LOCAL2", LOG_LOCAL2 },
|
|
| 625 |
+ {"LOG_LOCAL2", LOG_LOCAL2},
|
|
| 626 | 626 |
#endif |
| 627 | 627 |
#ifdef LOG_LOCAL3 |
| 628 |
- { "LOG_LOCAL3", LOG_LOCAL3 },
|
|
| 628 |
+ {"LOG_LOCAL3", LOG_LOCAL3},
|
|
| 629 | 629 |
#endif |
| 630 | 630 |
#ifdef LOG_LOCAL4 |
| 631 |
- { "LOG_LOCAL4", LOG_LOCAL4 },
|
|
| 631 |
+ {"LOG_LOCAL4", LOG_LOCAL4},
|
|
| 632 | 632 |
#endif |
| 633 | 633 |
#ifdef LOG_LOCAL5 |
| 634 |
- { "LOG_LOCAL5", LOG_LOCAL5 },
|
|
| 634 |
+ {"LOG_LOCAL5", LOG_LOCAL5},
|
|
| 635 | 635 |
#endif |
| 636 | 636 |
#ifdef LOG_LOCAL6 |
| 637 |
- { "LOG_LOCAL6", LOG_LOCAL6 },
|
|
| 637 |
+ {"LOG_LOCAL6", LOG_LOCAL6},
|
|
| 638 | 638 |
#endif |
| 639 | 639 |
#ifdef LOG_LOCAL7 |
| 640 |
- { "LOG_LOCAL7", LOG_LOCAL7 },
|
|
| 640 |
+ {"LOG_LOCAL7", LOG_LOCAL7},
|
|
| 641 | 641 |
#endif |
| 642 |
- { NULL, -1 }
|
|
| 643 |
-}; |
|
| 642 |
+ {NULL, -1}};
|
|
| 644 | 643 |
|
| 645 | 644 |
int logg_facility(const char *name) |
| 646 | 645 |
{
|
| 647 |
- int i; |
|
| 646 |
+ int i; |
|
| 648 | 647 |
|
| 649 |
- for(i = 0; facilitymap[i].name; i++) |
|
| 650 |
- if(!strcmp(facilitymap[i].name, name)) |
|
| 651 |
- return facilitymap[i].code; |
|
| 648 |
+ for (i = 0; facilitymap[i].name; i++) |
|
| 649 |
+ if (!strcmp(facilitymap[i].name, name)) |
|
| 650 |
+ return facilitymap[i].code; |
|
| 652 | 651 |
|
| 653 | 652 |
return -1; |
| 654 | 653 |
} |