41a07f5de85c7b565ae8c267374d53ecda707d9c
[openafs.git] / src / util / serverLog.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  *
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 /*  serverLog.c     - Server logging                                      */
11 /*                                                                        */
12 /*  Information Technology Center                                         */
13 /*  Date: 05/21/97                                                        */
14 /*                                                                        */
15 /*  Function    - These routines implement logging from the servers.      */
16 /*                                                                        */
17 /* ********************************************************************** */
18
19 #include <afsconfig.h>
20 #include <afs/param.h>
21 #include <afs/stds.h>
22
23 #include <afs/procmgmt.h>       /* signal(), kill(), wait(), etc. */
24
25 #include <roken.h>              /* Must come after procmgmt.h */
26 #ifdef AFS_PTHREAD_ENV
27  #include <opr/softsig.h>
28  #include <afs/procmgmt_softsig.h>      /* Must come after softsig.h */
29 #endif
30 #include <afs/opr.h>
31 #include "afsutil.h"
32 #include "fileutil.h"
33 #include <lwp.h>
34
35 #if defined(AFS_PTHREAD_ENV)
36 #include <pthread.h>
37 static pthread_once_t serverLogOnce = PTHREAD_ONCE_INIT;
38 static pthread_mutex_t serverLogMutex;
39 #define LOCK_SERVERLOG() opr_Verify(pthread_mutex_lock(&serverLogMutex) == 0)
40 #define UNLOCK_SERVERLOG() opr_Verify(pthread_mutex_unlock(&serverLogMutex) == 0)
41
42 #ifdef AFS_NT40_ENV
43 #define NULLDEV "NUL"
44 #else
45 #define NULLDEV "/dev/null"
46 #endif
47
48 #else /* AFS_PTHREAD_ENV */
49 #define LOCK_SERVERLOG()
50 #define UNLOCK_SERVERLOG()
51 #endif /* AFS_PTHREAD_ENV */
52
53 #ifdef AFS_NT40_ENV
54 #define F_OK 0
55 #define O_NONBLOCK 0
56 #endif
57
58 /*!
59  * Placeholder function to return dummy thread number.
60  */
61 static int
62 dummyThreadNum(void)
63 {
64     return -1;
65 }
66 static int (*threadNumProgram) (void) = dummyThreadNum;
67
68 /* After single-threaded startup, accesses to serverlogFD and
69  * serverLogSyslog* are protected by LOCK_SERVERLOG(). */
70 static int serverLogFD = -1;    /*!< The log file descriptor. */
71 static struct logOptions serverLogOpts; /*!< logging options */
72
73 int LogLevel;                   /*!< The current logging level. */
74 static int threadIdLogs = 0;    /*!< Include the thread id in log messages when true. */
75 static int resetSignals = 0;    /*!< Reset signal handlers for the next signal when true. */
76 static char *ourName = NULL;    /*!< The fully qualified log file path, saved for reopens. */
77
78 static int OpenLogFile(const char *fileName);
79 static void RotateLogFile(void);
80
81 /*!
82  * Determine if the file is a named pipe.
83  *
84  * This check is performed to support named pipes as logs by not rotating them
85  * and opening them with a non-blocking flags.
86  *
87  * \param[in] fileName  log file name
88  *
89  * \returns non-zero if log file is a named pipe.
90  */
91 static int
92 IsFIFO(const char *fileName)
93 {
94     struct stat statbuf;
95     return (lstat(fileName, &statbuf) == 0) && (S_ISFIFO(statbuf.st_mode));
96 }
97
98 /*!
99  * Return the current logging level.
100  */
101 int
102 GetLogLevel(void)
103 {
104     return LogLevel;
105 }
106
107 /*!
108  * Return the log destination.
109  */
110 enum logDest
111 GetLogDest(void)
112 {
113     return serverLogOpts.lopt_dest;
114 }
115
116 /*!
117  * Get the log filename for file based logging.
118  *
119  * An empty string is returned if the log destination is not
120  * file based.  The caller must make a copy of the string
121  * if it is accessed after the CloseLog.
122  */
123 const char *
124 GetLogFilename(void)
125 {
126     return serverLogOpts.lopt_dest == logDest_file ? (const char*)ourName : "";
127 }
128
129 /*!
130  * Set the function to log thread numbers.
131  */
132 void
133 SetLogThreadNumProgram(int (*func) (void) )
134 {
135     threadNumProgram = func;
136 }
137
138 /*!
139  * Write a block of bytes to the log.
140  *
141  * Write a block of bytes directly to the log without formatting
142  * or prepending a timestamp.
143  *
144  * \param[in] buf  pointer to bytes to write
145  * \param[in] len  number of bytes to write
146  */
147 void
148 WriteLogBuffer(char *buf, afs_uint32 len)
149 {
150     LOCK_SERVERLOG();
151     if (serverLogFD >= 0) {
152         if (write(serverLogFD, buf, len) < 0)
153             ; /* don't care */
154     }
155     UNLOCK_SERVERLOG();
156 }
157
158 /*!
159  * Get the current thread number.
160  */
161 int
162 LogThreadNum(void)
163 {
164   return (*threadNumProgram) ();
165 }
166
167 /*!
168  * Write a message to the log.
169  *
170  * \param[in] format  printf-style format string
171  * \param[in] args    variable list of arguments
172  */
173 void
174 vFSLog(const char *format, va_list args)
175 {
176     time_t currenttime;
177     char tbuffer[1024];
178     char *info;
179     size_t len;
180     struct tm tm;
181     int num;
182
183     currenttime = time(NULL);
184     len = strftime(tbuffer, sizeof(tbuffer), "%a %b %d %H:%M:%S %Y ",
185                    localtime_r(&currenttime, &tm));
186     info = &tbuffer[len];
187
188     if (threadIdLogs) {
189         num = (*threadNumProgram) ();
190         if (num > -1) {
191             snprintf(info, (sizeof tbuffer) - strlen(tbuffer), "[%d] ",
192                      num);
193             info += strlen(info);
194         }
195     }
196
197     vsnprintf(info, (sizeof tbuffer) - strlen(tbuffer), format, args);
198
199     len = strlen(tbuffer);
200     LOCK_SERVERLOG();
201 #ifdef HAVE_SYSLOG
202     if (serverLogOpts.dest == logDest_syslog) {
203         syslog(LOG_INFO, "%s", info);
204     } else
205 #endif
206     if (serverLogFD >= 0) {
207         if (write(serverLogFD, tbuffer, len) < 0)
208             ; /* don't care */
209     }
210     UNLOCK_SERVERLOG();
211
212 #if !defined(AFS_PTHREAD_ENV) && !defined(AFS_NT40_ENV)
213     if (serverLogOpts.dest == logDest_file) {
214         fflush(stdout);
215         fflush(stderr);         /* in case they're sharing the same FD */
216     }
217 #endif
218 }                               /*vFSLog */
219
220 /*!
221  * Write a message to the log.
222  *
223  * \param[in] format  printf-style format specification
224  * \param[in] ...     arguments for format specification
225  */
226 void
227 FSLog(const char *format, ...)
228 {
229     va_list args;
230
231     va_start(args, format);
232     vFSLog(format, args);
233     va_end(args);
234 }                               /*FSLog */
235
236 /*!
237  * Write the command-line invocation to the log.
238  *
239  * \param[in] argc      argument count from main()
240  * \param[in] argv      argument vector from main()
241  * \param[in] progname  program name
242  * \param[in] version   program version
243  * \param[in] logstring log message string
244  * \param[in] log       printf-style log function
245  */
246 void
247 LogCommandLine(int argc, char **argv, const char *progname,
248                const char *version, const char *logstring,
249                void (*log) (const char *format, ...))
250 {
251     int i, l;
252     char *commandLine, *cx;
253
254     opr_Assert(argc > 0);
255
256     for (l = i = 0; i < argc; i++)
257         l += strlen(argv[i]) + 1;
258     if ((commandLine = malloc(l))) {
259         for (cx = commandLine, i = 0; i < argc; i++) {
260             strcpy(cx, argv[i]);
261             cx += strlen(cx);
262             *(cx++) = ' ';
263         }
264         commandLine[l-1] = '\0';
265         (*log)("%s %s %s%s(%s)\n", logstring, progname,
266                     version, strlen(version)>0?" ":"", commandLine);
267         free(commandLine);
268     } else {
269         /* What, we're out of memory already!? */
270         (*log)("%s %s%s%s\n", logstring,
271               progname, strlen(version)>0?" ":"", version);
272     }
273 }
274
275 /*!
276  * Write the single-DES deprecation warning to the log.
277  */
278 void
279 LogDesWarning(void)
280 {
281     /* The blank newlines help this stand out a bit more in the log. */
282     ViceLog(0, ("\n"));
283     ViceLog(0, ("WARNING: You are using single-DES keys in a KeyFile. Using single-DES\n"));
284     ViceLog(0, ("WARNING: long-term keys is considered insecure, and it is strongly\n"));
285     ViceLog(0, ("WARNING: recommended that you migrate to stronger encryption. See\n"));
286     ViceLog(0, ("WARNING: OPENAFS-SA-2013-003 on http://www.openafs.org/security/\n"));
287     ViceLog(0, ("WARNING: for details.\n"));
288     ViceLog(0, ("\n"));
289 }
290
291 /*!
292  * Move the current log file out of the way so a new one can be started.
293  *
294  * The format of the new name depends on the logging style.  The traditional
295  * Transarc style appends ".old" to the log file name.  When MR-AFS style
296  * logging is in effect, a time stamp is appended to the log file name instead
297  * of ".old".
298  *
299  * \bug  Unfortunately, no check is made to avoid overwriting
300  *       old logs in the traditional Transarc mode.
301  *
302  * \param fileName  fully qualified log file path
303  */
304 static void
305 RenameLogFile(const char *fileName)
306 {
307     int code;
308     char *nextName = NULL;
309     int tries;
310     time_t t;
311     struct stat buf;
312     struct tm *timeFields;
313
314     switch (serverLogOpts.lopt_rotateStyle) {
315     case logRotate_none:
316         break;
317     case logRotate_old:
318         code = asprintf(&nextName, "%s.old", fileName);
319         if (code < 0) {
320             nextName = NULL;
321         }
322         break;
323     case logRotate_timestamp:
324         time(&t);
325         for (tries = 0; nextName == NULL && tries < 100; t++, tries++) {
326             timeFields = localtime(&t);
327             code = asprintf(&nextName, "%s.%d%02d%02d%02d%02d%02d",
328                             fileName, timeFields->tm_year + 1900,
329                             timeFields->tm_mon + 1, timeFields->tm_mday,
330                             timeFields->tm_hour, timeFields->tm_min,
331                             timeFields->tm_sec);
332             if (code < 0) {
333                 nextName = NULL;
334                 break;
335             }
336             if (lstat(nextName, &buf) == 0) {
337                 /* Avoid clobbering a log. */
338                 free(nextName);
339                 nextName = NULL;
340             }
341         }
342         break;
343     default:
344         opr_Assert(0);
345     }
346     if (nextName != NULL) {
347         rk_rename(fileName, nextName);  /* Don't check the error code. */
348         free(nextName);
349     }
350 }
351
352 /*!
353  * Write message to the log to indicate the log level.
354  *
355  * This helper function is called by the signal handlers when the log level is
356  * changed, to write a message to the log to indicate the log level has been
357  * changed.
358  */
359 static void*
360 DebugOn(void *param)
361 {
362     int loglevel = (intptr_t)param;
363     if (loglevel == 0) {
364         ViceLog(0, ("Reset Debug levels to 0\n"));
365     } else {
366         ViceLog(0, ("Set Debug On level = %d\n", loglevel));
367     }
368     return 0;
369 }                               /*DebugOn */
370
371 /*!
372  * Signal handler to increase the logging level.
373  *
374  * Increase the current logging level to 1 if it in currently 0,
375  * otherwise, increase the current logging level by a factor of 5 if it
376  * is currently non-zero.
377  *
378  * Enables thread id logging when the log level is greater than 1.
379  */
380 void
381 SetDebug_Signal(int signo)
382 {
383     if (LogLevel > 0) {
384         LogLevel *= 5;
385
386 #if defined(AFS_PTHREAD_ENV)
387         if (LogLevel > 1 && threadNumProgram != NULL &&
388             threadIdLogs == 0) {
389             threadIdLogs = 1;
390         }
391 #endif
392     } else {
393         LogLevel = 1;
394
395 #if defined(AFS_PTHREAD_ENV)
396         if (threadIdLogs == 1)
397             threadIdLogs = 0;
398 #endif
399     }
400 #if defined(AFS_PTHREAD_ENV)
401     DebugOn((void *)(intptr_t)LogLevel);
402 #else /* AFS_PTHREAD_ENV */
403     IOMGR_SoftSig(DebugOn, (void *)(intptr_t)LogLevel);
404 #endif /* AFS_PTHREAD_ENV */
405
406     if (resetSignals) {
407         /* When pthreaded softsig handlers are not in use, some platforms
408          * require this signal handler to be set again. */
409         (void)signal(signo, SetDebug_Signal);
410     }
411 }                               /*SetDebug_Signal */
412
413 /*!
414  * Signal handler to reset the logging level.
415  *
416  * Reset the logging level and disable thread id logging.
417  *
418  * \note This handler has the side-effect of rotating and reopening
419  *       MR-AFS style logs.
420  */
421 void
422 ResetDebug_Signal(int signo)
423 {
424     LogLevel = 0;
425
426 #if defined(AFS_PTHREAD_ENV)
427     DebugOn((void *)(intptr_t)LogLevel);
428 #else /* AFS_PTHREAD_ENV */
429     IOMGR_SoftSig(DebugOn, (void *)(intptr_t)LogLevel);
430 #endif /* AFS_PTHREAD_ENV */
431
432     if (resetSignals) {
433         /* When pthreaded softsig handlers are not in use, some platforms
434          * require this signal handler to be set again. */
435         (void)signal(signo, ResetDebug_Signal);
436     }
437 #if defined(AFS_PTHREAD_ENV)
438     if (threadIdLogs == 1)
439         threadIdLogs = 0;
440 #endif
441     if (serverLogOpts.lopt_rotateOnReset) {
442         RotateLogFile();
443     }
444 }                               /*ResetDebug_Signal */
445
446 /*!
447  * Handle requests to reopen the log.
448  *
449  * This signal handler will reopen the log file. A new, empty log file
450  * will be created if the log file does not already exist.
451  *
452  * External log rotation programs may rotate a server log file by
453  * renaming the existing server log file and then immediately sending a
454  * signal to the corresponding server process.  Server log messages will
455  * continue to be appended to the renamed server log file until the
456  * server log is reopened.  After this signal handler completes, server
457  * log messages will be written to the new log file.  This allows
458  * external log rotation programs to rotate log files without
459  * messages being dropped.
460  */
461 void
462 ReOpenLog_Signal(int signo)
463 {
464     ReOpenLog();
465     if (resetSignals) {
466         (void)signal(signo, ReOpenLog_Signal);
467     }
468 }
469
470 #ifdef AFS_PTHREAD_ENV
471 /*!
472  * Register pthread-safe signal handlers for server log management.
473  *
474  * \note opr_softsig_Init() must be called before this function.
475  */
476 void
477 SetupLogSoftSignals(void)
478 {
479     opr_softsig_Register(SIGHUP, ResetDebug_Signal);
480     opr_softsig_Register(SIGTSTP, SetDebug_Signal);
481     opr_softsig_Register(SIGUSR1, ReOpenLog_Signal);
482 #ifndef AFS_NT40_ENV
483     (void)signal(SIGPIPE, SIG_IGN);
484 #endif
485 }
486 #endif /* AFS_PTHREAD_ENV */
487
488 /*!
489  * Register signal handlers for server log management.
490  *
491  * \note This function is deprecated and should not be used
492  *       in new code. This function should be removed when
493  *       all the servers have been converted to pthreads
494  *       and lwp has been removed.
495  */
496 void
497 SetupLogSignals(void)
498 {
499     resetSignals = 1;
500     (void)signal(SIGHUP, ResetDebug_Signal);
501     (void)signal(SIGTSTP, SetDebug_Signal);
502     (void)signal(SIGUSR1, ReOpenLog_Signal);
503 #ifndef AFS_NT40_ENV
504     (void)signal(SIGPIPE, SIG_IGN);
505 #endif
506 }
507
508 #if defined(AFS_PTHREAD_ENV)
509 static void
510 InitServerLogMutex(void)
511 {
512     opr_Verify(pthread_mutex_init(&serverLogMutex, NULL) == 0);
513 }
514 #endif /* AFS_PTHREAD_ENV */
515
516 /*!
517  * Redirect stdout and stderr to the log file.
518  *
519  * \note Call directly after opening the log file.
520  *
521  * \param[in] fileName  log file name
522  */
523 static void
524 RedirectStdStreams(const char *fileName)
525 {
526     if (freopen(fileName, "a", stdout) == NULL)
527         ; /* don't care */
528     if (freopen(fileName, "a", stderr) != NULL) {
529 #ifdef HAVE_SETVBUF
530         setvbuf(stderr, NULL, _IONBF, 0);
531 #else
532         setbuf(stderr, NULL);
533 #endif
534     }
535 }
536
537 /*!
538  * Open the log file.
539  *
540  * Open the log file using the options given in OpenLog().
541  *
542  * \returns 0 on success
543  */
544 static int
545 OpenLogFile(const char *fileName)
546 {
547     /*
548      * This function should allow various libraries that inconsistently
549      * use stdout/stderr to all go to the same place
550      */
551     int tempfd;
552     int flags = O_WRONLY | O_CREAT | O_APPEND;
553
554     opr_Assert(serverLogOpts.dest == logDest_file);
555
556     opr_Assert(fileName != NULL);
557
558     if (IsFIFO(fileName)) {
559         /* Support named pipes as logs by not rotating them. */
560         flags |= O_NONBLOCK;
561     } else if (serverLogOpts.lopt_rotateOnOpen) {
562         /* Old style logging always started a new log file. */
563         flags |= O_TRUNC;
564         RenameLogFile(fileName);
565     }
566
567     tempfd = open(fileName, flags, 0666);
568     if (tempfd < 0) {
569         printf("Unable to open log file %s\n", fileName);
570         return -1;
571     }
572     RedirectStdStreams(fileName);
573
574     /* Save our name for reopening. */
575     free(ourName);
576     ourName = strdup(fileName);
577     opr_Assert(ourName != NULL);
578
579     serverLogFD = tempfd;
580
581     return 0;
582 }
583
584 /*!
585  * Open the log file descriptor or a connection to the system log.
586  *
587  * This function should be called once during program initialization and
588  * must be called before calling FSLog() or WriteLogBuffer().  The
589  * fields of the given argument specify the logging destination and
590  * various optional features.
591  *
592  * The lopt_logLevel value specifies the initial logging level.
593  *
594  * The lopt_dest enum specifies the logging destination; either
595  * file based (logDest_file) or the system log (logDest_syslog).
596  *
597  * File Based Logging
598  * ------------------
599  *
600  * A file will be opened for log messages when the lopt_dest enum is set
601  * to logDest_file.  The file specified by lopt_filename will be opened
602  * for appending log messages.  A new file will be created if the log
603  * file does not exist.
604  *
605  * The lopt_rotateOnOpen flag specifies whether an existing log file is
606  * to be renamed and a new log file created during the call to OpenLog.
607  * The lopt_rotateOnOpen flag has no effect if the file given by
608  * lopt_filename is a named pipe (fifo).
609  *
610  * The lopt_rotateOnReset flag specifies whether the log file is renamed
611  * and then reopened when the reset signal (SIGHUP) is caught.
612  *
613  * The lopt_rotateStyle enum specifies how the new log file is renamed when
614  * lopt_rotateOnOpen or lopt_rotateOnReset are set. The lopt_rotateStyle
615  * may be the traditional Transarc style (logRotate_old) or the MR-AFS
616  * style (logRotate_timestamp).
617  *
618  * When lopt_rotateStyle is set to logRotate_old, the suffix ".old" is
619  * appended to the log file name. The existing ".old" log file is
620  * removed.
621  *
622  * When lopt_rotateStyle is set to logRotate_timestamp, a timestamp
623  * string is appended to the log file name and existing files are not
624  * removed.
625  *
626  * \note  Messages written to stdout and stderr are redirected to the log
627  *        file when file-based logging is in effect.
628  *
629  * System Logging
630  * --------------
631  *
632  * A connection to the system log (syslog) will be established for log
633  * messages when the lopt_dest enum is set to logDest_syslog.
634  *
635  * The lopt_facility specifies the system log facility to be used when
636  * writing messages to the system log.
637  *
638  * The lopt_tag string specifies the indentification string to be used
639  * when writing messages to the system log.
640  *
641  * \param opts  logging options. A copy of the logging
642  *              options will be made before returning to
643  *              the caller.
644  *
645  * \returns 0 on success
646  */
647 int
648 OpenLog(struct logOptions *opts)
649 {
650     int code;
651
652 #if defined(AFS_PTHREAD_ENV)
653     opr_Verify(pthread_once(&serverLogOnce, InitServerLogMutex) == 0);
654 #endif /* AFS_PTHREAD_ENV */
655
656     LogLevel = serverLogOpts.logLevel = opts->logLevel;
657     serverLogOpts.dest = opts->dest;
658     switch (serverLogOpts.dest) {
659     case logDest_file:
660         serverLogOpts.lopt_rotateOnOpen = opts->lopt_rotateOnOpen;
661         serverLogOpts.lopt_rotateOnReset = opts->lopt_rotateOnReset;
662         serverLogOpts.lopt_rotateStyle = opts->lopt_rotateStyle;
663         /* OpenLogFile() sets ourName; don't cache filename here. */
664         code = OpenLogFile(opts->lopt_filename);
665         break;
666 #ifdef HAVE_SYSLOG
667     case logDest_syslog:
668         serverLogOpts.lopt_rotateOnOpen = 0;
669         serverLogOpts.lopt_rotateOnReset = 0;
670         serverLogOpts.lopt_rotateStyle = logRotate_none;
671         openlog(opts->lopt_tag, LOG_PID, opts->lopt_facility);
672         code = 0;
673         break;
674 #endif
675     default:
676         opr_Assert(0);
677     }
678     return code;
679 }                               /*OpenLog */
680
681 /*!
682  * Reopen the log file descriptor.
683  *
684  * Reopen the log file descriptor in order to support rotation
685  * of the log files.  Has no effect when logging to the syslog.
686  *
687  * \returns  0 on success
688  */
689 int
690 ReOpenLog(void)
691 {
692     int flags = O_WRONLY | O_APPEND | O_CREAT;
693
694 #ifdef HAVE_SYSLOG
695     if (serverLogOpts.dest == logDest_syslog) {
696         return 0;
697     }
698 #endif
699
700     LOCK_SERVERLOG();
701     if (ourName == NULL) {
702         UNLOCK_SERVERLOG();
703         return -1;
704     }
705     if (IsFIFO(ourName)) {
706         flags |= O_NONBLOCK;
707     }
708     if (serverLogFD >= 0)
709         close(serverLogFD);
710     serverLogFD = open(ourName, flags, 0666);
711     if (serverLogFD >= 0) {
712         RedirectStdStreams(ourName);
713     }
714     UNLOCK_SERVERLOG();
715     return serverLogFD < 0 ? -1 : 0;
716 }
717
718 /*!
719  * Rotate the log file by renaming then truncating.
720  */
721 static void
722 RotateLogFile(void)
723 {
724     LOCK_SERVERLOG();
725     if (ourName != NULL) {
726         if (serverLogFD >= 0) {
727             close(serverLogFD);
728             serverLogFD = -1;
729         }
730         OpenLogFile(ourName);
731     }
732     UNLOCK_SERVERLOG();
733 }
734
735 /*!
736  * Close the server log file.
737  *
738  * \note Must be preceeded by OpenLog().
739  */
740 void
741 CloseLog(void)
742 {
743     LOCK_SERVERLOG();
744
745 #ifdef HAVE_SYSLOG
746     if (serverLogOpts.dest == logDest_syslog) {
747         closelog();
748     } else
749 #endif
750     {
751         if (serverLogFD >= 0) {
752             close(serverLogFD);
753             serverLogFD = -1;
754         }
755         free(ourName);
756         ourName = NULL;
757     }
758     UNLOCK_SERVERLOG();
759 }