![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to mod_accesslog.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 mod_accesslog.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 "buffer.h"
4:
5: #include "plugin.h"
6:
7: #include "inet_ntop_cache.h"
8:
9: #include "sys-socket.h"
10:
11: #include <sys/types.h>
12: #include <sys/stat.h>
13:
14: #include <ctype.h>
15: #include <stdlib.h>
16: #include <string.h>
17: #include <fcntl.h>
18: #include <unistd.h>
19: #include <errno.h>
20: #include <time.h>
21:
22: #include <stdio.h>
23:
24: #ifdef HAVE_SYSLOG_H
25: # include <syslog.h>
26: #endif
27:
28: typedef struct {
29: char key;
30: enum {
31: FORMAT_UNSET,
32: FORMAT_UNSUPPORTED,
33: FORMAT_PERCENT,
34: FORMAT_REMOTE_HOST,
35: FORMAT_REMOTE_IDENT,
36: FORMAT_REMOTE_USER,
37: FORMAT_TIMESTAMP,
38: FORMAT_REQUEST_LINE,
39: FORMAT_STATUS,
40: FORMAT_BYTES_OUT_NO_HEADER,
41: FORMAT_HEADER,
42:
43: FORMAT_REMOTE_ADDR,
44: FORMAT_LOCAL_ADDR,
45: FORMAT_COOKIE,
46: FORMAT_TIME_USED_MS,
47: FORMAT_ENV,
48: FORMAT_FILENAME,
49: FORMAT_REQUEST_PROTOCOL,
50: FORMAT_REQUEST_METHOD,
51: FORMAT_SERVER_PORT,
52: FORMAT_QUERY_STRING,
53: FORMAT_TIME_USED,
54: FORMAT_URL,
55: FORMAT_SERVER_NAME,
56: FORMAT_HTTP_HOST,
57: FORMAT_CONNECTION_STATUS,
58: FORMAT_BYTES_IN,
59: FORMAT_BYTES_OUT,
60:
61: FORMAT_RESPONSE_HEADER
62: } type;
63: } format_mapping;
64:
65: /**
66: *
67: *
68: * "%h %l %u %t \"%r\" %>s %b \"%{Referer}i\" \"%{User-Agent}i\""
69: *
70: */
71:
72: static const format_mapping fmap[] =
73: {
74: { '%', FORMAT_PERCENT },
75: { 'h', FORMAT_REMOTE_HOST },
76: { 'l', FORMAT_REMOTE_IDENT },
77: { 'u', FORMAT_REMOTE_USER },
78: { 't', FORMAT_TIMESTAMP },
79: { 'r', FORMAT_REQUEST_LINE },
80: { 's', FORMAT_STATUS },
81: { 'b', FORMAT_BYTES_OUT_NO_HEADER },
82: { 'i', FORMAT_HEADER },
83:
84: { 'a', FORMAT_REMOTE_ADDR },
85: { 'A', FORMAT_LOCAL_ADDR },
86: { 'B', FORMAT_BYTES_OUT_NO_HEADER },
87: { 'C', FORMAT_COOKIE },
88: { 'D', FORMAT_TIME_USED_MS },
89: { 'e', FORMAT_ENV },
90: { 'f', FORMAT_FILENAME },
91: { 'H', FORMAT_REQUEST_PROTOCOL },
92: { 'm', FORMAT_REQUEST_METHOD },
93: { 'n', FORMAT_UNSUPPORTED }, /* we have no notes */
94: { 'p', FORMAT_SERVER_PORT },
95: { 'P', FORMAT_UNSUPPORTED }, /* we are only one process */
96: { 'q', FORMAT_QUERY_STRING },
97: { 'T', FORMAT_TIME_USED },
98: { 'U', FORMAT_URL }, /* w/o querystring */
99: { 'v', FORMAT_SERVER_NAME },
100: { 'V', FORMAT_HTTP_HOST },
101: { 'X', FORMAT_CONNECTION_STATUS },
102: { 'I', FORMAT_BYTES_IN },
103: { 'O', FORMAT_BYTES_OUT },
104:
105: { 'o', FORMAT_RESPONSE_HEADER },
106:
107: { '\0', FORMAT_UNSET }
108: };
109:
110:
111: typedef struct {
112: enum { FIELD_UNSET, FIELD_STRING, FIELD_FORMAT } type;
113:
114: buffer *string;
115: int field;
116: } format_field;
117:
118: typedef struct {
119: format_field **ptr;
120:
121: size_t used;
122: size_t size;
123: } format_fields;
124:
125: typedef struct {
126: buffer *access_logfile;
127: int log_access_fd;
128: buffer *access_logbuffer; /* each logfile has a separate buffer */
129:
130: unsigned short use_syslog; /* syslog has global buffer */
131: unsigned short syslog_level;
132:
133: buffer *format;
134:
135: time_t last_generated_accesslog_ts;
136: time_t *last_generated_accesslog_ts_ptr;
137:
138: buffer *ts_accesslog_str;
139: buffer *ts_accesslog_fmt_str;
140: unsigned short append_tz_offset;
141:
142: format_fields *parsed_format;
143: } plugin_config;
144:
145: typedef struct {
146: PLUGIN_DATA;
147:
148: plugin_config **config_storage;
149: plugin_config conf;
150:
151: buffer *syslog_logbuffer; /* syslog has global buffer. no caching, always written directly */
152: } plugin_data;
153:
154: INIT_FUNC(mod_accesslog_init) {
155: plugin_data *p;
156:
157: p = calloc(1, sizeof(*p));
158: p->syslog_logbuffer = buffer_init();
159:
160: return p;
161: }
162:
163: static void accesslog_append_escaped(buffer *dest, buffer *str) {
164: char *ptr, *start, *end;
165:
166: /* replaces non-printable chars with \xHH where HH is the hex representation of the byte */
167: /* exceptions: " => \", \ => \\, whitespace chars => \n \t etc. */
168: if (str->used == 0) return;
169: buffer_prepare_append(dest, str->used - 1);
170:
171: for (ptr = start = str->ptr, end = str->ptr + str->used - 1; ptr < end; ptr++) {
172: char const c = *ptr;
173: if (c >= ' ' && c <= '~' && c != '"' && c != '\\') {
174: /* nothing to change, add later as one block */
175: } else {
176: /* copy previous part */
177: if (start < ptr) {
178: buffer_append_string_len(dest, start, ptr - start);
179: }
180: start = ptr + 1;
181:
182: switch (c) {
183: case '"':
184: BUFFER_APPEND_STRING_CONST(dest, "\\\"");
185: break;
186: case '\\':
187: BUFFER_APPEND_STRING_CONST(dest, "\\\\");
188: break;
189: case '\b':
190: BUFFER_APPEND_STRING_CONST(dest, "\\b");
191: break;
192: case '\n':
193: BUFFER_APPEND_STRING_CONST(dest, "\\n");
194: break;
195: case '\r':
196: BUFFER_APPEND_STRING_CONST(dest, "\\r");
197: break;
198: case '\t':
199: BUFFER_APPEND_STRING_CONST(dest, "\\t");
200: break;
201: case '\v':
202: BUFFER_APPEND_STRING_CONST(dest, "\\v");
203: break;
204: default: {
205: /* non printable char => \xHH */
206: char hh[5] = {'\\','x',0,0,0};
207: char h = c / 16;
208: hh[2] = (h > 9) ? (h - 10 + 'A') : (h + '0');
209: h = c % 16;
210: hh[3] = (h > 9) ? (h - 10 + 'A') : (h + '0');
211: buffer_append_string_len(dest, &hh[0], 4);
212: }
213: break;
214: }
215: }
216: }
217:
218: if (start < end) {
219: buffer_append_string_len(dest, start, end - start);
220: }
221: }
222:
223: static int accesslog_parse_format(server *srv, format_fields *fields, buffer *format) {
224: size_t i, j, k = 0, start = 0;
225:
226: if (format->used == 0) return -1;
227:
228: for (i = 0; i < format->used - 1; i++) {
229: switch(format->ptr[i]) {
230: case '%':
231: if (i > 0 && start != i) {
232: /* copy the string before this % */
233: if (fields->size == 0) {
234: fields->size = 16;
235: fields->used = 0;
236: fields->ptr = malloc(fields->size * sizeof(format_field * ));
237: } else if (fields->used == fields->size) {
238: fields->size += 16;
239: fields->ptr = realloc(fields->ptr, fields->size * sizeof(format_field * ));
240: }
241:
242: fields->ptr[fields->used] = malloc(sizeof(format_field));
243: fields->ptr[fields->used]->type = FIELD_STRING;
244: fields->ptr[fields->used]->string = buffer_init();
245:
246: buffer_copy_string_len(fields->ptr[fields->used]->string, format->ptr + start, i - start);
247:
248: fields->used++;
249: }
250:
251: /* we need a new field */
252:
253: if (fields->size == 0) {
254: fields->size = 16;
255: fields->used = 0;
256: fields->ptr = malloc(fields->size * sizeof(format_field * ));
257: } else if (fields->used == fields->size) {
258: fields->size += 16;
259: fields->ptr = realloc(fields->ptr, fields->size * sizeof(format_field * ));
260: }
261:
262: /* search for the terminating command */
263: switch (format->ptr[i+1]) {
264: case '>':
265: case '<':
266: /* after the } has to be a character */
267: if (format->ptr[i+2] == '\0') {
268: log_error_write(srv, __FILE__, __LINE__, "s", "%< and %> have to be followed by a format-specifier");
269: return -1;
270: }
271:
272:
273: for (j = 0; fmap[j].key != '\0'; j++) {
274: if (fmap[j].key != format->ptr[i+2]) continue;
275:
276: /* found key */
277:
278: fields->ptr[fields->used] = malloc(sizeof(format_field));
279: fields->ptr[fields->used]->type = FIELD_FORMAT;
280: fields->ptr[fields->used]->field = fmap[j].type;
281: fields->ptr[fields->used]->string = NULL;
282:
283: fields->used++;
284:
285: break;
286: }
287:
288: if (fmap[j].key == '\0') {
289: log_error_write(srv, __FILE__, __LINE__, "s", "%< and %> have to be followed by a valid format-specifier");
290: return -1;
291: }
292:
293: start = i + 3;
294: i = start - 1; /* skip the string */
295:
296: break;
297: case '{':
298: /* go forward to } */
299:
300: for (k = i+2; k < format->used - 1; k++) {
301: if (format->ptr[k] == '}') break;
302: }
303:
304: if (k == format->used - 1) {
305: log_error_write(srv, __FILE__, __LINE__, "s", "%{ has to be terminated by a }");
306: return -1;
307: }
308:
309: /* after the } has to be a character */
310: if (format->ptr[k+1] == '\0') {
311: log_error_write(srv, __FILE__, __LINE__, "s", "%{...} has to be followed by a format-specifier");
312: return -1;
313: }
314:
315: if (k == i + 2) {
316: log_error_write(srv, __FILE__, __LINE__, "s", "%{...} has to be contain a string");
317: return -1;
318: }
319:
320: for (j = 0; fmap[j].key != '\0'; j++) {
321: if (fmap[j].key != format->ptr[k+1]) continue;
322:
323: /* found key */
324:
325: fields->ptr[fields->used] = malloc(sizeof(format_field));
326: fields->ptr[fields->used]->type = FIELD_FORMAT;
327: fields->ptr[fields->used]->field = fmap[j].type;
328: fields->ptr[fields->used]->string = buffer_init();
329:
330: buffer_copy_string_len(fields->ptr[fields->used]->string, format->ptr + i + 2, k - (i + 2));
331:
332: fields->used++;
333:
334: break;
335: }
336:
337: if (fmap[j].key == '\0') {
338: log_error_write(srv, __FILE__, __LINE__, "s", "%{...} has to be followed by a valid format-specifier");
339: return -1;
340: }
341:
342: start = k + 2;
343: i = start - 1; /* skip the string */
344:
345: break;
346: default:
347: /* after the % has to be a character */
348: if (format->ptr[i+1] == '\0') {
349: log_error_write(srv, __FILE__, __LINE__, "s", "% has to be followed by a format-specifier");
350: return -1;
351: }
352:
353: for (j = 0; fmap[j].key != '\0'; j++) {
354: if (fmap[j].key != format->ptr[i+1]) continue;
355:
356: /* found key */
357:
358: fields->ptr[fields->used] = malloc(sizeof(format_field));
359: fields->ptr[fields->used]->type = FIELD_FORMAT;
360: fields->ptr[fields->used]->field = fmap[j].type;
361: fields->ptr[fields->used]->string = NULL;
362:
363: fields->used++;
364:
365: break;
366: }
367:
368: if (fmap[j].key == '\0') {
369: log_error_write(srv, __FILE__, __LINE__, "s", "% has to be followed by a valid format-specifier");
370: return -1;
371: }
372:
373: start = i + 2;
374: i = start - 1; /* skip the string */
375:
376: break;
377: }
378:
379: break;
380: }
381: }
382:
383: if (start < i) {
384: /* copy the string */
385: if (fields->size == 0) {
386: fields->size = 16;
387: fields->used = 0;
388: fields->ptr = malloc(fields->size * sizeof(format_field * ));
389: } else if (fields->used == fields->size) {
390: fields->size += 16;
391: fields->ptr = realloc(fields->ptr, fields->size * sizeof(format_field * ));
392: }
393:
394: fields->ptr[fields->used] = malloc(sizeof(format_field));
395: fields->ptr[fields->used]->type = FIELD_STRING;
396: fields->ptr[fields->used]->string = buffer_init();
397:
398: buffer_copy_string_len(fields->ptr[fields->used]->string, format->ptr + start, i - start);
399:
400: fields->used++;
401: }
402:
403: return 0;
404: }
405:
406: FREE_FUNC(mod_accesslog_free) {
407: plugin_data *p = p_d;
408: size_t i;
409:
410: if (!p) return HANDLER_GO_ON;
411:
412: if (p->config_storage) {
413:
414: for (i = 0; i < srv->config_context->used; i++) {
415: plugin_config *s = p->config_storage[i];
416:
417: if (!s) continue;
418:
419: if (s->access_logbuffer->used) {
420: if (s->log_access_fd != -1) {
421: write(s->log_access_fd, s->access_logbuffer->ptr, s->access_logbuffer->used - 1);
422: }
423: }
424:
425: if (s->log_access_fd != -1) close(s->log_access_fd);
426:
427: buffer_free(s->ts_accesslog_str);
428: buffer_free(s->ts_accesslog_fmt_str);
429: buffer_free(s->access_logbuffer);
430: buffer_free(s->format);
431: buffer_free(s->access_logfile);
432:
433: if (s->parsed_format) {
434: size_t j;
435: for (j = 0; j < s->parsed_format->used; j++) {
436: if (s->parsed_format->ptr[j]->string) buffer_free(s->parsed_format->ptr[j]->string);
437: free(s->parsed_format->ptr[j]);
438: }
439: free(s->parsed_format->ptr);
440: free(s->parsed_format);
441: }
442:
443: free(s);
444: }
445:
446: free(p->config_storage);
447: }
448:
449: free(p);
450: if (p->syslog_logbuffer) buffer_free(p->syslog_logbuffer);
451:
452: return HANDLER_GO_ON;
453: }
454:
455: SETDEFAULTS_FUNC(log_access_open) {
456: plugin_data *p = p_d;
457: size_t i = 0;
458:
459: config_values_t cv[] = {
460: { "accesslog.filename", NULL, T_CONFIG_STRING, T_CONFIG_SCOPE_CONNECTION },
461: { "accesslog.use-syslog", NULL, T_CONFIG_BOOLEAN, T_CONFIG_SCOPE_CONNECTION },
462: { "accesslog.format", NULL, T_CONFIG_STRING, T_CONFIG_SCOPE_CONNECTION },
463: { "accesslog.syslog-level", NULL, T_CONFIG_SHORT, T_CONFIG_SCOPE_CONNECTION },
464: { NULL, NULL, T_CONFIG_UNSET, T_CONFIG_SCOPE_UNSET }
465: };
466:
467: if (!p) return HANDLER_ERROR;
468:
469: p->config_storage = calloc(1, srv->config_context->used * sizeof(specific_config *));
470:
471: for (i = 0; i < srv->config_context->used; i++) {
472: plugin_config *s;
473:
474: s = calloc(1, sizeof(plugin_config));
475: s->access_logfile = buffer_init();
476: s->format = buffer_init();
477: s->access_logbuffer = buffer_init();
478: s->ts_accesslog_str = buffer_init();
479: s->ts_accesslog_fmt_str = buffer_init();
480: s->log_access_fd = -1;
481: s->last_generated_accesslog_ts = 0;
482: s->last_generated_accesslog_ts_ptr = &(s->last_generated_accesslog_ts);
483: s->syslog_level = LOG_INFO;
484:
485:
486: cv[0].destination = s->access_logfile;
487: cv[1].destination = &(s->use_syslog);
488: cv[2].destination = s->format;
489: cv[3].destination = &(s->syslog_level);
490:
491: p->config_storage[i] = s;
492:
493: if (0 != config_insert_values_global(srv, ((data_config *)srv->config_context->data[i])->value, cv)) {
494: return HANDLER_ERROR;
495: }
496:
497: if (i == 0 && buffer_is_empty(s->format)) {
498: /* set a default logfile string */
499:
500: buffer_copy_string_len(s->format, CONST_STR_LEN("%h %V %u %t \"%r\" %>s %b \"%{Referer}i\" \"%{User-Agent}i\""));
501: }
502:
503: /* parse */
504:
505: if (s->format->used) {
506: size_t j, count;
507:
508: s->parsed_format = calloc(1, sizeof(*(s->parsed_format)));
509:
510: if (-1 == accesslog_parse_format(srv, s->parsed_format, s->format)) {
511:
512: log_error_write(srv, __FILE__, __LINE__, "sb",
513: "parsing accesslog-definition failed:", s->format);
514:
515: return HANDLER_ERROR;
516: }
517:
518: /* make sure they didn't try to send the timestamp in twice...
519: * also, save the format string in a different variable (this
520: * will save a few conditionals later)
521: */
522: count = 0;
523: for (j = 0; j < s->parsed_format->used; j++) {
524: if (FIELD_FORMAT == s->parsed_format->ptr[j]->type) {
525: if (FORMAT_TIMESTAMP == s->parsed_format->ptr[j]->field) {
526: if (!buffer_is_empty(s->parsed_format->ptr[j]->string)) {
527: buffer_copy_string(s->ts_accesslog_fmt_str, s->parsed_format->ptr[j]->string->ptr);
528: }
529:
530: if (++count > 1) {
531: log_error_write(srv, __FILE__, __LINE__, "sb",
532: "you may not use the timestamp twice in the same access log:", s->format);
533:
534: return HANDLER_ERROR;
535: }
536: }
537: }
538: }
539:
540: #if 0
541: /* debugging */
542: for (j = 0; j < s->parsed_format->used; j++) {
543: switch (s->parsed_format->ptr[j]->type) {
544: case FIELD_FORMAT:
545: log_error_write(srv, __FILE__, __LINE__, "ssds",
546: "config:", "format", s->parsed_format->ptr[j]->field,
547: s->parsed_format->ptr[j]->string ?
548: s->parsed_format->ptr[j]->string->ptr : "" );
549: break;
550: case FIELD_STRING:
551: log_error_write(srv, __FILE__, __LINE__, "ssbs", "config:", "string '", s->parsed_format->ptr[j]->string, "'");
552: break;
553: default:
554: break;
555: }
556: }
557: #endif
558: }
559:
560: s->append_tz_offset = 0;
561: if (buffer_is_empty(s->ts_accesslog_fmt_str)) {
562: #if defined(HAVE_STRUCT_TM_GMTOFF)
563: BUFFER_COPY_STRING_CONST(s->ts_accesslog_fmt_str, "[%d/%b/%Y:%H:%M:%S ");
564: s->append_tz_offset = 1;
565: #else
566: BUFFER_COPY_STRING_CONST(s->ts_accesslog_fmt_str, "[%d/%b/%Y:%H:%M:%S +0000]");
567: #endif
568: }
569:
570: if (s->use_syslog) {
571: /* ignore the next checks */
572: continue;
573: }
574:
575: if (s->access_logfile->used < 2) continue;
576:
577: if (-1 == (s->log_access_fd = open_logfile_or_pipe(srv, s->access_logfile->ptr)))
578: return HANDLER_ERROR;
579:
580: }
581:
582: return HANDLER_GO_ON;
583: }
584:
585: SIGHUP_FUNC(log_access_cycle) {
586: plugin_data *p = p_d;
587: size_t i;
588:
589: if (!p->config_storage) return HANDLER_GO_ON;
590:
591: for (i = 0; i < srv->config_context->used; i++) {
592: plugin_config *s = p->config_storage[i];
593:
594: if (s->access_logbuffer->used) {
595: if (s->log_access_fd != -1) {
596: write(s->log_access_fd, s->access_logbuffer->ptr, s->access_logbuffer->used - 1);
597: }
598:
599: buffer_reset(s->access_logbuffer);
600: }
601:
602: if (s->use_syslog == 0 &&
603: s->access_logfile->used > 1 &&
604: s->access_logfile->ptr[0] != '|') {
605:
606: close(s->log_access_fd);
607:
608: if (-1 == (s->log_access_fd =
609: open(s->access_logfile->ptr, O_APPEND | O_WRONLY | O_CREAT | O_LARGEFILE, 0644))) {
610:
611: log_error_write(srv, __FILE__, __LINE__, "ss", "cycling access-log failed:", strerror(errno));
612:
613: return HANDLER_ERROR;
614: }
615: #ifdef FD_CLOEXEC
616: fcntl(s->log_access_fd, F_SETFD, FD_CLOEXEC);
617: #endif
618: }
619: }
620:
621: return HANDLER_GO_ON;
622: }
623:
624: #define PATCH(x) \
625: p->conf.x = s->x;
626: static int mod_accesslog_patch_connection(server *srv, connection *con, plugin_data *p) {
627: size_t i, j;
628: plugin_config *s = p->config_storage[0];
629:
630: PATCH(access_logfile);
631: PATCH(format);
632: PATCH(log_access_fd);
633: PATCH(last_generated_accesslog_ts_ptr);
634: PATCH(access_logbuffer);
635: PATCH(ts_accesslog_str);
636: PATCH(ts_accesslog_fmt_str);
637: PATCH(append_tz_offset);
638: PATCH(parsed_format);
639: PATCH(use_syslog);
640: PATCH(syslog_level);
641:
642: /* skip the first, the global context */
643: for (i = 1; i < srv->config_context->used; i++) {
644: data_config *dc = (data_config *)srv->config_context->data[i];
645: s = p->config_storage[i];
646:
647: /* condition didn't match */
648: if (!config_check_cond(srv, con, dc)) continue;
649:
650: /* merge config */
651: for (j = 0; j < dc->value->used; j++) {
652: data_unset *du = dc->value->data[j];
653:
654: if (buffer_is_equal_string(du->key, CONST_STR_LEN("accesslog.filename"))) {
655: PATCH(access_logfile);
656: PATCH(log_access_fd);
657: PATCH(access_logbuffer);
658: } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("accesslog.format"))) {
659: PATCH(format);
660: PATCH(parsed_format);
661: PATCH(last_generated_accesslog_ts_ptr);
662: PATCH(ts_accesslog_str);
663: PATCH(ts_accesslog_fmt_str);
664: PATCH(append_tz_offset);
665: } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("accesslog.use-syslog"))) {
666: PATCH(use_syslog);
667: } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("accesslog.syslog-level"))) {
668: PATCH(syslog_level);
669: }
670: }
671: }
672:
673: return 0;
674: }
675: #undef PATCH
676:
677: REQUESTDONE_FUNC(log_access_write) {
678: plugin_data *p = p_d;
679: buffer *b;
680: size_t j;
681:
682: int newts = 0;
683: data_string *ds;
684:
685: mod_accesslog_patch_connection(srv, con, p);
686:
687: /* No output device, nothing to do */
688: if (!p->conf.use_syslog && p->conf.log_access_fd == -1) return HANDLER_GO_ON;
689:
690: if (p->conf.use_syslog) {
691: b = p->syslog_logbuffer;
692: } else {
693: b = p->conf.access_logbuffer;
694: }
695:
696: if (b->used == 0) {
697: buffer_copy_string_len(b, CONST_STR_LEN(""));
698: }
699:
700: for (j = 0; j < p->conf.parsed_format->used; j++) {
701: switch(p->conf.parsed_format->ptr[j]->type) {
702: case FIELD_STRING:
703: buffer_append_string_buffer(b, p->conf.parsed_format->ptr[j]->string);
704: break;
705: case FIELD_FORMAT:
706: switch(p->conf.parsed_format->ptr[j]->field) {
707: case FORMAT_TIMESTAMP:
708:
709: /* cache the generated timestamp */
710: if (srv->cur_ts != *(p->conf.last_generated_accesslog_ts_ptr)) {
711: struct tm tm;
712: #if defined(HAVE_STRUCT_TM_GMTOFF)
713: long scd, hrs, min;
714: #endif
715:
716: buffer_prepare_copy(p->conf.ts_accesslog_str, 255);
717: #if defined(HAVE_STRUCT_TM_GMTOFF)
718: # ifdef HAVE_LOCALTIME_R
719: localtime_r(&(srv->cur_ts), &tm);
720: strftime(p->conf.ts_accesslog_str->ptr, p->conf.ts_accesslog_str->size - 1, p->conf.ts_accesslog_fmt_str->ptr, &tm);
721: # else /* HAVE_LOCALTIME_R */
722: strftime(p->conf.ts_accesslog_str->ptr, p->conf.ts_accesslog_str->size - 1, p->conf.ts_accesslog_fmt_str->ptr, localtime_r(&(srv->cur_ts)));
723: # endif /* HAVE_LOCALTIME_R */
724: p->conf.ts_accesslog_str->used = strlen(p->conf.ts_accesslog_str->ptr) + 1;
725:
726: if (p->conf.append_tz_offset) {
727: buffer_append_string_len(p->conf.ts_accesslog_str, tm.tm_gmtoff >= 0 ? "+" : "-", 1);
728:
729: scd = abs(tm.tm_gmtoff);
730: hrs = scd / 3600;
731: min = (scd % 3600) / 60;
732:
733: /* hours */
734: if (hrs < 10) buffer_append_string_len(p->conf.ts_accesslog_str, CONST_STR_LEN("0"));
735: buffer_append_long(p->conf.ts_accesslog_str, hrs);
736:
737: if (min < 10) buffer_append_string_len(p->conf.ts_accesslog_str, CONST_STR_LEN("0"));
738: buffer_append_long(p->conf.ts_accesslog_str, min);
739: buffer_append_string_len(p->conf.ts_accesslog_str, CONST_STR_LEN("]"));
740: }
741: #else /* HAVE_STRUCT_TM_GMTOFF */
742: # ifdef HAVE_GMTIME_R
743: gmtime_r(&(srv->cur_ts), &tm);
744: strftime(p->conf.ts_accesslog_str->ptr, p->conf.ts_accesslog_str->size - 1, p->conf.ts_accesslog_fmt_str->ptr, &tm);
745: # else /* HAVE_GMTIME_R */
746: strftime(p->conf.ts_accesslog_str->ptr, p->conf.ts_accesslog_str->size - 1, p->conf.ts_accesslog_fmt_str->ptr, gmtime(&(srv->cur_ts)));
747: # endif /* HAVE_GMTIME_R */
748: p->conf.ts_accesslog_str->used = strlen(p->conf.ts_accesslog_str->ptr) + 1;
749: #endif /* HAVE_STRUCT_TM_GMTOFF */
750:
751: *(p->conf.last_generated_accesslog_ts_ptr) = srv->cur_ts;
752: newts = 1;
753: }
754:
755: buffer_append_string_buffer(b, p->conf.ts_accesslog_str);
756:
757: break;
758: case FORMAT_REMOTE_HOST:
759:
760: /* handle inet_ntop cache */
761:
762: buffer_append_string(b, inet_ntop_cache_get_ip(srv, &(con->dst_addr)));
763:
764: break;
765: case FORMAT_REMOTE_IDENT:
766: /* ident */
767: buffer_append_string_len(b, CONST_STR_LEN("-"));
768: break;
769: case FORMAT_REMOTE_USER:
770: if (NULL != (ds = (data_string *)array_get_element(con->environment, "REMOTE_USER")) && ds->value->used > 1) {
771: accesslog_append_escaped(b, ds->value);
772: } else {
773: buffer_append_string_len(b, CONST_STR_LEN("-"));
774: }
775: break;
776: case FORMAT_REQUEST_LINE:
777: if (con->request.request_line->used) {
778: accesslog_append_escaped(b, con->request.request_line);
779: }
780: break;
781: case FORMAT_STATUS:
782: buffer_append_long(b, con->http_status);
783: break;
784:
785: case FORMAT_BYTES_OUT_NO_HEADER:
786: if (con->bytes_written > 0) {
787: buffer_append_off_t(b,
788: con->bytes_written - con->bytes_header <= 0 ? 0 : con->bytes_written - con->bytes_header);
789: } else {
790: buffer_append_string_len(b, CONST_STR_LEN("-"));
791: }
792: break;
793: case FORMAT_HEADER:
794: if (NULL != (ds = (data_string *)array_get_element(con->request.headers, p->conf.parsed_format->ptr[j]->string->ptr))) {
795: accesslog_append_escaped(b, ds->value);
796: } else {
797: buffer_append_string_len(b, CONST_STR_LEN("-"));
798: }
799: break;
800: case FORMAT_RESPONSE_HEADER:
801: if (NULL != (ds = (data_string *)array_get_element(con->response.headers, p->conf.parsed_format->ptr[j]->string->ptr))) {
802: accesslog_append_escaped(b, ds->value);
803: } else {
804: buffer_append_string_len(b, CONST_STR_LEN("-"));
805: }
806: break;
807: case FORMAT_ENV:
808: if (NULL != (ds = (data_string *)array_get_element(con->environment, p->conf.parsed_format->ptr[j]->string->ptr))) {
809: accesslog_append_escaped(b, ds->value);
810: } else {
811: buffer_append_string_len(b, CONST_STR_LEN("-"));
812: }
813: break;
814: case FORMAT_FILENAME:
815: if (con->physical.path->used > 1) {
816: buffer_append_string_buffer(b, con->physical.path);
817: } else {
818: buffer_append_string_len(b, CONST_STR_LEN("-"));
819: }
820: break;
821: case FORMAT_BYTES_OUT:
822: if (con->bytes_written > 0) {
823: buffer_append_off_t(b, con->bytes_written);
824: } else {
825: buffer_append_string_len(b, CONST_STR_LEN("-"));
826: }
827: break;
828: case FORMAT_BYTES_IN:
829: if (con->bytes_read > 0) {
830: buffer_append_off_t(b, con->bytes_read);
831: } else {
832: buffer_append_string_len(b, CONST_STR_LEN("-"));
833: }
834: break;
835: case FORMAT_TIME_USED:
836: buffer_append_long(b, srv->cur_ts - con->request_start);
837: break;
838: case FORMAT_SERVER_NAME:
839: if (con->server_name->used > 1) {
840: buffer_append_string_buffer(b, con->server_name);
841: } else {
842: buffer_append_string_len(b, CONST_STR_LEN("-"));
843: }
844: break;
845: case FORMAT_HTTP_HOST:
846: if (con->uri.authority->used > 1) {
847: accesslog_append_escaped(b, con->uri.authority);
848: } else {
849: buffer_append_string_len(b, CONST_STR_LEN("-"));
850: }
851: break;
852: case FORMAT_REQUEST_PROTOCOL:
853: buffer_append_string_len(b,
854: con->request.http_version == HTTP_VERSION_1_1 ? "HTTP/1.1" : "HTTP/1.0", 8);
855: break;
856: case FORMAT_REQUEST_METHOD:
857: buffer_append_string(b, get_http_method_name(con->request.http_method));
858: break;
859: case FORMAT_PERCENT:
860: buffer_append_string_len(b, CONST_STR_LEN("%"));
861: break;
862: case FORMAT_SERVER_PORT:
863: {
864: const char *colon;
865: buffer *srvtoken = ((server_socket*)(con->srv_socket))->srv_token;
866: if (srvtoken->ptr[0] == '[') {
867: colon = strstr(srvtoken->ptr, "]:");
868: } else {
869: colon = strchr(srvtoken->ptr, ':');
870: }
871: if (colon) {
872: buffer_append_string(b, colon+1);
873: } else {
874: buffer_append_long(b, srv->srvconf.port);
875: }
876: }
877: break;
878: case FORMAT_QUERY_STRING:
879: accesslog_append_escaped(b, con->uri.query);
880: break;
881: case FORMAT_URL:
882: accesslog_append_escaped(b, con->uri.path_raw);
883: break;
884: case FORMAT_CONNECTION_STATUS:
885: switch(con->keep_alive) {
886: case 0: buffer_append_string_len(b, CONST_STR_LEN("-")); break;
887: default: buffer_append_string_len(b, CONST_STR_LEN("+")); break;
888: }
889: break;
890: default:
891: /*
892: { 'a', FORMAT_REMOTE_ADDR },
893: { 'A', FORMAT_LOCAL_ADDR },
894: { 'C', FORMAT_COOKIE },
895: { 'D', FORMAT_TIME_USED_MS },
896: */
897:
898: break;
899: }
900: break;
901: default:
902: break;
903: }
904: }
905:
906: buffer_append_string_len(b, CONST_STR_LEN("\n"));
907:
908: if (p->conf.use_syslog || /* syslog doesn't cache */
909: (p->conf.access_logfile->used && p->conf.access_logfile->ptr[0] == '|') || /* pipes don't cache */
910: newts ||
911: b->used > BUFFER_MAX_REUSE_SIZE) {
912: if (p->conf.use_syslog) {
913: #ifdef HAVE_SYSLOG_H
914: if (b->used > 2) {
915: /* syslog appends a \n on its own */
916: syslog(p->conf.syslog_level, "%*s", (int) b->used - 2, b->ptr);
917: }
918: #endif
919: } else if (p->conf.log_access_fd != -1) {
920: write(p->conf.log_access_fd, b->ptr, b->used - 1);
921: }
922: buffer_reset(b);
923: }
924:
925: return HANDLER_GO_ON;
926: }
927:
928:
929: int mod_accesslog_plugin_init(plugin *p);
930: int mod_accesslog_plugin_init(plugin *p) {
931: p->version = LIGHTTPD_VERSION_ID;
932: p->name = buffer_init_string("accesslog");
933:
934: p->init = mod_accesslog_init;
935: p->set_defaults= log_access_open;
936: p->cleanup = mod_accesslog_free;
937:
938: p->handle_request_done = log_access_write;
939: p->handle_sighup = log_access_cycle;
940:
941: p->data = NULL;
942:
943: return 0;
944: }