![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ngx_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 / nginx / src / core|
Return to ngx_log.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / nginx / src / core |
1.1 misho 1:
2: /*
3: * Copyright (C) Igor Sysoev
4: * Copyright (C) Nginx, Inc.
5: */
6:
7:
8: #include <ngx_config.h>
9: #include <ngx_core.h>
10:
11:
12: static char *ngx_error_log(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
13:
14:
15: static ngx_command_t ngx_errlog_commands[] = {
16:
17: {ngx_string("error_log"),
18: NGX_MAIN_CONF|NGX_CONF_1MORE,
19: ngx_error_log,
20: 0,
21: 0,
22: NULL},
23:
24: ngx_null_command
25: };
26:
27:
28: static ngx_core_module_t ngx_errlog_module_ctx = {
29: ngx_string("errlog"),
30: NULL,
31: NULL
32: };
33:
34:
35: ngx_module_t ngx_errlog_module = {
36: NGX_MODULE_V1,
37: &ngx_errlog_module_ctx, /* module context */
38: ngx_errlog_commands, /* module directives */
39: NGX_CORE_MODULE, /* module type */
40: NULL, /* init master */
41: NULL, /* init module */
42: NULL, /* init process */
43: NULL, /* init thread */
44: NULL, /* exit thread */
45: NULL, /* exit process */
46: NULL, /* exit master */
47: NGX_MODULE_V1_PADDING
48: };
49:
50:
51: static ngx_log_t ngx_log;
52: static ngx_open_file_t ngx_log_file;
53: ngx_uint_t ngx_use_stderr = 1;
54:
55:
56: static ngx_str_t err_levels[] = {
57: ngx_null_string,
58: ngx_string("emerg"),
59: ngx_string("alert"),
60: ngx_string("crit"),
61: ngx_string("error"),
62: ngx_string("warn"),
63: ngx_string("notice"),
64: ngx_string("info"),
65: ngx_string("debug")
66: };
67:
68: static const char *debug_levels[] = {
69: "debug_core", "debug_alloc", "debug_mutex", "debug_event",
70: "debug_http", "debug_mail", "debug_mysql"
71: };
72:
73:
74: #if (NGX_HAVE_VARIADIC_MACROS)
75:
76: void
77: ngx_log_error_core(ngx_uint_t level, ngx_log_t *log, ngx_err_t err,
78: const char *fmt, ...)
79:
80: #else
81:
82: void
83: ngx_log_error_core(ngx_uint_t level, ngx_log_t *log, ngx_err_t err,
84: const char *fmt, va_list args)
85:
86: #endif
87: {
88: #if (NGX_HAVE_VARIADIC_MACROS)
89: va_list args;
90: #endif
91: u_char *p, *last, *msg;
92: u_char errstr[NGX_MAX_ERROR_STR];
93:
94: if (log->file->fd == NGX_INVALID_FILE) {
95: return;
96: }
97:
98: last = errstr + NGX_MAX_ERROR_STR;
99:
100: ngx_memcpy(errstr, ngx_cached_err_log_time.data,
101: ngx_cached_err_log_time.len);
102:
103: p = errstr + ngx_cached_err_log_time.len;
104:
105: p = ngx_slprintf(p, last, " [%V] ", &err_levels[level]);
106:
107: /* pid#tid */
108: p = ngx_slprintf(p, last, "%P#" NGX_TID_T_FMT ": ",
109: ngx_log_pid, ngx_log_tid);
110:
111: if (log->connection) {
112: p = ngx_slprintf(p, last, "*%uA ", log->connection);
113: }
114:
115: msg = p;
116:
117: #if (NGX_HAVE_VARIADIC_MACROS)
118:
119: va_start(args, fmt);
120: p = ngx_vslprintf(p, last, fmt, args);
121: va_end(args);
122:
123: #else
124:
125: p = ngx_vslprintf(p, last, fmt, args);
126:
127: #endif
128:
129: if (err) {
130: p = ngx_log_errno(p, last, err);
131: }
132:
133: if (level != NGX_LOG_DEBUG && log->handler) {
134: p = log->handler(log, p, last - p);
135: }
136:
137: if (p > last - NGX_LINEFEED_SIZE) {
138: p = last - NGX_LINEFEED_SIZE;
139: }
140:
141: ngx_linefeed(p);
142:
143: (void) ngx_write_fd(log->file->fd, errstr, p - errstr);
144:
145: if (!ngx_use_stderr
146: || level > NGX_LOG_WARN
147: || log->file->fd == ngx_stderr)
148: {
149: return;
150: }
151:
152: msg -= (7 + err_levels[level].len + 3);
153:
154: (void) ngx_sprintf(msg, "nginx: [%V] ", &err_levels[level]);
155:
156: (void) ngx_write_console(ngx_stderr, msg, p - msg);
157: }
158:
159:
160: #if !(NGX_HAVE_VARIADIC_MACROS)
161:
162: void ngx_cdecl
163: ngx_log_error(ngx_uint_t level, ngx_log_t *log, ngx_err_t err,
164: const char *fmt, ...)
165: {
166: va_list args;
167:
168: if (log->log_level >= level) {
169: va_start(args, fmt);
170: ngx_log_error_core(level, log, err, fmt, args);
171: va_end(args);
172: }
173: }
174:
175:
176: void ngx_cdecl
177: ngx_log_debug_core(ngx_log_t *log, ngx_err_t err, const char *fmt, ...)
178: {
179: va_list args;
180:
181: va_start(args, fmt);
182: ngx_log_error_core(NGX_LOG_DEBUG, log, err, fmt, args);
183: va_end(args);
184: }
185:
186: #endif
187:
188:
189: void ngx_cdecl
190: ngx_log_abort(ngx_err_t err, const char *fmt, ...)
191: {
192: u_char *p;
193: va_list args;
194: u_char errstr[NGX_MAX_CONF_ERRSTR];
195:
196: va_start(args, fmt);
197: p = ngx_vsnprintf(errstr, sizeof(errstr) - 1, fmt, args);
198: va_end(args);
199:
200: ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, err,
201: "%*s", p - errstr, errstr);
202: }
203:
204:
205: void ngx_cdecl
206: ngx_log_stderr(ngx_err_t err, const char *fmt, ...)
207: {
208: u_char *p, *last;
209: va_list args;
210: u_char errstr[NGX_MAX_ERROR_STR];
211:
212: last = errstr + NGX_MAX_ERROR_STR;
213: p = errstr + 7;
214:
215: ngx_memcpy(errstr, "nginx: ", 7);
216:
217: va_start(args, fmt);
218: p = ngx_vslprintf(p, last, fmt, args);
219: va_end(args);
220:
221: if (err) {
222: p = ngx_log_errno(p, last, err);
223: }
224:
225: if (p > last - NGX_LINEFEED_SIZE) {
226: p = last - NGX_LINEFEED_SIZE;
227: }
228:
229: ngx_linefeed(p);
230:
231: (void) ngx_write_console(ngx_stderr, errstr, p - errstr);
232: }
233:
234:
235: u_char *
236: ngx_log_errno(u_char *buf, u_char *last, ngx_err_t err)
237: {
238: if (buf > last - 50) {
239:
240: /* leave a space for an error code */
241:
242: buf = last - 50;
243: *buf++ = '.';
244: *buf++ = '.';
245: *buf++ = '.';
246: }
247:
248: #if (NGX_WIN32)
249: buf = ngx_slprintf(buf, last, ((unsigned) err < 0x80000000)
250: ? " (%d: " : " (%Xd: ", err);
251: #else
252: buf = ngx_slprintf(buf, last, " (%d: ", err);
253: #endif
254:
255: buf = ngx_strerror(err, buf, last - buf);
256:
257: if (buf < last) {
258: *buf++ = ')';
259: }
260:
261: return buf;
262: }
263:
264:
265: ngx_log_t *
266: ngx_log_init(u_char *prefix)
267: {
268: u_char *p, *name;
269: size_t nlen, plen;
270:
271: ngx_log.file = &ngx_log_file;
272: ngx_log.log_level = NGX_LOG_NOTICE;
273:
274: name = (u_char *) NGX_ERROR_LOG_PATH;
275:
276: /*
277: * we use ngx_strlen() here since BCC warns about
278: * condition is always false and unreachable code
279: */
280:
281: nlen = ngx_strlen(name);
282:
283: if (nlen == 0) {
284: ngx_log_file.fd = ngx_stderr;
285: return &ngx_log;
286: }
287:
288: p = NULL;
289:
290: #if (NGX_WIN32)
291: if (name[1] != ':') {
292: #else
293: if (name[0] != '/') {
294: #endif
295:
296: if (prefix) {
297: plen = ngx_strlen(prefix);
298:
299: } else {
300: #ifdef NGX_PREFIX
301: prefix = (u_char *) NGX_PREFIX;
302: plen = ngx_strlen(prefix);
303: #else
304: plen = 0;
305: #endif
306: }
307:
308: if (plen) {
309: name = malloc(plen + nlen + 2);
310: if (name == NULL) {
311: return NULL;
312: }
313:
314: p = ngx_cpymem(name, prefix, plen);
315:
316: if (!ngx_path_separator(*(p - 1))) {
317: *p++ = '/';
318: }
319:
320: ngx_cpystrn(p, (u_char *) NGX_ERROR_LOG_PATH, nlen + 1);
321:
322: p = name;
323: }
324: }
325:
326: ngx_log_file.fd = ngx_open_file(name, NGX_FILE_APPEND,
327: NGX_FILE_CREATE_OR_OPEN,
328: NGX_FILE_DEFAULT_ACCESS);
329:
330: if (ngx_log_file.fd == NGX_INVALID_FILE) {
331: ngx_log_stderr(ngx_errno,
332: "[alert] could not open error log file: "
333: ngx_open_file_n " \"%s\" failed", name);
334: #if (NGX_WIN32)
335: ngx_event_log(ngx_errno,
336: "could not open error log file: "
337: ngx_open_file_n " \"%s\" failed", name);
338: #endif
339:
340: ngx_log_file.fd = ngx_stderr;
341: }
342:
343: if (p) {
344: ngx_free(p);
345: }
346:
347: return &ngx_log;
348: }
349:
350:
351: ngx_log_t *
352: ngx_log_create(ngx_cycle_t *cycle, ngx_str_t *name)
353: {
354: ngx_log_t *log;
355:
356: log = ngx_pcalloc(cycle->pool, sizeof(ngx_log_t));
357: if (log == NULL) {
358: return NULL;
359: }
360:
361: log->file = ngx_conf_open_file(cycle, name);
362: if (log->file == NULL) {
363: return NULL;
364: }
365:
366: return log;
367: }
368:
369:
370: char *
371: ngx_log_set_levels(ngx_conf_t *cf, ngx_log_t *log)
372: {
373: ngx_uint_t i, n, d, found;
374: ngx_str_t *value;
375:
376: value = cf->args->elts;
377:
378: for (i = 2; i < cf->args->nelts; i++) {
379: found = 0;
380:
381: for (n = 1; n <= NGX_LOG_DEBUG; n++) {
382: if (ngx_strcmp(value[i].data, err_levels[n].data) == 0) {
383:
384: if (log->log_level != 0) {
385: ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
386: "duplicate log level \"%V\"",
387: &value[i]);
388: return NGX_CONF_ERROR;
389: }
390:
391: log->log_level = n;
392: found = 1;
393: break;
394: }
395: }
396:
397: for (n = 0, d = NGX_LOG_DEBUG_FIRST; d <= NGX_LOG_DEBUG_LAST; d <<= 1) {
398: if (ngx_strcmp(value[i].data, debug_levels[n++]) == 0) {
399: if (log->log_level & ~NGX_LOG_DEBUG_ALL) {
400: ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
401: "invalid log level \"%V\"",
402: &value[i]);
403: return NGX_CONF_ERROR;
404: }
405:
406: log->log_level |= d;
407: found = 1;
408: break;
409: }
410: }
411:
412:
413: if (!found) {
414: ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
415: "invalid log level \"%V\"", &value[i]);
416: return NGX_CONF_ERROR;
417: }
418: }
419:
420: if (log->log_level == NGX_LOG_DEBUG) {
421: log->log_level = NGX_LOG_DEBUG_ALL;
422: }
423:
424: return NGX_CONF_OK;
425: }
426:
427:
428: static char *
429: ngx_error_log(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
430: {
431: ngx_str_t *value, name;
432:
433: if (cf->cycle->new_log.file) {
434: return "is duplicate";
435: }
436:
437: value = cf->args->elts;
438:
439: if (ngx_strcmp(value[1].data, "stderr") == 0) {
440: ngx_str_null(&name);
441:
442: } else {
443: name = value[1];
444: }
445:
446: cf->cycle->new_log.file = ngx_conf_open_file(cf->cycle, &name);
447: if (cf->cycle->new_log.file == NULL) {
448: return NULL;
449: }
450:
451: if (cf->args->nelts == 2) {
452: cf->cycle->new_log.log_level = NGX_LOG_ERR;
453: return NGX_CONF_OK;
454: }
455:
456: cf->cycle->new_log.log_level = 0;
457:
458: return ngx_log_set_levels(cf, &cf->cycle->new_log);
459: }