echo " + gcc version: $NGX_GCC_VER"
+have=NGX_COMPILER value="\"gcc $NGX_GCC_VER\"" . auto/define
+
# Solaris 7's /usr/ccs/bin/as does not support "-pipe"
echo " + icc version: $NGX_ICC_VER"
+have=NGX_COMPILER value="\"Intel C Compiler $NGX_ICC_VER\"" . auto/define
+
# optimizations
<title lang="en">nginx changelog</title>
+<changes ver="0.3.0" date="07.10.2005">
+
+<change type="change">
+<para lang="ru">
+ÕÂÒÁÎÏ ÄÅÓÑÔÉÄÎÅ×ÎÏÅ ÏÇÒÁÎÉÞÅÎÉÅ ×ÒÅÍÅÎÉ ÒÁÂÏÔÙ ÒÁÂÏÞÅÇÏ ÐÒÏÃÅÓÓÁ.
+ïÇÒÁÎÉÞÅÎÉÅ ÂÙÌÏ ××ÅÄÅÎÏ ÉÚ-ÚÁ ÐÅÒÅÐÏÌÎÅÎÉÑ ÔÁÊÍÅÒÏ× ÍÉÌÌÉÓÅËÕÎÄ.
+</para>
+<para lang="en">
+the 10-days live time limit of worker process was eliminated.
+The limit was introduced because of millisecond timers overflow.
+</para>
+</change>
+
+</changes>
+
+
<changes ver="0.2.6" date="05.10.2005">
<change type="change">
if (cycle == NULL) {
if (ngx_test_config) {
ngx_log_error(NGX_LOG_EMERG, log, 0,
- "the configuration file \"%s\" test failed",
+ "the configuration file %s test failed",
init_cycle.conf_file.data);
}
if (ngx_test_config) {
ngx_log_error(NGX_LOG_INFO, log, 0,
- "the configuration file \"%s\" was tested successfully",
+ "the configuration file %s was tested successfully",
cycle->conf_file.data);
return 0;
}
#define _NGINX_H_INCLUDED_
-#define NGINX_VER "nginx/0.2.6"
+#define NGINX_VER "nginx/0.3.0"
#define NGINX_VAR "NGINX"
#define NGX_OLDPID_EXT ".oldbin"
/* should be here because of the AcceptEx() preread */
size_t post_accept_buffer_size;
/* should be here because of the deferred accept */
- time_t post_accept_timeout;
+ ngx_msec_t post_accept_timeout;
ngx_listening_t *previous;
ngx_connection_t *connection;
#include <ngx_atomic.h>
+#include <ngx_rbtree.h>
#include <ngx_time.h>
#include <ngx_socket.h>
#include <ngx_errno.h>
#if (NGX_PCRE)
#include <ngx_regex.h>
#endif
-#include <ngx_rbtree.h>
#include <ngx_radix_tree.h>
#include <ngx_times.h>
#include <ngx_inet.h>
#define CRLF "\x0d\x0a"
+#define ngx_abs(value) (((value) >= 0) ? (value) : - (value))
+
+
#endif /* _NGX_CORE_H_INCLUDED_ */
temp = *root;
for ( ;; ) {
- if (node->key < temp->key) {
+
+ /* node->key < temp->key */
+
+ if ((ngx_rbtree_key_int_t) node->key - (ngx_rbtree_key_int_t) temp->key
+ < 0)
+ {
if (temp->left == sentinel) {
temp->left = node;
break;
#include <ngx_core.h>
+typedef ngx_uint_t ngx_rbtree_key_t;
+typedef ngx_int_t ngx_rbtree_key_int_t;
+
+
typedef struct ngx_rbtree_s ngx_rbtree_t;
struct ngx_rbtree_s {
- ngx_int_t key;
- ngx_rbtree_t *left;
- ngx_rbtree_t *right;
- ngx_rbtree_t *parent;
- char color;
+ ngx_rbtree_key_t key;
+ ngx_rbtree_t *left;
+ ngx_rbtree_t *right;
+ ngx_rbtree_t *parent;
+ char color;
};
static ngx_inline ngx_rbtree_t *
ngx_rbtree_min(ngx_rbtree_t *node, ngx_rbtree_t *sentinel)
{
- while (node->left != sentinel) {
- node = node->left;
- }
+ while (node->left != sentinel) {
+ node = node->left;
+ }
- return node;
+ return node;
}
* %[0][width][u][x|X]L int64_t/uint64_t
* %[0][width|m][u][x|X]A ngx_atomic_int_t/ngx_atomic_uint_t
* %P ngx_pid_t
+ * %M ngx_msec_t
* %r rlim_t
* %p pointer
* %V pointer to ngx_str_t
* %c char
* %% %
*
- * TODO:
- * %M ngx_msec_t
- *
* reserved:
* %t ptrdiff_t
* %S null-teminated wchar string
sign = 1;
break;
+ case 'M':
+ ui64 = (uint64_t) va_arg(args, ngx_msec_t);
+ sign = 0;
+ break;
+
case 'z':
if (sign) {
i64 = (int64_t) va_arg(args, ssize_t);
#include <ngx_core.h>
-ngx_epoch_msec_t ngx_elapsed_msec;
-ngx_epoch_msec_t ngx_old_elapsed_msec;
-ngx_epoch_msec_t ngx_start_msec;
+ngx_msec_t ngx_current_time;
-ngx_int_t ngx_gmtoff;
+ngx_int_t ngx_gmtoff;
static ngx_tm_t ngx_cached_gmtime;
ngx_gettimeofday(&tv);
- ngx_start_msec = (ngx_epoch_msec_t) tv.tv_sec * 1000 + tv.tv_usec / 1000;
- ngx_old_elapsed_msec = 0;
- ngx_elapsed_msec = 0;
+ ngx_current_time = (ngx_msec_t) tv.tv_sec * 1000 + tv.tv_usec / 1000;
#if !(NGX_WIN32)
tzset();
extern ngx_thread_volatile ngx_str_t ngx_cached_http_time;
extern ngx_thread_volatile ngx_str_t ngx_cached_http_log_time;
-extern ngx_epoch_msec_t ngx_start_msec;
+extern ngx_int_t ngx_gmtoff;
/*
- * msecs elapsed since ngx_start_msec in the current event cycle,
- * used in ngx_event_add_timer() and ngx_event_find_timer()
+ * milliseconds elapsed since epoch and truncated to ngx_msec_t,
+ * used in event timers
*/
-extern ngx_epoch_msec_t ngx_elapsed_msec;
-
-/*
- * msecs elapsed since ngx_start_msec in the previous event cycle,
- * used in ngx_event_expire_timers()
- */
-extern ngx_epoch_msec_t ngx_old_elapsed_msec;
-
-extern ngx_int_t ngx_gmtoff;
+extern ngx_msec_t ngx_current_time;
#endif /* _NGX_TIMES_H_INCLUDED_ */
ngx_devpoll_process_events(ngx_cycle_t *cycle)
{
int events, revents;
- ngx_int_t i;
- ngx_uint_t lock, accept_lock, expire;
size_t n;
- ngx_msec_t timer;
ngx_err_t err;
+ ngx_int_t i;
+ ngx_uint_t lock, accept_lock;
+ ngx_msec_t timer, delta;
#if 0
ngx_cycle_t **old_cycle;
#endif
ngx_event_t *rev, *wev;
ngx_connection_t *c;
- ngx_epoch_msec_t delta;
struct dvpoll dvp;
struct timeval tv;
- for ( ;; ) {
- timer = ngx_event_find_timer();
-
- if (timer != 0) {
- break;
- }
-
- ngx_log_debug0(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
- "devpoll expired timer");
-
- ngx_event_expire_timers((ngx_msec_t)
- (ngx_elapsed_msec - ngx_old_elapsed_msec));
- }
+ timer = ngx_event_find_timer();
/* NGX_TIMER_INFINITE == INFTIM */
- if (timer == NGX_TIMER_INFINITE) {
- expire = 0;
-
- } else {
- expire = 1;
- }
-
- ngx_old_elapsed_msec = ngx_elapsed_msec;
accept_lock = 0;
if (ngx_accept_mutex) {
|| timer > ngx_accept_mutex_delay)
{
timer = ngx_accept_mutex_delay;
- expire = 0;
}
}
}
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
- "devpoll timer: %d", timer);
+ "devpoll timer: %M", timer);
if (nchanges) {
n = nchanges * sizeof(struct pollfd);
ngx_gettimeofday(&tv);
ngx_time_update(tv.tv_sec);
- delta = ngx_elapsed_msec;
- ngx_elapsed_msec = (ngx_epoch_msec_t) tv.tv_sec * 1000
- + tv.tv_usec / 1000 - ngx_start_msec;
+ delta = ngx_current_time;
+ ngx_current_time = (ngx_msec_t) tv.tv_sec * 1000 + tv.tv_usec / 1000;
if (err) {
ngx_log_error((err == NGX_EINTR) ? NGX_LOG_INFO : NGX_LOG_ALERT,
}
if (timer != NGX_TIMER_INFINITE) {
- delta = ngx_elapsed_msec - delta;
+ delta = ngx_current_time - delta;
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
- "devpoll timer: %d, delta: %d", timer, (int) delta);
+ "devpoll timer: %M, delta: %M", timer, delta);
} else {
if (events == 0) {
ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
ngx_mutex_unlock(ngx_posted_events_mutex);
}
- if (expire && delta) {
- ngx_event_expire_timers((ngx_msec_t) delta);
- }
+ ngx_event_expire_timers();
if (!ngx_threaded) {
ngx_event_process_posted(cycle);
int events;
uint32_t revents;
ngx_int_t instance, i;
- ngx_uint_t lock, accept_lock, expire;
+ ngx_uint_t lock, accept_lock;
ngx_err_t err;
ngx_log_t *log;
- ngx_msec_t timer;
+ ngx_msec_t timer, delta;
ngx_event_t *rev, *wev;
struct timeval tv;
ngx_connection_t *c;
- ngx_epoch_msec_t delta;
- for ( ;; ) {
- timer = ngx_event_find_timer();
+ timer = ngx_event_find_timer();
#if (NGX_THREADS)
- if (timer == NGX_TIMER_ERROR) {
- return NGX_ERROR;
- }
+ if (timer == NGX_TIMER_ERROR) {
+ return NGX_ERROR;
+ }
- if (timer == NGX_TIMER_INFINITE || timer > 500) {
- timer = 500;
- break;
- }
+ if (timer == NGX_TIMER_INFINITE || timer > 500) {
+ timer = 500;
+ break;
+ }
#endif
- if (timer != 0) {
- break;
- }
-
- ngx_log_debug0(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
- "epoll expired timer");
-
- ngx_event_expire_timers((ngx_msec_t)
- (ngx_elapsed_msec - ngx_old_elapsed_msec));
-
- if (ngx_posted_events && ngx_threaded) {
- ngx_wakeup_worker_thread(cycle);
- }
- }
-
/* NGX_TIMER_INFINITE == INFTIM */
- if (timer == NGX_TIMER_INFINITE) {
- expire = 0;
-
- } else {
- expire = 1;
- }
-
- ngx_old_elapsed_msec = ngx_elapsed_msec;
accept_lock = 0;
if (ngx_accept_mutex) {
|| timer > ngx_accept_mutex_delay)
{
timer = ngx_accept_mutex_delay;
- expire = 0;
}
}
}
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
- "epoll timer: %d", timer);
+ "epoll timer: %M", timer);
events = epoll_wait(ep, event_list, nevents, timer);
ngx_gettimeofday(&tv);
ngx_time_update(tv.tv_sec);
- delta = ngx_elapsed_msec;
- ngx_elapsed_msec = (ngx_epoch_msec_t) tv.tv_sec * 1000
- + tv.tv_usec / 1000 - ngx_start_msec;
+ delta = ngx_current_time;
+ ngx_current_time = (ngx_msec_t) tv.tv_sec * 1000 + tv.tv_usec / 1000;
if (timer != NGX_TIMER_INFINITE) {
- delta = ngx_elapsed_msec - delta;
+ delta = ngx_current_time - delta;
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
- "epoll timer: %d, delta: %d", timer, (int) delta);
+ "epoll timer: %M, delta: %M", timer, delta);
} else {
if (events == 0) {
ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
ngx_mutex_unlock(ngx_posted_events_mutex);
}
- if (expire && delta) {
- ngx_event_expire_timers((ngx_msec_t) delta);
- }
+ ngx_event_expire_timers();
if (ngx_posted_events) {
if (ngx_threaded) {
u_int key;
u_long bytes;
ngx_err_t err;
- ngx_msec_t timer;
+ ngx_msec_t timer, delta;
ngx_event_t *ev;
struct timeval tv;
- ngx_epoch_msec_t delta;
ngx_event_ovlp_t *ovlp;
timer = ngx_event_find_timer();
- ngx_old_elapsed_msec = ngx_elapsed_msec;
- if (timer == 0) {
+ if (timer == NGX_TIMER_INFINITE) {
timer = INFINITE;
}
- ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0, "iocp timer: %d", timer);
+ ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0, "iocp timer: %M", timer);
rc = GetQueuedCompletionStatus(iocp, &bytes, (LPDWORD) &key,
- (LPOVERLAPPED *) &ovlp, timer);
+ (LPOVERLAPPED *) &ovlp, (u_long) timer);
if (rc == 0) {
err = ngx_errno;
ngx_log_debug4(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
"iocp: %d b:%d k:%d ov:%p", rc, bytes, key, ovlp);
- delta = ngx_elapsed_msec;
- ngx_elapsed_msec = (ngx_epoch_msec_t) tv.tv_sec * 1000
- + tv.tv_usec / 1000 - ngx_start_msec;
+ delta = ngx_current_time;
+ ngx_current_time = (ngx_msec_t) tv.tv_sec * 1000 + tv.tv_usec / 1000;
if (timer != INFINITE) {
- delta = ngx_elapsed_msec - delta;
+ delta = ngx_current_time - delta;
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
- "iocp timer: %d, delta: %d", timer, (int) delta);
+ "iocp timer: %M, delta: %M", timer, delta);
}
if (err) {
return NGX_ERROR;
}
- if (timer != INFINITE && delta) {
- ngx_event_expire_timers((ngx_msec_t) delta);
- }
+ ngx_event_expire_timers();
return NGX_OK;
}
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, err,
"iocp: aborted event %p", ev);
- if (timer != INFINITE && delta) {
- ngx_event_expire_timers((ngx_msec_t) delta);
- }
+ ngx_event_expire_timers();
return NGX_OK;
}
ev->handler(ev);
- if (timer != INFINITE && delta) {
- ngx_event_expire_timers((ngx_msec_t) delta);
- }
+ ngx_event_expire_timers();
return NGX_OK;
}
{
int events, n;
ngx_int_t i, instance;
- ngx_uint_t lock, accept_lock, expire;
+ ngx_uint_t lock, accept_lock;
ngx_err_t err;
- ngx_msec_t timer;
+ ngx_msec_t timer, delta;
ngx_event_t *ev;
- ngx_epoch_msec_t delta;
struct timeval tv;
struct timespec ts, *tp;
- for ( ;; ) {
- timer = ngx_event_find_timer();
+ timer = ngx_event_find_timer();
#if (NGX_THREADS)
- if (timer == NGX_TIMER_ERROR) {
- return NGX_ERROR;
- }
+ if (timer == NGX_TIMER_ERROR) {
+ return NGX_ERROR;
+ }
- if (timer == NGX_TIMER_INFINITE || timer > 500) {
- timer = 500;
- break;
- }
+ if (timer == NGX_TIMER_INFINITE || timer > 500) {
+ timer = 500;
+ break;
+ }
#endif
- if (timer != 0) {
- break;
- }
-
- ngx_log_debug0(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
- "kevent expired timer");
-
- ngx_event_expire_timers((ngx_msec_t)
- (ngx_elapsed_msec - ngx_old_elapsed_msec));
-
- if (ngx_posted_events && ngx_threaded) {
- ngx_wakeup_worker_thread(cycle);
- }
- }
-
- ngx_old_elapsed_msec = ngx_elapsed_msec;
- expire = 1;
accept_lock = 0;
if (ngx_accept_mutex) {
|| timer > ngx_accept_mutex_delay)
{
timer = ngx_accept_mutex_delay;
- expire = 0;
}
}
}
if (timer == NGX_TIMER_INFINITE) {
tp = NULL;
- expire = 0;
} else {
ts.tv_sec = timer / 1000;
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
"kevent events: %d", events);
- delta = ngx_elapsed_msec;
- ngx_elapsed_msec = (ngx_epoch_msec_t) tv.tv_sec * 1000
- + tv.tv_usec / 1000 - ngx_start_msec;
+ delta = ngx_current_time;
+ ngx_current_time = (ngx_msec_t) tv.tv_sec * 1000 + tv.tv_usec / 1000;
if (err) {
ngx_log_error((err == NGX_EINTR) ? NGX_LOG_INFO : NGX_LOG_ALERT,
}
if (timer != NGX_TIMER_INFINITE) {
- delta = ngx_elapsed_msec - delta;
+ delta = ngx_current_time - delta;
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
- "kevent timer: %d, delta: %d", timer, (int) delta);
+ "kevent timer: %M, delta: %M", timer, delta);
} else {
if (events == 0) {
ngx_mutex_unlock(ngx_posted_events_mutex);
}
- if (expire && delta) {
- ngx_event_expire_timers((ngx_msec_t) delta);
- }
+ ngx_event_expire_timers();
if (ngx_posted_events) {
if (ngx_threaded) {
ngx_poll_process_events(ngx_cycle_t *cycle)
{
int ready, revents;
- ngx_int_t i, nready;
- ngx_uint_t n, found, lock, expire;
- ngx_msec_t timer;
ngx_err_t err;
+ ngx_int_t i, nready;
+ ngx_uint_t n, found, lock;
+ ngx_msec_t timer, delta;
ngx_cycle_t **old_cycle;
ngx_event_t *ev;
- ngx_epoch_msec_t delta;
ngx_connection_t *c;
struct timeval tv;
- for ( ;; ) {
- timer = ngx_event_find_timer();
-
- if (timer != 0) {
- break;
- }
-
- ngx_log_debug0(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
- "poll expired timer");
-
- ngx_event_expire_timers((ngx_msec_t)
- (ngx_elapsed_msec - ngx_old_elapsed_msec));
- }
+ timer = ngx_event_find_timer();
/* NGX_TIMER_INFINITE == INFTIM */
- if (timer == NGX_TIMER_INFINITE) {
- expire = 0;
-
- } else {
- expire = 1;
- }
-
- ngx_old_elapsed_msec = ngx_elapsed_msec;
-
#if (NGX_DEBUG0)
if (cycle->log->log_level & NGX_LOG_DEBUG_ALL) {
for (i = 0; i < nevents; i++) {
|| timer > ngx_accept_mutex_delay))
{
timer = ngx_accept_mutex_delay;
- expire = 0;
}
}
}
- ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0, "poll timer: %d", timer);
+ ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0, "poll timer: %M", timer);
ready = poll(event_list, (u_int) nevents, (int) timer);
ngx_gettimeofday(&tv);
ngx_time_update(tv.tv_sec);
- delta = ngx_elapsed_msec;
- ngx_elapsed_msec = (ngx_epoch_msec_t) tv.tv_sec * 1000
- + tv.tv_usec / 1000 - ngx_start_msec;
+ delta = ngx_current_time;
+ ngx_current_time = (ngx_msec_t) tv.tv_sec * 1000 + tv.tv_usec / 1000;
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
"poll ready %d of %d", ready, nevents);
}
if (timer != NGX_TIMER_INFINITE) {
- delta = ngx_elapsed_msec - delta;
+ delta = ngx_current_time - delta;
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
- "poll timer: %d, delta: %d", timer, (int) delta);
+ "poll timer: %M, delta: %M", timer, delta);
} else {
if (ready == 0) {
ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
ngx_log_error(NGX_LOG_ALERT, cycle->log, 0, "poll ready != events");
}
- if (expire && delta) {
- ngx_event_expire_timers((ngx_msec_t) delta);
- }
+ ngx_event_expire_timers();
if (!ngx_threaded) {
ngx_event_process_posted(cycle);
{
int signo;
ngx_int_t instance;
- ngx_uint_t expire;
- ngx_msec_t timer;
+ ngx_msec_t timer, delta;
ngx_err_t err;
siginfo_t si;
ngx_event_t *rev, *wev;
struct timeval tv;
struct timespec ts, *tp;
struct sigaction sa;
- ngx_epoch_msec_t delta;
ngx_connection_t *c;
ngx_rtsig_conf_t *rtscf;
if (overflow) {
timer = 0;
- expire = 0;
} else {
- for ( ;; ) {
- timer = ngx_event_find_timer();
+ timer = ngx_event_find_timer();
#if (NGX_THREADS)
- if (timer == NGX_TIMER_ERROR) {
- return NGX_ERROR;
- }
-
- if (timer == NGX_TIMER_INFINITE || timer > 500) {
- timer = 500;
- break;
- }
-
-#endif
-
- if (timer != 0) {
- break;
- }
-
- ngx_log_debug0(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
- "rtsig expired timer");
-
- ngx_event_expire_timers((ngx_msec_t)
- (ngx_elapsed_msec - ngx_old_elapsed_msec));
+ if (timer == NGX_TIMER_ERROR) {
+ return NGX_ERROR;
+ }
- if (ngx_posted_events && ngx_threaded) {
- ngx_wakeup_worker_thread(cycle);
- }
+ if (timer == NGX_TIMER_INFINITE || timer > 500) {
+ timer = 500;
+ break;
}
- expire = 1;
+#endif
if (ngx_accept_mutex) {
if (ngx_accept_disabled > 0) {
|| timer > ngx_accept_mutex_delay))
{
timer = ngx_accept_mutex_delay;
- expire = 0;
}
}
}
if (timer == NGX_TIMER_INFINITE) {
tp = NULL;
- expire = 0;
} else {
ts.tv_sec = timer / 1000;
tp = &ts;
}
- ngx_old_elapsed_msec = ngx_elapsed_msec;
-
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
- "rtsig timer: %d", timer);
+ "rtsig timer: %M", timer);
/* Linux's sigwaitinfo() is sigtimedwait() with the NULL timeout pointer */
ngx_gettimeofday(&tv);
ngx_time_update(tv.tv_sec);
- delta = ngx_elapsed_msec;
- ngx_elapsed_msec = (ngx_epoch_msec_t) tv.tv_sec * 1000
- + tv.tv_usec / 1000 - ngx_start_msec;
+ delta = ngx_current_time;
+ ngx_current_time = (ngx_msec_t) tv.tv_sec * 1000 + tv.tv_usec / 1000;
if (err) {
ngx_accept_mutex_unlock();
}
if (timer != NGX_TIMER_INFINITE) {
- delta = ngx_elapsed_msec - delta;
+ delta = ngx_current_time - delta;
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
- "rtsig timer: %d, delta: %d", timer, (int) delta);
+ "rtsig timer: %M, delta: %M", timer, delta);
}
rtscf = ngx_event_get_conf(ngx_cycle->conf_ctx, ngx_rtsig_module);
ngx_accept_mutex_unlock();
- if (expire && delta) {
- ngx_event_expire_timers((ngx_msec_t) delta);
- }
+ ngx_event_expire_timers();
if (ngx_posted_events) {
if (ngx_threaded) {
ngx_select_process_events(ngx_cycle_t *cycle)
{
int ready, nready;
- ngx_uint_t i, found, lock, expire;
+ ngx_uint_t i, found, lock;
ngx_err_t err;
- ngx_msec_t timer;
+ ngx_msec_t timer, delta;
ngx_event_t *ev;
ngx_connection_t *c;
- ngx_epoch_msec_t delta;
struct timeval tv, *tp;
#if (NGX_HAVE_SELECT_CHANGE_TIMEOUT)
- static ngx_epoch_msec_t deltas = 0;
+ static ngx_msec_t deltas = 0;
#endif
- for ( ;; ) {
- timer = ngx_event_find_timer();
-
- if (timer != 0) {
- break;
- }
-
- ngx_log_debug0(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
- "select expired timer");
-
- ngx_event_expire_timers((ngx_msec_t)
- (ngx_elapsed_msec - ngx_old_elapsed_msec));
- }
-
- ngx_old_elapsed_msec = ngx_elapsed_msec;
-
- expire = 1;
+ timer = ngx_event_find_timer();
#if !(NGX_WIN32)
|| timer > ngx_accept_mutex_delay))
{
timer = ngx_accept_mutex_delay;
- expire = 0;
}
}
}
if (timer == NGX_TIMER_INFINITE) {
tp = NULL;
- expire = 0;
} else {
- tv.tv_sec = timer / 1000;
- tv.tv_usec = (timer % 1000) * 1000;
+ tv.tv_sec = (long) (timer / 1000);
+ tv.tv_usec = (long) ((timer % 1000) * 1000);
tp = &tv;
}
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
- "select timer: %d", timer);
+ "select timer: %M", timer);
work_read_fd_set = master_read_fd_set;
work_write_fd_set = master_write_fd_set;
#if (NGX_HAVE_SELECT_CHANGE_TIMEOUT)
if (timer != NGX_TIMER_INFINITE) {
- delta = timer - (tv.tv_sec * 1000 + tv.tv_usec / 1000);
+ delta = timer - ((ngx_msec_t) tv.tv_sec * 1000 + tv.tv_usec / 1000);
/*
* learn the real time and update the cached time
ngx_time_update(tv.tv_sec);
deltas = tv.tv_usec / 1000;
- ngx_elapsed_msec = (ngx_epoch_msec_t) tv.tv_sec * 1000
- + tv.tv_usec / 1000 - ngx_start_msec;
+ ngx_current_time = (ngx_msec_t) tv.tv_sec * 1000
+ + tv.tv_usec / 1000;
} else {
- ngx_elapsed_msec += delta;
+ ngx_current_time += delta;
}
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
- "select timer: %d, delta: %d", timer, (int) delta);
+ "select timer: %M, delta: %M", timer, delta);
} else {
- delta = 0;
+ deltas = 0;
+
ngx_gettimeofday(&tv);
ngx_time_update(tv.tv_sec);
- ngx_elapsed_msec = (ngx_epoch_msec_t) tv.tv_sec * 1000
- + tv.tv_usec / 1000 - ngx_start_msec;
+ delta = ngx_current_time;
+ ngx_current_time = (ngx_msec_t) tv.tv_sec * 1000 + tv.tv_usec / 1000;
if (ready == 0) {
ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
ngx_gettimeofday(&tv);
ngx_time_update(tv.tv_sec);
- delta = ngx_elapsed_msec;
- ngx_elapsed_msec = (ngx_epoch_msec_t) tv.tv_sec * 1000
- + tv.tv_usec / 1000 - ngx_start_msec;
+ delta = ngx_current_time;
+ ngx_current_time = (ngx_msec_t) tv.tv_sec * 1000 + tv.tv_usec / 1000;
if (timer != NGX_TIMER_INFINITE) {
- delta = ngx_elapsed_msec - delta;
+ delta = ngx_current_time - delta;
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
- "select timer: %d, delta: %d", timer, (int) delta);
+ "select timer: %M, delta: %M", timer, delta);
} else {
if (ready == 0) {
ngx_log_error(NGX_LOG_ALERT, cycle->log, 0, "select ready != events");
}
- if (expire && delta) {
- ngx_event_expire_timers((ngx_msec_t) delta);
- }
+ ngx_event_expire_timers();
if (!ngx_threaded) {
ngx_event_process_posted(cycle);
* STUB: The inline of "ngx_rbtree_t rbtree;"
*/
- ngx_int_t rbtree_key;
- void *rbtree_left;
- void *rbtree_right;
- void *rbtree_parent;
- char rbtree_color;
+ ngx_rbtree_key_t rbtree_key;
+ void *rbtree_left;
+ void *rbtree_right;
+ void *rbtree_parent;
+ char rbtree_color;
unsigned closed:1;
ngx_mutex_unlock(ngx_event_timer_mutex);
- timer = (ngx_msec_t)
- (node->key * NGX_TIMER_RESOLUTION -
- ngx_elapsed_msec / NGX_TIMER_RESOLUTION * NGX_TIMER_RESOLUTION);
-#if 0
- (node->key * NGX_TIMER_RESOLUTION - ngx_elapsed_msec);
-#endif
+ timer = (ngx_msec_t) node->key - ngx_current_time;
return timer > 0 ? timer : 0 ;
}
void
-ngx_event_expire_timers(ngx_msec_t timer)
+ngx_event_expire_timers(void)
{
ngx_event_t *ev;
ngx_rbtree_t *node;
- if (timer < 0) {
- /* avoid the endless loop if the time goes backward for some reason */
- timer = 0;
- }
-
for ( ;; ) {
if (ngx_event_timer_rbtree == &ngx_event_timer_sentinel) {
node = ngx_rbtree_min((ngx_rbtree_t *) ngx_event_timer_rbtree,
&ngx_event_timer_sentinel);
- if (node->key <= (ngx_msec_t)
- (ngx_old_elapsed_msec + timer) / NGX_TIMER_RESOLUTION)
+ /* node->key <= ngx_current_time */
+
+ if ((ngx_rbtree_key_int_t) node->key
+ - (ngx_rbtree_key_int_t) ngx_current_time
+ <= 0)
{
ev = (ngx_event_t *)
((char *) node - offsetof(ngx_event_t, rbtree_key));
#endif
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ev->log, 0,
- "event timer del: %d: %i",
+ "event timer del: %d: %M",
ngx_event_ident(ev->data), ev->rbtree_key);
ngx_rbtree_delete((ngx_rbtree_t **) &ngx_event_timer_rbtree,
#define NGX_TIMER_INFINITE (ngx_msec_t) -1
#define NGX_TIMER_ERROR (ngx_msec_t) -2
-
-/*
- * the 32-bit timer key value resolution
- *
- * 1 msec - 24 days
- * 10 msec - 8 months
- * 50 msec - 3 years 5 months
- * 100 msec - 6 years 10 months
- */
-
-#define NGX_TIMER_RESOLUTION 1
-
#define NGX_TIMER_LAZY_DELAY 300
ngx_int_t ngx_event_timer_init(ngx_log_t *log);
ngx_msec_t ngx_event_find_timer(void);
-void ngx_event_expire_timers(ngx_msec_t timer);
+void ngx_event_expire_timers(void);
#if (NGX_THREADS)
ngx_event_del_timer(ngx_event_t *ev)
{
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ev->log, 0,
- "event timer del: %d: %d",
+ "event timer del: %d: %M",
ngx_event_ident(ev->data), ev->rbtree_key);
if (ngx_mutex_lock(ngx_event_timer_mutex) == NGX_ERROR) {
static ngx_inline void
ngx_event_add_timer(ngx_event_t *ev, ngx_msec_t timer)
{
- ngx_int_t key;
+ ngx_rbtree_key_t key;
+ ngx_rbtree_key_int_t diff;
- key = (ngx_int_t)
- (ngx_elapsed_msec / NGX_TIMER_RESOLUTION * NGX_TIMER_RESOLUTION
- + timer) / NGX_TIMER_RESOLUTION;
-#if 0
- (ngx_elapsed_msec + timer) / NGX_TIMER_RESOLUTION;
-#endif
+ key = ngx_current_time + timer;
if (ev->timer_set) {
* the rbtree operations for the fast connections.
*/
- if (abs(key - ev->rbtree_key)
- < NGX_TIMER_LAZY_DELAY / NGX_TIMER_RESOLUTION)
- {
+ diff = (ngx_rbtree_key_int_t) (key - ev->rbtree_key);
+
+ if (ngx_abs(diff) < NGX_TIMER_LAZY_DELAY) {
ngx_log_debug3(NGX_LOG_DEBUG_EVENT, ev->log, 0,
- "event timer: %d, old: %i, new: %i",
+ "event timer: %d, old: %M, new: %M",
ngx_event_ident(ev->data), ev->rbtree_key, key);
return;
}
ev->rbtree_key = key;
- ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ev->log, 0,
- "event timer add: %d: %i",
- ngx_event_ident(ev->data), ev->rbtree_key);
+ ngx_log_debug3(NGX_LOG_DEBUG_EVENT, ev->log, 0,
+ "event timer add: %d: %M:%M",
+ ngx_event_ident(ev->data), timer, ev->rbtree_key);
if (ngx_mutex_lock(ngx_event_timer_mutex) == NGX_ERROR) {
return;
} ngx_http_autoindex_loc_conf_t;
-#define NGX_HTTP_AUTOINDEX_NAME_LEN 50
+#define NGX_HTTP_AUTOINDEX_PREALLOCATE 50
+
+#define NGX_HTTP_AUTOINDEX_NAME_LEN 50
static int ngx_libc_cdecl ngx_http_autoindex_cmp_entries(const void *one,
const void *two);
static ngx_int_t ngx_http_autoindex_error(ngx_http_request_t *r,
- ngx_dir_t *dir, u_char *name);
+ ngx_dir_t *dir, ngx_str_t *name);
static ngx_int_t ngx_http_autoindex_init(ngx_cycle_t *cycle);
static void *ngx_http_autoindex_create_loc_conf(ngx_conf_t *cf);
static char *ngx_http_autoindex_merge_loc_conf(ngx_conf_t *cf,
static ngx_int_t
ngx_http_autoindex_handler(ngx_http_request_t *r)
{
- u_char *last, scale;
+ u_char *last, *filename, scale;
off_t length;
- size_t len, copy;
+ size_t len, copy, allocated;
ngx_tm_t tm;
- ngx_int_t rc, size;
- ngx_uint_t i, level;
ngx_err_t err;
ngx_buf_t *b;
- ngx_chain_t out;
- ngx_str_t dname, fname;
+ ngx_int_t rc, size;
+ ngx_str_t path;
ngx_dir_t dir;
+ ngx_uint_t i, level;
ngx_pool_t *pool;
+ ngx_chain_t out;
ngx_array_t entries;
- ngx_http_core_loc_conf_t *clcf;
ngx_http_autoindex_entry_t *entry;
ngx_http_autoindex_loc_conf_t *alcf;
return NGX_DECLINED;
}
- /* TODO: pool should be temporary pool */
- pool = r->pool;
-
- clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
+ /* NGX_DIR_MASK_LEN is lesser than NGX_HTTP_AUTOINDEX_PREALLOCATE */
- if (clcf->alias) {
- dname.data = ngx_palloc(pool, clcf->root.len + r->uri.len
- + NGX_DIR_MASK_LEN + 1
- - clcf->name.len);
- if (dname.data == NULL) {
- return NGX_HTTP_INTERNAL_SERVER_ERROR;
- }
-
- last = ngx_cpymem(dname.data, clcf->root.data, clcf->root.len);
- last = ngx_cpystrn(last, r->uri.data + clcf->name.len,
- r->uri.len - clcf->name.len + 1);
-
- } else {
- dname.data = ngx_palloc(pool, clcf->root.len + r->uri.len
- + NGX_DIR_MASK_LEN);
- if (dname.data == NULL) {
- return NGX_HTTP_INTERNAL_SERVER_ERROR;
- }
-
- last = ngx_cpymem(dname.data, clcf->root.data, clcf->root.len);
- last = ngx_cpystrn(last, r->uri.data, r->uri.len);
+ last = ngx_http_map_uri_to_path(r, &path, NGX_HTTP_AUTOINDEX_PREALLOCATE);
+ if (last == NULL) {
+ return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
- dname.len = last - dname.data;
+ allocated = path.len;
+ path.len = last - path.data - 1;
+ path.data[path.len] = '\0';
ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
- "http autoindex: \"%s\"", dname.data);
-
+ "http autoindex: \"%s\"", path.data);
- if (ngx_open_dir(&dname, &dir) == NGX_ERROR) {
+ if (ngx_open_dir(&path, &dir) == NGX_ERROR) {
err = ngx_errno;
if (err == NGX_ENOENT
}
ngx_log_error(level, r->connection->log, err,
- ngx_open_dir_n " \"%s\" failed", dname.data);
+ ngx_open_dir_n " \"%s\" failed", path.data);
return rc;
}
#if (NGX_SUPPRESS_WARN)
+
/* MSVC thinks 'entries' may be used without having been initialized */
ngx_memzero(&entries, sizeof(ngx_array_t));
+
#endif
- if (ngx_array_init(&entries, pool, 50, sizeof(ngx_http_autoindex_entry_t))
- == NGX_ERROR)
+ /* TODO: pool should be temporary pool */
+ pool = r->pool;
+
+ if (ngx_array_init(&entries, pool, 40, sizeof(ngx_http_autoindex_entry_t))
+ != NGX_OK)
{
- return ngx_http_autoindex_error(r, &dir, dname.data);
+ return ngx_http_autoindex_error(r, &dir, &path);
}
r->headers_out.status = NGX_HTTP_OK;
return rc;
}
- fname.len = 0;
-#if (NGX_SUPPRESS_WARN)
- fname.data = NULL;
-#endif
+ filename = path.data;
+ filename[path.len] = '/';
for ( ;; ) {
ngx_set_errno(0);
if (err != NGX_ENOMOREFILES) {
ngx_log_error(NGX_LOG_CRIT, r->connection->log, err,
- ngx_read_dir_n " \"%s\" failed", dname.data);
- return ngx_http_autoindex_error(r, &dir, dname.data);
+ ngx_read_dir_n " \"%V\" failed", &path);
+ return ngx_http_autoindex_error(r, &dir, &path);
}
break;
if (!dir.valid_info) {
- if (dname.len + 1 + len + 1 > fname.len) {
- fname.len = dname.len + 1 + len + 1 + 32;
+ /* 1 byte for '/' and 1 byte for terminating '\0' */
+
+ if (path.len + 1 + len + 1 > allocated) {
+ allocated = path.len + 1 + len + 1
+ + NGX_HTTP_AUTOINDEX_PREALLOCATE;
- fname.data = ngx_palloc(pool, fname.len);
- if (fname.data == NULL) {
- return ngx_http_autoindex_error(r, &dir, dname.data);
+ filename = ngx_palloc(pool, allocated);
+ if (filename == NULL) {
+ return ngx_http_autoindex_error(r, &dir, &path);
}
- last = ngx_cpystrn(fname.data, dname.data,
- dname.len + 1);
+ last = ngx_cpystrn(filename, path.data, path.len + 1);
*last++ = '/';
}
ngx_cpystrn(last, ngx_de_name(&dir), len + 1);
- if (ngx_de_info(fname.data, &dir) == NGX_FILE_ERROR) {
+ if (ngx_de_info(filename, &dir) == NGX_FILE_ERROR) {
err = ngx_errno;
if (err != NGX_ENOENT) {
ngx_log_error(NGX_LOG_CRIT, r->connection->log, err,
- ngx_de_info_n " \"%s\" failed", fname.data);
- return ngx_http_autoindex_error(r, &dir, dname.data);
+ ngx_de_info_n " \"%s\" failed", filename);
+ return ngx_http_autoindex_error(r, &dir, &path);
}
- if (ngx_de_link_info(fname.data, &dir) == NGX_FILE_ERROR) {
+ if (ngx_de_link_info(filename, &dir) == NGX_FILE_ERROR) {
ngx_log_error(NGX_LOG_CRIT, r->connection->log, ngx_errno,
ngx_de_link_info_n " \"%s\" failed",
- fname.data);
- return ngx_http_autoindex_error(r, &dir, dname.data);
+ filename);
+ return ngx_http_autoindex_error(r, &dir, &path);
}
}
}
entry = ngx_array_push(&entries);
if (entry == NULL) {
- return ngx_http_autoindex_error(r, &dir, dname.data);
+ return ngx_http_autoindex_error(r, &dir, &path);
}
entry->name.len = len;
entry->name.data = ngx_palloc(pool, len + 1);
if (entry->name.data == NULL) {
- return ngx_http_autoindex_error(r, &dir, dname.data);
+ return ngx_http_autoindex_error(r, &dir, &path);
}
ngx_cpystrn(entry->name.data, ngx_de_name(&dir), len + 1);
if (ngx_close_dir(&dir) == NGX_ERROR) {
ngx_log_error(NGX_LOG_ALERT, r->connection->log, ngx_errno,
- ngx_close_dir_n " \"%s\" failed", dname.data);
+ ngx_close_dir_n " \"%s\" failed", &path);
}
len = sizeof(title) - 1
static ngx_int_t
-ngx_http_autoindex_error(ngx_http_request_t *r, ngx_dir_t *dir, u_char *name)
+ngx_http_autoindex_error(ngx_http_request_t *r, ngx_dir_t *dir, ngx_str_t *name)
{
if (ngx_close_dir(dir) == NGX_ERROR) {
ngx_log_error(NGX_LOG_ALERT, r->connection->log, ngx_errno,
- ngx_close_dir_n " \"%s\" failed", name);
+ ngx_close_dir_n " \"%V\" failed", name);
}
return NGX_HTTP_INTERNAL_SERVER_ERROR;
typedef struct {
ngx_uint_t current;
- size_t allocated;
- u_char *path;
- ngx_str_t uri;
+ ngx_str_t path;
ngx_str_t index;
ngx_uint_t tested; /* unsigned tested:1 */
#define NGX_HTTP_DEFAULT_INDEX "index.html"
-static ngx_int_t ngx_http_index_alloc(ngx_http_request_t *r, size_t size,
- ngx_http_index_ctx_t *ctx, ngx_http_core_loc_conf_t *clcf);
static ngx_int_t ngx_http_index_test_dir(ngx_http_request_t *r,
ngx_http_index_ctx_t *ctx);
static ngx_int_t ngx_http_index_error(ngx_http_request_t *r,
static ngx_int_t
ngx_http_index_handler(ngx_http_request_t *r)
{
- u_char *name;
+ u_char *last;
size_t len;
ngx_fd_t fd;
ngx_int_t rc;
ngx_err_t err;
+ ngx_str_t uri;
ngx_log_t *log;
ngx_uint_t i;
ngx_http_index_t *index;
* and may be called several times
*/
- clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
ilcf = ngx_http_get_module_loc_conf(r, ngx_http_index_module);
ctx = ngx_http_get_module_ctx(r, ngx_http_index_module);
e.ip = index[i].lengths->elts;
e.request = r;
- len = 1;
+ /* 1 byte for terminating '\0' and 4 bytes is preallocation */
+
+ len = 1 + 4;
while (*(uintptr_t *) e.ip) {
lcode = *(ngx_http_script_len_code_pt *) e.ip;
ctx->index.len = len;
}
- if (len > ctx->allocated) {
- if (ngx_http_index_alloc(r, len, ctx, clcf) != NGX_OK) {
- return NGX_HTTP_INTERNAL_SERVER_ERROR;
+ if (len > ctx->path.len) {
+
+ last = ngx_http_map_uri_to_path(r, &ctx->path, len);
+ if (last == NULL) {
+ return NGX_ERROR;
}
+
+ ctx->index.data = last;
}
if (index[i].values == NULL) {
- ngx_memcpy(ctx->index.data, index[i].name.data, ctx->index.len);
+
+ /* index[i].name.len includes the terminating '\0' */
+
+ ngx_memcpy(ctx->index.data, index[i].name.data, index[i].name.len);
} else {
e.ip = index[i].values->elts;
*e.pos++ = '\0';
}
- name = ctx->path;
-
ngx_log_debug1(NGX_LOG_DEBUG_HTTP, log, 0,
- "open index \"%s\"", name);
+ "open index \"%s\"", ctx->path.data);
- fd = ngx_open_file(name, NGX_FILE_RDONLY, NGX_FILE_OPEN);
+ fd = ngx_open_file(ctx->path.data, NGX_FILE_RDONLY, NGX_FILE_OPEN);
if (fd == (ngx_fd_t) NGX_AGAIN) {
ctx->current = i;
err = ngx_errno;
ngx_log_debug1(NGX_LOG_DEBUG_HTTP, log, err,
- ngx_open_file_n " \"%s\" failed", name);
+ ngx_open_file_n " \"%s\" failed", ctx->path.data);
if (err == NGX_ENOTDIR) {
return ngx_http_index_error(r, ctx, err);
}
ngx_log_error(NGX_LOG_ERR, log, err,
- ngx_open_file_n " \"%s\" failed", name);
+ ngx_open_file_n " \"%s\" failed", ctx->path.data);
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
}
cln->fd = fd;
- cln->name = name;
+ cln->name = ctx->path.data;
cln->log = r->pool->log;
if (ngx_pool_cleanup_add(r->pool, ngx_pool_cleanup_file, cln) == NULL) {
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
+ clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
- if (clcf->alias) {
- name = ngx_cpymem(ctx->uri.data, r->uri.data, r->uri.len);
- ngx_memcpy(name, ctx->index.data, ctx->index.len - 1);
- }
-
- ctx->uri.len = r->uri.len + ctx->index.len - 1;
-
- return ngx_http_internal_redirect(r, &ctx->uri, &r->args);
- }
-
- return NGX_DECLINED;
-}
-
-
-static ngx_int_t
-ngx_http_index_alloc(ngx_http_request_t *r, size_t size,
- ngx_http_index_ctx_t *ctx, ngx_http_core_loc_conf_t *clcf)
-{
- ctx->allocated = size;
-
- if (!clcf->alias) {
- ctx->path = ngx_palloc(r->pool, clcf->root.len + r->uri.len + size);
- if (ctx->path == NULL) {
- return NGX_ERROR;
- }
+ uri.len = r->uri.len + ctx->index.len - 1;
- ctx->uri.data = ngx_cpymem(ctx->path, clcf->root.data, clcf->root.len);
+ if (!clcf->alias) {
+ uri.data = ctx->path.data + clcf->root.len;
- ctx->index.data = ngx_cpymem(ctx->uri.data, r->uri.data, r->uri.len);
-
- } else {
- ctx->path = ngx_palloc(r->pool,
- clcf->root.len + r->uri.len - clcf->name.len + size);
- if (ctx->path == NULL) {
- return NGX_ERROR;
- }
+ } else {
+ uri.data = ngx_palloc(r->pool, uri.len);
+ if (uri.data == NULL) {
+ return NGX_HTTP_INTERNAL_SERVER_ERROR;
+ }
- ctx->uri.data = ngx_palloc(r->pool, r->uri.len + size);
- if (ctx->uri.data == NULL) {
- return NGX_ERROR;
+ last = ngx_cpymem(uri.data, r->uri.data, r->uri.len);
+ ngx_memcpy(last, ctx->index.data, ctx->index.len - 1);
}
- ngx_memcpy(ctx->path, clcf->root.data, clcf->root.len);
-
- ctx->index.data = ngx_cpymem(ctx->path + clcf->root.len,
- r->uri.data + clcf->name.len,
- r->uri.len - clcf->name.len);
+ return ngx_http_internal_redirect(r, &uri, &r->args);
}
- return NGX_OK;
+ return NGX_DECLINED;
}
*(ctx->index.data - 1) = '\0';
ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
- "http index check dir: \"%s\"", ctx->path);
+ "http index check dir: \"%s\"", ctx->path.data);
- if (ngx_file_info(ctx->path, &fi) == -1) {
+ if (ngx_file_info(ctx->path.data, &fi) == -1) {
err = ngx_errno;
}
ngx_log_error(NGX_LOG_CRIT, r->connection->log, err,
- ngx_file_info_n " \"%s\" failed", ctx->path);
+ ngx_file_info_n " \"%s\" failed", ctx->path.data);
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
}
ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
- "\"%s\" is not a directory", ctx->path);
+ "\"%s\" is not a directory", ctx->path.data);
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
{
if (err == NGX_EACCES) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, err,
- "\"%s\" is forbidden", ctx->path);
+ "\"%s\" is forbidden", ctx->path.data);
return NGX_HTTP_FORBIDDEN;
}
ngx_log_error(NGX_LOG_ERR, r->connection->log, err,
- "\"%s\" is not found", ctx->path);
+ "\"%s\" is not found", ctx->path.data);
return NGX_HTTP_NOT_FOUND;
}
n = ngx_http_script_variables_count(&value[i]);
if (n == 0) {
- index->name.len++;
-
if (ilcf->max_index_len != 0
&& ilcf->max_index_len < index->name.len)
{
ilcf->max_index_len = index->name.len;
}
+ /* include the terminating '\0' to the length to use ngx_memcpy() */
+ index->name.len++;
+
continue;
}
static ngx_int_t
ngx_http_static_handler(ngx_http_request_t *r)
{
- u_char *last;
- ngx_fd_t fd;
- ngx_int_t rc;
- ngx_uint_t level;
- ngx_str_t name, location;
- ngx_err_t err;
- ngx_log_t *log;
- ngx_buf_t *b;
- ngx_chain_t out;
- ngx_file_info_t fi;
- ngx_pool_cleanup_file_t *cln;
- ngx_http_core_loc_conf_t *clcf;
+ u_char *last, *location;
+ ngx_fd_t fd;
+ ngx_int_t rc;
+ ngx_uint_t level;
+ ngx_str_t path;
+ ngx_err_t err;
+ ngx_log_t *log;
+ ngx_buf_t *b;
+ ngx_chain_t out;
+ ngx_file_info_t fi;
+ ngx_pool_cleanup_file_t *cln;
+ ngx_http_core_loc_conf_t *clcf;
if (r->uri.data[r->uri.len - 1] == '/') {
return NGX_DECLINED;
log = r->connection->log;
- clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
-
/*
- * make a file name, reserve 2 bytes for a trailing '/'
- * in a possible redirect and for the last '\0'
+ * ngx_http_map_uri_to_path() allocates memory for terminating '\0'
+ * so we do not need to reserve memory for '/' for possible redirect
*/
- if (!clcf->alias) {
- name.data = ngx_palloc(r->pool, clcf->root.len + r->uri.len + 2);
- if (name.data == NULL) {
- return NGX_HTTP_INTERNAL_SERVER_ERROR;
- }
-
- location.data = ngx_cpymem(name.data, clcf->root.data, clcf->root.len);
- last = ngx_cpystrn(location.data, r->uri.data, r->uri.len + 1);
-
- name.len = last - name.data;
- location.len = last - location.data + 1;
-
- } else {
- name.data = ngx_palloc(r->pool, clcf->root.len + r->uri.len + 2
- - clcf->name.len);
- if (name.data == NULL) {
- return NGX_HTTP_INTERNAL_SERVER_ERROR;
- }
-
- last = ngx_cpymem(name.data, clcf->root.data, clcf->root.len);
- last = ngx_cpystrn(last, r->uri.data + clcf->name.len,
- r->uri.len + 1 - clcf->name.len);
-
- name.len = last - name.data;
-
- location.data = ngx_palloc(r->pool, r->uri.len + 2);
- if (location.data == NULL) {
- return NGX_HTTP_INTERNAL_SERVER_ERROR;
- }
-
- last = ngx_cpystrn(location.data, r->uri.data, r->uri.len + 1);
-
- location.len = last - location.data + 1;
+ last = ngx_http_map_uri_to_path(r, &path, 0);
+ if (last == NULL) {
+ return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
ngx_log_debug1(NGX_LOG_DEBUG_HTTP, log, 0,
- "http filename: \"%s\"", name.data);
-
- /* open file */
-
-#if (NGX_WIN9X)
-
- if (ngx_win32_version < NGX_WIN_NT) {
-
- /*
- * there is no way to open a file or a directory in Win9X with
- * one syscall because Win9X has no FILE_FLAG_BACKUP_SEMANTICS flag
- * so we need to check its type before the opening
- */
-
- if (ngx_file_info(name.data, &fi) == NGX_FILE_ERROR) {
- err = ngx_errno;
- ngx_log_error(NGX_LOG_ERR, log, err,
- ngx_file_info_n " \"%s\" failed", name.data);
-
- if (err == NGX_ENOENT || err == NGX_ENOTDIR) {
- return NGX_HTTP_NOT_FOUND;
-
- } else if (err == NGX_EACCES) {
- return NGX_HTTP_FORBIDDEN;
-
- } else {
- return NGX_HTTP_INTERNAL_SERVER_ERROR;
- }
- }
-
- if (ngx_is_dir(&fi)) {
- r->headers_out.location = ngx_http_add_header(&r->headers_out,
- ngx_http_headers_out);
- if (r->headers_out.location == NULL) {
- return NGX_HTTP_INTERNAL_SERVER_ERROR;
- }
-
- *last++ = '/';
- *last = '\0';
- r->headers_out.location->value.len = last - location;
- r->headers_out.location->value.data = location;
-
- return NGX_HTTP_MOVED_PERMANENTLY;
- }
- }
-
-#endif
+ "http filename: \"%s\"", path.data);
-
- fd = ngx_open_file(name.data, NGX_FILE_RDONLY, NGX_FILE_OPEN);
+ fd = ngx_open_file(path.data, NGX_FILE_RDONLY, NGX_FILE_OPEN);
if (fd == NGX_INVALID_FILE) {
err = ngx_errno;
rc = NGX_HTTP_INTERNAL_SERVER_ERROR;
}
+ clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
+
if (rc != NGX_HTTP_NOT_FOUND || clcf->log_not_found) {
ngx_log_error(level, log, err,
- ngx_open_file_n " \"%s\" failed", name.data);
+ ngx_open_file_n " \"%s\" failed", path.data);
}
return rc;
if (ngx_fd_info(fd, &fi) == NGX_FILE_ERROR) {
ngx_log_error(NGX_LOG_CRIT, log, ngx_errno,
- ngx_fd_info_n " \"%s\" failed", name.data);
+ ngx_fd_info_n " \"%s\" failed", path.data);
if (ngx_close_file(fd) == NGX_FILE_ERROR) {
ngx_log_error(NGX_LOG_ALERT, log, ngx_errno,
- ngx_close_file_n " \"%s\" failed", name.data);
+ ngx_close_file_n " \"%s\" failed", path.data);
}
return NGX_HTTP_INTERNAL_SERVER_ERROR;
if (ngx_close_file(fd) == NGX_FILE_ERROR) {
ngx_log_error(NGX_LOG_ALERT, log, ngx_errno,
- ngx_close_file_n " \"%s\" failed", name.data);
+ ngx_close_file_n " \"%s\" failed", path.data);
}
- *last++ = '/';
- *last = '\0';
-
r->headers_out.location = ngx_palloc(r->pool, sizeof(ngx_table_elt_t));
if (r->headers_out.location == NULL) {
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
+ clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
+
+ if (!clcf->alias) {
+ location = path.data + clcf->root.len;
+
+ } else {
+ location = ngx_palloc(r->pool, r->uri.len + 1);
+ if (location == NULL) {
+ return NGX_HTTP_INTERNAL_SERVER_ERROR;
+ }
+
+ last = ngx_cpymem(location, r->uri.data, r->uri.len);
+ }
+
+ *last = '/';
+
/*
* we do not need to set the r->headers_out.location->hash and
* r->headers_out.location->key fields
*/
- r->headers_out.location->value = location;
+ r->headers_out.location->value.len = r->uri.len + 1;
+ r->headers_out.location->value.data = location;
return NGX_HTTP_MOVED_PERMANENTLY;
}
if (!ngx_is_file(&fi)) {
ngx_log_error(NGX_LOG_CRIT, log, ngx_errno,
- "\"%s\" is not a regular file", name.data);
+ "\"%s\" is not a regular file", path.data);
if (ngx_close_file(fd) == NGX_FILE_ERROR) {
ngx_log_error(NGX_LOG_ALERT, log, ngx_errno,
- ngx_close_file_n " \"%s\" failed", name.data);
+ ngx_close_file_n " \"%s\" failed", path.data);
}
return NGX_HTTP_NOT_FOUND;
}
cln->fd = fd;
- cln->name = name.data;
+ cln->name = path.data;
cln->log = r->pool->log;
if (ngx_pool_cleanup_add(r->pool, ngx_pool_cleanup_file, cln) == NULL) {
b->file_last = ngx_file_size(&fi);
b->file->fd = fd;
- b->file->name = name;
+ b->file->name = path;
b->file->log = log;
out.buf = b;
}
+ngx_int_t
+ngx_http_set_exten(ngx_http_request_t *r)
+{
+ ngx_int_t i;
+
+ r->exten.len = 0;
+ r->exten.data = NULL;
+
+ for (i = r->uri.len - 1; i > 1; i--) {
+ if (r->uri.data[i] == '.' && r->uri.data[i - 1] != '/') {
+ r->exten.len = r->uri.len - i - 1;
+
+ if (r->exten.len > 0) {
+ r->exten.data = ngx_palloc(r->pool, r->exten.len + 1);
+ if (r->exten.data == NULL) {
+ return NGX_ERROR;
+ }
+
+ ngx_cpystrn(r->exten.data, &r->uri.data[i + 1],
+ r->exten.len + 1);
+ }
+
+ break;
+
+ } else if (r->uri.data[i] == '/') {
+ break;
+ }
+ }
+
+ r->low_case_exten = 0;
+
+ return NGX_OK;
+}
+
+
ngx_int_t
ngx_http_send_header(ngx_http_request_t *r)
{
}
-ngx_int_t
-ngx_http_set_exten(ngx_http_request_t *r)
+u_char *
+ngx_http_map_uri_to_path(ngx_http_request_t *r, ngx_str_t *path,
+ size_t reserved)
{
- ngx_int_t i;
-
- r->exten.len = 0;
- r->exten.data = NULL;
-
- for (i = r->uri.len - 1; i > 1; i--) {
- if (r->uri.data[i] == '.' && r->uri.data[i - 1] != '/') {
- r->exten.len = r->uri.len - i - 1;
+ u_char *last;
+ size_t alias;
+ ngx_http_core_loc_conf_t *clcf;
- if (r->exten.len > 0) {
- r->exten.data = ngx_palloc(r->pool, r->exten.len + 1);
- if (r->exten.data == NULL) {
- return NGX_ERROR;
- }
+ clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
- ngx_cpystrn(r->exten.data, &r->uri.data[i + 1],
- r->exten.len + 1);
- }
+ alias = clcf->alias ? clcf->name.len : 0;
- break;
+ path->len = clcf->root.len + r->uri.len - alias + 1 + reserved;
- } else if (r->uri.data[i] == '/') {
- break;
- }
+ path->data = ngx_palloc(r->pool, path->len);
+ if (path->data == NULL) {
+ return NULL;
}
- r->low_case_exten = 0;
+ last = ngx_cpymem(path->data, clcf->root.data, clcf->root.len);
+ last = ngx_cpystrn(last, r->uri.data + alias, r->uri.len - alias + 1);
- return NGX_OK;
+ return last;
}
ngx_int_t ngx_http_set_content_type(ngx_http_request_t *r);
ngx_int_t ngx_http_set_exten(ngx_http_request_t *r);
+u_char *ngx_http_map_uri_to_path(ngx_http_request_t *r, ngx_str_t *name,
+ size_t reserved);
ngx_int_t ngx_http_auth_basic_user(ngx_http_request_t *r);
ngx_int_t ngx_http_subrequest(ngx_http_request_t *r,
rev = c->read;
rev->handler = ngx_http_lingering_close_handler;
- r->lingering_time = ngx_time() + clcf->lingering_time / 1000;
+ r->lingering_time = ngx_time() + (time_t) (clcf->lingering_time / 1000);
ngx_add_timer(rev, clcf->lingering_timeout);
if (ngx_handle_read_event(rev, 0) == NGX_ERROR) {
static ngx_http_variable_value_t *
ngx_http_variable_request_filename(ngx_http_request_t *r, uintptr_t data)
{
- u_char *p;
- ngx_http_core_loc_conf_t *clcf;
ngx_http_variable_value_t *vv;
vv = ngx_palloc(r->pool, sizeof(ngx_http_variable_value_t));
vv->value = 0;
- clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
-
- if (!clcf->alias) {
- vv->text.len = clcf->root.len + r->uri.len;
- vv->text.data = ngx_palloc(r->pool, vv->text.len);
- if (vv->text.data == NULL) {
- return NULL;
- }
-
- p = ngx_cpymem(vv->text.data, clcf->root.data, clcf->root.len);
- ngx_memcpy(p, r->uri.data, r->uri.len + 1);
+ if (ngx_http_map_uri_to_path(r, &vv->text, 0) == NULL) {
+ return NULL;
+ }
- } else {
- vv->text.len = clcf->root.len + r->uri.len + 2 - clcf->name.len;
- vv->text.data = ngx_palloc(r->pool, vv->text.len);
- if (vv->text.data == NULL) {
- return NULL;
- }
+ /* ngx_http_map_uri_to_path() allocates memory for terminating '\0' */
- p = ngx_cpymem(vv->text.data, clcf->root.data, clcf->root.len);
- ngx_memcpy(p, r->uri.data + clcf->name.len,
- r->uri.len + 1 - clcf->name.len);
- }
+ vv->text.len--;
return vv;
}
{
ngx_log_error(NGX_LOG_NOTICE, log, 0, NGINX_VER);
+#ifdef NGX_COMPILER
+ ngx_log_error(NGX_LOG_NOTICE, log, 0, "built by " NGX_COMPILER);
+#endif
+
#if (NGX_HAVE_OS_SPECIFIC_INIT)
ngx_os_specific_status(log);
#endif
break;
case SIGALRM:
- if (!ngx_terminate) {
- ngx_timer = 1;
- action = ", shutting down old worker processes";
- }
-
break;
case SIGIO:
ngx_uint_t ngx_threaded;
sig_atomic_t ngx_reap;
-sig_atomic_t ngx_timer;
sig_atomic_t ngx_sigio;
sig_atomic_t ngx_terminate;
sig_atomic_t ngx_quit;
continue;
}
- if (ngx_timer) {
- ngx_timer = 0;
-
- if (!ngx_noaccepting) {
- ngx_start_worker_processes(cycle, ccf->worker_processes,
- NGX_PROCESS_JUST_RESPAWN);
- ngx_start_garbage_collector(cycle, NGX_PROCESS_JUST_RESPAWN);
- live = 1;
- ngx_signal_worker_processes(cycle,
- ngx_signal_value(NGX_SHUTDOWN_SIGNAL));
- }
- }
-
if (ngx_reconfigure) {
ngx_reconfigure = 0;
static void
ngx_start_worker_processes(ngx_cycle_t *cycle, ngx_int_t n, ngx_int_t type)
{
- ngx_int_t i;
- ngx_channel_t ch;
- struct itimerval itv;
+ ngx_int_t i;
+ ngx_channel_t ch;
ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "start worker processes");
&ch, sizeof(ngx_channel_t), cycle->log);
}
}
-
- /*
- * we have to limit the maximum life time of the worker processes
- * by 10 days because our millisecond event timer is limited
- * by 24 days on 32-bit platforms
- */
-
- itv.it_interval.tv_sec = 0;
- itv.it_interval.tv_usec = 0;
- itv.it_value.tv_sec = 10 * 24 * 60 * 60;
- itv.it_value.tv_usec = 0;
-
- if (setitimer(ITIMER_REAL, &itv, NULL) == -1) {
- ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
- "setitimer() failed");
- }
}
ngx_int_t n;
ngx_uint_t i;
struct rlimit rlmt;
- struct timeval tv;
ngx_core_conf_t *ccf;
ngx_listening_t *ls;
- ngx_gettimeofday(&tv);
-
- ngx_start_msec = (ngx_epoch_msec_t) tv.tv_sec * 1000 + tv.tv_usec / 1000;
- ngx_old_elapsed_msec = 0;
- ngx_elapsed_msec = 0;
-
-
ngx_process = NGX_PROCESS_WORKER;
ccf = (ngx_core_conf_t *) ngx_get_conf(cycle->conf_ctx, ngx_core_module);
extern ngx_uint_t ngx_exiting;
extern sig_atomic_t ngx_reap;
-extern sig_atomic_t ngx_timer;
extern sig_atomic_t ngx_sigio;
extern sig_atomic_t ngx_quit;
extern sig_atomic_t ngx_debug_quit;
#include <ngx_core.h>
-typedef uint64_t ngx_epoch_msec_t;
+typedef ngx_rbtree_key_t ngx_msec_t;
-typedef ngx_int_t ngx_msec_t;
+typedef struct tm ngx_tm_t;
-typedef struct tm ngx_tm_t;
+#define ngx_tm_sec tm_sec
+#define ngx_tm_min tm_min
+#define ngx_tm_hour tm_hour
+#define ngx_tm_mday tm_mday
+#define ngx_tm_mon tm_mon
+#define ngx_tm_year tm_year
+#define ngx_tm_wday tm_wday
+#define ngx_tm_isdst tm_isdst
-#define ngx_tm_sec tm_sec
-#define ngx_tm_min tm_min
-#define ngx_tm_hour tm_hour
-#define ngx_tm_mday tm_mday
-#define ngx_tm_mon tm_mon
-#define ngx_tm_year tm_year
-#define ngx_tm_wday tm_wday
-#define ngx_tm_isdst tm_isdst
-
-#define ngx_tm_sec_t int
-#define ngx_tm_min_t int
-#define ngx_tm_hour_t int
-#define ngx_tm_mday_t int
-#define ngx_tm_mon_t int
-#define ngx_tm_year_t int
-#define ngx_tm_wday_t int
+#define ngx_tm_sec_t int
+#define ngx_tm_min_t int
+#define ngx_tm_hour_t int
+#define ngx_tm_mday_t int
+#define ngx_tm_mon_t int
+#define ngx_tm_year_t int
+#define ngx_tm_wday_t int
#if (NGX_HAVE_GMTOFF)
-#define ngx_tm_gmtoff tm_gmtoff
-#define ngx_tm_zone tm_zone
+#define ngx_tm_gmtoff tm_gmtoff
+#define ngx_tm_zone tm_zone
#endif
#include <ngx_core.h>
-typedef uint64_t ngx_epoch_msec_t;
+typedef ngx_rbtree_key_t ngx_msec_t;
-typedef ngx_int_t ngx_msec_t;
+typedef SYSTEMTIME ngx_tm_t;
+typedef FILETIME ngx_mtime_t;
+#define ngx_tm_sec wSecond
+#define ngx_tm_min wMinute
+#define ngx_tm_hour wHour
+#define ngx_tm_mday wDay
+#define ngx_tm_mon wMonth
+#define ngx_tm_year wYear
+#define ngx_tm_wday wDayOfWeek
-typedef SYSTEMTIME ngx_tm_t;
-typedef FILETIME ngx_mtime_t;
+#define ngx_tm_sec_t u_short
+#define ngx_tm_min_t u_short
+#define ngx_tm_hour_t u_short
+#define ngx_tm_mday_t u_short
+#define ngx_tm_mon_t u_short
+#define ngx_tm_year_t u_short
+#define ngx_tm_wday_t u_short
-#define ngx_tm_sec wSecond
-#define ngx_tm_min wMinute
-#define ngx_tm_hour wHour
-#define ngx_tm_mday wDay
-#define ngx_tm_mon wMonth
-#define ngx_tm_year wYear
-#define ngx_tm_wday wDayOfWeek
-#define ngx_tm_sec_t u_short
-#define ngx_tm_min_t u_short
-#define ngx_tm_hour_t u_short
-#define ngx_tm_mday_t u_short
-#define ngx_tm_mon_t u_short
-#define ngx_tm_year_t u_short
-#define ngx_tm_wday_t u_short
-
-
-#define ngx_msleep Sleep
+#define ngx_msleep Sleep
#define NGX_HAVE_GETTIMEZONE 1
projects / nginx.git / commitdiff