![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to log.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / lighttpd / src|
Return to log.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / lighttpd / src |
1.1 misho 1: #include "base.h"
2: #include "log.h"
3: #include "array.h"
4:
5: #include <sys/types.h>
6:
7: #include <errno.h>
8: #include <fcntl.h>
9: #include <time.h>
10: #include <unistd.h>
11: #include <string.h>
12: #include <stdlib.h>
13:
14: #include <stdarg.h>
15: #include <stdio.h>
16:
17: #ifdef HAVE_SYSLOG_H
18: # include <syslog.h>
19: #endif
20:
21: #ifdef HAVE_VALGRIND_VALGRIND_H
22: # include <valgrind/valgrind.h>
23: #endif
24:
25: #ifndef O_LARGEFILE
26: # define O_LARGEFILE 0
27: #endif
28:
29: /* Close fd and _try_ to get a /dev/null for it instead.
30: * close() alone may trigger some bugs when a
31: * process opens another file and gets fd = STDOUT_FILENO or STDERR_FILENO
32: * and later tries to just print on stdout/stderr
33: *
34: * Returns 0 on success and -1 on failure (fd gets closed in all cases)
35: */
36: int openDevNull(int fd) {
37: int tmpfd;
38: close(fd);
39: #if defined(__WIN32)
40: /* Cygwin should work with /dev/null */
41: tmpfd = open("nul", O_RDWR);
42: #else
43: tmpfd = open("/dev/null", O_RDWR);
44: #endif
45: if (tmpfd != -1 && tmpfd != fd) {
46: dup2(tmpfd, fd);
47: close(tmpfd);
48: }
49: return (tmpfd != -1) ? 0 : -1;
50: }
51:
52: int open_logfile_or_pipe(server *srv, const char* logfile) {
53: int fd;
54:
55: if (logfile[0] == '|') {
56: #ifdef HAVE_FORK
57: /* create write pipe and spawn process */
58:
59: int to_log_fds[2];
60:
61: if (pipe(to_log_fds)) {
62: log_error_write(srv, __FILE__, __LINE__, "ss", "pipe failed: ", strerror(errno));
63: return -1;
64: }
65:
66: /* fork, execve */
67: switch (fork()) {
68: case 0:
69: /* child */
70: close(STDIN_FILENO);
71:
72: /* dup the filehandle to STDIN */
73: if (to_log_fds[0] != STDIN_FILENO) {
74: if (STDIN_FILENO != dup2(to_log_fds[0], STDIN_FILENO)) {
75: log_error_write(srv, __FILE__, __LINE__, "ss",
76: "dup2 failed: ", strerror(errno));
77: exit(-1);
78: }
79: close(to_log_fds[0]);
80: }
81: close(to_log_fds[1]);
82:
83: #ifndef FD_CLOEXEC
84: {
85: int i;
86: /* we don't need the client socket */
87: for (i = 3; i < 256; i++) {
88: close(i);
89: }
90: }
91: #endif
92:
93: /* close old stderr */
94: openDevNull(STDERR_FILENO);
95:
96: /* exec the log-process (skip the | ) */
97: execl("/bin/sh", "sh", "-c", logfile + 1, NULL);
98: log_error_write(srv, __FILE__, __LINE__, "sss",
99: "spawning log process failed: ", strerror(errno),
100: logfile + 1);
101:
102: exit(-1);
103: break;
104: case -1:
105: /* error */
106: log_error_write(srv, __FILE__, __LINE__, "ss", "fork failed: ", strerror(errno));
107: return -1;
108: default:
109: close(to_log_fds[0]);
110: fd = to_log_fds[1];
111: break;
112: }
113:
114: #else
115: return -1;
116: #endif
117: } else if (-1 == (fd = open(logfile, O_APPEND | O_WRONLY | O_CREAT | O_LARGEFILE, 0644))) {
118: log_error_write(srv, __FILE__, __LINE__, "SSSS",
119: "opening errorlog '", logfile,
120: "' failed: ", strerror(errno));
121:
122: return -1;
123: }
124:
125: #ifdef FD_CLOEXEC
126: fcntl(fd, F_SETFD, FD_CLOEXEC);
127: #endif
128:
129: return fd;
130: }
131:
132:
133: /**
134: * open the errorlog
135: *
136: * we have 4 possibilities:
137: * - stderr (default)
138: * - syslog
139: * - logfile
140: * - pipe
141: *
142: * if the open failed, report to the user and die
143: *
144: */
145:
146: int log_error_open(server *srv) {
147: #ifdef HAVE_SYSLOG_H
148: /* perhaps someone wants to use syslog() */
149: openlog("lighttpd", LOG_CONS | LOG_PID, LOG_DAEMON);
150: #endif
151:
152: srv->errorlog_mode = ERRORLOG_FD;
153: srv->errorlog_fd = STDERR_FILENO;
154:
155: if (srv->srvconf.errorlog_use_syslog) {
156: srv->errorlog_mode = ERRORLOG_SYSLOG;
157: } else if (!buffer_is_empty(srv->srvconf.errorlog_file)) {
158: const char *logfile = srv->srvconf.errorlog_file->ptr;
159:
160: if (-1 == (srv->errorlog_fd = open_logfile_or_pipe(srv, logfile))) {
161: return -1;
162: }
163: srv->errorlog_mode = (logfile[0] == '|') ? ERRORLOG_PIPE : ERRORLOG_FILE;
164: }
165:
166: log_error_write(srv, __FILE__, __LINE__, "s", "server started");
167:
168: if (srv->errorlog_mode == ERRORLOG_FD && !srv->srvconf.dont_daemonize) {
169: /* We can only log to stderr in dont-daemonize mode;
170: * if we do daemonize and no errorlog file is specified, we log into /dev/null
171: */
172: srv->errorlog_fd = -1;
173: }
174:
175: if (!buffer_is_empty(srv->srvconf.breakagelog_file)) {
176: int breakage_fd;
177: const char *logfile = srv->srvconf.breakagelog_file->ptr;
178:
179: if (srv->errorlog_mode == ERRORLOG_FD) {
180: srv->errorlog_fd = dup(STDERR_FILENO);
181: #ifdef FD_CLOEXEC
182: fcntl(srv->errorlog_fd, F_SETFD, FD_CLOEXEC);
183: #endif
184: }
185:
186: if (-1 == (breakage_fd = open_logfile_or_pipe(srv, logfile))) {
187: return -1;
188: }
189:
190: if (STDERR_FILENO != breakage_fd) {
191: dup2(breakage_fd, STDERR_FILENO);
192: close(breakage_fd);
193: }
194: } else if (!srv->srvconf.dont_daemonize) {
195: /* move stderr to /dev/null */
196: openDevNull(STDERR_FILENO);
197: }
198: return 0;
199: }
200:
201: /**
202: * open the errorlog
203: *
204: * if the open failed, report to the user and die
205: * if no filename is given, use syslog instead
206: *
207: */
208:
209: int log_error_cycle(server *srv) {
210: /* only cycle if the error log is a file */
211:
212: if (srv->errorlog_mode == ERRORLOG_FILE) {
213: const char *logfile = srv->srvconf.errorlog_file->ptr;
214: /* already check of opening time */
215:
216: int new_fd;
217:
218: if (-1 == (new_fd = open_logfile_or_pipe(srv, logfile))) {
219: /* write to old log */
220: log_error_write(srv, __FILE__, __LINE__, "SSSSS",
221: "cycling errorlog '", logfile,
222: "' failed: ", strerror(errno),
223: ", falling back to syslog()");
224:
225: close(srv->errorlog_fd);
226: srv->errorlog_fd = -1;
227: #ifdef HAVE_SYSLOG_H
228: srv->errorlog_mode = ERRORLOG_SYSLOG;
229: #endif
230: } else {
231: /* ok, new log is open, close the old one */
232: close(srv->errorlog_fd);
233: srv->errorlog_fd = new_fd;
234: #ifdef FD_CLOEXEC
235: /* close fd on exec (cgi) */
236: fcntl(srv->errorlog_fd, F_SETFD, FD_CLOEXEC);
237: #endif
238: }
239: }
240:
241: return 0;
242: }
243:
244: int log_error_close(server *srv) {
245: switch(srv->errorlog_mode) {
246: case ERRORLOG_PIPE:
247: case ERRORLOG_FILE:
248: case ERRORLOG_FD:
249: if (-1 != srv->errorlog_fd) {
250: /* don't close STDERR */
251: if (STDERR_FILENO != srv->errorlog_fd)
252: close(srv->errorlog_fd);
253: srv->errorlog_fd = -1;
254: }
255: break;
256: case ERRORLOG_SYSLOG:
257: #ifdef HAVE_SYSLOG_H
258: closelog();
259: #endif
260: break;
261: }
262:
263: return 0;
264: }
265:
266: /* lowercase: append space, uppercase: don't */
267: static void log_buffer_append_printf(buffer *out, const char *fmt, va_list ap) {
268: for(; *fmt; fmt++) {
269: int d;
270: char *s;
271: buffer *b;
272: off_t o;
273:
274: switch(*fmt) {
275: case 's': /* string */
276: s = va_arg(ap, char *);
277: buffer_append_string(out, s);
278: buffer_append_string_len(out, CONST_STR_LEN(" "));
279: break;
280: case 'b': /* buffer */
281: b = va_arg(ap, buffer *);
282: buffer_append_string_buffer(out, b);
283: buffer_append_string_len(out, CONST_STR_LEN(" "));
284: break;
285: case 'd': /* int */
286: d = va_arg(ap, int);
287: buffer_append_long(out, d);
288: buffer_append_string_len(out, CONST_STR_LEN(" "));
289: break;
290: case 'o': /* off_t */
291: o = va_arg(ap, off_t);
292: buffer_append_off_t(out, o);
293: buffer_append_string_len(out, CONST_STR_LEN(" "));
294: break;
295: case 'x': /* int (hex) */
296: d = va_arg(ap, int);
297: buffer_append_string_len(out, CONST_STR_LEN("0x"));
298: buffer_append_long_hex(out, d);
299: buffer_append_string_len(out, CONST_STR_LEN(" "));
300: break;
301: case 'S': /* string */
302: s = va_arg(ap, char *);
303: buffer_append_string(out, s);
304: break;
305: case 'B': /* buffer */
306: b = va_arg(ap, buffer *);
307: buffer_append_string_buffer(out, b);
308: break;
309: case 'D': /* int */
310: d = va_arg(ap, int);
311: buffer_append_long(out, d);
312: break;
313: case 'O': /* off_t */
314: o = va_arg(ap, off_t);
315: buffer_append_off_t(out, o);
316: break;
317: case 'X': /* int (hex) */
318: d = va_arg(ap, int);
319: buffer_append_string_len(out, CONST_STR_LEN("0x"));
320: buffer_append_long_hex(out, d);
321: break;
322: case '(':
323: case ')':
324: case '<':
325: case '>':
326: case ',':
327: case ' ':
328: buffer_append_string_len(out, fmt, 1);
329: break;
330: }
331: }
332: }
333:
334: static int log_buffer_prepare(buffer *b, server *srv, const char *filename, unsigned int line) {
335: switch(srv->errorlog_mode) {
336: case ERRORLOG_PIPE:
337: case ERRORLOG_FILE:
338: case ERRORLOG_FD:
339: if (-1 == srv->errorlog_fd) return -1;
340: /* cache the generated timestamp */
341: if (srv->cur_ts != srv->last_generated_debug_ts) {
342: buffer_prepare_copy(srv->ts_debug_str, 255);
343: strftime(srv->ts_debug_str->ptr, srv->ts_debug_str->size - 1, "%Y-%m-%d %H:%M:%S", localtime(&(srv->cur_ts)));
344: srv->ts_debug_str->used = strlen(srv->ts_debug_str->ptr) + 1;
345:
346: srv->last_generated_debug_ts = srv->cur_ts;
347: }
348:
349: buffer_copy_string_buffer(b, srv->ts_debug_str);
350: buffer_append_string_len(b, CONST_STR_LEN(": ("));
351: break;
352: case ERRORLOG_SYSLOG:
353: /* syslog is generating its own timestamps */
354: buffer_copy_string_len(b, CONST_STR_LEN("("));
355: break;
356: }
357:
358: buffer_append_string(b, filename);
359: buffer_append_string_len(b, CONST_STR_LEN("."));
360: buffer_append_long(b, line);
361: buffer_append_string_len(b, CONST_STR_LEN(") "));
362:
363: return 0;
364: }
365:
366: static void log_write(server *srv, buffer *b) {
367: switch(srv->errorlog_mode) {
368: case ERRORLOG_PIPE:
369: case ERRORLOG_FILE:
370: case ERRORLOG_FD:
371: buffer_append_string_len(b, CONST_STR_LEN("\n"));
372: write(srv->errorlog_fd, b->ptr, b->used - 1);
373: break;
374: case ERRORLOG_SYSLOG:
375: syslog(LOG_ERR, "%s", b->ptr);
376: break;
377: }
378: }
379:
380: int log_error_write(server *srv, const char *filename, unsigned int line, const char *fmt, ...) {
381: va_list ap;
382:
383: if (-1 == log_buffer_prepare(srv->errorlog_buf, srv, filename, line)) return 0;
384:
385: va_start(ap, fmt);
386: log_buffer_append_printf(srv->errorlog_buf, fmt, ap);
387: va_end(ap);
388:
389: log_write(srv, srv->errorlog_buf);
390:
391: return 0;
392: }
393:
394: int log_error_write_multiline_buffer(server *srv, const char *filename, unsigned int line, buffer *multiline, const char *fmt, ...) {
395: va_list ap;
396: size_t prefix_used;
397: buffer *b = srv->errorlog_buf;
398: char *pos, *end, *current_line;
399:
400: if (multiline->used < 2) return 0;
401:
402: if (-1 == log_buffer_prepare(b, srv, filename, line)) return 0;
403:
404: va_start(ap, fmt);
405: log_buffer_append_printf(b, fmt, ap);
406: va_end(ap);
407:
408: prefix_used = b->used;
409:
410: current_line = pos = multiline->ptr;
411: end = multiline->ptr + multiline->used;
412:
413: for ( ; pos < end ; ++pos) {
414: switch (*pos) {
415: case '\n':
416: case '\r':
417: case '\0': /* handles end of string */
418: if (current_line < pos) {
419: /* truncate to prefix */
420: b->used = prefix_used;
421: b->ptr[b->used - 1] = '\0';
422:
423: buffer_append_string_len(b, current_line, pos - current_line);
424: log_write(srv, b);
425: }
426: current_line = pos + 1;
427: break;
428: default:
429: break;
430: }
431: }
432:
433: return 0;
434: }