| |
| /* |
| * Copyright (C) Igor Sysoev |
| * Copyright (C) Nginx, Inc. |
| */ |
| |
| |
| #include <ngx_config.h> |
| #include <ngx_core.h> |
| |
| |
| static char *ngx_error_log(ngx_conf_t *cf, ngx_command_t *cmd, void *conf); |
| static char *ngx_log_set_levels(ngx_conf_t *cf, ngx_log_t *log); |
| static void ngx_log_insert(ngx_log_t *log, ngx_log_t *new_log); |
| |
| |
| static ngx_command_t ngx_errlog_commands[] = { |
| |
| {ngx_string("error_log"), |
| NGX_MAIN_CONF|NGX_CONF_1MORE, |
| ngx_error_log, |
| 0, |
| 0, |
| NULL}, |
| |
| ngx_null_command |
| }; |
| |
| |
| static ngx_core_module_t ngx_errlog_module_ctx = { |
| ngx_string("errlog"), |
| NULL, |
| NULL |
| }; |
| |
| |
| ngx_module_t ngx_errlog_module = { |
| NGX_MODULE_V1, |
| &ngx_errlog_module_ctx, /* module context */ |
| ngx_errlog_commands, /* module directives */ |
| NGX_CORE_MODULE, /* module type */ |
| NULL, /* init master */ |
| NULL, /* init module */ |
| NULL, /* init process */ |
| NULL, /* init thread */ |
| NULL, /* exit thread */ |
| NULL, /* exit process */ |
| NULL, /* exit master */ |
| NGX_MODULE_V1_PADDING |
| }; |
| |
| |
| static ngx_log_t ngx_log; |
| static ngx_open_file_t ngx_log_file; |
| ngx_uint_t ngx_use_stderr = 1; |
| |
| |
| static ngx_str_t err_levels[] = { |
| ngx_null_string, |
| ngx_string("emerg"), |
| ngx_string("alert"), |
| ngx_string("crit"), |
| ngx_string("error"), |
| ngx_string("warn"), |
| ngx_string("notice"), |
| ngx_string("info"), |
| ngx_string("debug") |
| }; |
| |
| static const char *debug_levels[] = { |
| "debug_core", "debug_alloc", "debug_mutex", "debug_event", |
| "debug_http", "debug_mail", "debug_mysql" |
| }; |
| |
| |
| #if (NGX_HAVE_VARIADIC_MACROS) |
| |
| void |
| ngx_log_error_core(ngx_uint_t level, ngx_log_t *log, ngx_err_t err, |
| const char *fmt, ...) |
| |
| #else |
| |
| void |
| ngx_log_error_core(ngx_uint_t level, ngx_log_t *log, ngx_err_t err, |
| const char *fmt, va_list args) |
| |
| #endif |
| { |
| #if (NGX_HAVE_VARIADIC_MACROS) |
| va_list args; |
| #endif |
| u_char *p, *last, *msg; |
| u_char errstr[NGX_MAX_ERROR_STR]; |
| ngx_uint_t wrote_stderr, debug_connection; |
| |
| last = errstr + NGX_MAX_ERROR_STR; |
| |
| ngx_memcpy(errstr, ngx_cached_err_log_time.data, |
| ngx_cached_err_log_time.len); |
| |
| p = errstr + ngx_cached_err_log_time.len; |
| |
| p = ngx_slprintf(p, last, " [%V] ", &err_levels[level]); |
| |
| /* pid#tid */ |
| p = ngx_slprintf(p, last, "%P#" NGX_TID_T_FMT ": ", |
| ngx_log_pid, ngx_log_tid); |
| |
| if (log->connection) { |
| p = ngx_slprintf(p, last, "*%uA ", log->connection); |
| } |
| |
| msg = p; |
| |
| #if (NGX_HAVE_VARIADIC_MACROS) |
| |
| va_start(args, fmt); |
| p = ngx_vslprintf(p, last, fmt, args); |
| va_end(args); |
| |
| #else |
| |
| p = ngx_vslprintf(p, last, fmt, args); |
| |
| #endif |
| |
| if (err) { |
| p = ngx_log_errno(p, last, err); |
| } |
| |
| if (level != NGX_LOG_DEBUG && log->handler) { |
| p = log->handler(log, p, last - p); |
| } |
| |
| if (p > last - NGX_LINEFEED_SIZE) { |
| p = last - NGX_LINEFEED_SIZE; |
| } |
| |
| ngx_linefeed(p); |
| |
| wrote_stderr = 0; |
| debug_connection = (log->log_level & NGX_LOG_DEBUG_CONNECTION) != 0; |
| |
| while (log) { |
| |
| if (log->log_level < level && !debug_connection) { |
| break; |
| } |
| |
| (void) ngx_write_fd(log->file->fd, errstr, p - errstr); |
| |
| if (log->file->fd == ngx_stderr) { |
| wrote_stderr = 1; |
| } |
| |
| log = log->next; |
| } |
| |
| if (!ngx_use_stderr |
| || level > NGX_LOG_WARN |
| || wrote_stderr) |
| { |
| return; |
| } |
| |
| msg -= (7 + err_levels[level].len + 3); |
| |
| (void) ngx_sprintf(msg, "nginx: [%V] ", &err_levels[level]); |
| |
| (void) ngx_write_console(ngx_stderr, msg, p - msg); |
| } |
| |
| |
| #if !(NGX_HAVE_VARIADIC_MACROS) |
| |
| void ngx_cdecl |
| ngx_log_error(ngx_uint_t level, ngx_log_t *log, ngx_err_t err, |
| const char *fmt, ...) |
| { |
| va_list args; |
| |
| if (log->log_level >= level) { |
| va_start(args, fmt); |
| ngx_log_error_core(level, log, err, fmt, args); |
| va_end(args); |
| } |
| } |
| |
| |
| void ngx_cdecl |
| ngx_log_debug_core(ngx_log_t *log, ngx_err_t err, const char *fmt, ...) |
| { |
| va_list args; |
| |
| va_start(args, fmt); |
| ngx_log_error_core(NGX_LOG_DEBUG, log, err, fmt, args); |
| va_end(args); |
| } |
| |
| #endif |
| |
| |
| void ngx_cdecl |
| ngx_log_abort(ngx_err_t err, const char *fmt, ...) |
| { |
| u_char *p; |
| va_list args; |
| u_char errstr[NGX_MAX_CONF_ERRSTR]; |
| |
| va_start(args, fmt); |
| p = ngx_vsnprintf(errstr, sizeof(errstr) - 1, fmt, args); |
| va_end(args); |
| |
| ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, err, |
| "%*s", p - errstr, errstr); |
| } |
| |
| |
| void ngx_cdecl |
| ngx_log_stderr(ngx_err_t err, const char *fmt, ...) |
| { |
| u_char *p, *last; |
| va_list args; |
| u_char errstr[NGX_MAX_ERROR_STR]; |
| |
| last = errstr + NGX_MAX_ERROR_STR; |
| p = errstr + 7; |
| |
| ngx_memcpy(errstr, "nginx: ", 7); |
| |
| va_start(args, fmt); |
| p = ngx_vslprintf(p, last, fmt, args); |
| va_end(args); |
| |
| if (err) { |
| p = ngx_log_errno(p, last, err); |
| } |
| |
| if (p > last - NGX_LINEFEED_SIZE) { |
| p = last - NGX_LINEFEED_SIZE; |
| } |
| |
| ngx_linefeed(p); |
| |
| (void) ngx_write_console(ngx_stderr, errstr, p - errstr); |
| } |
| |
| |
| u_char * |
| ngx_log_errno(u_char *buf, u_char *last, ngx_err_t err) |
| { |
| if (buf > last - 50) { |
| |
| /* leave a space for an error code */ |
| |
| buf = last - 50; |
| *buf++ = '.'; |
| *buf++ = '.'; |
| *buf++ = '.'; |
| } |
| |
| #if (NGX_WIN32) |
| buf = ngx_slprintf(buf, last, ((unsigned) err < 0x80000000) |
| ? " (%d: " : " (%Xd: ", err); |
| #else |
| buf = ngx_slprintf(buf, last, " (%d: ", err); |
| #endif |
| |
| buf = ngx_strerror(err, buf, last - buf); |
| |
| if (buf < last) { |
| *buf++ = ')'; |
| } |
| |
| return buf; |
| } |
| |
| |
| ngx_log_t * |
| ngx_log_init(u_char *prefix) |
| { |
| u_char *p, *name; |
| size_t nlen, plen; |
| |
| ngx_log.file = &ngx_log_file; |
| ngx_log.log_level = NGX_LOG_NOTICE; |
| |
| name = (u_char *) NGX_ERROR_LOG_PATH; |
| |
| /* |
| * we use ngx_strlen() here since BCC warns about |
| * condition is always false and unreachable code |
| */ |
| |
| nlen = ngx_strlen(name); |
| |
| if (nlen == 0) { |
| ngx_log_file.fd = ngx_stderr; |
| return &ngx_log; |
| } |
| |
| p = NULL; |
| |
| #if (NGX_WIN32) |
| if (name[1] != ':') { |
| #else |
| if (name[0] != '/') { |
| #endif |
| |
| if (prefix) { |
| plen = ngx_strlen(prefix); |
| |
| } else { |
| #ifdef NGX_PREFIX |
| prefix = (u_char *) NGX_PREFIX; |
| plen = ngx_strlen(prefix); |
| #else |
| plen = 0; |
| #endif |
| } |
| |
| if (plen) { |
| name = malloc(plen + nlen + 2); |
| if (name == NULL) { |
| return NULL; |
| } |
| |
| p = ngx_cpymem(name, prefix, plen); |
| |
| if (!ngx_path_separator(*(p - 1))) { |
| *p++ = '/'; |
| } |
| |
| ngx_cpystrn(p, (u_char *) NGX_ERROR_LOG_PATH, nlen + 1); |
| |
| p = name; |
| } |
| } |
| |
| ngx_log_file.fd = ngx_open_file(name, NGX_FILE_APPEND, |
| NGX_FILE_CREATE_OR_OPEN, |
| NGX_FILE_DEFAULT_ACCESS); |
| |
| if (ngx_log_file.fd == NGX_INVALID_FILE) { |
| ngx_log_stderr(ngx_errno, |
| "[alert] could not open error log file: " |
| ngx_open_file_n " \"%s\" failed", name); |
| #if (NGX_WIN32) |
| ngx_event_log(ngx_errno, |
| "could not open error log file: " |
| ngx_open_file_n " \"%s\" failed", name); |
| #endif |
| |
| ngx_log_file.fd = ngx_stderr; |
| } |
| |
| if (p) { |
| ngx_free(p); |
| } |
| |
| return &ngx_log; |
| } |
| |
| |
| ngx_int_t |
| ngx_log_open_default(ngx_cycle_t *cycle) |
| { |
| static ngx_str_t error_log = ngx_string(NGX_ERROR_LOG_PATH); |
| |
| if (cycle->new_log.file == NULL) { |
| cycle->new_log.file = ngx_conf_open_file(cycle, &error_log); |
| if (cycle->new_log.file == NULL) { |
| return NGX_ERROR; |
| } |
| |
| cycle->new_log.log_level = NGX_LOG_ERR; |
| } |
| |
| return NGX_OK; |
| } |
| |
| |
| ngx_int_t |
| ngx_log_redirect_stderr(ngx_cycle_t *cycle) |
| { |
| ngx_fd_t fd; |
| |
| if (cycle->log_use_stderr) { |
| return NGX_OK; |
| } |
| |
| fd = cycle->log->file->fd; |
| |
| if (fd != ngx_stderr) { |
| if (ngx_set_stderr(fd) == NGX_FILE_ERROR) { |
| ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno, |
| ngx_set_stderr_n " failed"); |
| |
| return NGX_ERROR; |
| } |
| } |
| |
| return NGX_OK; |
| } |
| |
| |
| static char * |
| ngx_log_set_levels(ngx_conf_t *cf, ngx_log_t *log) |
| { |
| ngx_uint_t i, n, d, found; |
| ngx_str_t *value; |
| |
| if (cf->args->nelts == 2) { |
| log->log_level = NGX_LOG_ERR; |
| return NGX_CONF_OK; |
| } |
| |
| value = cf->args->elts; |
| |
| for (i = 2; i < cf->args->nelts; i++) { |
| found = 0; |
| |
| for (n = 1; n <= NGX_LOG_DEBUG; n++) { |
| if (ngx_strcmp(value[i].data, err_levels[n].data) == 0) { |
| |
| if (log->log_level != 0) { |
| ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, |
| "duplicate log level \"%V\"", |
| &value[i]); |
| return NGX_CONF_ERROR; |
| } |
| |
| log->log_level = n; |
| found = 1; |
| break; |
| } |
| } |
| |
| for (n = 0, d = NGX_LOG_DEBUG_FIRST; d <= NGX_LOG_DEBUG_LAST; d <<= 1) { |
| if (ngx_strcmp(value[i].data, debug_levels[n++]) == 0) { |
| if (log->log_level & ~NGX_LOG_DEBUG_ALL) { |
| ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, |
| "invalid log level \"%V\"", |
| &value[i]); |
| return NGX_CONF_ERROR; |
| } |
| |
| log->log_level |= d; |
| found = 1; |
| break; |
| } |
| } |
| |
| |
| if (!found) { |
| ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, |
| "invalid log level \"%V\"", &value[i]); |
| return NGX_CONF_ERROR; |
| } |
| } |
| |
| if (log->log_level == NGX_LOG_DEBUG) { |
| log->log_level = NGX_LOG_DEBUG_ALL; |
| } |
| |
| return NGX_CONF_OK; |
| } |
| |
| |
| static char * |
| ngx_error_log(ngx_conf_t *cf, ngx_command_t *cmd, void *conf) |
| { |
| ngx_log_t *dummy; |
| |
| dummy = &cf->cycle->new_log; |
| |
| return ngx_log_set_log(cf, &dummy); |
| } |
| |
| |
| char * |
| ngx_log_set_log(ngx_conf_t *cf, ngx_log_t **head) |
| { |
| ngx_log_t *new_log; |
| ngx_str_t *value, name; |
| |
| if (*head != NULL && (*head)->log_level == 0) { |
| new_log = *head; |
| |
| } else { |
| |
| new_log = ngx_pcalloc(cf->pool, sizeof(ngx_log_t)); |
| if (new_log == NULL) { |
| return NGX_CONF_ERROR; |
| } |
| |
| if (*head == NULL) { |
| *head = new_log; |
| } |
| } |
| |
| value = cf->args->elts; |
| |
| if (ngx_strcmp(value[1].data, "stderr") == 0) { |
| ngx_str_null(&name); |
| cf->cycle->log_use_stderr = 1; |
| |
| } else { |
| name = value[1]; |
| } |
| |
| new_log->file = ngx_conf_open_file(cf->cycle, &name); |
| if (new_log->file == NULL) { |
| return NGX_CONF_ERROR; |
| } |
| |
| if (ngx_log_set_levels(cf, new_log) != NGX_CONF_OK) { |
| return NGX_CONF_ERROR; |
| } |
| |
| if (*head != new_log) { |
| ngx_log_insert(*head, new_log); |
| } |
| |
| return NGX_CONF_OK; |
| } |
| |
| |
| static void |
| ngx_log_insert(ngx_log_t *log, ngx_log_t *new_log) |
| { |
| ngx_log_t tmp; |
| |
| if (new_log->log_level > log->log_level) { |
| |
| /* |
| * list head address is permanent, insert new log after |
| * head and swap its contents with head |
| */ |
| |
| tmp = *log; |
| *log = *new_log; |
| *new_log = tmp; |
| |
| log->next = new_log; |
| return; |
| } |
| |
| while (log->next) { |
| if (new_log->log_level > log->next->log_level) { |
| new_log->next = log->next; |
| log->next = new_log; |
| return; |
| } |
| |
| log = log->next; |
| } |
| |
| log->next = new_log; |
| } |