Fijxu
/
nginx-quic
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

nginx-0.0.1-2002-08-26-19:18:19 import

This commit is contained in:
Igor Sysoev 2002-08-26 15:18:19 +00:00
parent e5c593ec28
commit 62dc699b22
30 changed files with 431 additions and 175 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

57
src/core/nginx.c
View File

@ -85,43 +85,57 @@ static void ngx_open_listening_sockets(ngx_log_t *log)
/* for each listening socket */
ls = (ngx_listen_t *) ngx_listening_sockets->elts;
for (i = 0; i < ngx_listening_sockets->nelts; i++) {
if (ls[i].done)
continue;
#if (WIN32)
s = WSASocket(ls[i].family, ls[i].type, ls[i].protocol, NULL, 0, 0);
#else
s = socket(ls[i].family, ls[i].type, ls[i].protocol);
#endif
if (s == -1)
if (ls[i].inherited) {
/* TODO: close on exit */
/* TODO: nonblocking */
/* TODO: deferred accept */
ls[i].done = 1;
continue;
}
s = ngx_socket(ls[i].family, ls[i].type, ls[i].protocol,
ls[i].flags);
if (s == -1) {
ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
"nginx: socket %s falied", ls[i].addr_text);
ngx_socket_n " %s falied", ls[i].addr_text);
exit(1);
}
if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR,
(const void *) &reuseaddr, sizeof(int)) == -1)
(const void *) &reuseaddr, sizeof(int)) == -1) {
ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
"nginx: setsockopt (SO_REUSEADDR) %s failed",
"setsockopt(SO_REUSEADDR) %s failed",
ls[i].addr_text);
exit(1);
}
/* TODO: close on exit */
if (ls[i].nonblocking) {
if (ngx_nonblocking(s) == -1)
if (ngx_nonblocking(s) == -1) {
ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
ngx_nonblocking_n " %s failed",
ls[i].addr_text);
exit(1);
}
}
if (bind(s, (struct sockaddr *) ls[i].addr, ls[i].addr_len) == -1) {
if (bind(s, ls[i].sockaddr, ls[i].socklen) == -1) {
err = ngx_socket_errno;
ngx_log_error(NGX_LOG_ALERT, log, err,
"bind to %s failed", ls[i].addr_text);
ngx_log_error(NGX_LOG_EMERG, log, err,
"bind() to %s failed", ls[i].addr_text);
if (err != NGX_EADDRINUSE)
exit(1);
if (ngx_close_socket(s) == -1)
ngx_log_error(NGX_LOG_ALERT, log, ngx_socket_errno,
ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
ngx_close_socket_n " %s failed",
ls[i].addr_text);
@ -129,9 +143,11 @@ static void ngx_open_listening_sockets(ngx_log_t *log)
continue;
}
if (listen(s, ls[i].backlog) == -1)
if (listen(s, ls[i].backlog) == -1) {
ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
"listen to %s failed", ls[i].addr_text);
"listen() to %s failed", ls[i].addr_text);
exit(1);
}
/* TODO: deferred accept */
@ -142,10 +158,13 @@ static void ngx_open_listening_sockets(ngx_log_t *log)
if (!failed)
break;
ngx_log_error(NGX_LOG_NOTICE, log, 0, "try to bind again after 500ms");
ngx_log_error(NGX_LOG_NOTICE, log, 0,
"try again to bind() after 500ms");
ngx_msleep(500);
}
if (failed)
ngx_log_error(NGX_LOG_EMERG, log, 0, "can't bind");
if (failed) {
ngx_log_error(NGX_LOG_EMERG, log, 0, "can not bind(), exiting");
exit(1);
}
}

4
src/core/ngx_alloc.c
View File

@ -12,8 +12,8 @@ void *ngx_alloc(size_t size, ngx_log_t *log)
p = malloc(size);
if (p == NULL)
ngx_log_error(NGX_LOG_ALERT, log, ngx_errno,
"ngx_alloc: malloc() %d bytes failed", size);
ngx_log_error(NGX_LOG_EMERG, log, ngx_errno,
"malloc() %d bytes failed", size);
return p;
}

1
src/core/ngx_config.h
View File

@ -48,6 +48,7 @@
#else /* POSIX */
#include <unistd.h>
#include <stddef.h> /* offsetof */
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>

9
src/core/ngx_connection.h
View File

@ -26,6 +26,15 @@ struct ngx_connection_s {
ngx_server_t *server;
ngx_server_t *servers;
ngx_pool_t *pool;
int family;
struct sockaddr *sockaddr;
socklen_t socklen;
size_t addr;
char *addr_text;
size_t addr_textlen;
time_t post_accept_timeout;
};

10
src/core/ngx_hunk.c
View File

@ -18,7 +18,7 @@ ngx_hunk_t *ngx_get_hunk(ngx_pool_t *pool, int size, int before, int after)
h->type = NGX_HUNK_TEMP;
h->tag = 0;
h->fd = (ngx_file_t) -1;
h->fd = (ngx_fd_t) -1;
return h;
}
@ -39,7 +39,7 @@ ngx_hunk_t *ngx_get_hunk_before(ngx_pool_t *pool, ngx_hunk_t *hunk, int size)
h->type = NGX_HUNK_TEMP;
h->tag = 0;
h->fd = (ngx_file_t) -1;
h->fd = (ngx_fd_t) -1;
} else {
h->pre_start = h->start = h->pos.mem = h->last.mem
@ -48,7 +48,7 @@ ngx_hunk_t *ngx_get_hunk_before(ngx_pool_t *pool, ngx_hunk_t *hunk, int size)
h->type = NGX_HUNK_TEMP;
h->tag = 0;
h->fd = (ngx_file_t) -1;
h->fd = (ngx_fd_t) -1;
}
return h;
@ -71,7 +71,7 @@ ngx_hunk_t *ngx_get_hunk_after(ngx_pool_t *pool, ngx_hunk_t *hunk, int size)
hunk->last.mem;
h->type = NGX_HUNK_TEMP;
h->tag = 0;
h->fd = (ngx_file_t) -1;
h->fd = (ngx_fd_t) -1;
} else {
h->pre_start = h->start = h->pos.mem = h->last.mem =
@ -80,7 +80,7 @@ ngx_hunk_t *ngx_get_hunk_after(ngx_pool_t *pool, ngx_hunk_t *hunk, int size)
h->type = NGX_HUNK_TEMP;
h->tag = 0;
h->fd = (ngx_file_t) -1;
h->fd = (ngx_fd_t) -1;
}
return h;

2
src/core/ngx_hunk.h
View File

@ -48,7 +48,7 @@ struct ngx_hunk_s {
char *pre_start; /* start of pre-allocated hunk */
char *post_end; /* end of post-allocated hunk */
int tag;
ngx_file_t fd;
ngx_fd_t fd;
};
typedef struct ngx_chain_s ngx_chain_t;

12
src/core/ngx_listen.h
View File

@ -11,22 +11,26 @@
typedef struct {
ngx_socket_t fd;
void *addr;
size_t addr_len;
char *addr_text;
struct sockaddr *sockaddr;
socklen_t socklen;
size_t addr;
char *addr_text;
size_t addr_textlen;
int family;
int type;
int protocol;
int flags;
ngx_log_t *log;
void *server;
int (*handler)(ngx_connection_t *c);
int backlog;
time_t post_accept_timeout;
unsigned done:1;
unsigned close:1;
unsigned inherited:1;
unsigned nonblocking:1;
#if 0
unsigned overlapped:1;

50
src/core/ngx_log.c
View File

@ -37,31 +37,15 @@ void ngx_log_error_core(int level, ngx_log_t *log, ngx_err_t err,
#endif
ngx_localtime(&tm);
len = ngx_snprintf(errstr, sizeof(errstr), "%02d:%02d:%02d",
len = ngx_snprintf(errstr, sizeof(errstr), "%4d/%02d/%02d %02d:%02d:%02d",
tm.ngx_tm_year + 1900, tm.ngx_tm_mon, tm.ngx_tm_mday,
tm.ngx_tm_hour, tm.ngx_tm_min, tm.ngx_tm_sec);
if (err) {
if ((unsigned) err < 0x80000000)
len += ngx_snprintf(errstr + len, sizeof(errstr) - len - 1,
" [%s] (%d)",
err_levels[level], err);
else
len += ngx_snprintf(errstr + len, sizeof(errstr) - len - 1,
" [%s] (%X)",
err_levels[level], err);
len += ngx_snprintf(errstr + len, sizeof(errstr) - len - 1,
" [%s] ", err_levels[level]);
len += ngx_strerror_r(err, errstr + len, sizeof(errstr) - len - 1);
if (len < sizeof(errstr) - 2) {
errstr[len++] = ':';
errstr[len++] = ' ';
} else {
len = sizeof(errstr) - 2;
}
} else {
len += ngx_snprintf(errstr + len, sizeof(errstr) - len - 1,
" [%s] ", err_levels[level]);
}
len += ngx_snprintf(errstr + len, sizeof(errstr) - len - 1,
"%d#%d: ", getpid(), 0);
#if (HAVE_VARIADIC_MACROS)
va_start(args, fmt);
@ -71,15 +55,31 @@ void ngx_log_error_core(int level, ngx_log_t *log, ngx_err_t err,
len += ngx_vsnprintf(errstr + len, sizeof(errstr) - len - 1, fmt, args);
#endif
if (err) {
if ((unsigned) err < 0x80000000)
len += ngx_snprintf(errstr + len, sizeof(errstr) - len - 1,
" (%d: ", err);
else
len += ngx_snprintf(errstr + len, sizeof(errstr) - len - 1,
" (%X: ", err);
len += ngx_strerror_r(err, errstr + len, sizeof(errstr) - len - 1);
if (len < sizeof(errstr) - 2) {
errstr[len++] = ')';
} else {
len = sizeof(errstr) - 2;
}
}
if (level != NGX_LOG_DEBUG && log->handler)
len += log->handler(log->data, errstr + len, sizeof(errstr) - len - 1);
if (len > sizeof(errstr) - 2)
len = sizeof(errstr) - 2;
errstr[len] = '\n';
errstr[len + 1] = '\0';
fputs(errstr, stderr);
if (level == NGX_LOG_EMERG)
exit(1);
}
#if !(HAVE_VARIADIC_MACROS)

16
src/core/ngx_log.h
View File

@ -3,6 +3,7 @@
#include <ngx_errno.h>
#include <ngx_file.h>
typedef enum {
NGX_LOG_EMERG = 0,
@ -59,13 +60,14 @@ typedef enum {
*/
typedef struct {
int log_level;
char *action;
char *context;
#if 0
void *data; /* i.e. ngx_http_proxy_error_context_t */
char *func(ngx_log_t *log);
#endif
int log_level;
ngx_fd_t fd;
void *data;
size_t (*handler)(void *ctx, char *buf, size_t len);
/* STUB */
char *action;
char *context;
/* */
} ngx_log_t;
#define MAX_ERROR_STR 2048

11
src/event/modules/ngx_aio_module.c
View File

@ -1,4 +1,14 @@
/* 1 */
int ngx_posix_aio_process_events(ngx_log_t *log)
{
listen via SIGIO;
aio_* via SIGxxx;
sigsuspend()/sigwaitinfo()/sigtimedwait();
}
/* 2 */
int ngx_posix_aio_process_events(ngx_log_t *log)
{
unmask signal
@ -18,6 +28,7 @@ int ngx_posix_aio_process_events(ngx_log_t *log)
aio
}
/* 3 */
int ngx_posix_aio_process_events(ngx_log_t *log)
{
unmask signal

18
src/event/modules/ngx_kqueue_module.c
View File

@ -18,7 +18,7 @@
#error "kqueue is not supported on this platform"
#endif
static void ngx_add_timer(ngx_event_t *ev, u_int timer);
static void ngx_add_timer_core(ngx_event_t *ev, u_int timer);
static void ngx_inline ngx_del_timer(ngx_event_t *ev);
@ -35,9 +35,11 @@ void ngx_kqueue_init(int max_connections, ngx_log_t *log)
nchanges = 0;
nevents = 512;
if ((kq = kqueue()) == -1)
if ((kq = kqueue()) == -1) {
ngx_log_error(NGX_LOG_EMERG, log, ngx_errno,
"ngx_kqueue_init: kqueue failed");
"kqueue() failed");
exit(1);
}
change_list = ngx_alloc(size, log);
event_list = ngx_alloc(size, log);
@ -56,7 +58,7 @@ void ngx_kqueue_init(int max_connections, ngx_log_t *log)
int ngx_kqueue_add_event(ngx_event_t *ev, int event, u_int flags)
{
if (event == NGX_TIMER_EVENT) {
ngx_add_timer(ev, flags);
ngx_add_timer_core(ev, flags);
return 0;
}
@ -154,8 +156,14 @@ int ngx_kqueue_process_events(ngx_log_t *log)
delta -= ev->timer_delta;
nx = ev->timer_next;
ngx_del_timer(ev);
#if 1
ev->timedout = 1;
if (ev->event_handler(ev) == -1)
ev->close_handler(ev);
#else
if (ev->timer_handler(ev) == -1)
ev->close_handler(ev);
#endif
ev = nx;
}
@ -207,7 +215,7 @@ int ngx_kqueue_process_events(ngx_log_t *log)
return 0;
}
static void ngx_add_timer(ngx_event_t *ev, u_int timer)
static void ngx_add_timer_core(ngx_event_t *ev, u_int timer)
{
ngx_event_t *e;

30
src/event/modules/ngx_select_module.c
View File

@ -23,7 +23,7 @@ static ngx_event_t event_queue;
static ngx_event_t timer_queue;
static void ngx_add_timer(ngx_event_t *ev, u_int timer);
static void ngx_add_timer_core(ngx_event_t *ev, u_int timer);
static void ngx_inline ngx_del_timer(ngx_event_t *ev);
static fd_set *ngx_select_get_fd_set(ngx_socket_t fd, int event,
@ -31,19 +31,17 @@ static fd_set *ngx_select_get_fd_set(ngx_socket_t fd, int event,
void ngx_select_init(int max_connections, ngx_log_t *log)
{
if (max_connections > FD_SETSIZE) {
ngx_log_error(NGX_LOG_EMERG, log, 0,
#if (WIN32)
if (max_connections > FD_SETSIZE)
ngx_log_error(NGX_LOG_EMERG, log, 0,
"ngx_select_init: maximum number of descriptors "
"supported by select() is %d",
FD_SETSIZE);
"maximum number of descriptors "
"supported by select() is %d", FD_SETSIZE);
#else
if (max_connections >= FD_SETSIZE)
ngx_log_error(NGX_LOG_EMERG, log, 0,
"ngx_select_init: maximum descriptor number"
"supported by select() is %d",
FD_SETSIZE - 1);
"maximum descriptor number"
"supported by select() is %d", FD_SETSIZE - 1);
#endif
exit(1);
}
FD_ZERO(&master_read_fds);
FD_ZERO(&master_write_fds);
@ -71,7 +69,7 @@ int ngx_select_add_event(ngx_event_t *ev, int event, u_int flags)
ngx_connection_t *cn = (ngx_connection_t *) ev->data;
if (event == NGX_TIMER_EVENT) {
ngx_add_timer(ev, flags);
ngx_add_timer_core(ev, flags);
return 0;
}
@ -271,8 +269,14 @@ int ngx_select_process_events(ngx_log_t *log)
delta -= ev->timer_delta;
nx = ev->timer_next;
ngx_del_timer(ev);
#if 1
ev->timedout = 1;
if (ev->event_handler(ev) == -1)
ev->close_handler(ev);
#else
if (ev->timer_handler(ev) == -1)
ev->close_handler(ev);
#endif
ev = nx;
}
@ -316,7 +320,7 @@ int ngx_select_process_events(ngx_log_t *log)
return 0;
}
static void ngx_add_timer(ngx_event_t *ev, u_int timer)
static void ngx_add_timer_core(ngx_event_t *ev, u_int timer)
{
ngx_event_t *e;

25
src/event/ngx_event.c
View File

@ -46,15 +46,15 @@ void ngx_pre_thread(ngx_array_t *ls, ngx_pool_t *pool, ngx_log_t *log)
int i, fd;
ngx_listen_t *s;
/* per group */
/* STUB */
int max_connections = 512;
ngx_init_events(max_connections, log);
ngx_connections = ngx_alloc(sizeof(ngx_connection_t)
* max_connections, log);
ngx_read_events = ngx_alloc(sizeof(ngx_event_t) * max_connections, log);
ngx_write_events = ngx_alloc(sizeof(ngx_event_t) * max_connections, log);
ngx_connections = ngx_alloc(sizeof(ngx_connection_t)
* max_connections, log);
/* for each listening socket */
s = (ngx_listen_t *) ls->elts;
@ -62,16 +62,23 @@ void ngx_pre_thread(ngx_array_t *ls, ngx_pool_t *pool, ngx_log_t *log)
fd = s[i].fd;
ngx_memzero(&ngx_read_events[fd], sizeof(ngx_event_t));
ngx_memzero(&ngx_write_events[fd], sizeof(ngx_event_t));
ngx_memzero(&ngx_connections[fd], sizeof(ngx_connection_t));
ngx_memzero(&ngx_read_events[fd], sizeof(ngx_event_t));
ngx_connections[fd].fd = fd;
ngx_connections[fd].family = s[i].family;
ngx_connections[fd].socklen = s[i].socklen;
ngx_connections[fd].sockaddr = ngx_palloc(pool, s[i].socklen);
ngx_connections[fd].addr = s[i].addr;
ngx_connections[fd].addr_text = s[i].addr_text;
ngx_connections[fd].addr_textlen = s[i].addr_textlen;
ngx_connections[fd].post_accept_timeout = s[i].post_accept_timeout;
ngx_connections[fd].server = s[i].server;
ngx_connections[fd].read = (void *) &ngx_read_events[fd].data;
ngx_connections[fd].handler = s[i].handler;
ngx_read_events[fd].data = &ngx_connections[fd];
ngx_read_events[fd].log = ngx_connections[fd].log = s[i].log;
ngx_connections[fd].log = s[i].log;
ngx_read_events[fd].log = ngx_connections[fd].log;
ngx_read_events[fd].data = &ngx_connections[fd];
ngx_read_events[fd].event_handler = &ngx_event_accept;
ngx_read_events[fd].listening = 1;
@ -79,7 +86,7 @@ void ngx_pre_thread(ngx_array_t *ls, ngx_pool_t *pool, ngx_log_t *log)
ngx_read_events[fd].available = 0;
#if (HAVE_DEFERRED_ACCEPT)
ngx_read_events[fd].accept_filter = s[i].accept_filter;
ngx_read_events[fd].deferred_accept = s[i].deferred_accept;
#endif
ngx_add_event(&ngx_read_events[fd], NGX_READ_EVENT, 0);
}

12
src/event/ngx_event.h
View File

@ -51,7 +51,7 @@ struct ngx_event_s {
unsigned unexpected_eof:1;
#if (HAVE_DEFERRED_ACCEPT)
unsigned accept_filter:1;
unsigned deferred_accept:1;
#endif
#if (HAVE_KQUEUE)
unsigned eof:1;
@ -81,10 +81,12 @@ typedef struct {
/*
NGX_LEVEL_EVENT (default) select, poll, kqueue
NGX_LEVEL_EVENT (default) select, poll, /dev/poll, kqueue
requires to read whole data
NGX_ONESHOT_EVENT kqueue
NGX_ONESHOT_EVENT select, poll, kqueue
NGX_CLEAR_EVENT kqueue
NGX_AIO_EVENT overlapped, aio_read, aioread
no need to add or delete events
*/
#if (HAVE_KQUEUE)
@ -93,6 +95,7 @@ NGX_CLEAR_EVENT kqueue
#define NGX_WRITE_EVENT EVFILT_WRITE
#define NGX_TIMER_EVENT (-EVFILT_SYSCOUNT - 1)
#define NGX_LEVEL_EVENT 0
#define NGX_ONESHOT_EVENT EV_ONESHOT
#define NGX_CLEAR_EVENT EV_CLEAR
@ -102,6 +105,7 @@ NGX_CLEAR_EVENT kqueue
#define NGX_WRITE_EVENT 1
#define NGX_TIMER_EVENT 2
#define NGX_LEVEL_EVENT 0
#define NGX_ONESHOT_EVENT 1
#define NGX_CLEAR_EVENT 2
@ -127,6 +131,8 @@ NGX_CLEAR_EVENT kqueue
#endif
#define ngx_add_timer(ev, time) ngx_add_event(ev, NGX_TIMER_EVENT, time)
extern ngx_event_t *ngx_read_events;
extern ngx_event_t *ngx_write_events;
extern ngx_connection_t *ngx_connections;

33
src/event/ngx_event_accept.c
View File

@ -1,5 +1,6 @@
#include <ngx_config.h>
#include <ngx_core.h>
#include <ngx_types.h>
#include <ngx_log.h>
#include <ngx_connection.h>
@ -22,21 +23,22 @@ int ngx_event_accept(ngx_event_t *ev)
ev->ready = 0;
do {
if ((s = accept(cn->fd, (struct sockaddr *) &addr, &addrlen)) == -1) {
if ((s = accept(cn->fd, cn->sockaddr, &cn->socklen)) == -1) {
err = ngx_socket_errno;
if (err == NGX_EAGAIN) {
ngx_log_error(NGX_LOG_INFO, ev->log, err,
"ngx_event_accept: EAGAIN while accept");
return 0;
"ngx_event_accept: EAGAIN while accept %s",
cn->addr_text);
return NGX_OK;
}
ngx_log_error(NGX_LOG_ERR, ev->log, err,
"ngx_event_accept: accept failed");
/* if we return -1 listen socket would be closed */
return 0;
"ngx_event_accept: accept %s failed", cn->addr_text);
/* if we return NGX_ERROR listen socket would be closed */
return NGX_OK;
}
ngx_log_debug(ev->log, "ngx_event_accept: accepted socket: %d" _ s);
ngx_log_debug(ev->log, "ngx_event_accept: accept: %d" _ s);
#if !(HAVE_INHERITED_NONBLOCK)
if (ngx_nonblocking(s) == -1)
@ -48,6 +50,13 @@ int ngx_event_accept(ngx_event_t *ev)
ngx_memzero(&ngx_write_events[s], sizeof(ngx_event_t));
ngx_memzero(&ngx_connections[s], sizeof(ngx_connection_t));
ngx_connections[s].sockaddr = cn->sockaddr;
ngx_connections[s].family = cn->family;
ngx_connections[s].socklen = cn->socklen;
ngx_connections[s].addr = cn->addr;
ngx_connections[s].addr_textlen = cn->addr_textlen;
ngx_connections[s].post_accept_timeout = cn->post_accept_timeout;
ngx_read_events[s].data = ngx_write_events[s].data
= &ngx_connections[s];
ngx_connections[s].read = &ngx_read_events[s];
@ -60,16 +69,16 @@ int ngx_event_accept(ngx_event_t *ev)
ngx_write_events[s].timer = ngx_read_events[s].timer = 10000;
ngx_write_events[s].timer_handler =
ngx_read_events[s].timer_handler = ngx_event_close;
ngx_read_events[s].timer_handler = ngx_event_close_connection;
ngx_write_events[s].close_handler =
ngx_read_events[s].close_handler = ngx_event_close;
ngx_read_events[s].close_handler = ngx_event_close_connection;
ngx_connections[s].server = cn->server;
ngx_connections[s].servers = cn->servers;
ngx_connections[s].log =
ngx_read_events[s].log = ngx_write_events[s].log = ev->log;
#if (HAVE_DEFERRED_ACCEPT)
if (ev->accept_filter)
ngx_read_events[s].ready = 1;

2
src/event/ngx_event_close.c
View File

@ -5,7 +5,7 @@
#include <ngx_event_close.h>
int ngx_event_close(ngx_event_t *ev)
int ngx_event_close_connection(ngx_event_t *ev)
{
int rc;
ngx_connection_t *cn = (ngx_connection_t *) ev->data;

2
src/event/ngx_event_close.h
View File

@ -4,7 +4,7 @@
#include <ngx_event.h>
int ngx_event_close(ngx_event_t *ev);
int ngx_event_close_connection(ngx_event_t *ev);
#endif /* _NGX_EVENT_CLOSE_H_INCLUDED_ */

20
src/event/ngx_event_recv.c
View File

@ -14,6 +14,12 @@ int ngx_event_recv_core(ngx_event_t *ev, char *buf, size_t size)
c = (ngx_connection_t *) ev->data;
if (ev->timedout) {
ngx_set_socket_errno(NGX_ETIMEDOUT);
ngx_log_error(NGX_LOG_ERR, ev->log, NGX_ETIMEDOUT, "recv() failed");
return NGX_ERROR;
}
#if (HAVE_KQUEUE)
ngx_log_debug(ev->log, "ngx_event_recv: eof:%d, avail:%d, err:%d" _
ev->eof _ ev->available _ ev->error);
@ -22,10 +28,7 @@ int ngx_event_recv_core(ngx_event_t *ev, char *buf, size_t size)
#endif
if (ev->eof && ev->available == 0) {
if (ev->error) {
ngx_log_error(NGX_LOG_ERR, ev->log, ev->error,
"ngx_event_recv: recv() failed while %s",
ev->log->action);
ngx_log_error(NGX_LOG_ERR, ev->log, ev->error, "recv() failed");
return NGX_ERROR;
}
@ -39,16 +42,11 @@ int ngx_event_recv_core(ngx_event_t *ev, char *buf, size_t size)
err = ngx_socket_errno;
if (err == NGX_EAGAIN) {
ngx_log_error(NGX_LOG_INFO, ev->log, err,
"ngx_event_recv: recv() returns EAGAIN while %s",
ev->log->action);
ngx_log_error(NGX_LOG_INFO, ev->log, err, "recv() returns EAGAIN");
return NGX_AGAIN;
}
ngx_log_error(NGX_LOG_INFO, ev->log, err,
"ngx_event_recv: recv() failed while %s",
ev->log->action);
ngx_log_error(NGX_LOG_ERR, ev->log, err, "recv() failed");
return NGX_ERROR;
}

10
src/http/ngx_http.c
View File

@ -40,10 +40,16 @@ int ngx_http_init(ngx_pool_t *pool, ngx_log_t *log)
ls->family = AF_INET;
ls->type = SOCK_STREAM;
ls->protocol = IPPROTO_IP;
ls->addr = &addr;
ls->addr_len = sizeof(struct sockaddr_in);
#if (NGX_OVERLAPPED)
ls->flags = WSA_FLAG_OVERLAPPED;
#endif
ls->sockaddr = (struct sockaddr *) &addr;
ls->socklen = sizeof(struct sockaddr_in);
ls->addr = offsetof(struct sockaddr_in, sin_addr);
ls->addr_text = addr_text;
ls->addr_textlen = INET_ADDRSTRLEN;
ls->backlog = -1;
ls->post_accept_timeout = 10000;
ls->nonblocking = 1;
ls->handler = ngx_http_init_connection;

8
src/http/ngx_http.h
View File

@ -70,7 +70,7 @@ typedef struct ngx_http_request_s ngx_http_request_t;
struct ngx_http_request_s {
char *filename;
char *location;
ngx_file_t fd;
ngx_fd_t fd;
ngx_http_headers_out_t *headers_out;
@ -113,6 +113,12 @@ struct ngx_http_request_s {
#endif
};
typedef struct {
char *action;
char *client;
char *url;
} ngx_http_log_ctx_t;
#define NGX_INDEX "index.html"

242
src/http/ngx_http_event.c
View File

@ -1,5 +1,7 @@
#include <ngx_config.h>
#include <ngx_core.h>
#include <ngx_string.h>
#include <ngx_file.h>
#include <ngx_log.h>
#include <ngx_alloc.h>
@ -8,15 +10,8 @@
#include <ngx_http.h>
/*
ngx_read should check errors (if we ask) and return
-2 EAGAIN
-1 error
0 EOF
>0 number of bytes
*/
int ngx_http_init_connection(ngx_connection_t *c);
int ngx_http_init_connection(ngx_connection_t *c);
static int ngx_http_init_request(ngx_event_t *ev);
static int ngx_http_process_request(ngx_event_t *ev);
@ -26,61 +21,90 @@ static int ngx_process_http_request_header(ngx_http_request_t *r);
static int ngx_process_http_request(ngx_http_request_t *r);
static int ngx_http_close_request(ngx_event_t *ev);
static size_t ngx_http_log_error(void *data, char *buf, size_t len);
/* STUB */
static int ngx_http_writer(ngx_event_t *ev);
/*
returns
-1 if error
0 need more data or EOF (filter is deleted)
1 there is unread data
*/
int ngx_http_init_connection(ngx_connection_t *c)
{
ngx_event_t *ev;
ngx_event_t *ev;
struct sockaddr *addr;
ngx_http_log_ctx_t *ctx;
ev = c->read;
ev->event_handler = ngx_http_init_request;
ev->log->action = "reading client request line";
ngx_log_debug(ev->log, "ngx_http_init_connection: entered");
/* TODO: connection's pool size */
ngx_test_null(c->pool, ngx_create_pool(1024, ev->log), NGX_ERROR);
/* XXX: ev->timer ? */
if (ngx_add_event(ev, NGX_TIMER_EVENT, ev->timer) == -1)
return -1;
ngx_test_null(addr, ngx_palloc(c->pool, c->socklen), NGX_ERROR);
ngx_memcpy(addr, c->sockaddr, c->socklen);
c->sockaddr = addr;
ngx_test_null(c->addr_text, ngx_palloc(c->pool, c->addr_textlen),
NGX_ERROR);
inet_ntop(c->family, (char *)c->sockaddr + c->addr,
c->addr_text, c->addr_textlen);
ngx_test_null(ctx, ngx_pcalloc(c->pool, sizeof(ngx_http_log_ctx_t)),
NGX_ERROR);
ctx->client = c->addr_text;
ctx->action = "reading client request line";
c->log->data = ctx;
c->log->handler = ngx_http_log_error;
ngx_add_timer(ev, c->post_accept_timeout);
#if (HAVE_DEFERRED_ACCEPT)
if (ev->ready)
return ngx_http_init_request(ev);
else
#endif
#if (NGX_CLEAR_EVENT)
#if (USE_KQUEUE)
return ngx_add_event(ev, NGX_READ_EVENT, NGX_CLEAR_EVENT);
#else
return ngx_add_event(ev, NGX_READ_EVENT, NGX_ONESHOT_EVENT);
#if (HAVE_AIO_EVENT)
if (ngx_event_type == NGX_AIO_EVENT)
return ngx_http_init_request(ev);
else
#endif
#if (HAVE_CLEAR_EVENT)
if (ngx_event_type == NGX_KQUEUE_EVENT)
return ngx_add_event(ev, NGX_READ_EVENT, NGX_CLEAR_EVENT);
else
#else
return ngx_add_event(ev, NGX_READ_EVENT, NGX_LEVEL_EVENT);
#endif
#endif
}
int ngx_http_init_request(ngx_event_t *ev)
{
ngx_connection_t *c = (ngx_connection_t *) ev->data;
ngx_http_server_t *srv = (ngx_http_server_t *) c->server;
ngx_http_request_t *r;
ngx_connection_t *c;
ngx_http_server_t *srv;
ngx_http_request_t *r;
ngx_log_debug(ev->log, "ngx_http_init_request: entered");
c = (ngx_connection_t *) ev->data;
srv = (ngx_http_server_t *) c->server;
ngx_test_null(c->pool, ngx_create_pool(16384, ev->log), -1);
ngx_test_null(r, ngx_pcalloc(c->pool, sizeof(ngx_http_request_t)), -1);
ngx_test_null(r, ngx_pcalloc(c->pool, sizeof(ngx_http_request_t)),
NGX_ERROR);
c->data = r;
r->connection = c;
r->server = srv;
ngx_test_null(r->pool, ngx_create_pool(16384, ev->log), -1);
ngx_test_null(r->buff, ngx_palloc(r->pool, sizeof(ngx_buff_t)), -1);
ngx_test_null(r->buff->buff, ngx_palloc(r->pool, srv->buff_size), -1);
ngx_test_null(r->pool, ngx_create_pool(16384, ev->log), NGX_ERROR);
/* TODO: buff -> hunk */
ngx_test_null(r->buff, ngx_palloc(r->pool, sizeof(ngx_buff_t)), NGX_ERROR);
ngx_test_null(r->buff->buff, ngx_palloc(r->pool, srv->buff_size),
NGX_ERROR);
r->buff->pos = r->buff->last = r->buff->buff;
r->buff->end = r->buff->buff + srv->buff_size;
@ -90,33 +114,39 @@ int ngx_http_init_request(ngx_event_t *ev)
ev->event_handler = ngx_http_process_request;
ev->close_handler = ngx_http_close_request;
c->write->close_handler = ngx_http_close_request;
return ngx_http_process_request(ev);
}
int ngx_http_process_request(ngx_event_t *ev)
{
int n;
ngx_connection_t *c = (ngx_connection_t *) ev->data;
ngx_http_request_t *r = (ngx_http_request_t *) c->data;
ngx_connection_t *c ;
ngx_http_request_t *r;
c = (ngx_connection_t *) ev->data;
r = (ngx_http_request_t *) c->data;
ngx_log_debug(ev->log, "http process request");
n = ngx_event_recv(ev, r->buff->last, r->buff->end - r->buff->last);
if (n == -2)
return 0;
if (n == NGX_AGAIN)
return NGX_AGAIN;
if (n == -1)
return -1;
if (n == NGX_ERROR) {
/* close request */
return NGX_ERROR;
}
ngx_log_debug(ev->log, "http read %d" _ n);
if (n == 0) {
if (ev->unexpected_eof) {
ngx_log_error(NGX_LOG_INFO, ev->log, 0,
"ngx_http_process_request: "
"connection is closed while %s", ev->action);
return -1;
ngx_log_error(NGX_LOG_INFO, ev->log, 0, "connection is closed");
/* close request */
return NGX_ERROR;
}
return ngx_http_close_request(ev);
@ -183,6 +213,14 @@ static int ngx_process_http_request_header(ngx_http_request_t *r)
return ngx_process_http_request(r);
}
#if 0
static int ngx_http_lock_read(ngx_event_t *ev)
{
ngx_del_event(ev, NGX_READ_EVENT);
ev->read_blocked = 1;
}
#endif
static int ngx_process_http_request(ngx_http_request_t *r)
{
int err, rc;
@ -245,6 +283,114 @@ static int ngx_process_http_request(ngx_http_request_t *r)
return NGX_OK;
}
#if 0
static int ngx_http_handler(ngx_http_request_t *r)
{
find_http_handler();
if (r->discard_body && r->connection->read->ready)
ngx_http_discarad_body();
rc = http_handler();
/* transfer not completed */
if (rc == NGX_AGAIN)
return rc;
if (rc == NGX_ERROR) {
log http request
close http request
return rc;
}
if (rc > 300) {
send special response
}
/* rc == NGX_OK */
if (!keepalive)
if (linger)
set linger timeout on read
shutdown socket
else
close socket
log http request
close http request
if (keepalive)
return NGX_OK;
else
close connection
return NGX_OK;
}
static int ngx_http_writer(ngx_event_t *ev)
{
int rc;
ngx_connection_t *c = (ngx_connection_t *) ev->data;
ngx_http_request_t *r = (ngx_http_request_t *) c->data;
rc = ngx_http_filter(r, NULL);
if (rc == NGX_AGAIN)
return rc;
if (rc == NGX_ERROR)
return rc;
/* rc == NGX_OK */
if (!keepalive)
if (linger)
shutdown socket
else
close socket
log http request
close http request
if (keepalive)
return NGX_OK;
else
close connection
return NGX_OK;
}
static int ngx_http_discarded_read(ngx_event_t *ev)
{
if (ev->timedout)
return NGX_ERROR;
while (full) {
recv();
}
return NGX_OK;
}
static int ngx_http_keepalive_handler(ngx_event_t *ev)
{
ngx_connection_t *c;
ngx_http_log_ctx_t *ctx;
if (closed)
/* NGX_LOG_INFO or even silent */
return NGX_ERROR;
c = (ngx_connection_t *) ev->data;
ctx = (ngx_http_log_ctx_t *) c->log->data;
ctx->action = "reading client request line";
c->log->handler = ngx_http_log_error;
return ngx_http_init_request(ev);
}
#endif
static int ngx_http_writer(ngx_event_t *ev)
{
@ -352,5 +498,17 @@ static int ngx_http_close_request(ngx_event_t *ev)
ngx_del_event(c->read, NGX_TIMER_EVENT);
ngx_del_event(c->write, NGX_TIMER_EVENT);
return ngx_event_close(ev);
return ngx_event_close_connection(ev);
}
static size_t ngx_http_log_error(void *data, char *buf, size_t len)
{
ngx_http_log_ctx_t *ctx = (ngx_http_log_ctx_t *) data;
if (ctx->url)
return ngx_snprintf(buf, len, " while %s, client: %s, URL: %s",
ctx->action, ctx->client, ctx->url);
else
return ngx_snprintf(buf, len, " while %s, client: %s",
ctx->action, ctx->client);
}

2
src/os/unix/freebsd/ngx_sendfile.c
View File

@ -24,7 +24,7 @@
int ngx_sendfile(ngx_socket_t s,
ngx_iovec_t *headers, int hdr_cnt,
ngx_file_t fd, off_t offset, size_t nbytes,
ngx_fd_t fd, off_t offset, size_t nbytes,
ngx_iovec_t *trailers, int trl_cnt,
off_t *sent,
ngx_log_t *log)

1
src/os/unix/ngx_errno.h
View File

@ -11,6 +11,7 @@ typedef int ngx_err_t;
#define NGX_EINTR EINTR
#define NGX_EAGAIN EWOULDBLOCK
#define NGX_EADDRINUSE EADDRINUSE
#define NGX_ETIMEDOUT ETIMEDOUT
#define ngx_errno errno
#define ngx_socket_errno errno

4
src/os/unix/ngx_file.c
View File

@ -1,8 +1,8 @@
ssize_t ngx_read_file(ngx_file_t file, char *buf, size_t size)
ssize_t ngx_read_file(ngx_file_t file, char *buf, size_t size, off_t offset)
{
read();
return pread(file->fd, buf, size, offset);
}
#if 0

2
src/os/unix/ngx_file.h
View File

@ -5,7 +5,7 @@
#include <sys/types.h>
#include <sys/stat.h>
typedef int ngx_file_t;
typedef int ngx_fd_t;
typedef struct stat ngx_file_info_t;

2
src/os/unix/ngx_sendfile.h
View File

@ -10,7 +10,7 @@
int ngx_sendfile(ngx_socket_t s,
ngx_iovec_t *headers, int hdr_cnt,
ngx_file_t fd, off_t offset, size_t nbytes,
ngx_fd_t fd, off_t offset, size_t nbytes,
ngx_iovec_t *trailers, int trl_cnt,
off_t *sent,
ngx_log_t *log);

7
src/os/unix/ngx_socket.h
View File

@ -9,11 +9,14 @@ typedef int ngx_socket_t;
#define ngx_init_sockets
#define ngx_socket(af, type, proto, flags) socket(af, type, proto)
#define ngx_socket_n "socket()"
#define ngx_nonblocking(s) fcntl(s, F_SETFL, O_NONBLOCK)
#define ngx_nonblocking_n "fcntl (O_NONBLOCK)"
#define ngx_nonblocking_n "fcntl(O_NONBLOCK)"
#define ngx_close_socket close
#define ngx_close_socket_n "close"
#define ngx_close_socket_n "close()"
#endif /* _NGX_SOCKET_H_INCLUDED_ */

4
src/os/win32/ngx_file.h
View File

@ -10,7 +10,9 @@
#define INVALID_FILE_ATTRIBUTES 0xFFFFFFFF
#endif
typedef HANDLE ngx_file_t;
typedef HANDLE ngx_fd_t;
typedef unsigned __int64 off_t;
typedef BY_HANDLE_FILE_INFORMATION ngx_file_info_t;

8
src/os/win32/ngx_socket.h
View File

@ -9,11 +9,15 @@ typedef SOCKET ngx_socket_t;
void ngx_init_sockets(ngx_log_t *log);
#define ngx_socket(af, type, proto, flags) \
WSASocket(af, type, proto, NULL, 0, flags)
#define ngx_socket_n "WSASocket()"
int ngx_nonblocking_n(s);
#define ngx_nonblocking_n "ioctlsocket (FIONBIO)"
#define ngx_nonblocking_n "ioctlsocket(FIONBIO)"
#define ngx_close_socket closesocket
#define ngx_close_socket_n "closesocket"
#define ngx_close_socket_n "closesocket()"
#endif /* _NGX_SOCKET_H_INCLUDED_ */

2
src/os/win32/ngx_types.h
View File

@ -5,9 +5,7 @@
#include <ngx_config.h>
typedef HANDLE ngx_file_t;
typedef long time_t;
typedef unsigned __int64 off_t;
#define QD_FMT "%I64d"