b42525b74e7830d06ddcd65a9c1d71a58bd9cc7c
[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 routiens 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 static int
59 dummyThreadNum(void)
60 {
61     return -1;
62 }
63 static int (*threadNumProgram) (void) = dummyThreadNum;
64
65 static int serverLogFD = -1;
66
67 #ifndef AFS_NT40_ENV
68 int serverLogSyslog = 0;
69 int serverLogSyslogFacility = LOG_DAEMON;
70 char *serverLogSyslogTag = 0;
71 #endif
72
73 int LogLevel;
74 int mrafsStyleLogs = 0;
75 static int threadIdLogs = 0;
76 static int resetSignals = 0;
77 static char *ourName = NULL;
78
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 void
99 SetLogThreadNumProgram(int (*func) (void) )
100 {
101     threadNumProgram = func;
102 }
103
104 void
105 WriteLogBuffer(char *buf, afs_uint32 len)
106 {
107     LOCK_SERVERLOG();
108     if (serverLogFD >= 0) {
109         if (write(serverLogFD, buf, len) < 0)
110             ; /* don't care */
111     }
112     UNLOCK_SERVERLOG();
113 }
114
115 int
116 LogThreadNum(void)
117 {
118   return (*threadNumProgram) ();
119 }
120
121 void
122 vFSLog(const char *format, va_list args)
123 {
124     time_t currenttime;
125     char tbuffer[1024];
126     char *info;
127     size_t len;
128     struct tm tm;
129     int num;
130
131     currenttime = time(NULL);
132     len = strftime(tbuffer, sizeof(tbuffer), "%a %b %d %H:%M:%S %Y ",
133                    localtime_r(&currenttime, &tm));
134     info = &tbuffer[len];
135
136     if (threadIdLogs) {
137         num = (*threadNumProgram) ();
138         if (num > -1) {
139             snprintf(info, (sizeof tbuffer) - strlen(tbuffer), "[%d] ",
140                      num);
141             info += strlen(info);
142         }
143     }
144
145     vsnprintf(info, (sizeof tbuffer) - strlen(tbuffer), format, args);
146
147     len = strlen(tbuffer);
148     LOCK_SERVERLOG();
149 #ifndef AFS_NT40_ENV
150     if (serverLogSyslog) {
151         syslog(LOG_INFO, "%s", info);
152     } else
153 #endif
154     if (serverLogFD >= 0) {
155         if (write(serverLogFD, tbuffer, len) < 0)
156             ; /* don't care */
157     }
158     UNLOCK_SERVERLOG();
159
160 #if !defined(AFS_PTHREAD_ENV) && !defined(AFS_NT40_ENV)
161     if (!serverLogSyslog) {
162         fflush(stdout);
163         fflush(stderr);         /* in case they're sharing the same FD */
164     }
165 #endif
166 }                               /*vFSLog */
167
168 /* VARARGS1 */
169 /*@printflike@*/
170 void
171 FSLog(const char *format, ...)
172 {
173     va_list args;
174
175     va_start(args, format);
176     vFSLog(format, args);
177     va_end(args);
178 }                               /*FSLog */
179
180 void
181 LogCommandLine(int argc, char **argv, const char *progname,
182                const char *version, const char *logstring,
183                void (*log) (const char *format, ...))
184 {
185     int i, l;
186     char *commandLine, *cx;
187
188     opr_Assert(argc > 0);
189
190     for (l = i = 0; i < argc; i++)
191         l += strlen(argv[i]) + 1;
192     if ((commandLine = malloc(l))) {
193         for (cx = commandLine, i = 0; i < argc; i++) {
194             strcpy(cx, argv[i]);
195             cx += strlen(cx);
196             *(cx++) = ' ';
197         }
198         commandLine[l-1] = '\0';
199         (*log)("%s %s %s%s(%s)\n", logstring, progname,
200                     version, strlen(version)>0?" ":"", commandLine);
201         free(commandLine);
202     } else {
203         /* What, we're out of memory already!? */
204         (*log)("%s %s%s%s\n", logstring,
205               progname, strlen(version)>0?" ":"", version);
206     }
207 }
208
209 void
210 LogDesWarning(void)
211 {
212     /* The blank newlines help this stand out a bit more in the log. */
213     ViceLog(0, ("\n"));
214     ViceLog(0, ("WARNING: You are using single-DES keys in a KeyFile. Using single-DES\n"));
215     ViceLog(0, ("WARNING: long-term keys is considered insecure, and it is strongly\n"));
216     ViceLog(0, ("WARNING: recommended that you migrate to stronger encryption. See\n"));
217     ViceLog(0, ("WARNING: OPENAFS-SA-2013-003 on http://www.openafs.org/security/\n"));
218     ViceLog(0, ("WARNING: for details.\n"));
219     ViceLog(0, ("\n"));
220 }
221
222 /*!
223  * Move the current log file out of the way so a new one can be started.
224  *
225  * The format of the new name depends on the logging style.  The traditional
226  * Transarc style appends ".old" to the log file name.  When MR-AFS style
227  * logging is in effect, a time stamp is appended to the log file name instead
228  * of ".old".
229  *
230  * \bug  Unfortunately, no check is made to avoid overwriting
231  *       old logs in the traditional Transarc mode.
232  *
233  * \param fileName  fully qualified log file path
234  */
235 static void
236 RenameLogFile(const char *fileName)
237 {
238     int code;
239     char *nextName = NULL;
240
241     if (mrafsStyleLogs) {
242         int tries;
243         time_t t;
244         struct stat buf;
245         struct tm *timeFields;
246
247         time(&t);
248         for (tries = 0; nextName == NULL && tries < 100; t++, tries++) {
249             timeFields = localtime(&t);
250             code = asprintf(&nextName, "%s.%d%02d%02d%02d%02d%02d",
251                             fileName, timeFields->tm_year + 1900,
252                             timeFields->tm_mon + 1, timeFields->tm_mday,
253                             timeFields->tm_hour, timeFields->tm_min,
254                             timeFields->tm_sec);
255             if (code < 0) {
256                 nextName = NULL;
257                 break;
258             }
259             if (lstat(nextName, &buf) == 0) {
260                 /* Avoid clobbering a log. */
261                 free(nextName);
262                 nextName = NULL;
263             }
264         }
265     } else {
266         code = asprintf(&nextName, "%s.old", fileName);
267         if (code < 0) {
268             nextName = NULL;
269         }
270     }
271     if (nextName != NULL) {
272         rk_rename(fileName, nextName);  /* Don't check the error code. */
273         free(nextName);
274     }
275 }
276
277 static void*
278 DebugOn(void *param)
279 {
280     int loglevel = (intptr_t)param;
281     if (loglevel == 0) {
282         ViceLog(0, ("Reset Debug levels to 0\n"));
283     } else {
284         ViceLog(0, ("Set Debug On level = %d\n", loglevel));
285     }
286     return 0;
287 }                               /*DebugOn */
288
289
290
291 void
292 SetDebug_Signal(int signo)
293 {
294     if (LogLevel > 0) {
295         LogLevel *= 5;
296
297 #if defined(AFS_PTHREAD_ENV)
298         if (LogLevel > 1 && threadNumProgram != NULL &&
299             threadIdLogs == 0) {
300             threadIdLogs = 1;
301         }
302 #endif
303     } else {
304         LogLevel = 1;
305
306 #if defined(AFS_PTHREAD_ENV)
307         if (threadIdLogs == 1)
308             threadIdLogs = 0;
309 #endif
310     }
311 #if defined(AFS_PTHREAD_ENV)
312     DebugOn((void *)(intptr_t)LogLevel);
313 #else /* AFS_PTHREAD_ENV */
314     IOMGR_SoftSig(DebugOn, (void *)(intptr_t)LogLevel);
315 #endif /* AFS_PTHREAD_ENV */
316
317     if (resetSignals) {
318         /* When pthreaded softsig handlers are not in use, some platforms
319          * require this signal handler to be set again. */
320         (void)signal(signo, SetDebug_Signal);
321     }
322 }                               /*SetDebug_Signal */
323
324 void
325 ResetDebug_Signal(int signo)
326 {
327     LogLevel = 0;
328
329 #if defined(AFS_PTHREAD_ENV)
330     DebugOn((void *)(intptr_t)LogLevel);
331 #else /* AFS_PTHREAD_ENV */
332     IOMGR_SoftSig(DebugOn, (void *)(intptr_t)LogLevel);
333 #endif /* AFS_PTHREAD_ENV */
334
335     if (resetSignals) {
336         /* When pthreaded softsig handlers are not in use, some platforms
337          * require this signal handler to be set again. */
338         (void)signal(signo, ResetDebug_Signal);
339     }
340 #if defined(AFS_PTHREAD_ENV)
341     if (threadIdLogs == 1)
342         threadIdLogs = 0;
343 #endif
344     if (mrafsStyleLogs) {
345         RotateLogFile();
346     }
347 }                               /*ResetDebug_Signal */
348
349
350 #ifdef AFS_PTHREAD_ENV
351 /*!
352  * Register pthread-safe signal handlers for server log management.
353  *
354  * \note opr_softsig_Init() must be called before this function.
355  */
356 void
357 SetupLogSoftSignals(void)
358 {
359     opr_softsig_Register(SIGHUP, ResetDebug_Signal);
360     opr_softsig_Register(SIGTSTP, SetDebug_Signal);
361 #ifndef AFS_NT40_ENV
362     (void)signal(SIGPIPE, SIG_IGN);
363 #endif
364 }
365 #endif /* AFS_PTHREAD_ENV */
366
367 /*!
368  * Register signal handlers for server log management.
369  *
370  * \note This function is deprecated and should not be used
371  *       in new code. This function should be removed when
372  *       all the servers have been converted to pthreads
373  *       and lwp has been removed.
374  */
375 void
376 SetupLogSignals(void)
377 {
378     resetSignals = 1;
379     (void)signal(SIGHUP, ResetDebug_Signal);
380     /* Note that we cannot use SIGUSR1 -- Linux stole it for pthreads! */
381     (void)signal(SIGTSTP, SetDebug_Signal);
382 #ifndef AFS_NT40_ENV
383     (void)signal(SIGPIPE, SIG_IGN);
384 #endif
385 }
386
387 #if defined(AFS_PTHREAD_ENV)
388 static void
389 InitServerLogMutex(void)
390 {
391     opr_Verify(pthread_mutex_init(&serverLogMutex, NULL) == 0);
392 }
393 #endif /* AFS_PTHREAD_ENV */
394
395 /*!
396  * Redirect stdout and stderr to the log file.
397  *
398  * \note Call directly after opening the log file.
399  *
400  * \param[in] fileName  log file name
401  */
402 static void
403 RedirectStdStreams(const char *fileName)
404 {
405     if (freopen(fileName, "a", stdout) == NULL)
406         ; /* don't care */
407     if (freopen(fileName, "a", stderr) != NULL) {
408 #ifdef HAVE_SETVBUF
409         setvbuf(stderr, NULL, _IONBF, 0);
410 #else
411         setbuf(stderr, NULL);
412 #endif
413     }
414 }
415
416 int
417 OpenLog(const char *fileName)
418 {
419     /*
420      * This function should allow various libraries that inconsistently
421      * use stdout/stderr to all go to the same place
422      */
423     int tempfd;
424     int flags = O_WRONLY | O_TRUNC | O_CREAT | O_APPEND;
425
426 #if defined(AFS_PTHREAD_ENV)
427     opr_Verify(pthread_once(&serverLogOnce, InitServerLogMutex) == 0);
428 #endif /* AFS_PTHREAD_ENV */
429
430 #ifndef AFS_NT40_ENV
431     if (serverLogSyslog) {
432         openlog(serverLogSyslogTag, LOG_PID, serverLogSyslogFacility);
433         return (0);
434     }
435 #endif
436
437     opr_Assert(fileName != NULL);
438
439     if (IsFIFO(fileName)) {
440         /* Support named pipes as logs by not rotating them. */
441         flags |= O_NONBLOCK;
442     } else {
443         RenameLogFile(fileName);
444     }
445
446     tempfd = open(fileName, flags, 0666);
447     if (tempfd < 0) {
448         printf("Unable to open log file %s\n", fileName);
449         return -1;
450     }
451     RedirectStdStreams(fileName);
452
453     /* Save our name for reopening. */
454     free(ourName);
455     ourName = strdup(fileName);
456     opr_Assert(ourName != NULL);
457
458     serverLogFD = tempfd;
459
460     return 0;
461 }                               /*OpenLog */
462
463 int
464 ReOpenLog(const char *fileName)
465 {
466     int flags = O_WRONLY | O_APPEND | O_CREAT;
467
468 #if !defined(AFS_NT40_ENV)
469     if (serverLogSyslog) {
470         return 0;
471     }
472 #endif
473
474     if (IsFIFO(fileName)) {
475         flags |= O_NONBLOCK;
476     }
477
478     LOCK_SERVERLOG();
479     if (serverLogFD >= 0)
480         close(serverLogFD);
481     serverLogFD = open(fileName, flags, 0666);
482     if (serverLogFD >= 0) {
483         RedirectStdStreams(fileName);
484     }
485     UNLOCK_SERVERLOG();
486     return serverLogFD < 0 ? -1 : 0;
487 }
488
489 /*!
490  * Rotate the log file by renaming then truncating.
491  */
492 static void
493 RotateLogFile(void)
494 {
495     LOCK_SERVERLOG();
496     if (ourName != NULL) {
497         if (serverLogFD >= 0) {
498             close(serverLogFD);
499             serverLogFD = -1;
500         }
501         OpenLog(ourName);
502     }
503     UNLOCK_SERVERLOG();
504 }
505
506 /*!
507  * Close the server log file.
508  *
509  * \note Must be preceeded by OpenLog().
510  */
511 void
512 CloseLog(void)
513 {
514     LOCK_SERVERLOG();
515 #ifndef AFS_NT40_ENV
516     if (serverLogSyslog) {
517         closelog();
518     } else
519 #endif
520     {
521         if (serverLogFD >= 0) {
522             close(serverLogFD);
523             serverLogFD = -1;
524         }
525         free(ourName);
526         ourName = NULL;
527     }
528     UNLOCK_SERVERLOG();
529 }