1 /* 2 * util/log.c - implementation of the log code 3 * 4 * Copyright (c) 2007, NLnet Labs. All rights reserved. 5 * 6 * This software is open source. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 12 * Redistributions of source code must retain the above copyright notice, 13 * this list of conditions and the following disclaimer. 14 * 15 * Redistributions in binary form must reproduce the above copyright notice, 16 * this list of conditions and the following disclaimer in the documentation 17 * and/or other materials provided with the distribution. 18 * 19 * Neither the name of the NLNET LABS nor the names of its contributors may 20 * be used to endorse or promote products derived from this software without 21 * specific prior written permission. 22 * 23 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 24 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 25 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 26 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 27 * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 28 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED 29 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 30 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 31 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 32 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 33 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 34 */ 35 /** 36 * \file 37 * Implementation of log.h. 38 */ 39 40 #include "config.h" 41 #include "util/log.h" 42 #include "util/locks.h" 43 #include "sldns/sbuffer.h" 44 #include <stdarg.h> 45 #ifdef HAVE_TIME_H 46 #include <time.h> 47 #endif 48 #ifdef HAVE_SYSLOG_H 49 # include <syslog.h> 50 #else 51 /**define LOG_ constants */ 52 # define LOG_CRIT 2 53 # define LOG_ERR 3 54 # define LOG_WARNING 4 55 # define LOG_NOTICE 5 56 # define LOG_INFO 6 57 # define LOG_DEBUG 7 58 #endif 59 #ifdef UB_ON_WINDOWS 60 # include "winrc/win_svc.h" 61 #endif 62 63 /* default verbosity */ 64 enum verbosity_value verbosity = 0; 65 /** the file logged to. */ 66 static FILE* logfile = 0; 67 /** if key has been created */ 68 static int key_created = 0; 69 /** pthread key for thread ids in logfile */ 70 static ub_thread_key_t logkey; 71 #ifndef THREADS_DISABLED 72 /** pthread mutex to protect FILE* */ 73 static lock_quick_t log_lock; 74 #endif 75 /** the identity of this executable/process */ 76 static const char* ident="unbound"; 77 #if defined(HAVE_SYSLOG_H) || defined(UB_ON_WINDOWS) 78 /** are we using syslog(3) to log to */ 79 static int logging_to_syslog = 0; 80 #endif /* HAVE_SYSLOG_H */ 81 /** time to print in log, if NULL, use time(2) */ 82 static time_t* log_now = NULL; 83 /** print time in UTC or in secondsfrom1970 */ 84 static int log_time_asc = 0; 85 86 void 87 log_init(const char* filename, int use_syslog, const char* chrootdir) 88 { 89 FILE *f; 90 if(!key_created) { 91 key_created = 1; 92 ub_thread_key_create(&logkey, NULL); 93 lock_quick_init(&log_lock); 94 } 95 lock_quick_lock(&log_lock); 96 if(logfile 97 #if defined(HAVE_SYSLOG_H) || defined(UB_ON_WINDOWS) 98 || logging_to_syslog 99 #endif 100 ) { 101 lock_quick_unlock(&log_lock); /* verbose() needs the lock */ 102 verbose(VERB_QUERY, "switching log to %s", 103 use_syslog?"syslog":(filename&&filename[0]?filename:"stderr")); 104 lock_quick_lock(&log_lock); 105 } 106 if(logfile && logfile != stderr) 107 fclose(logfile); 108 #ifdef HAVE_SYSLOG_H 109 if(logging_to_syslog) { 110 closelog(); 111 logging_to_syslog = 0; 112 } 113 if(use_syslog) { 114 /* do not delay opening until first write, because we may 115 * chroot and no longer be able to access dev/log and so on */ 116 openlog(ident, LOG_NDELAY, LOG_DAEMON); 117 logging_to_syslog = 1; 118 lock_quick_unlock(&log_lock); 119 return; 120 } 121 #elif defined(UB_ON_WINDOWS) 122 if(logging_to_syslog) { 123 logging_to_syslog = 0; 124 } 125 if(use_syslog) { 126 logging_to_syslog = 1; 127 lock_quick_unlock(&log_lock); 128 return; 129 } 130 #endif /* HAVE_SYSLOG_H */ 131 if(!filename || !filename[0]) { 132 logfile = stderr; 133 lock_quick_unlock(&log_lock); 134 return; 135 } 136 /* open the file for logging */ 137 if(chrootdir && chrootdir[0] && strncmp(filename, chrootdir, 138 strlen(chrootdir)) == 0) 139 filename += strlen(chrootdir); 140 f = fopen(filename, "a"); 141 if(!f) { 142 lock_quick_unlock(&log_lock); 143 log_err("Could not open logfile %s: %s", filename, 144 strerror(errno)); 145 return; 146 } 147 #ifndef UB_ON_WINDOWS 148 /* line buffering does not work on windows */ 149 setvbuf(f, NULL, (int)_IOLBF, 0); 150 #endif 151 logfile = f; 152 lock_quick_unlock(&log_lock); 153 } 154 155 void log_file(FILE *f) 156 { 157 lock_quick_lock(&log_lock); 158 logfile = f; 159 lock_quick_unlock(&log_lock); 160 } 161 162 void log_thread_set(int* num) 163 { 164 ub_thread_key_set(logkey, num); 165 } 166 167 int log_thread_get(void) 168 { 169 unsigned int* tid; 170 if(!key_created) return 0; 171 tid = (unsigned int*)ub_thread_key_get(logkey); 172 return (int)(tid?*tid:0); 173 } 174 175 void log_ident_set(const char* id) 176 { 177 ident = id; 178 } 179 180 void log_set_time(time_t* t) 181 { 182 log_now = t; 183 } 184 185 void log_set_time_asc(int use_asc) 186 { 187 log_time_asc = use_asc; 188 } 189 190 void 191 log_vmsg(int pri, const char* type, 192 const char *format, va_list args) 193 { 194 char message[MAXSYSLOGMSGLEN]; 195 unsigned int* tid = (unsigned int*)ub_thread_key_get(logkey); 196 time_t now; 197 #if defined(HAVE_STRFTIME) && defined(HAVE_LOCALTIME_R) 198 char tmbuf[32]; 199 struct tm tm; 200 #elif defined(UB_ON_WINDOWS) 201 char tmbuf[128], dtbuf[128]; 202 #endif 203 (void)pri; 204 vsnprintf(message, sizeof(message), format, args); 205 #ifdef HAVE_SYSLOG_H 206 if(logging_to_syslog) { 207 syslog(pri, "[%d:%x] %s: %s", 208 (int)getpid(), tid?*tid:0, type, message); 209 return; 210 } 211 #elif defined(UB_ON_WINDOWS) 212 if(logging_to_syslog) { 213 char m[32768]; 214 HANDLE* s; 215 LPCTSTR str = m; 216 DWORD tp = MSG_GENERIC_ERR; 217 WORD wt = EVENTLOG_ERROR_TYPE; 218 if(strcmp(type, "info") == 0) { 219 tp=MSG_GENERIC_INFO; 220 wt=EVENTLOG_INFORMATION_TYPE; 221 } else if(strcmp(type, "warning") == 0) { 222 tp=MSG_GENERIC_WARN; 223 wt=EVENTLOG_WARNING_TYPE; 224 } else if(strcmp(type, "notice") == 0 225 || strcmp(type, "debug") == 0) { 226 tp=MSG_GENERIC_SUCCESS; 227 wt=EVENTLOG_SUCCESS; 228 } 229 snprintf(m, sizeof(m), "[%s:%x] %s: %s", 230 ident, tid?*tid:0, type, message); 231 s = RegisterEventSource(NULL, SERVICE_NAME); 232 if(!s) return; 233 ReportEvent(s, wt, 0, tp, NULL, 1, 0, &str, NULL); 234 DeregisterEventSource(s); 235 return; 236 } 237 #endif /* HAVE_SYSLOG_H */ 238 lock_quick_lock(&log_lock); 239 if(!logfile) { 240 lock_quick_unlock(&log_lock); 241 return; 242 } 243 if(log_now) 244 now = (time_t)*log_now; 245 else now = (time_t)time(NULL); 246 #if defined(HAVE_STRFTIME) && defined(HAVE_LOCALTIME_R) 247 if(log_time_asc && strftime(tmbuf, sizeof(tmbuf), "%b %d %H:%M:%S", 248 localtime_r(&now, &tm))%(sizeof(tmbuf)) != 0) { 249 /* %sizeof buf!=0 because old strftime returned max on error */ 250 fprintf(logfile, "%s %s[%d:%x] %s: %s\n", tmbuf, 251 ident, (int)getpid(), tid?*tid:0, type, message); 252 } else 253 #elif defined(UB_ON_WINDOWS) 254 if(log_time_asc && GetTimeFormat(LOCALE_USER_DEFAULT, 0, NULL, NULL, 255 tmbuf, sizeof(tmbuf)) && GetDateFormat(LOCALE_USER_DEFAULT, 0, 256 NULL, NULL, dtbuf, sizeof(dtbuf))) { 257 fprintf(logfile, "%s %s %s[%d:%x] %s: %s\n", dtbuf, tmbuf, 258 ident, (int)getpid(), tid?*tid:0, type, message); 259 } else 260 #endif 261 fprintf(logfile, "[" ARG_LL "d] %s[%d:%x] %s: %s\n", (long long)now, 262 ident, (int)getpid(), tid?*tid:0, type, message); 263 #ifdef UB_ON_WINDOWS 264 /* line buffering does not work on windows */ 265 fflush(logfile); 266 #endif 267 lock_quick_unlock(&log_lock); 268 } 269 270 /** 271 * implementation of log_info 272 * @param format: format string printf-style. 273 */ 274 void 275 log_info(const char *format, ...) 276 { 277 va_list args; 278 va_start(args, format); 279 log_vmsg(LOG_INFO, "info", format, args); 280 va_end(args); 281 } 282 283 /** 284 * implementation of log_err 285 * @param format: format string printf-style. 286 */ 287 void 288 log_err(const char *format, ...) 289 { 290 va_list args; 291 va_start(args, format); 292 log_vmsg(LOG_ERR, "error", format, args); 293 va_end(args); 294 } 295 296 /** 297 * implementation of log_warn 298 * @param format: format string printf-style. 299 */ 300 void 301 log_warn(const char *format, ...) 302 { 303 va_list args; 304 va_start(args, format); 305 log_vmsg(LOG_WARNING, "warning", format, args); 306 va_end(args); 307 } 308 309 /** 310 * implementation of fatal_exit 311 * @param format: format string printf-style. 312 */ 313 void 314 fatal_exit(const char *format, ...) 315 { 316 va_list args; 317 va_start(args, format); 318 log_vmsg(LOG_CRIT, "fatal error", format, args); 319 va_end(args); 320 exit(1); 321 } 322 323 /** 324 * implementation of verbose 325 * @param level: verbose level for the message. 326 * @param format: format string printf-style. 327 */ 328 void 329 verbose(enum verbosity_value level, const char* format, ...) 330 { 331 va_list args; 332 va_start(args, format); 333 if(verbosity >= level) { 334 if(level == VERB_OPS) 335 log_vmsg(LOG_NOTICE, "notice", format, args); 336 else if(level == VERB_DETAIL) 337 log_vmsg(LOG_INFO, "info", format, args); 338 else log_vmsg(LOG_DEBUG, "debug", format, args); 339 } 340 va_end(args); 341 } 342 343 /** log hex data */ 344 static void 345 log_hex_f(enum verbosity_value v, const char* msg, void* data, size_t length) 346 { 347 size_t i, j; 348 uint8_t* data8 = (uint8_t*)data; 349 const char* hexchar = "0123456789ABCDEF"; 350 char buf[1024+1]; /* alloc blocksize hex chars + \0 */ 351 const size_t blocksize = 512; 352 size_t len; 353 354 if(length == 0) { 355 verbose(v, "%s[%u]", msg, (unsigned)length); 356 return; 357 } 358 359 for(i=0; i<length; i+=blocksize/2) { 360 len = blocksize/2; 361 if(length - i < blocksize/2) 362 len = length - i; 363 for(j=0; j<len; j++) { 364 buf[j*2] = hexchar[ data8[i+j] >> 4 ]; 365 buf[j*2 + 1] = hexchar[ data8[i+j] & 0xF ]; 366 } 367 buf[len*2] = 0; 368 verbose(v, "%s[%u:%u] %.*s", msg, (unsigned)length, 369 (unsigned)i, (int)len*2, buf); 370 } 371 } 372 373 void 374 log_hex(const char* msg, void* data, size_t length) 375 { 376 log_hex_f(verbosity, msg, data, length); 377 } 378 379 void log_buf(enum verbosity_value level, const char* msg, sldns_buffer* buf) 380 { 381 if(verbosity < level) 382 return; 383 log_hex_f(level, msg, sldns_buffer_begin(buf), sldns_buffer_limit(buf)); 384 } 385 386 #ifdef USE_WINSOCK 387 char* wsa_strerror(DWORD err) 388 { 389 static char unknown[32]; 390 391 switch(err) { 392 case WSA_INVALID_HANDLE: return "Specified event object handle is invalid."; 393 case WSA_NOT_ENOUGH_MEMORY: return "Insufficient memory available."; 394 case WSA_INVALID_PARAMETER: return "One or more parameters are invalid."; 395 case WSA_OPERATION_ABORTED: return "Overlapped operation aborted."; 396 case WSA_IO_INCOMPLETE: return "Overlapped I/O event object not in signaled state."; 397 case WSA_IO_PENDING: return "Overlapped operations will complete later."; 398 case WSAEINTR: return "Interrupted function call."; 399 case WSAEBADF: return "File handle is not valid."; 400 case WSAEACCES: return "Permission denied."; 401 case WSAEFAULT: return "Bad address."; 402 case WSAEINVAL: return "Invalid argument."; 403 case WSAEMFILE: return "Too many open files."; 404 case WSAEWOULDBLOCK: return "Resource temporarily unavailable."; 405 case WSAEINPROGRESS: return "Operation now in progress."; 406 case WSAEALREADY: return "Operation already in progress."; 407 case WSAENOTSOCK: return "Socket operation on nonsocket."; 408 case WSAEDESTADDRREQ: return "Destination address required."; 409 case WSAEMSGSIZE: return "Message too long."; 410 case WSAEPROTOTYPE: return "Protocol wrong type for socket."; 411 case WSAENOPROTOOPT: return "Bad protocol option."; 412 case WSAEPROTONOSUPPORT: return "Protocol not supported."; 413 case WSAESOCKTNOSUPPORT: return "Socket type not supported."; 414 case WSAEOPNOTSUPP: return "Operation not supported."; 415 case WSAEPFNOSUPPORT: return "Protocol family not supported."; 416 case WSAEAFNOSUPPORT: return "Address family not supported by protocol family."; 417 case WSAEADDRINUSE: return "Address already in use."; 418 case WSAEADDRNOTAVAIL: return "Cannot assign requested address."; 419 case WSAENETDOWN: return "Network is down."; 420 case WSAENETUNREACH: return "Network is unreachable."; 421 case WSAENETRESET: return "Network dropped connection on reset."; 422 case WSAECONNABORTED: return "Software caused connection abort."; 423 case WSAECONNRESET: return "Connection reset by peer."; 424 case WSAENOBUFS: return "No buffer space available."; 425 case WSAEISCONN: return "Socket is already connected."; 426 case WSAENOTCONN: return "Socket is not connected."; 427 case WSAESHUTDOWN: return "Cannot send after socket shutdown."; 428 case WSAETOOMANYREFS: return "Too many references."; 429 case WSAETIMEDOUT: return "Connection timed out."; 430 case WSAECONNREFUSED: return "Connection refused."; 431 case WSAELOOP: return "Cannot translate name."; 432 case WSAENAMETOOLONG: return "Name too long."; 433 case WSAEHOSTDOWN: return "Host is down."; 434 case WSAEHOSTUNREACH: return "No route to host."; 435 case WSAENOTEMPTY: return "Directory not empty."; 436 case WSAEPROCLIM: return "Too many processes."; 437 case WSAEUSERS: return "User quota exceeded."; 438 case WSAEDQUOT: return "Disk quota exceeded."; 439 case WSAESTALE: return "Stale file handle reference."; 440 case WSAEREMOTE: return "Item is remote."; 441 case WSASYSNOTREADY: return "Network subsystem is unavailable."; 442 case WSAVERNOTSUPPORTED: return "Winsock.dll version out of range."; 443 case WSANOTINITIALISED: return "Successful WSAStartup not yet performed."; 444 case WSAEDISCON: return "Graceful shutdown in progress."; 445 case WSAENOMORE: return "No more results."; 446 case WSAECANCELLED: return "Call has been canceled."; 447 case WSAEINVALIDPROCTABLE: return "Procedure call table is invalid."; 448 case WSAEINVALIDPROVIDER: return "Service provider is invalid."; 449 case WSAEPROVIDERFAILEDINIT: return "Service provider failed to initialize."; 450 case WSASYSCALLFAILURE: return "System call failure."; 451 case WSASERVICE_NOT_FOUND: return "Service not found."; 452 case WSATYPE_NOT_FOUND: return "Class type not found."; 453 case WSA_E_NO_MORE: return "No more results."; 454 case WSA_E_CANCELLED: return "Call was canceled."; 455 case WSAEREFUSED: return "Database query was refused."; 456 case WSAHOST_NOT_FOUND: return "Host not found."; 457 case WSATRY_AGAIN: return "Nonauthoritative host not found."; 458 case WSANO_RECOVERY: return "This is a nonrecoverable error."; 459 case WSANO_DATA: return "Valid name, no data record of requested type."; 460 case WSA_QOS_RECEIVERS: return "QOS receivers."; 461 case WSA_QOS_SENDERS: return "QOS senders."; 462 case WSA_QOS_NO_SENDERS: return "No QOS senders."; 463 case WSA_QOS_NO_RECEIVERS: return "QOS no receivers."; 464 case WSA_QOS_REQUEST_CONFIRMED: return "QOS request confirmed."; 465 case WSA_QOS_ADMISSION_FAILURE: return "QOS admission error."; 466 case WSA_QOS_POLICY_FAILURE: return "QOS policy failure."; 467 case WSA_QOS_BAD_STYLE: return "QOS bad style."; 468 case WSA_QOS_BAD_OBJECT: return "QOS bad object."; 469 case WSA_QOS_TRAFFIC_CTRL_ERROR: return "QOS traffic control error."; 470 case WSA_QOS_GENERIC_ERROR: return "QOS generic error."; 471 case WSA_QOS_ESERVICETYPE: return "QOS service type error."; 472 case WSA_QOS_EFLOWSPEC: return "QOS flowspec error."; 473 case WSA_QOS_EPROVSPECBUF: return "Invalid QOS provider buffer."; 474 case WSA_QOS_EFILTERSTYLE: return "Invalid QOS filter style."; 475 case WSA_QOS_EFILTERTYPE: return "Invalid QOS filter type."; 476 case WSA_QOS_EFILTERCOUNT: return "Incorrect QOS filter count."; 477 case WSA_QOS_EOBJLENGTH: return "Invalid QOS object length."; 478 case WSA_QOS_EFLOWCOUNT: return "Incorrect QOS flow count."; 479 /*case WSA_QOS_EUNKOWNPSOBJ: return "Unrecognized QOS object.";*/ 480 case WSA_QOS_EPOLICYOBJ: return "Invalid QOS policy object."; 481 case WSA_QOS_EFLOWDESC: return "Invalid QOS flow descriptor."; 482 case WSA_QOS_EPSFLOWSPEC: return "Invalid QOS provider-specific flowspec."; 483 case WSA_QOS_EPSFILTERSPEC: return "Invalid QOS provider-specific filterspec."; 484 case WSA_QOS_ESDMODEOBJ: return "Invalid QOS shape discard mode object."; 485 case WSA_QOS_ESHAPERATEOBJ: return "Invalid QOS shaping rate object."; 486 case WSA_QOS_RESERVED_PETYPE: return "Reserved policy QOS element type."; 487 default: 488 snprintf(unknown, sizeof(unknown), 489 "unknown WSA error code %d", (int)err); 490 return unknown; 491 } 492 } 493 #endif /* USE_WINSOCK */ 494