14 |
15 |
16 | typedef struct {
17 | u_char *addr;
18 | size_t size;
19 | ngx_str_t name;
20 | ngx_log_t *log;
21 | ngx_uint_t exists; /* unsigned exists:1; */
22 | } ngx_shm_t;
23 |
24 |
25 | ngx_int_t ngx_shm_alloc(ngx_shm_t *shm);
26 | void ngx_shm_free(ngx_shm_t *shm);
27 |
28 |
29 | #endif /* _NGX_SHMEM_H_INCLUDED_ */
30 |
--------------------------------------------------------------------------------
/html/50x.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | Error
5 |
12 |
13 |
14 | An error occurred.
15 | Sorry, the page you are looking for is currently unavailable.
16 | Please try again later.
17 | If you are the system administrator of this resource then you should check
18 | the error log for details.
19 | Faithfully yours, nginx.
20 |
21 |
22 |
--------------------------------------------------------------------------------
/contrib/README:
--------------------------------------------------------------------------------
1 |
2 | geo2nginx.pl by Andrei Nigmatulin
3 |
4 | The perl script to convert CSV geoip database ( free download
5 | at http://www.maxmind.com/app/geoip_country ) to format, suitable
6 | for use by the ngx_http_geo_module.
7 |
8 |
9 | unicode2nginx by Maxim Dounin
10 |
11 | The perl script to convert unicode mappings ( available
12 | at http://www.unicode.org/Public/MAPPINGS/ ) to the nginx
13 | configuration file format.
14 | Two generated full maps for windows-1251 and koi8-r.
15 |
16 |
17 | vim by Evan Miller
18 |
19 | Syntax highlighting of nginx configuration for vim, to be
20 | placed into ~/.vim/.
21 |
22 |
--------------------------------------------------------------------------------
/auto/lib/pcre/makefile.bcc:
--------------------------------------------------------------------------------
1 |
2 | # Copyright (C) Igor Sysoev
3 | # Copyright (C) Nginx, Inc.
4 |
5 |
6 | CFLAGS = -q -O2 -tWM -w-8004 $(CPU_OPT)
7 | PCREFLAGS = -DHAVE_CONFIG_H -DPCRE_STATIC -DPOSIX_MALLOC_THRESHOLD=10 \
8 | -DSUPPORT_PCRE8 -DHAVE_MEMMOVE
9 |
10 |
11 | pcre.lib:
12 | cd $(PCRE)
13 |
14 | bcc32 -c $(CFLAGS) -I. $(PCREFLAGS) pcre_*.c
15 |
16 | copy /y nul pcre.lst
17 | for %n in (*.obj) do @echo +%n ^^& >> pcre.lst
18 | echo + >> pcre.lst
19 |
20 | tlib pcre.lib @pcre.lst
21 |
22 | pcre.h:
23 | cd $(PCRE)
24 |
25 | copy /y pcre.h.generic pcre.h
26 | copy /y config.h.generic config.h
27 | copy /y pcre_chartables.c.dist pcre_chartables.c
28 |
--------------------------------------------------------------------------------
/conf/scgi_params:
--------------------------------------------------------------------------------
1 |
2 | scgi_param REQUEST_METHOD $request_method;
3 | scgi_param REQUEST_URI $request_uri;
4 | scgi_param QUERY_STRING $query_string;
5 | scgi_param CONTENT_TYPE $content_type;
6 |
7 | scgi_param DOCUMENT_URI $document_uri;
8 | scgi_param DOCUMENT_ROOT $document_root;
9 | scgi_param SCGI 1;
10 | scgi_param SERVER_PROTOCOL $server_protocol;
11 | scgi_param HTTPS $https if_not_empty;
12 |
13 | scgi_param REMOTE_ADDR $remote_addr;
14 | scgi_param REMOTE_PORT $remote_port;
15 | scgi_param SERVER_PORT $server_port;
16 | scgi_param SERVER_NAME $server_name;
17 |
--------------------------------------------------------------------------------
/eg/requestqueue/conf/nginx-perl.conf:
--------------------------------------------------------------------------------
1 |
2 | worker_processes 1;
3 | daemon off;
4 | master_process off;
5 |
6 | error_log /dev/stderr;
7 |
8 | events {
9 | worker_connections 1024;
10 | }
11 |
12 | http {
13 | default_type text/plain;
14 |
15 | perl_inc ../../objs/src/http/modules/perl/blib/lib;
16 | perl_inc ../../objs/src/http/modules/perl/blib/arch;
17 |
18 | perl_inc lib;
19 | perl_inc ../lib;
20 |
21 | perl_require Requestqueue.pm;
22 |
23 | server {
24 | listen 55555;
25 |
26 | location = /index.html {
27 | perl_access Requestqueue::access_handler;
28 | }
29 | }
30 |
31 | }
32 |
33 |
--------------------------------------------------------------------------------
/conf/uwsgi_params:
--------------------------------------------------------------------------------
1 |
2 | uwsgi_param QUERY_STRING $query_string;
3 | uwsgi_param REQUEST_METHOD $request_method;
4 | uwsgi_param CONTENT_TYPE $content_type;
5 | uwsgi_param CONTENT_LENGTH $content_length;
6 |
7 | uwsgi_param REQUEST_URI $request_uri;
8 | uwsgi_param PATH_INFO $document_uri;
9 | uwsgi_param DOCUMENT_ROOT $document_root;
10 | uwsgi_param SERVER_PROTOCOL $server_protocol;
11 | uwsgi_param HTTPS $https if_not_empty;
12 |
13 | uwsgi_param REMOTE_ADDR $remote_addr;
14 | uwsgi_param REMOTE_PORT $remote_port;
15 | uwsgi_param SERVER_PORT $server_port;
16 | uwsgi_param SERVER_NAME $server_name;
17 |
--------------------------------------------------------------------------------
/src/os/unix/ngx_freebsd.h:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | * Copyright (C) Igor Sysoev
4 | * Copyright (C) Nginx, Inc.
5 | */
6 |
7 |
8 | #ifndef _NGX_FREEBSD_H_INCLUDED_
9 | #define _NGX_FREEBSD_H_INCLUDED_
10 |
11 |
12 | void ngx_debug_init(void);
13 | ngx_chain_t *ngx_freebsd_sendfile_chain(ngx_connection_t *c, ngx_chain_t *in,
14 | off_t limit);
15 |
16 | extern int ngx_freebsd_kern_osreldate;
17 | extern int ngx_freebsd_hw_ncpu;
18 | extern u_long ngx_freebsd_net_inet_tcp_sendspace;
19 |
20 | extern ngx_uint_t ngx_freebsd_sendfile_nbytes_bug;
21 | extern ngx_uint_t ngx_freebsd_use_tcp_nopush;
22 | extern ngx_uint_t ngx_debug_malloc;
23 |
24 |
25 | #endif /* _NGX_FREEBSD_H_INCLUDED_ */
26 |
--------------------------------------------------------------------------------
/src/misc/ngx_cpp_test_module.cpp:
--------------------------------------------------------------------------------
1 |
2 | // stub module to test header files' C++ compatibility
3 |
4 | extern "C" {
5 | #include
6 | #include
7 | #include
8 | #include
9 | #include
10 |
11 | #include
12 |
13 | #include
14 | #include
15 | #include
16 | #include
17 | }
18 |
19 | // nginx header files should go before other, because they define 64-bit off_t
20 | // #include
21 |
22 |
23 | void ngx_cpp_test_handler(void *data);
24 |
25 | void
26 | ngx_cpp_test_handler(void *data)
27 | {
28 | return;
29 | }
30 |
--------------------------------------------------------------------------------
/auto/lib/test:
--------------------------------------------------------------------------------
1 |
2 | # Copyright (C) Igor Sysoev
3 | # Copyright (C) Nginx, Inc.
4 |
5 |
6 | echo $ngx_n "checking for $ngx_lib ...$ngx_c"
7 |
8 | cat << END >> $NGX_AUTOCONF_ERR
9 |
10 | ----------------------------------------
11 | checking for $ngx_lib
12 |
13 | END
14 |
15 | ngx_found=no
16 |
17 | cat << END > $NGX_AUTOTEST.c
18 |
19 | $ngx_lib_incs
20 |
21 | int main() {
22 | $ngx_lib_test;
23 | return 0;
24 | }
25 |
26 |
27 | eval "$CC $cc_test_flags $ngx_lib_cflags \
28 | -o $NGX_AUTOTEST $NGX_AUTOTEST.c $ngx_libs \
29 | >> $NGX_ERR 2>&1"
30 |
31 | if [ -x $NGX_AUTOTEST ]; then
32 | echo " found"
33 |
34 | ngx_found=yes
35 |
36 | else
37 | echo " not found"
38 | fi
39 |
40 | rm -rf $NGX_AUTOTEST*
41 |
--------------------------------------------------------------------------------
/eg/helloworld/conf/nginx-perl.conf:
--------------------------------------------------------------------------------
1 |
2 | worker_processes 1;
3 | daemon off;
4 | master_process off;
5 |
6 | error_log /dev/stderr debug;
7 |
8 | events {
9 | worker_connections 1024;
10 | }
11 |
12 | http {
13 | default_type text/plain;
14 |
15 | perl_inc ../../objs/src/http/modules/perl/blib/lib;
16 | perl_inc ../../objs/src/http/modules/perl/blib/arch;
17 |
18 | perl_inc lib;
19 | perl_inc ../lib;
20 |
21 | perl_require Helloworld.pm;
22 |
23 | perl_eval '
24 | $Helloworld::NAME = "Helloworld";
25 | ';
26 |
27 | perl_init_worker Helloworld::init_worker;
28 |
29 | server {
30 | listen 55555;
31 |
32 | location / {
33 | perl_handler Helloworld::handler;
34 | }
35 | }
36 |
37 | }
38 |
39 |
--------------------------------------------------------------------------------
/auto/lib/make:
--------------------------------------------------------------------------------
1 |
2 | # Copyright (C) Igor Sysoev
3 | # Copyright (C) Nginx, Inc.
4 |
5 |
6 | if [ $PCRE != NONE -a $PCRE != NO -a $PCRE != YES ]; then
7 | . auto/lib/pcre/make
8 | fi
9 |
10 | if [ $MD5 != NONE -a $MD5 != NO -a $MD5 != YES ]; then
11 | . auto/lib/md5/make
12 | fi
13 |
14 | if [ $SHA1 != NONE -a $SHA1 != NO -a $SHA1 != YES ]; then
15 | . auto/lib/sha1/make
16 | fi
17 |
18 | if [ $OPENSSL != NONE -a $OPENSSL != NO -a $OPENSSL != YES ]; then
19 | . auto/lib/openssl/make
20 | fi
21 |
22 | if [ $ZLIB != NONE -a $ZLIB != NO -a $ZLIB != YES ]; then
23 | . auto/lib/zlib/make
24 | fi
25 |
26 | if [ $NGX_LIBATOMIC != NO -a $NGX_LIBATOMIC != YES ]; then
27 | . auto/lib/libatomic/make
28 | fi
29 |
30 | if [ $USE_PERL = YES ]; then
31 | . auto/lib/perl/make
32 | fi
33 |
--------------------------------------------------------------------------------
/src/core/ngx_crc.h:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | * Copyright (C) Igor Sysoev
4 | * Copyright (C) Nginx, Inc.
5 | */
6 |
7 |
8 | #ifndef _NGX_CRC_H_INCLUDED_
9 | #define _NGX_CRC_H_INCLUDED_
10 |
11 |
12 | #include
13 | #include
14 |
15 |
16 | /* 32-bit crc16 */
17 |
18 | static ngx_inline uint32_t
19 | ngx_crc(u_char *data, size_t len)
20 | {
21 | uint32_t sum;
22 |
23 | for (sum = 0; len; len--) {
24 |
25 | /*
26 | * gcc 2.95.2 x86 and icc 7.1.006 compile
27 | * that operator into the single "rol" opcode,
28 | * msvc 6.0sp2 compiles it into four opcodes.
29 | */
30 | sum = sum >> 1 | sum << 31;
31 |
32 | sum += *data++;
33 | }
34 |
35 | return sum;
36 | }
37 |
38 |
39 | #endif /* _NGX_CRC_H_INCLUDED_ */
40 |
--------------------------------------------------------------------------------
/src/event/ngx_event_posted.c:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | * Copyright (C) Igor Sysoev
4 | * Copyright (C) Nginx, Inc.
5 | */
6 |
7 |
8 | #include
9 | #include
10 | #include
11 |
12 |
13 | ngx_queue_t ngx_posted_accept_events;
14 | ngx_queue_t ngx_posted_events;
15 |
16 |
17 | void
18 | ngx_event_process_posted(ngx_cycle_t *cycle, ngx_queue_t *posted)
19 | {
20 | ngx_queue_t *q;
21 | ngx_event_t *ev;
22 |
23 | while (!ngx_queue_empty(posted)) {
24 |
25 | q = ngx_queue_head(posted);
26 | ev = ngx_queue_data(q, ngx_event_t, queue);
27 |
28 | ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
29 | "posted event %p", ev);
30 |
31 | ngx_delete_posted_event(ev);
32 |
33 | ev->handler(ev);
34 | }
35 | }
36 |
--------------------------------------------------------------------------------
/eg/websockets/conf/nginx-perl.conf:
--------------------------------------------------------------------------------
1 |
2 | worker_processes 1;
3 | daemon off;
4 | master_process off;
5 |
6 | error_log /dev/stderr debug;
7 |
8 | events {
9 | worker_connections 1024;
10 | }
11 |
12 | http {
13 | default_type text/plain;
14 |
15 | perl_inc ../../blib/lib;
16 | perl_inc ../../blib/arch;
17 |
18 | perl_inc lib;
19 | perl_inc ../lib;
20 |
21 | perl_require Websockets/Echo.pm;
22 | perl_require Websockets/Draw.pm;
23 |
24 | server {
25 | listen 55555;
26 |
27 | location /echo/ { perl_handler Websockets::Echo::handler; }
28 | location /draw/ { perl_handler Websockets::Draw::handler; }
29 |
30 | location = /echo { rewrite ^ /echo/ permanent; }
31 | location = /draw { rewrite ^ /draw/ permanent; }
32 | }
33 | }
34 |
35 |
--------------------------------------------------------------------------------
/src/core/ngx_syslog.h:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | * Copyright (C) Nginx, Inc.
4 | */
5 |
6 |
7 | #ifndef _NGX_SYSLOG_H_INCLUDED_
8 | #define _NGX_SYSLOG_H_INCLUDED_
9 |
10 |
11 | typedef struct {
12 | ngx_pool_t *pool;
13 | ngx_uint_t facility;
14 | ngx_uint_t severity;
15 | ngx_str_t tag;
16 |
17 | ngx_addr_t server;
18 | ngx_connection_t conn;
19 | ngx_uint_t busy; /* unsigned busy:1; */
20 | } ngx_syslog_peer_t;
21 |
22 |
23 | char *ngx_syslog_process_conf(ngx_conf_t *cf, ngx_syslog_peer_t *peer);
24 | u_char *ngx_syslog_add_header(ngx_syslog_peer_t *peer, u_char *buf);
25 | void ngx_syslog_writer(ngx_log_t *log, ngx_uint_t level, u_char *buf,
26 | size_t len);
27 | ssize_t ngx_syslog_send(ngx_syslog_peer_t *peer, u_char *buf, size_t len);
28 |
29 |
30 | #endif /* _NGX_SYSLOG_H_INCLUDED_ */
31 |
--------------------------------------------------------------------------------
/eg/self-sufficient/conf/nginx-perl.conf:
--------------------------------------------------------------------------------
1 |
2 | worker_processes 1;
3 | daemon off;
4 | master_process off;
5 |
6 | error_log /dev/stderr debug;
7 |
8 | events {
9 | worker_connections 1024;
10 | }
11 |
12 | http {
13 | default_type text/plain;
14 |
15 | perl_inc ../../objs/src/http/modules/perl/blib/lib;
16 | perl_inc ../../objs/src/http/modules/perl/blib/arch;
17 |
18 | perl_inc lib;
19 | perl_inc ../lib;
20 |
21 | perl_require Selfsufficient.pm;
22 |
23 | perl_eval ' $Selfsufficient::SOMETHING = "else" ';
24 |
25 | server {
26 | listen 55555;
27 |
28 | location / {
29 | perl_handler Selfsufficient::handler;
30 | }
31 |
32 | location /tralala {
33 | set $name "tra";
34 | perl_handler Selfsufficient::handler;
35 | }
36 |
37 | }
38 |
39 | }
40 |
41 |
--------------------------------------------------------------------------------
/eg/requestqueue/lib/Requestqueue.pm:
--------------------------------------------------------------------------------
1 | package Requestqueue;
2 |
3 | use strict;
4 | use warnings;
5 | no warnings 'uninitialized';
6 |
7 | use Nginx;
8 |
9 | our @QUEUE;
10 | our $MAX_ACTIVE_REQUESTS = 4;
11 | our $ACTIVE_REQUESTS = 0;
12 |
13 |
14 | sub access_handler {
15 | my ($r) = @_;
16 |
17 | if ($ACTIVE_REQUESTS < $MAX_ACTIVE_REQUESTS) {
18 | $ACTIVE_REQUESTS++;
19 |
20 | return NGX_OK;
21 | } else {
22 | $r->log_error(0, "Too many concurrent requests, queueing");
23 |
24 | push @QUEUE, $r;
25 |
26 | return NGX_DONE;
27 | }
28 | }
29 |
30 |
31 | sub Nginx::DESTROY {
32 | if (@QUEUE == 0) {
33 | $ACTIVE_REQUESTS--;
34 | } else {
35 | my $r = shift @QUEUE;
36 |
37 | $r->log_error(0, "Dequeuing");
38 |
39 | $r->phase_handler_inc;
40 | $r->core_run_phases;
41 | }
42 | }
43 |
44 |
45 | 1;
46 |
--------------------------------------------------------------------------------
/src/os/unix/ngx_channel.h:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | * Copyright (C) Igor Sysoev
4 | * Copyright (C) Nginx, Inc.
5 | */
6 |
7 |
8 | #ifndef _NGX_CHANNEL_H_INCLUDED_
9 | #define _NGX_CHANNEL_H_INCLUDED_
10 |
11 |
12 | #include
13 | #include
14 | #include
15 |
16 |
17 | typedef struct {
18 | ngx_uint_t command;
19 | ngx_pid_t pid;
20 | ngx_int_t slot;
21 | ngx_fd_t fd;
22 | } ngx_channel_t;
23 |
24 |
25 | ngx_int_t ngx_write_channel(ngx_socket_t s, ngx_channel_t *ch, size_t size,
26 | ngx_log_t *log);
27 | ngx_int_t ngx_read_channel(ngx_socket_t s, ngx_channel_t *ch, size_t size,
28 | ngx_log_t *log);
29 | ngx_int_t ngx_add_channel_event(ngx_cycle_t *cycle, ngx_fd_t fd,
30 | ngx_int_t event, ngx_event_handler_pt handler);
31 | void ngx_close_channel(ngx_fd_t *fd, ngx_log_t *log);
32 |
33 |
34 | #endif /* _NGX_CHANNEL_H_INCLUDED_ */
35 |
--------------------------------------------------------------------------------
/auto/os/win32:
--------------------------------------------------------------------------------
1 |
2 | # Copyright (C) Igor Sysoev
3 | # Copyright (C) Nginx, Inc.
4 |
5 |
6 | have=NGX_WIN32 . auto/have_headers
7 |
8 | CORE_INCS="$WIN32_INCS"
9 | CORE_DEPS="$WIN32_DEPS"
10 | CORE_SRCS="$WIN32_SRCS $IOCP_SRCS"
11 | OS_CONFIG="$WIN32_CONFIG"
12 | NGX_ICONS="$NGX_WIN32_ICONS"
13 | SELECT_SRCS=$WIN32_SELECT_SRCS
14 |
15 | case "$NGX_CC_NAME" in
16 |
17 | gcc)
18 | CORE_LIBS="$CORE_LIBS -ladvapi32 -lws2_32"
19 | ;;
20 |
21 | *)
22 | CORE_LIBS="$CORE_LIBS advapi32.lib ws2_32.lib"
23 | ;;
24 |
25 | esac
26 |
27 | EVENT_MODULES="$EVENT_MODULES $IOCP_MODULE"
28 | EVENT_FOUND=YES
29 |
30 | if [ $EVENT_SELECT = NO ]; then
31 | CORE_SRCS="$CORE_SRCS $SELECT_SRCS"
32 | EVENT_MODULES="$EVENT_MODULES $SELECT_MODULE"
33 | fi
34 |
35 | if [ $NGX_IPV6 = YES ]; then
36 | have=NGX_HAVE_INET6 . auto/have
37 | fi
38 |
39 | have=NGX_HAVE_AIO . auto/have
40 | have=NGX_HAVE_IOCP . auto/have
41 |
--------------------------------------------------------------------------------
/src/core/ngx_murmurhash.c:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | * Copyright (C) Austin Appleby
4 | */
5 |
6 |
7 | #include
8 | #include
9 |
10 |
11 | uint32_t
12 | ngx_murmur_hash2(u_char *data, size_t len)
13 | {
14 | uint32_t h, k;
15 |
16 | h = 0 ^ len;
17 |
18 | while (len >= 4) {
19 | k = data[0];
20 | k |= data[1] << 8;
21 | k |= data[2] << 16;
22 | k |= data[3] << 24;
23 |
24 | k *= 0x5bd1e995;
25 | k ^= k >> 24;
26 | k *= 0x5bd1e995;
27 |
28 | h *= 0x5bd1e995;
29 | h ^= k;
30 |
31 | data += 4;
32 | len -= 4;
33 | }
34 |
35 | switch (len) {
36 | case 3:
37 | h ^= data[2] << 16;
38 | case 2:
39 | h ^= data[1] << 8;
40 | case 1:
41 | h ^= data[0];
42 | h *= 0x5bd1e995;
43 | }
44 |
45 | h ^= h >> 13;
46 | h *= 0x5bd1e995;
47 | h ^= h >> 15;
48 |
49 | return h;
50 | }
51 |
--------------------------------------------------------------------------------
/src/os/unix/ngx_sunpro_sparc64.il:
--------------------------------------------------------------------------------
1 | /
2 | / Copyright (C) Igor Sysoev
3 | / Copyright (C) Nginx, Inc.
4 | /
5 |
6 |
7 | / "casa [%o2] 0x80, %o1, %o0" and
8 | / "casxa [%o2] 0x80, %o1, %o0" do the following:
9 | /
10 | / if ([%o2] == %o1) {
11 | / swap(%o0, [%o2]);
12 | / } else {
13 | / %o0 = [%o2];
14 | / }
15 |
16 |
17 | / ngx_atomic_uint_t ngx_casa(ngx_atomic_uint_t set, ngx_atomic_uint_t old,
18 | / ngx_atomic_t *lock);
19 | /
20 | / the arguments are passed in the %o0, %o1, %o2
21 | / the result is returned in the %o0
22 |
23 | .inline ngx_casa,0
24 | casa [%o2] 0x80, %o1, %o0
25 | .end
26 |
27 |
28 | / ngx_atomic_uint_t ngx_casxa(ngx_atomic_uint_t set, ngx_atomic_uint_t old,
29 | / ngx_atomic_t *lock);
30 | /
31 | / the arguments are passed in the %o0, %o1, %o2
32 | / the result is returned in the %o0
33 |
34 | .inline ngx_casxa,0
35 | casxa [%o2] 0x80, %o1, %o0
36 | .end
37 |
--------------------------------------------------------------------------------
/auto/init:
--------------------------------------------------------------------------------
1 |
2 | # Copyright (C) Igor Sysoev
3 | # Copyright (C) Nginx, Inc.
4 |
5 |
6 | NGX_MAKEFILE=$NGX_OBJS/Makefile
7 | NGX_MODULES_C=$NGX_OBJS/ngx_modules.c
8 |
9 | NGX_AUTO_HEADERS_H=$NGX_OBJS/ngx_auto_headers.h
10 | NGX_AUTO_CONFIG_H=$NGX_OBJS/ngx_auto_config.h
11 |
12 | NGX_AUTOTEST=$NGX_OBJS/autotest
13 | NGX_AUTOCONF_ERR=$NGX_OBJS/autoconf.err
14 |
15 | # STUBs
16 | NGX_ERR=$NGX_OBJS/autoconf.err
17 | MAKEFILE=$NGX_OBJS/Makefile
18 |
19 |
20 | NGX_PCH=
21 | NGX_USE_PCH=
22 |
23 |
24 | # check the echo's "-n" option and "\c" capability
25 |
26 | if echo "test\c" | grep c >/dev/null; then
27 |
28 | if echo -n test | grep n >/dev/null; then
29 | ngx_n=
30 | ngx_c=
31 |
32 | else
33 | ngx_n=-n
34 | ngx_c=
35 | fi
36 |
37 | else
38 | ngx_n=
39 | ngx_c='\c'
40 | fi
41 |
42 |
43 | # create Makefile
44 |
45 | cat << END > Makefile
46 |
47 | default: build
48 |
49 | clean:
50 | rm -rf Makefile $NGX_OBJS
51 | rm -rf blib
52 | END
53 |
--------------------------------------------------------------------------------
/src/http/modules/perl/Perl.pm:
--------------------------------------------------------------------------------
1 | package Nginx::Perl;
2 |
3 | our $VERSION = '1.8.1.10';
4 |
5 |
6 | 1;
7 | __END__
8 |
9 | =head1 NAME
10 |
11 | Nginx::Perl - full-featured perl support for nginx
12 |
13 | =head1 DESCRIPTION
14 |
15 | This is just a meta package to use as a dependency and
16 | for official package name on CPAN.
17 |
18 | Most of the documentation contained in L, check it out.
19 |
20 | Web page: L
21 |
22 | =head1 SEE ALSO
23 |
24 | L,
25 | L, L, L, L,
26 | L,
27 | L
28 |
29 | =head1 AUTHOR
30 |
31 | Alexandr Gomoliako
32 |
33 | =head1 LICENSE
34 |
35 | Copyright 2011 Alexandr Gomoliako. All rights reserved.
36 |
37 | This module is free software. It may be used, redistributed and/or modified
38 | under the same terms as B itself.
39 |
40 | =cut
41 |
42 |
--------------------------------------------------------------------------------
/src/mail/ngx_mail_pop3_module.h:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | * Copyright (C) Igor Sysoev
4 | * Copyright (C) Nginx, Inc.
5 | */
6 |
7 |
8 | #ifndef _NGX_MAIL_POP3_MODULE_H_INCLUDED_
9 | #define _NGX_MAIL_POP3_MODULE_H_INCLUDED_
10 |
11 |
12 | #include
13 | #include
14 | #include
15 |
16 |
17 | typedef struct {
18 | ngx_str_t capability;
19 | ngx_str_t starttls_capability;
20 | ngx_str_t starttls_only_capability;
21 | ngx_str_t auth_capability;
22 |
23 | ngx_uint_t auth_methods;
24 |
25 | ngx_array_t capabilities;
26 | } ngx_mail_pop3_srv_conf_t;
27 |
28 |
29 | void ngx_mail_pop3_init_session(ngx_mail_session_t *s, ngx_connection_t *c);
30 | void ngx_mail_pop3_init_protocol(ngx_event_t *rev);
31 | void ngx_mail_pop3_auth_state(ngx_event_t *rev);
32 | ngx_int_t ngx_mail_pop3_parse_command(ngx_mail_session_t *s);
33 |
34 |
35 | extern ngx_module_t ngx_mail_pop3_module;
36 |
37 |
38 | #endif /* _NGX_MAIL_POP3_MODULE_H_INCLUDED_ */
39 |
--------------------------------------------------------------------------------
/src/mail/ngx_mail_imap_module.h:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | * Copyright (C) Igor Sysoev
4 | * Copyright (C) Nginx, Inc.
5 | */
6 |
7 |
8 | #ifndef _NGX_MAIL_IMAP_MODULE_H_INCLUDED_
9 | #define _NGX_MAIL_IMAP_MODULE_H_INCLUDED_
10 |
11 |
12 | #include
13 | #include
14 | #include
15 |
16 |
17 | typedef struct {
18 | size_t client_buffer_size;
19 |
20 | ngx_str_t capability;
21 | ngx_str_t starttls_capability;
22 | ngx_str_t starttls_only_capability;
23 |
24 | ngx_uint_t auth_methods;
25 |
26 | ngx_array_t capabilities;
27 | } ngx_mail_imap_srv_conf_t;
28 |
29 |
30 | void ngx_mail_imap_init_session(ngx_mail_session_t *s, ngx_connection_t *c);
31 | void ngx_mail_imap_init_protocol(ngx_event_t *rev);
32 | void ngx_mail_imap_auth_state(ngx_event_t *rev);
33 | ngx_int_t ngx_mail_imap_parse_command(ngx_mail_session_t *s);
34 |
35 |
36 | extern ngx_module_t ngx_mail_imap_module;
37 |
38 |
39 | #endif /* _NGX_MAIL_IMAP_MODULE_H_INCLUDED_ */
40 |
--------------------------------------------------------------------------------
/src/core/ngx_thread_pool.h:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | * Copyright (C) Nginx, Inc.
4 | * Copyright (C) Valentin V. Bartenev
5 | */
6 |
7 |
8 | #ifndef _NGX_THREAD_POOL_H_INCLUDED_
9 | #define _NGX_THREAD_POOL_H_INCLUDED_
10 |
11 |
12 | #include
13 | #include
14 | #include
15 |
16 |
17 | struct ngx_thread_task_s {
18 | ngx_thread_task_t *next;
19 | ngx_uint_t id;
20 | void *ctx;
21 | void (*handler)(void *data, ngx_log_t *log);
22 | ngx_event_t event;
23 | };
24 |
25 |
26 | typedef struct ngx_thread_pool_s ngx_thread_pool_t;
27 |
28 |
29 | ngx_thread_pool_t *ngx_thread_pool_add(ngx_conf_t *cf, ngx_str_t *name);
30 | ngx_thread_pool_t *ngx_thread_pool_get(ngx_cycle_t *cycle, ngx_str_t *name);
31 |
32 | ngx_thread_task_t *ngx_thread_task_alloc(ngx_pool_t *pool, size_t size);
33 | ngx_int_t ngx_thread_task_post(ngx_thread_pool_t *tp, ngx_thread_task_t *task);
34 |
35 |
36 | #endif /* _NGX_THREAD_POOL_H_INCLUDED_ */
37 |
--------------------------------------------------------------------------------
/auto/endianness:
--------------------------------------------------------------------------------
1 |
2 | # Copyright (C) Igor Sysoev
3 | # Copyright (C) Nginx, Inc.
4 |
5 |
6 | echo $ngx_n "checking for system byte ordering ...$ngx_c"
7 | echo >> $NGX_ERR
8 | echo "checking for system byte ordering" >> $NGX_ERR
9 |
10 |
11 | cat << END > $NGX_AUTOTEST.c
12 |
13 | int main() {
14 | int i = 0x11223344;
15 | char *p;
16 |
17 | p = (char *) &i;
18 | if (*p == 0x44) return 0;
19 | return 1;
20 | }
21 |
22 | END
23 |
24 | ngx_test="$CC $CC_TEST_FLAGS $CC_AUX_FLAGS \
25 | -o $NGX_AUTOTEST $NGX_AUTOTEST.c $NGX_LD_OPT $ngx_feature_libs"
26 |
27 | eval "$ngx_test >> $NGX_AUTOCONF_ERR 2>&1"
28 |
29 | if [ -x $NGX_AUTOTEST ]; then
30 | if $NGX_AUTOTEST >/dev/null 2>&1; then
31 | echo " little endian"
32 | have=NGX_HAVE_LITTLE_ENDIAN . auto/have
33 | else
34 | echo " big endian"
35 | fi
36 |
37 | rm -rf $NGX_AUTOTEST*
38 |
39 | else
40 | rm -rf $NGX_AUTOTEST*
41 |
42 | echo
43 | echo "$0: error: cannot detect system byte ordering"
44 | exit 1
45 | fi
46 |
--------------------------------------------------------------------------------
/conf/fastcgi_params:
--------------------------------------------------------------------------------
1 |
2 | fastcgi_param QUERY_STRING $query_string;
3 | fastcgi_param REQUEST_METHOD $request_method;
4 | fastcgi_param CONTENT_TYPE $content_type;
5 | fastcgi_param CONTENT_LENGTH $content_length;
6 |
7 | fastcgi_param SCRIPT_NAME $fastcgi_script_name;
8 | fastcgi_param REQUEST_URI $request_uri;
9 | fastcgi_param DOCUMENT_URI $document_uri;
10 | fastcgi_param DOCUMENT_ROOT $document_root;
11 | fastcgi_param SERVER_PROTOCOL $server_protocol;
12 | fastcgi_param HTTPS $https if_not_empty;
13 |
14 | fastcgi_param GATEWAY_INTERFACE CGI/1.1;
15 | fastcgi_param SERVER_SOFTWARE nginx/$nginx_version;
16 |
17 | fastcgi_param REMOTE_ADDR $remote_addr;
18 | fastcgi_param REMOTE_PORT $remote_port;
19 | fastcgi_param SERVER_ADDR $server_addr;
20 | fastcgi_param SERVER_PORT $server_port;
21 | fastcgi_param SERVER_NAME $server_name;
22 |
23 | # PHP only, required if PHP was built with --enable-force-cgi-redirect
24 | fastcgi_param REDIRECT_STATUS 200;
25 |
--------------------------------------------------------------------------------
/src/core/ngx_spinlock.c:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | * Copyright (C) Igor Sysoev
4 | * Copyright (C) Nginx, Inc.
5 | */
6 |
7 |
8 | #include
9 | #include
10 |
11 |
12 | void
13 | ngx_spinlock(ngx_atomic_t *lock, ngx_atomic_int_t value, ngx_uint_t spin)
14 | {
15 |
16 | #if (NGX_HAVE_ATOMIC_OPS)
17 |
18 | ngx_uint_t i, n;
19 |
20 | for ( ;; ) {
21 |
22 | if (*lock == 0 && ngx_atomic_cmp_set(lock, 0, value)) {
23 | return;
24 | }
25 |
26 | if (ngx_ncpu > 1) {
27 |
28 | for (n = 1; n < spin; n <<= 1) {
29 |
30 | for (i = 0; i < n; i++) {
31 | ngx_cpu_pause();
32 | }
33 |
34 | if (*lock == 0 && ngx_atomic_cmp_set(lock, 0, value)) {
35 | return;
36 | }
37 | }
38 | }
39 |
40 | ngx_sched_yield();
41 | }
42 |
43 | #else
44 |
45 | #if (NGX_THREADS)
46 |
47 | #error ngx_spinlock() or ngx_atomic_cmp_set() are not defined !
48 |
49 | #endif
50 |
51 | #endif
52 |
53 | }
54 |
--------------------------------------------------------------------------------
/auto/types/uintptr_t:
--------------------------------------------------------------------------------
1 |
2 | # Copyright (C) Igor Sysoev
3 | # Copyright (C) Nginx, Inc.
4 |
5 |
6 | echo $ngx_n "checking for uintptr_t ...$ngx_c"
7 | echo >> $NGX_AUTOCONF_ERR
8 | echo "checking for uintptr_t" >> $NGX_AUTOCONF_ERR
9 |
10 | found=no
11 |
12 | cat << END > $NGX_AUTOTEST.c
13 |
14 | #include
15 | $NGX_INTTYPES_H
16 |
17 | int main() {
18 | uintptr_t i = 0;
19 | return (int) i;
20 | }
21 |
22 | END
23 |
24 | ngx_test="$CC $CC_TEST_FLAGS $CC_AUX_FLAGS \
25 | -o $NGX_AUTOTEST $NGX_AUTOTEST.c $NGX_LD_OPT"
26 |
27 | eval "$ngx_test >> $NGX_AUTOCONF_ERR 2>&1"
28 |
29 | if [ -x $NGX_AUTOTEST ]; then
30 | echo " uintptr_t found"
31 | found=yes
32 | else
33 | echo $ngx_n " uintptr_t not found" $ngx_c
34 | fi
35 |
36 | rm -rf $NGX_AUTOTEST*
37 |
38 |
39 | if [ $found = no ]; then
40 | found="uint`expr 8 \* $ngx_ptr_size`_t"
41 | echo ", $found used"
42 |
43 | echo "typedef $found uintptr_t;" >> $NGX_AUTO_CONFIG_H
44 | echo "typedef $found intptr_t;" | sed -e 's/u//g' >> $NGX_AUTO_CONFIG_H
45 | fi
46 |
--------------------------------------------------------------------------------
/src/os/unix/ngx_alloc.h:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | * Copyright (C) Igor Sysoev
4 | * Copyright (C) Nginx, Inc.
5 | */
6 |
7 |
8 | #ifndef _NGX_ALLOC_H_INCLUDED_
9 | #define _NGX_ALLOC_H_INCLUDED_
10 |
11 |
12 | #include
13 | #include
14 |
15 |
16 | void *ngx_alloc(size_t size, ngx_log_t *log);
17 | void *ngx_calloc(size_t size, ngx_log_t *log);
18 |
19 | #define ngx_free free
20 |
21 |
22 | /*
23 | * Linux has memalign() or posix_memalign()
24 | * Solaris has memalign()
25 | * FreeBSD 7.0 has posix_memalign(), besides, early version's malloc()
26 | * aligns allocations bigger than page size at the page boundary
27 | */
28 |
29 | #if (NGX_HAVE_POSIX_MEMALIGN || NGX_HAVE_MEMALIGN)
30 |
31 | void *ngx_memalign(size_t alignment, size_t size, ngx_log_t *log);
32 |
33 | #else
34 |
35 | #define ngx_memalign(alignment, size, log) ngx_alloc(size, log)
36 |
37 | #endif
38 |
39 |
40 | extern ngx_uint_t ngx_pagesize;
41 | extern ngx_uint_t ngx_pagesize_shift;
42 | extern ngx_uint_t ngx_cacheline_size;
43 |
44 |
45 | #endif /* _NGX_ALLOC_H_INCLUDED_ */
46 |
--------------------------------------------------------------------------------
/src/http/ngx_http_spdy_module.h:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | * Copyright (C) Nginx, Inc.
4 | * Copyright (C) Valentin V. Bartenev
5 | */
6 |
7 |
8 | #ifndef _NGX_HTTP_SPDY_MODULE_H_INCLUDED_
9 | #define _NGX_HTTP_SPDY_MODULE_H_INCLUDED_
10 |
11 |
12 | #include
13 | #include
14 | #include
15 |
16 |
17 | typedef struct {
18 | size_t recv_buffer_size;
19 | u_char *recv_buffer;
20 | } ngx_http_spdy_main_conf_t;
21 |
22 |
23 | typedef struct {
24 | size_t pool_size;
25 | ngx_uint_t concurrent_streams;
26 | ngx_uint_t streams_index_mask;
27 | ngx_msec_t recv_timeout;
28 | ngx_msec_t keepalive_timeout;
29 | ngx_int_t headers_comp;
30 | } ngx_http_spdy_srv_conf_t;
31 |
32 |
33 | typedef struct {
34 | size_t chunk_size;
35 | } ngx_http_spdy_loc_conf_t;
36 |
37 |
38 | extern ngx_module_t ngx_http_spdy_module;
39 |
40 |
41 | #endif /* _NGX_HTTP_SPDY_MODULE_H_INCLUDED_ */
42 |
--------------------------------------------------------------------------------
/conf/fastcgi.conf:
--------------------------------------------------------------------------------
1 |
2 | fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
3 | fastcgi_param QUERY_STRING $query_string;
4 | fastcgi_param REQUEST_METHOD $request_method;
5 | fastcgi_param CONTENT_TYPE $content_type;
6 | fastcgi_param CONTENT_LENGTH $content_length;
7 |
8 | fastcgi_param SCRIPT_NAME $fastcgi_script_name;
9 | fastcgi_param REQUEST_URI $request_uri;
10 | fastcgi_param DOCUMENT_URI $document_uri;
11 | fastcgi_param DOCUMENT_ROOT $document_root;
12 | fastcgi_param SERVER_PROTOCOL $server_protocol;
13 | fastcgi_param HTTPS $https if_not_empty;
14 |
15 | fastcgi_param GATEWAY_INTERFACE CGI/1.1;
16 | fastcgi_param SERVER_SOFTWARE nginx/$nginx_version;
17 |
18 | fastcgi_param REMOTE_ADDR $remote_addr;
19 | fastcgi_param REMOTE_PORT $remote_port;
20 | fastcgi_param SERVER_ADDR $server_addr;
21 | fastcgi_param SERVER_PORT $server_port;
22 | fastcgi_param SERVER_NAME $server_name;
23 |
24 | # PHP only, required if PHP was built with --enable-force-cgi-redirect
25 | fastcgi_param REDIRECT_STATUS 200;
26 |
--------------------------------------------------------------------------------
/src/http/modules/perl/Makefile.PL:
--------------------------------------------------------------------------------
1 |
2 | # Copyright (C) Igor Sysoev, Alexandr Gomoliako
3 | # Copyright (C) Nginx, Inc.
4 |
5 | use ExtUtils::MakeMaker;
6 |
7 | WriteMakefile(
8 | NAME => 'Nginx',
9 | VERSION_FROM => 'Nginx.pm',
10 | PREREQ_PM => {},
11 | ABSTRACT_FROM => 'Nginx.pm',
12 | AUTHOR => 'Igor Sysoev, Alexandr Gomoliako',
13 | CCFLAGS => "$ENV{NGX_PM_CFLAGS}",
14 | OPTIMIZE => '-O',
15 | INC => join(" ", map {
16 | m#^/# ? "-I $_" : "-I ../../../../../$_"
17 | } (split /\s+/, $ENV{NGX_INCS})),
18 |
19 | depend => {
20 | 'Nginx.c' => join(" ", map {
21 | m#^/# ? $_ : "../../../../../$_"
22 | } (split(/\s+/, $ENV{NGX_DEPS}),
23 | "src/http/modules/perl/ngx_http_perl_module.h"))
24 | },
25 |
26 | PM => {
27 | 'Nginx.pm' => '$(INST_LIBDIR)/Nginx.pm',
28 | 'Test.pm' => '$(INST_LIBDIR)/Nginx/Test.pm',
29 | 'Perl.pm' => '$(INST_LIBDIR)/Nginx/Perl.pm',
30 | }
31 | );
32 |
--------------------------------------------------------------------------------
/src/mail/ngx_mail_smtp_module.h:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | * Copyright (C) Igor Sysoev
4 | * Copyright (C) Nginx, Inc.
5 | */
6 |
7 |
8 | #ifndef _NGX_MAIL_SMTP_MODULE_H_INCLUDED_
9 | #define _NGX_MAIL_SMTP_MODULE_H_INCLUDED_
10 |
11 |
12 | #include
13 | #include
14 | #include
15 | #include
16 |
17 |
18 | typedef struct {
19 | ngx_msec_t greeting_delay;
20 |
21 | size_t client_buffer_size;
22 |
23 | ngx_str_t capability;
24 | ngx_str_t starttls_capability;
25 | ngx_str_t starttls_only_capability;
26 |
27 | ngx_str_t server_name;
28 | ngx_str_t greeting;
29 |
30 | ngx_uint_t auth_methods;
31 |
32 | ngx_array_t capabilities;
33 | } ngx_mail_smtp_srv_conf_t;
34 |
35 |
36 | void ngx_mail_smtp_init_session(ngx_mail_session_t *s, ngx_connection_t *c);
37 | void ngx_mail_smtp_init_protocol(ngx_event_t *rev);
38 | void ngx_mail_smtp_auth_state(ngx_event_t *rev);
39 | ngx_int_t ngx_mail_smtp_parse_command(ngx_mail_session_t *s);
40 |
41 |
42 | extern ngx_module_t ngx_mail_smtp_module;
43 |
44 |
45 | #endif /* _NGX_MAIL_SMTP_MODULE_H_INCLUDED_ */
46 |
--------------------------------------------------------------------------------
/src/core/ngx_md5.h:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | * Copyright (C) Igor Sysoev
4 | * Copyright (C) Nginx, Inc.
5 | */
6 |
7 |
8 | #ifndef _NGX_MD5_H_INCLUDED_
9 | #define _NGX_MD5_H_INCLUDED_
10 |
11 |
12 | #include
13 | #include
14 |
15 |
16 | #if (NGX_HAVE_MD5)
17 |
18 | #if (NGX_HAVE_OPENSSL_MD5_H)
19 | #include
20 | #else
21 | #include
22 | #endif
23 |
24 |
25 | typedef MD5_CTX ngx_md5_t;
26 |
27 |
28 | #if (NGX_OPENSSL_MD5)
29 |
30 | #define ngx_md5_init MD5_Init
31 | #define ngx_md5_update MD5_Update
32 | #define ngx_md5_final MD5_Final
33 |
34 | #else
35 |
36 | #define ngx_md5_init MD5Init
37 | #define ngx_md5_update MD5Update
38 | #define ngx_md5_final MD5Final
39 |
40 | #endif
41 |
42 |
43 | #else /* !NGX_HAVE_MD5 */
44 |
45 |
46 | typedef struct {
47 | uint64_t bytes;
48 | uint32_t a, b, c, d;
49 | u_char buffer[64];
50 | } ngx_md5_t;
51 |
52 |
53 | void ngx_md5_init(ngx_md5_t *ctx);
54 | void ngx_md5_update(ngx_md5_t *ctx, const void *data, size_t size);
55 | void ngx_md5_final(u_char result[16], ngx_md5_t *ctx);
56 |
57 |
58 | #endif
59 |
60 | #endif /* _NGX_MD5_H_INCLUDED_ */
61 |
--------------------------------------------------------------------------------
/src/core/ngx_shmtx.h:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | * Copyright (C) Igor Sysoev
4 | * Copyright (C) Nginx, Inc.
5 | */
6 |
7 |
8 | #ifndef _NGX_SHMTX_H_INCLUDED_
9 | #define _NGX_SHMTX_H_INCLUDED_
10 |
11 |
12 | #include
13 | #include
14 |
15 |
16 | typedef struct {
17 | ngx_atomic_t lock;
18 | #if (NGX_HAVE_POSIX_SEM)
19 | ngx_atomic_t wait;
20 | #endif
21 | } ngx_shmtx_sh_t;
22 |
23 |
24 | typedef struct {
25 | #if (NGX_HAVE_ATOMIC_OPS)
26 | ngx_atomic_t *lock;
27 | #if (NGX_HAVE_POSIX_SEM)
28 | ngx_atomic_t *wait;
29 | ngx_uint_t semaphore;
30 | sem_t sem;
31 | #endif
32 | #else
33 | ngx_fd_t fd;
34 | u_char *name;
35 | #endif
36 | ngx_uint_t spin;
37 | } ngx_shmtx_t;
38 |
39 |
40 | ngx_int_t ngx_shmtx_create(ngx_shmtx_t *mtx, ngx_shmtx_sh_t *addr,
41 | u_char *name);
42 | void ngx_shmtx_destroy(ngx_shmtx_t *mtx);
43 | ngx_uint_t ngx_shmtx_trylock(ngx_shmtx_t *mtx);
44 | void ngx_shmtx_lock(ngx_shmtx_t *mtx);
45 | void ngx_shmtx_unlock(ngx_shmtx_t *mtx);
46 | ngx_uint_t ngx_shmtx_force_unlock(ngx_shmtx_t *mtx, ngx_pid_t pid);
47 |
48 |
49 | #endif /* _NGX_SHMTX_H_INCLUDED_ */
50 |
--------------------------------------------------------------------------------
/README:
--------------------------------------------------------------------------------
1 | NAME
2 | nginx-perl - full-featured perl support for nginx
3 |
4 | DESCRIPTION
5 | nginx-perl completes original embedded perl with asynchronous
6 | capabilities and a few useful functions.
7 |
8 | URL
9 |
10 |
11 | FEATURES
12 | - full official nginx perl API;
13 | - asynchronous connections (ngx_connector, ngx_reader, ngx_writer);
14 | - timer (ngx_timer);
15 | - SSL (ngx_ssl_handshaker);
16 | - resolver (ngx_resolver);
17 | - access handlers (perl_access);
18 | - app handlers (perl_app);
19 | - configuration level eval (perl_eval);
20 | - init_worker, exit_worker handlers (perl_init_worker, perl_exit_worker);
21 | - logging functions (ngx_log_*);
22 | - client connection takeover for websockets, etc;
23 |
24 | AUTHOR
25 | Alexandr Gomoliako , Igor Sysoev
26 |
27 | COPYRIGHT AND LICENSE
28 | Copyright (C) Igor Sysoev
29 |
30 | Copyright 2011 Alexandr Gomoliako. All rights reserved.
31 |
32 | nginx-perl is free software. It may be used, redistributed and/or
33 | modified under the same terms as nginx itself. Take a look into LICENSE
34 | for details.
35 |
36 |
--------------------------------------------------------------------------------
/src/os/unix/ngx_setproctitle.h:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | * Copyright (C) Igor Sysoev
4 | * Copyright (C) Nginx, Inc.
5 | */
6 |
7 |
8 | #ifndef _NGX_SETPROCTITLE_H_INCLUDED_
9 | #define _NGX_SETPROCTITLE_H_INCLUDED_
10 |
11 |
12 | #if (NGX_HAVE_SETPROCTITLE)
13 |
14 | /* FreeBSD, NetBSD, OpenBSD */
15 |
16 | #define ngx_init_setproctitle(log) NGX_OK
17 | #define ngx_setproctitle(title) setproctitle("%s", title)
18 |
19 |
20 | #else /* !NGX_HAVE_SETPROCTITLE */
21 |
22 | #if !defined NGX_SETPROCTITLE_USES_ENV
23 |
24 | #if (NGX_SOLARIS)
25 |
26 | #define NGX_SETPROCTITLE_USES_ENV 1
27 | #define NGX_SETPROCTITLE_PAD ' '
28 |
29 | ngx_int_t ngx_init_setproctitle(ngx_log_t *log);
30 | void ngx_setproctitle(char *title);
31 |
32 | #elif (NGX_LINUX) || (NGX_DARWIN)
33 |
34 | #define NGX_SETPROCTITLE_USES_ENV 1
35 | #define NGX_SETPROCTITLE_PAD '\0'
36 |
37 | ngx_int_t ngx_init_setproctitle(ngx_log_t *log);
38 | void ngx_setproctitle(char *title);
39 |
40 | #else
41 |
42 | #define ngx_init_setproctitle(log) NGX_OK
43 | #define ngx_setproctitle(title)
44 |
45 | #endif /* OSes */
46 |
47 | #endif /* NGX_SETPROCTITLE_USES_ENV */
48 |
49 | #endif /* NGX_HAVE_SETPROCTITLE */
50 |
51 |
52 | #endif /* _NGX_SETPROCTITLE_H_INCLUDED_ */
53 |
--------------------------------------------------------------------------------
/eg/helloworld/lib/Helloworld.pm:
--------------------------------------------------------------------------------
1 | package Helloworld;
2 |
3 | use strict;
4 | use warnings;
5 | no warnings 'uninitialized';
6 |
7 | use Sys::Hostname;
8 |
9 | use Nginx;
10 |
11 | our $NAME = 'unnamed';
12 |
13 |
14 | sub init_worker {
15 |
16 | my $hostname = hostname;
17 |
18 | warn << " END";
19 |
20 |
21 | Helloworld is running on *:55555
22 |
23 | http://127.0.0.1:55555/
24 | http://$hostname:55555/
25 |
26 |
27 | END
28 | }
29 |
30 |
31 | sub handler {
32 | my ($r) = @_;
33 |
34 | return OK
35 | if $r->has_request_body ( \&handler_post );
36 |
37 | return &handler_post;
38 | }
39 |
40 |
41 | sub handler_post {
42 | my ($r) = @_;
43 |
44 | $r->main_count_inc;
45 |
46 |
47 | my $buf = "Hello from $NAME\n";
48 |
49 | $r->header_out('Cache-Control', 'no-cache');
50 | $r->header_out('Pragma', 'no-cache');
51 | $r->header_out('Content-Length', length($buf));
52 |
53 | $r->send_http_header('text/html; charset=UTF-8');
54 |
55 | $r->print($buf)
56 | unless $r->header_only;
57 |
58 | $r->send_special(NGX_HTTP_LAST);
59 | $r->finalize_request(NGX_OK);
60 |
61 |
62 | return NGX_DONE;
63 | }
64 |
65 |
66 | 1;
67 |
68 |
--------------------------------------------------------------------------------
/src/os/unix/ngx_sunpro_amd64.il:
--------------------------------------------------------------------------------
1 | /
2 | / Copyright (C) Igor Sysoev
3 | / Copyright (C) Nginx, Inc.
4 | /
5 |
6 | / ngx_atomic_uint_t ngx_atomic_cmp_set(ngx_atomic_t *lock,
7 | / ngx_atomic_uint_t old, ngx_atomic_uint_t set);
8 | /
9 | / the arguments are passed in %rdi, %rsi, %rdx
10 | / the result is returned in the %rax
11 |
12 | .inline ngx_atomic_cmp_set,0
13 | movq %rsi, %rax
14 | lock
15 | cmpxchgq %rdx, (%rdi)
16 | setz %al
17 | movzbq %al, %rax
18 | .end
19 |
20 |
21 | / ngx_atomic_int_t ngx_atomic_fetch_add(ngx_atomic_t *value,
22 | / ngx_atomic_int_t add);
23 | /
24 | / the arguments are passed in %rdi, %rsi
25 | / the result is returned in the %rax
26 |
27 | .inline ngx_atomic_fetch_add,0
28 | movq %rsi, %rax
29 | lock
30 | xaddq %rax, (%rdi)
31 | .end
32 |
33 |
34 | / ngx_cpu_pause()
35 | /
36 | / the "rep; nop" is used instead of "pause" to avoid the "[ PAUSE ]" hardware
37 | / capability added by linker because Solaris/amd64 does not know about it:
38 | /
39 | / ld.so.1: nginx: fatal: hardware capability unsupported: 0x2000 [ PAUSE ]
40 |
41 | .inline ngx_cpu_pause,0
42 | rep; nop
43 | .end
44 |
--------------------------------------------------------------------------------
/eg/http-client/conf/nginx-perl.conf:
--------------------------------------------------------------------------------
1 |
2 | worker_processes 1;
3 | daemon off;
4 | master_process off;
5 |
6 | error_log /dev/stderr;
7 |
8 | events {
9 | worker_connections 1024;
10 | }
11 |
12 | http {
13 | default_type text/plain;
14 |
15 | perl_inc ../../objs/src/http/modules/perl/blib/lib;
16 | perl_inc ../../objs/src/http/modules/perl/blib/arch;
17 |
18 | perl_inc lib;
19 | perl_inc ../lib;
20 |
21 | perl_require Httpclient.pm;
22 |
23 | server {
24 | listen 55555;
25 |
26 | location / {
27 | set $dispatcher "127.0.0.1:55556";
28 | perl_handler Httpclient::handler;
29 | }
30 | }
31 |
32 |
33 | # bunch of fake backends
34 |
35 | server {
36 | listen 55556;
37 |
38 | set $demo_backends "127.0.0.1:55557
39 | 127.0.0.1:55558
40 | 127.0.0.1:55559";
41 |
42 | location / {
43 | perl_handler Httpclient::demo_handler;
44 | }
45 | }
46 |
47 | server {
48 | listen 55557;
49 | listen 55558;
50 | listen 55559;
51 |
52 | location / {
53 | perl_handler Httpclient::demo_handler2;
54 | }
55 | }
56 | }
57 |
58 |
--------------------------------------------------------------------------------
/auto/lib/libatomic/conf:
--------------------------------------------------------------------------------
1 |
2 | # Copyright (C) Igor Sysoev
3 | # Copyright (C) Nginx, Inc.
4 |
5 |
6 | if [ $NGX_LIBATOMIC != YES ]; then
7 |
8 | have=NGX_HAVE_LIBATOMIC . auto/have
9 | CORE_INCS="$CORE_INCS $NGX_LIBATOMIC/src"
10 | LINK_DEPS="$LINK_DEPS $NGX_LIBATOMIC/src/libatomic_ops.a"
11 | CORE_LIBS="$CORE_LIBS $NGX_LIBATOMIC/src/libatomic_ops.a"
12 |
13 | else
14 |
15 | ngx_feature="atomic_ops library"
16 | ngx_feature_name=NGX_HAVE_LIBATOMIC
17 | ngx_feature_run=yes
18 | ngx_feature_incs="#define AO_REQUIRE_CAS
19 | #include "
20 | ngx_feature_path=
21 | ngx_feature_libs="-latomic_ops"
22 | ngx_feature_test="long n = 0;
23 | if (!AO_compare_and_swap(&n, 0, 1))
24 | return 1;
25 | if (AO_fetch_and_add(&n, 1) != 1)
26 | return 1;
27 | if (n != 2)
28 | return 1;
29 | AO_nop();"
30 | . auto/feature
31 |
32 | if [ $ngx_found = yes ]; then
33 | CORE_LIBS="$CORE_LIBS $ngx_feature_libs"
34 | else
35 |
36 | cat << END
37 |
38 | $0: error: libatomic_ops library was not found.
39 |
40 | END
41 | exit 1
42 | fi
43 | fi
44 |
--------------------------------------------------------------------------------
/src/os/unix/ngx_sunpro_x86.il:
--------------------------------------------------------------------------------
1 | /
2 | / Copyright (C) Igor Sysoev
3 | / Copyright (C) Nginx, Inc.
4 | /
5 |
6 | / ngx_atomic_uint_t ngx_atomic_cmp_set(ngx_atomic_t *lock,
7 | / ngx_atomic_uint_t old, ngx_atomic_uint_t set);
8 | /
9 | / the arguments are passed on stack (%esp), 4(%esp), 8(%esp)
10 |
11 | .inline ngx_atomic_cmp_set,0
12 | movl (%esp), %ecx
13 | movl 4(%esp), %eax
14 | movl 8(%esp), %edx
15 | lock
16 | cmpxchgl %edx, (%ecx)
17 | setz %al
18 | movzbl %al, %eax
19 | .end
20 |
21 |
22 | / ngx_atomic_int_t ngx_atomic_fetch_add(ngx_atomic_t *value,
23 | / ngx_atomic_int_t add);
24 | /
25 | / the arguments are passed on stack (%esp), 4(%esp)
26 |
27 | .inline ngx_atomic_fetch_add,0
28 | movl (%esp), %ecx
29 | movl 4(%esp), %eax
30 | lock
31 | xaddl %eax, (%ecx)
32 | .end
33 |
34 |
35 | / ngx_cpu_pause()
36 | /
37 | / the "rep; nop" is used instead of "pause" to avoid the "[ PAUSE ]" hardware
38 | / capability added by linker because Solaris/i386 does not know about it:
39 | /
40 | / ld.so.1: nginx: fatal: hardware capability unsupported: 0x2000 [ PAUSE ]
41 |
42 | .inline ngx_cpu_pause,0
43 | rep; nop
44 | .end
45 |
--------------------------------------------------------------------------------
/contrib/unicode2nginx/unicode-to-nginx.pl:
--------------------------------------------------------------------------------
1 | #!/usr/bin/perl -w
2 |
3 | # Convert unicode mappings to nginx configuration file format.
4 |
5 | # You may find useful mappings in various places, including
6 | # unicode.org official site:
7 | #
8 | # http://www.unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WINDOWS/CP1251.TXT
9 | # http://www.unicode.org/Public/MAPPINGS/VENDORS/MISC/KOI8-R.TXT
10 |
11 | # Needs perl 5.6 or later.
12 |
13 | # Written by Maxim Dounin, mdounin@rambler-co.ru
14 |
15 | ###############################################################################
16 |
17 | require 5.006;
18 |
19 | while (<>) {
20 | # Skip comments and empty lines
21 |
22 | next if /^#/;
23 | next if /^\s*$/;
24 | chomp;
25 |
26 | # Convert mappings
27 |
28 | if (/^\s*0x(..)\s*0x(....)\s*(#.*)/) {
29 | # Mapping "#"
30 | my $cs_code = $1;
31 | my $un_code = $2;
32 | my $un_name = $3;
33 |
34 | # Produce UTF-8 sequence from character code;
35 |
36 | my $un_utf8 = join('', map { sprintf("%02X", $_) } unpack("C*", pack("U", hex($un_code))));
37 |
38 | print " $cs_code $un_utf8 ; $un_name\n";
39 |
40 | } else {
41 | warn "Unrecognized line: '$_'";
42 | }
43 | }
44 |
45 | ###############################################################################
46 |
--------------------------------------------------------------------------------
/src/core/ngx_array.h:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | * Copyright (C) Igor Sysoev
4 | * Copyright (C) Nginx, Inc.
5 | */
6 |
7 |
8 | #ifndef _NGX_ARRAY_H_INCLUDED_
9 | #define _NGX_ARRAY_H_INCLUDED_
10 |
11 |
12 | #include
13 | #include
14 |
15 |
16 | typedef struct {
17 | void *elts;
18 | ngx_uint_t nelts;
19 | size_t size;
20 | ngx_uint_t nalloc;
21 | ngx_pool_t *pool;
22 | } ngx_array_t;
23 |
24 |
25 | ngx_array_t *ngx_array_create(ngx_pool_t *p, ngx_uint_t n, size_t size);
26 | void ngx_array_destroy(ngx_array_t *a);
27 | void *ngx_array_push(ngx_array_t *a);
28 | void *ngx_array_push_n(ngx_array_t *a, ngx_uint_t n);
29 |
30 |
31 | static ngx_inline ngx_int_t
32 | ngx_array_init(ngx_array_t *array, ngx_pool_t *pool, ngx_uint_t n, size_t size)
33 | {
34 | /*
35 | * set "array->nelts" before "array->elts", otherwise MSVC thinks
36 | * that "array->nelts" may be used without having been initialized
37 | */
38 |
39 | array->nelts = 0;
40 | array->size = size;
41 | array->nalloc = n;
42 | array->pool = pool;
43 |
44 | array->elts = ngx_palloc(pool, n * size);
45 | if (array->elts == NULL) {
46 | return NGX_ERROR;
47 | }
48 |
49 | return NGX_OK;
50 | }
51 |
52 |
53 | #endif /* _NGX_ARRAY_H_INCLUDED_ */
54 |
--------------------------------------------------------------------------------
/auto/include:
--------------------------------------------------------------------------------
1 |
2 | # Copyright (C) Igor Sysoev
3 | # Copyright (C) Nginx, Inc.
4 |
5 |
6 | echo $ngx_n "checking for $ngx_include ...$ngx_c"
7 |
8 | cat << END >> $NGX_AUTOCONF_ERR
9 |
10 | ----------------------------------------
11 | checking for $ngx_include
12 |
13 | END
14 |
15 |
16 | ngx_found=no
17 |
18 | cat << END > $NGX_AUTOTEST.c
19 |
20 | $NGX_INCLUDE_SYS_PARAM_H
21 | #include <$ngx_include>
22 |
23 | int main() {
24 | return 0;
25 | }
26 |
27 | END
28 |
29 |
30 | ngx_test="$CC -o $NGX_AUTOTEST $NGX_AUTOTEST.c"
31 |
32 | eval "$ngx_test >> $NGX_AUTOCONF_ERR 2>&1"
33 |
34 | if [ -x $NGX_AUTOTEST ]; then
35 |
36 | ngx_found=yes
37 |
38 | echo " found"
39 |
40 | ngx_name=`echo $ngx_include \
41 | | tr abcdefghijklmnopqrstuvwxyz/. ABCDEFGHIJKLMNOPQRSTUVWXYZ__`
42 |
43 |
44 | have=NGX_HAVE_$ngx_name . auto/have_headers
45 |
46 | eval "NGX_INCLUDE_$ngx_name='#include <$ngx_include>'"
47 |
48 | #STUB
49 | eval "NGX_$ngx_name='#include <$ngx_include>'"
50 |
51 | else
52 | echo " not found"
53 |
54 | echo "----------" >> $NGX_AUTOCONF_ERR
55 | cat $NGX_AUTOTEST.c >> $NGX_AUTOCONF_ERR
56 | echo "----------" >> $NGX_AUTOCONF_ERR
57 | echo $ngx_test >> $NGX_AUTOCONF_ERR
58 | echo "----------" >> $NGX_AUTOCONF_ERR
59 | fi
60 |
61 | rm -rf $NGX_AUTOTEST*
62 |
--------------------------------------------------------------------------------
/src/core/ngx_list.c:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | * Copyright (C) Igor Sysoev
4 | * Copyright (C) Nginx, Inc.
5 | */
6 |
7 |
8 | #include
9 | #include
10 |
11 |
12 | ngx_list_t *
13 | ngx_list_create(ngx_pool_t *pool, ngx_uint_t n, size_t size)
14 | {
15 | ngx_list_t *list;
16 |
17 | list = ngx_palloc(pool, sizeof(ngx_list_t));
18 | if (list == NULL) {
19 | return NULL;
20 | }
21 |
22 | if (ngx_list_init(list, pool, n, size) != NGX_OK) {
23 | return NULL;
24 | }
25 |
26 | return list;
27 | }
28 |
29 |
30 | void *
31 | ngx_list_push(ngx_list_t *l)
32 | {
33 | void *elt;
34 | ngx_list_part_t *last;
35 |
36 | last = l->last;
37 |
38 | if (last->nelts == l->nalloc) {
39 |
40 | /* the last part is full, allocate a new list part */
41 |
42 | last = ngx_palloc(l->pool, sizeof(ngx_list_part_t));
43 | if (last == NULL) {
44 | return NULL;
45 | }
46 |
47 | last->elts = ngx_palloc(l->pool, l->nalloc * l->size);
48 | if (last->elts == NULL) {
49 | return NULL;
50 | }
51 |
52 | last->nelts = 0;
53 | last->next = NULL;
54 |
55 | l->last->next = last;
56 | l->last = last;
57 | }
58 |
59 | elt = (char *) last->elts + l->size * last->nelts;
60 | last->nelts++;
61 |
62 | return elt;
63 | }
64 |
--------------------------------------------------------------------------------
/auto/lib/google-perftools/conf:
--------------------------------------------------------------------------------
1 |
2 | # Copyright (C) Igor Sysoev
3 | # Copyright (C) Nginx, Inc.
4 |
5 |
6 | ngx_feature="Google perftools"
7 | ngx_feature_name=
8 | ngx_feature_run=no
9 | ngx_feature_incs=
10 | ngx_feature_path=
11 | ngx_feature_libs="-lprofiler"
12 | ngx_feature_test="ProfilerStop()"
13 | . auto/feature
14 |
15 |
16 | if [ $ngx_found = no ]; then
17 |
18 | # FreeBSD port
19 |
20 | ngx_feature="Google perftools in /usr/local/"
21 |
22 | if [ $NGX_RPATH = YES ]; then
23 | ngx_feature_libs="-R/usr/local/lib -L/usr/local/lib -lprofiler"
24 | else
25 | ngx_feature_libs="-L/usr/local/lib -lprofiler"
26 | fi
27 |
28 | . auto/feature
29 | fi
30 |
31 |
32 | if [ $ngx_found = no ]; then
33 |
34 | # MacPorts
35 |
36 | ngx_feature="Google perftools in /opt/local/"
37 |
38 | if [ $NGX_RPATH = YES ]; then
39 | ngx_feature_libs="-R/opt/local/lib -L/opt/local/lib -lprofiler"
40 | else
41 | ngx_feature_libs="-L/opt/local/lib -lprofiler"
42 | fi
43 |
44 | . auto/feature
45 | fi
46 |
47 |
48 | if [ $ngx_found = yes ]; then
49 | CORE_LIBS="$CORE_LIBS $ngx_feature_libs"
50 |
51 | else
52 |
53 | cat << END
54 |
55 | $0: error: the Google perftools module requires the Google perftools
56 | library. You can either do not enable the module or install the library.
57 |
58 | END
59 |
60 | exit 1
61 | fi
62 |
--------------------------------------------------------------------------------
/src/core/ngx_times.h:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | * Copyright (C) Igor Sysoev
4 | * Copyright (C) Nginx, Inc.
5 | */
6 |
7 |
8 | #ifndef _NGX_TIMES_H_INCLUDED_
9 | #define _NGX_TIMES_H_INCLUDED_
10 |
11 |
12 | #include
13 | #include
14 |
15 |
16 | typedef struct {
17 | time_t sec;
18 | ngx_uint_t msec;
19 | ngx_int_t gmtoff;
20 | } ngx_time_t;
21 |
22 |
23 | void ngx_time_init(void);
24 | void ngx_time_update(void);
25 | void ngx_time_sigsafe_update(void);
26 | u_char *ngx_http_time(u_char *buf, time_t t);
27 | u_char *ngx_http_cookie_time(u_char *buf, time_t t);
28 | void ngx_gmtime(time_t t, ngx_tm_t *tp);
29 |
30 | time_t ngx_next_time(time_t when);
31 | #define ngx_next_time_n "mktime()"
32 |
33 |
34 | extern volatile ngx_time_t *ngx_cached_time;
35 |
36 | #define ngx_time() ngx_cached_time->sec
37 | #define ngx_timeofday() (ngx_time_t *) ngx_cached_time
38 |
39 | extern volatile ngx_str_t ngx_cached_err_log_time;
40 | extern volatile ngx_str_t ngx_cached_http_time;
41 | extern volatile ngx_str_t ngx_cached_http_log_time;
42 | extern volatile ngx_str_t ngx_cached_http_log_iso8601;
43 | extern volatile ngx_str_t ngx_cached_syslog_time;
44 |
45 | /*
46 | * milliseconds elapsed since epoch and truncated to ngx_msec_t,
47 | * used in event timers
48 | */
49 | extern volatile ngx_msec_t ngx_current_msec;
50 |
51 |
52 | #endif /* _NGX_TIMES_H_INCLUDED_ */
53 |
--------------------------------------------------------------------------------
/t/00-basic.t:
--------------------------------------------------------------------------------
1 | #!/usr/bin/perl
2 |
3 | # Copyright 2011 Alexandr Gomoliako
4 |
5 | use strict;
6 | use warnings;
7 | no warnings 'uninitialized';
8 |
9 | use Data::Dumper;
10 | use Test::More;
11 | use Nginx::Test;
12 |
13 |
14 | my $nginx = find_nginx_perl;
15 | my $dir = "objs/t00";
16 | mkdir "objs" unless -e "objs";
17 |
18 | plan skip_all => "Can't find executable binary ($nginx) to test"
19 | if !$nginx ||
20 | !-x $nginx ;
21 |
22 | plan 'no_plan';
23 |
24 |
25 | {
26 | my ($child, $peer) = fork_nginx_handler_die $nginx, $dir, '',<<' END';
27 |
28 | sub handler {
29 | my ($r) = @_;
30 |
31 | $r->main_count_inc;
32 |
33 |
34 | my $buf = "Hello\n";
35 |
36 | $r->header_out ('Content-Length', length ($buf));
37 | $r->send_http_header ('text/html; charset=UTF-8');
38 |
39 | $r->print ($buf)
40 | unless $r->header_only;
41 |
42 | $r->send_special (NGX_HTTP_LAST);
43 | $r->finalize_request (NGX_OK);
44 |
45 |
46 | return NGX_DONE;
47 | }
48 |
49 | END
50 |
51 | wait_for_peer $peer, 5
52 | or diag "wair_for_peer \"$peer\" failed\n";
53 |
54 | my ($body, $headers) = http_get $peer, '/', 2;
55 |
56 | ok $body =~ /Hello/i, "hello"
57 | or diag "body = $body\n", cat_nginx_logs $dir;
58 |
59 | }
60 |
61 |
62 |
63 |
--------------------------------------------------------------------------------
/src/core/ngx_regex.h:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | * Copyright (C) Igor Sysoev
4 | * Copyright (C) Nginx, Inc.
5 | */
6 |
7 |
8 | #ifndef _NGX_REGEX_H_INCLUDED_
9 | #define _NGX_REGEX_H_INCLUDED_
10 |
11 |
12 | #include
13 | #include
14 |
15 | #include
16 |
17 |
18 | #define NGX_REGEX_NO_MATCHED PCRE_ERROR_NOMATCH /* -1 */
19 |
20 | #define NGX_REGEX_CASELESS PCRE_CASELESS
21 |
22 |
23 | typedef struct {
24 | pcre *code;
25 | pcre_extra *extra;
26 | } ngx_regex_t;
27 |
28 |
29 | typedef struct {
30 | ngx_str_t pattern;
31 | ngx_pool_t *pool;
32 | ngx_int_t options;
33 |
34 | ngx_regex_t *regex;
35 | int captures;
36 | int named_captures;
37 | int name_size;
38 | u_char *names;
39 | ngx_str_t err;
40 | } ngx_regex_compile_t;
41 |
42 |
43 | typedef struct {
44 | ngx_regex_t *regex;
45 | u_char *name;
46 | } ngx_regex_elt_t;
47 |
48 |
49 | void ngx_regex_init(void);
50 | ngx_int_t ngx_regex_compile(ngx_regex_compile_t *rc);
51 |
52 | #define ngx_regex_exec(re, s, captures, size) \
53 | pcre_exec(re->code, re->extra, (const char *) (s)->data, (s)->len, 0, 0, \
54 | captures, size)
55 | #define ngx_regex_exec_n "pcre_exec()"
56 |
57 | ngx_int_t ngx_regex_exec_array(ngx_array_t *a, ngx_str_t *s, ngx_log_t *log);
58 |
59 |
60 | #endif /* _NGX_REGEX_H_INCLUDED_ */
61 |
--------------------------------------------------------------------------------
/src/os/unix/ngx_thread_id.c:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | * Copyright (C) Igor Sysoev
4 | * Copyright (C) Nginx, Inc.
5 | */
6 |
7 |
8 | #include
9 | #include
10 | #include
11 |
12 |
13 | #if (NGX_LINUX)
14 |
15 | /*
16 | * Linux thread id is a pid of thread created by clone(2),
17 | * glibc does not provide a wrapper for gettid().
18 | */
19 |
20 | ngx_tid_t
21 | ngx_thread_tid(void)
22 | {
23 | return syscall(SYS_gettid);
24 | }
25 |
26 | #elif (NGX_FREEBSD) && (__FreeBSD_version >= 900031)
27 |
28 | #include
29 |
30 | ngx_tid_t
31 | ngx_thread_tid(void)
32 | {
33 | return pthread_getthreadid_np();
34 | }
35 |
36 | #elif (NGX_DARWIN)
37 |
38 | /*
39 | * MacOSX thread has two thread ids:
40 | *
41 | * 1) MacOSX 10.6 (Snow Leoprad) has pthread_threadid_np() returning
42 | * an uint64_t value, which is obtained using the __thread_selfid()
43 | * syscall. It is a number above 300,000.
44 | */
45 |
46 | ngx_tid_t
47 | ngx_thread_tid(void)
48 | {
49 | uint64_t tid;
50 |
51 | (void) pthread_threadid_np(NULL, &tid);
52 | return tid;
53 | }
54 |
55 | /*
56 | * 2) Kernel thread mach_port_t returned by pthread_mach_thread_np().
57 | * It is a number in range 100-100,000.
58 | *
59 | * return pthread_mach_thread_np(pthread_self());
60 | */
61 |
62 | #else
63 |
64 | ngx_tid_t
65 | ngx_thread_tid(void)
66 | {
67 | return (uint64_t) (uintptr_t) pthread_self();
68 | }
69 |
70 | #endif
71 |
--------------------------------------------------------------------------------
/src/core/ngx_slab.h:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | * Copyright (C) Igor Sysoev
4 | * Copyright (C) Nginx, Inc.
5 | */
6 |
7 |
8 | #ifndef _NGX_SLAB_H_INCLUDED_
9 | #define _NGX_SLAB_H_INCLUDED_
10 |
11 |
12 | #include
13 | #include
14 |
15 |
16 | typedef struct ngx_slab_page_s ngx_slab_page_t;
17 |
18 | struct ngx_slab_page_s {
19 | uintptr_t slab;
20 | ngx_slab_page_t *next;
21 | uintptr_t prev;
22 | };
23 |
24 |
25 | typedef struct {
26 | ngx_shmtx_sh_t lock;
27 |
28 | size_t min_size;
29 | size_t min_shift;
30 |
31 | ngx_slab_page_t *pages;
32 | ngx_slab_page_t *last;
33 | ngx_slab_page_t free;
34 |
35 | u_char *start;
36 | u_char *end;
37 |
38 | ngx_shmtx_t mutex;
39 |
40 | u_char *log_ctx;
41 | u_char zero;
42 |
43 | unsigned log_nomem:1;
44 |
45 | void *data;
46 | void *addr;
47 | } ngx_slab_pool_t;
48 |
49 |
50 | void ngx_slab_init(ngx_slab_pool_t *pool);
51 | void *ngx_slab_alloc(ngx_slab_pool_t *pool, size_t size);
52 | void *ngx_slab_alloc_locked(ngx_slab_pool_t *pool, size_t size);
53 | void *ngx_slab_calloc(ngx_slab_pool_t *pool, size_t size);
54 | void *ngx_slab_calloc_locked(ngx_slab_pool_t *pool, size_t size);
55 | void ngx_slab_free(ngx_slab_pool_t *pool, void *p);
56 | void ngx_slab_free_locked(ngx_slab_pool_t *pool, void *p);
57 |
58 |
59 | #endif /* _NGX_SLAB_H_INCLUDED_ */
60 |
--------------------------------------------------------------------------------
/auto/cc/ccc:
--------------------------------------------------------------------------------
1 |
2 | # Copyright (C) Igor Sysoev
3 | # Copyright (C) Nginx, Inc.
4 |
5 |
6 | # Compaq C V6.5-207
7 |
8 | ngx_include_opt="-I"
9 |
10 | # warnings
11 |
12 | CFLAGS="$CFLAGS -msg_enable level6 -msg_fatal level6"
13 |
14 | CFLAGS="$CFLAGS -msg_disable unknownmacro"
15 | CFLAGS="$CFLAGS -msg_disable unusedincl"
16 | CFLAGS="$CFLAGS -msg_disable unnecincl"
17 | CFLAGS="$CFLAGS -msg_disable nestincl"
18 | CFLAGS="$CFLAGS -msg_disable strctpadding"
19 | CFLAGS="$CFLAGS -msg_disable ansialiascast"
20 | CFLAGS="$CFLAGS -msg_disable inlinestoclsmod"
21 | CFLAGS="$CFLAGS -msg_disable cxxkeyword"
22 | CFLAGS="$CFLAGS -msg_disable longlongsufx"
23 | CFLAGS="$CFLAGS -msg_disable valuepres"
24 |
25 | # STUB
26 | CFLAGS="$CFLAGS -msg_disable truncintcast"
27 | CFLAGS="$CFLAGS -msg_disable trunclongcast"
28 |
29 | CFLAGS="$CFLAGS -msg_disable truncintasn"
30 | CFLAGS="$CFLAGS -msg_disable trunclongint"
31 | CFLAGS="$CFLAGS -msg_disable intconcastsgn"
32 | CFLAGS="$CFLAGS -msg_disable intconstsign"
33 | CFLAGS="$CFLAGS -msg_disable switchlong"
34 | CFLAGS="$CFLAGS -msg_disable subscrbounds2"
35 |
36 | CFLAGS="$CFLAGS -msg_disable hexoctunsign"
37 |
38 | CFLAGS="$CFLAGS -msg_disable ignorecallval"
39 | CFLAGS="$CFLAGS -msg_disable nonstandcast"
40 | CFLAGS="$CFLAGS -msg_disable embedcomment"
41 | CFLAGS="$CFLAGS -msg_disable unreachcode"
42 | CFLAGS="$CFLAGS -msg_disable questcompare2"
43 | CFLAGS="$CFLAGS -msg_disable unusedtop"
44 | CFLAGS="$CFLAGS -msg_disable unrefdecl"
45 |
46 | CFLAGS="$CFLAGS -msg_disable bitnotint"
47 |
--------------------------------------------------------------------------------
/src/mail/ngx_mail_ssl_module.h:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | * Copyright (C) Igor Sysoev
4 | * Copyright (C) Nginx, Inc.
5 | */
6 |
7 |
8 | #ifndef _NGX_MAIL_SSL_H_INCLUDED_
9 | #define _NGX_MAIL_SSL_H_INCLUDED_
10 |
11 |
12 | #include
13 | #include
14 | #include
15 |
16 |
17 | #define NGX_MAIL_STARTTLS_OFF 0
18 | #define NGX_MAIL_STARTTLS_ON 1
19 | #define NGX_MAIL_STARTTLS_ONLY 2
20 |
21 |
22 | typedef struct {
23 | ngx_flag_t enable;
24 | ngx_flag_t prefer_server_ciphers;
25 |
26 | ngx_ssl_t ssl;
27 |
28 | ngx_uint_t starttls;
29 | ngx_uint_t protocols;
30 |
31 | ngx_uint_t verify;
32 | ngx_uint_t verify_depth;
33 |
34 | ssize_t builtin_session_cache;
35 |
36 | time_t session_timeout;
37 |
38 | ngx_str_t certificate;
39 | ngx_str_t certificate_key;
40 | ngx_str_t dhparam;
41 | ngx_str_t ecdh_curve;
42 | ngx_str_t client_certificate;
43 | ngx_str_t trusted_certificate;
44 | ngx_str_t crl;
45 |
46 | ngx_str_t ciphers;
47 |
48 | ngx_array_t *passwords;
49 |
50 | ngx_shm_zone_t *shm_zone;
51 |
52 | ngx_flag_t session_tickets;
53 | ngx_array_t *session_ticket_keys;
54 |
55 | u_char *file;
56 | ngx_uint_t line;
57 | } ngx_mail_ssl_conf_t;
58 |
59 |
60 | extern ngx_module_t ngx_mail_ssl_module;
61 |
62 |
63 | #endif /* _NGX_MAIL_SSL_H_INCLUDED_ */
64 |
--------------------------------------------------------------------------------
/src/os/unix/ngx_sunpro_atomic_sparc64.h:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | * Copyright (C) Igor Sysoev
4 | * Copyright (C) Nginx, Inc.
5 | */
6 |
7 |
8 | #if (NGX_PTR_SIZE == 4)
9 | #define NGX_CASA ngx_casa
10 | #else
11 | #define NGX_CASA ngx_casxa
12 | #endif
13 |
14 |
15 | ngx_atomic_uint_t
16 | ngx_casa(ngx_atomic_uint_t set, ngx_atomic_uint_t old, ngx_atomic_t *lock);
17 |
18 | ngx_atomic_uint_t
19 | ngx_casxa(ngx_atomic_uint_t set, ngx_atomic_uint_t old, ngx_atomic_t *lock);
20 |
21 | /* the code in src/os/unix/ngx_sunpro_sparc64.il */
22 |
23 |
24 | static ngx_inline ngx_atomic_uint_t
25 | ngx_atomic_cmp_set(ngx_atomic_t *lock, ngx_atomic_uint_t old,
26 | ngx_atomic_uint_t set)
27 | {
28 | set = NGX_CASA(set, old, lock);
29 |
30 | return (set == old);
31 | }
32 |
33 |
34 | static ngx_inline ngx_atomic_int_t
35 | ngx_atomic_fetch_add(ngx_atomic_t *value, ngx_atomic_int_t add)
36 | {
37 | ngx_atomic_uint_t old, res;
38 |
39 | old = *value;
40 |
41 | for ( ;; ) {
42 |
43 | res = old + add;
44 |
45 | res = NGX_CASA(res, old, value);
46 |
47 | if (res == old) {
48 | return res;
49 | }
50 |
51 | old = res;
52 | }
53 | }
54 |
55 |
56 | #define ngx_memory_barrier() \
57 | __asm (".volatile"); \
58 | __asm ("membar #LoadLoad | #LoadStore | #StoreStore | #StoreLoad"); \
59 | __asm (".nonvolatile")
60 |
61 | #define ngx_cpu_pause()
62 |
--------------------------------------------------------------------------------
/contrib/geo2nginx.pl:
--------------------------------------------------------------------------------
1 | #!/usr/bin/perl -w
2 |
3 | # (c) Andrei Nigmatulin, 2005
4 | #
5 | # this script provided "as is", without any warranties. use it at your own risk.
6 | #
7 | # special thanx to Andrew Sitnikov for perl port
8 | #
9 | # this script converts CSV geoip database (free download at http://www.maxmind.com/app/geoip_country)
10 | # to format, suitable for use with nginx_http_geo module (http://sysoev.ru/nginx)
11 | #
12 | # for example, line with ip range
13 | #
14 | # "62.16.68.0","62.16.127.255","1041253376","1041268735","RU","Russian Federation"
15 | #
16 | # will be converted to four subnetworks:
17 | #
18 | # 62.16.68.0/22 RU;
19 | # 62.16.72.0/21 RU;
20 | # 62.16.80.0/20 RU;
21 | # 62.16.96.0/19 RU;
22 |
23 |
24 | use warnings;
25 | use strict;
26 |
27 | while( ){
28 | if (/"[^"]+","[^"]+","([^"]+)","([^"]+)","([^"]+)"/){
29 | print_subnets($1, $2, $3);
30 | }
31 | }
32 |
33 | sub print_subnets {
34 | my ($a1, $a2, $c) = @_;
35 | my $l;
36 | while ($a1 <= $a2) {
37 | for ($l = 0; ($a1 & (1 << $l)) == 0 && ($a1 + ((1 << ($l + 1)) - 1)) <= $a2; $l++){};
38 | print long2ip($a1) . "/" . (32 - $l) . " " . $c . ";\n";
39 | $a1 += (1 << $l);
40 | }
41 | }
42 |
43 | sub long2ip {
44 | my $ip = shift;
45 |
46 | my $str = 0;
47 |
48 | $str = ($ip & 255);
49 |
50 | $ip >>= 8;
51 | $str = ($ip & 255).".$str";
52 |
53 | $ip >>= 8;
54 | $str = ($ip & 255).".$str";
55 |
56 | $ip >>= 8;
57 | $str = ($ip & 255).".$str";
58 | }
59 |
--------------------------------------------------------------------------------
/src/core/ngx_radix_tree.h:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | * Copyright (C) Igor Sysoev
4 | * Copyright (C) Nginx, Inc.
5 | */
6 |
7 |
8 | #ifndef _NGX_RADIX_TREE_H_INCLUDED_
9 | #define _NGX_RADIX_TREE_H_INCLUDED_
10 |
11 |
12 | #include
13 | #include
14 |
15 |
16 | #define NGX_RADIX_NO_VALUE (uintptr_t) -1
17 |
18 | typedef struct ngx_radix_node_s ngx_radix_node_t;
19 |
20 | struct ngx_radix_node_s {
21 | ngx_radix_node_t *right;
22 | ngx_radix_node_t *left;
23 | ngx_radix_node_t *parent;
24 | uintptr_t value;
25 | };
26 |
27 |
28 | typedef struct {
29 | ngx_radix_node_t *root;
30 | ngx_pool_t *pool;
31 | ngx_radix_node_t *free;
32 | char *start;
33 | size_t size;
34 | } ngx_radix_tree_t;
35 |
36 |
37 | ngx_radix_tree_t *ngx_radix_tree_create(ngx_pool_t *pool,
38 | ngx_int_t preallocate);
39 |
40 | ngx_int_t ngx_radix32tree_insert(ngx_radix_tree_t *tree,
41 | uint32_t key, uint32_t mask, uintptr_t value);
42 | ngx_int_t ngx_radix32tree_delete(ngx_radix_tree_t *tree,
43 | uint32_t key, uint32_t mask);
44 | uintptr_t ngx_radix32tree_find(ngx_radix_tree_t *tree, uint32_t key);
45 |
46 | #if (NGX_HAVE_INET6)
47 | ngx_int_t ngx_radix128tree_insert(ngx_radix_tree_t *tree,
48 | u_char *key, u_char *mask, uintptr_t value);
49 | ngx_int_t ngx_radix128tree_delete(ngx_radix_tree_t *tree,
50 | u_char *key, u_char *mask);
51 | uintptr_t ngx_radix128tree_find(ngx_radix_tree_t *tree, u_char *key);
52 | #endif
53 |
54 |
55 | #endif /* _NGX_RADIX_TREE_H_INCLUDED_ */
56 |
--------------------------------------------------------------------------------
/src/os/unix/ngx_socket.h:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | * Copyright (C) Igor Sysoev
4 | * Copyright (C) Nginx, Inc.
5 | */
6 |
7 |
8 | #ifndef _NGX_SOCKET_H_INCLUDED_
9 | #define _NGX_SOCKET_H_INCLUDED_
10 |
11 |
12 | #include
13 |
14 |
15 | #define NGX_WRITE_SHUTDOWN SHUT_WR
16 |
17 | typedef int ngx_socket_t;
18 |
19 | #define ngx_socket socket
20 | #define ngx_socket_n "socket()"
21 |
22 |
23 | #if (NGX_HAVE_FIONBIO)
24 |
25 | int ngx_nonblocking(ngx_socket_t s);
26 | int ngx_blocking(ngx_socket_t s);
27 |
28 | #define ngx_nonblocking_n "ioctl(FIONBIO)"
29 | #define ngx_blocking_n "ioctl(!FIONBIO)"
30 |
31 | #else
32 |
33 | #define ngx_nonblocking(s) fcntl(s, F_SETFL, fcntl(s, F_GETFL) | O_NONBLOCK)
34 | #define ngx_nonblocking_n "fcntl(O_NONBLOCK)"
35 |
36 | #define ngx_blocking(s) fcntl(s, F_SETFL, fcntl(s, F_GETFL) & ~O_NONBLOCK)
37 | #define ngx_blocking_n "fcntl(!O_NONBLOCK)"
38 |
39 | #endif
40 |
41 | int ngx_tcp_nopush(ngx_socket_t s);
42 | int ngx_tcp_push(ngx_socket_t s);
43 |
44 | #if (NGX_LINUX)
45 |
46 | #define ngx_tcp_nopush_n "setsockopt(TCP_CORK)"
47 | #define ngx_tcp_push_n "setsockopt(!TCP_CORK)"
48 |
49 | #else
50 |
51 | #define ngx_tcp_nopush_n "setsockopt(TCP_NOPUSH)"
52 | #define ngx_tcp_push_n "setsockopt(!TCP_NOPUSH)"
53 |
54 | #endif
55 |
56 |
57 | #define ngx_shutdown_socket shutdown
58 | #define ngx_shutdown_socket_n "shutdown()"
59 |
60 | #define ngx_close_socket close
61 | #define ngx_close_socket_n "close() socket"
62 |
63 |
64 | #endif /* _NGX_SOCKET_H_INCLUDED_ */
65 |
--------------------------------------------------------------------------------
/auto/cc/bcc:
--------------------------------------------------------------------------------
1 |
2 | # Copyright (C) Igor Sysoev
3 | # Copyright (C) Nginx, Inc.
4 |
5 |
6 | # Borland C++ 5.5
7 |
8 | # optimizations
9 |
10 | # maximize speed
11 | CFLAGS="$CFLAGS -O2"
12 |
13 | case $CPU in
14 | pentium)
15 | # optimize for Pentium and Athlon
16 | CPU_OPT="-5"
17 | ;;
18 |
19 | pentiumpro)
20 | # optimize for Pentium Pro, Pentium II and Pentium III
21 | CPU_OPT="-6"
22 | ;;
23 | esac
24 |
25 | # __stdcall
26 | #CPU_OPT="$CPU_OPT -ps"
27 | # __fastcall
28 | #CPU_OPT="$CPU_OPT -pr"
29 |
30 | CFLAGS="$CFLAGS $CPU_OPT"
31 |
32 | # multithreaded
33 | CFLAGS="$CFLAGS -tWM"
34 |
35 | # stop on warning
36 | CFLAGS="$CFLAGS -w!"
37 |
38 | # disable logo
39 | CFLAGS="$CFLAGS -q"
40 |
41 |
42 | # precompiled headers
43 | CORE_DEPS="$CORE_DEPS $NGX_OBJS/ngx_config.csm"
44 | NGX_PCH="$NGX_OBJS/ngx_config.csm"
45 | NGX_BUILD_PCH="-H=$NGX_OBJS/ngx_config.csm"
46 | NGX_USE_PCH="-Hu -H=$NGX_OBJS/ngx_config.csm"
47 |
48 |
49 | # Win32 GUI mode application
50 | #LINK="\$(CC) -laa"
51 |
52 |
53 | # the resource file
54 | NGX_RES="$NGX_OBJS/nginx.res"
55 | NGX_RCC="brcc32 -fo$NGX_OBJS/nginx.res \$(CORE_INCS) $NGX_WIN32_RC"
56 | # the pragma allows to link the resource file using bcc32 and
57 | # to avoid the direct ilink32 calling and the c0w32.obj's WinMain/main problem
58 | NGX_PRAGMA="#pragma resource \"$NGX_OBJS/nginx.res\""
59 |
60 |
61 | ngx_include_opt="-I"
62 | ngx_objout="-o"
63 | ngx_binout="-e"
64 | ngx_objext="obj"
65 | ngx_binext=".exe"
66 |
67 | ngx_long_start='@&&|
68 | '
69 | ngx_long_end='|'
70 |
71 | ngx_regex_dirsep='\\'
72 | ngx_dirsep="\\"
73 |
--------------------------------------------------------------------------------
/auto/lib/pcre/make:
--------------------------------------------------------------------------------
1 |
2 | # Copyright (C) Igor Sysoev
3 | # Copyright (C) Nginx, Inc.
4 |
5 |
6 | case "$NGX_CC_NAME" in
7 |
8 | msvc*)
9 | ngx_makefile=makefile.msvc
10 | ngx_opt="CPU_OPT=\"$CPU_OPT\" LIBC=$LIBC"
11 | ngx_pcre="PCRE=\"$PCRE\""
12 | ;;
13 |
14 | owc*)
15 | ngx_makefile=makefile.owc
16 | ngx_opt="CPU_OPT=\"$CPU_OPT\""
17 | ngx_pcre=`echo PCRE=\"$PCRE\" | sed -e "s/\//$ngx_regex_dirsep/g"`
18 | ;;
19 |
20 | bcc)
21 | ngx_makefile=makefile.bcc
22 | ngx_opt="-DCPU_OPT=\"$CPU_OPT\""
23 | ngx_pcre=`echo \-DPCRE=\"$PCRE\" | sed -e "s/\//$ngx_regex_dirsep/g"`
24 | ;;
25 |
26 | *)
27 | ngx_makefile=
28 | ;;
29 |
30 | esac
31 |
32 |
33 | if [ -n "$ngx_makefile" ]; then
34 |
35 | cat << END >> $NGX_MAKEFILE
36 |
37 | `echo "$PCRE/pcre.lib: $PCRE/pcre.h $NGX_MAKEFILE" \
38 | | sed -e "s/\//$ngx_regex_dirsep/g"`
39 | \$(MAKE) -f auto/lib/pcre/$ngx_makefile $ngx_pcre $ngx_opt
40 |
41 | `echo "$PCRE/pcre.h:" | sed -e "s/\//$ngx_regex_dirsep/g"`
42 | \$(MAKE) -f auto/lib/pcre/$ngx_makefile $ngx_pcre pcre.h
43 |
44 | END
45 |
46 | else
47 |
48 | cat << END >> $NGX_MAKEFILE
49 |
50 | $PCRE/pcre.h: $PCRE/Makefile
51 |
52 | $PCRE/Makefile: $NGX_MAKEFILE
53 | cd $PCRE \\
54 | && if [ -f Makefile ]; then \$(MAKE) distclean; fi \\
55 | && CC="\$(CC)" CFLAGS="$PCRE_OPT" \\
56 | ./configure --disable-shared $PCRE_CONF_OPT
57 |
58 | $PCRE/.libs/libpcre.a: $PCRE/Makefile
59 | cd $PCRE \\
60 | && \$(MAKE) libpcre.la
61 |
62 | END
63 |
64 | fi
65 |
--------------------------------------------------------------------------------
/auto/os/solaris:
--------------------------------------------------------------------------------
1 |
2 | # Copyright (C) Igor Sysoev
3 | # Copyright (C) Nginx, Inc.
4 |
5 |
6 | have=NGX_SOLARIS . auto/have_headers
7 |
8 | CORE_INCS="$UNIX_INCS"
9 | CORE_DEPS="$UNIX_DEPS $SOLARIS_DEPS"
10 | CORE_SRCS="$UNIX_SRCS $SOLARIS_SRCS "
11 | CORE_LIBS="$CORE_LIBS -lsocket -lnsl"
12 |
13 | NGX_RPATH=YES
14 |
15 | # Solaris's make does not support a blank line between target and rules
16 | ngx_spacer=
17 |
18 | CC_AUX_FLAGS="$CC_AUX_FLAGS -D_FILE_OFFSET_BITS=64 -lsocket -lnsl"
19 |
20 |
21 | if [ $ZLIB_ASM != NO ]; then
22 | echo "$0: error: the --with-zlib-asm=CPU option is not supported"
23 | echo "on that platform"
24 | echo
25 |
26 | exit 1
27 | fi
28 |
29 |
30 | ngx_feature="sendfilev()"
31 | ngx_feature_name="NGX_HAVE_SENDFILE"
32 | ngx_feature_run=no
33 | ngx_feature_incs="#include "
34 | ngx_feature_path=
35 | ngx_feature_libs="-lsendfile"
36 | ngx_feature_test="int fd = 1; sendfilevec_t vec[1];
37 | size_t sent; ssize_t n;
38 | n = sendfilev(fd, vec, 1, &sent);
39 | if (n == -1) return 1"
40 | . auto/feature
41 |
42 |
43 | if [ $ngx_found = yes ]; then
44 | CORE_SRCS="$CORE_SRCS $SOLARIS_SENDFILEV_SRCS"
45 | CORE_LIBS="$CORE_LIBS -lsendfile"
46 | fi
47 |
48 |
49 | ngx_feature="event ports"
50 | ngx_feature_name="NGX_HAVE_EVENTPORT"
51 | ngx_feature_run=no
52 | ngx_feature_incs="#include "
53 | ngx_feature_path=
54 | ngx_feature_libs=
55 | ngx_feature_test="int n = port_create()"
56 | . auto/feature
57 |
58 | if [ $ngx_found = yes ]; then
59 | CORE_SRCS="$CORE_SRCS $EVENTPORT_SRCS"
60 | EVENT_MODULES="$EVENT_MODULES $EVENTPORT_MODULE"
61 | fi
62 |
--------------------------------------------------------------------------------
/src/os/unix/ngx_process_cycle.h:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | * Copyright (C) Igor Sysoev
4 | * Copyright (C) Nginx, Inc.
5 | */
6 |
7 |
8 | #ifndef _NGX_PROCESS_CYCLE_H_INCLUDED_
9 | #define _NGX_PROCESS_CYCLE_H_INCLUDED_
10 |
11 |
12 | #include
13 | #include
14 |
15 |
16 | #define NGX_CMD_OPEN_CHANNEL 1
17 | #define NGX_CMD_CLOSE_CHANNEL 2
18 | #define NGX_CMD_QUIT 3
19 | #define NGX_CMD_TERMINATE 4
20 | #define NGX_CMD_REOPEN 5
21 |
22 |
23 | #define NGX_PROCESS_SINGLE 0
24 | #define NGX_PROCESS_MASTER 1
25 | #define NGX_PROCESS_SIGNALLER 2
26 | #define NGX_PROCESS_WORKER 3
27 | #define NGX_PROCESS_HELPER 4
28 |
29 |
30 | typedef struct {
31 | ngx_event_handler_pt handler;
32 | char *name;
33 | ngx_msec_t delay;
34 | } ngx_cache_manager_ctx_t;
35 |
36 |
37 | void ngx_master_process_cycle(ngx_cycle_t *cycle);
38 | void ngx_single_process_cycle(ngx_cycle_t *cycle);
39 |
40 |
41 | extern ngx_uint_t ngx_process;
42 | extern ngx_pid_t ngx_pid;
43 | extern ngx_pid_t ngx_new_binary;
44 | extern ngx_uint_t ngx_inherited;
45 | extern ngx_uint_t ngx_daemonized;
46 | extern ngx_uint_t ngx_exiting;
47 |
48 | extern sig_atomic_t ngx_reap;
49 | extern sig_atomic_t ngx_sigio;
50 | extern sig_atomic_t ngx_sigalrm;
51 | extern sig_atomic_t ngx_quit;
52 | extern sig_atomic_t ngx_debug_quit;
53 | extern sig_atomic_t ngx_terminate;
54 | extern sig_atomic_t ngx_noaccept;
55 | extern sig_atomic_t ngx_reconfigure;
56 | extern sig_atomic_t ngx_reopen;
57 | extern sig_atomic_t ngx_change_binary;
58 |
59 |
60 | #endif /* _NGX_PROCESS_CYCLE_H_INCLUDED_ */
61 |
--------------------------------------------------------------------------------
/auto/types/sizeof:
--------------------------------------------------------------------------------
1 |
2 | # Copyright (C) Igor Sysoev
3 | # Copyright (C) Nginx, Inc.
4 |
5 |
6 | echo $ngx_n "checking for $ngx_type size ...$ngx_c"
7 |
8 | cat << END >> $NGX_AUTOCONF_ERR
9 |
10 | ----------------------------------------
11 | checking for $ngx_type size
12 |
13 | END
14 |
15 | ngx_size=
16 |
17 | cat << END > $NGX_AUTOTEST.c
18 |
19 | #include
20 | #include
21 | $NGX_INCLUDE_UNISTD_H
22 | #include
23 | #include
24 | #include
25 | $NGX_INCLUDE_INTTYPES_H
26 | $NGX_INCLUDE_AUTO_CONFIG_H
27 |
28 | int main() {
29 | printf("%d", (int) sizeof($ngx_type));
30 | return 0;
31 | }
32 |
33 | END
34 |
35 |
36 | ngx_test="$CC $CC_TEST_FLAGS $CC_AUX_FLAGS \
37 | -o $NGX_AUTOTEST $NGX_AUTOTEST.c $NGX_LD_OPT $ngx_feature_libs"
38 |
39 | eval "$ngx_test >> $NGX_AUTOCONF_ERR 2>&1"
40 |
41 |
42 | if [ -x $NGX_AUTOTEST ]; then
43 | ngx_size=`$NGX_AUTOTEST`
44 | echo " $ngx_size bytes"
45 | fi
46 |
47 |
48 | rm -rf $NGX_AUTOTEST*
49 |
50 |
51 | case $ngx_size in
52 | 4)
53 | ngx_max_value=2147483647
54 | ngx_max_len='(sizeof("-2147483648") - 1)'
55 | ;;
56 |
57 | 8)
58 | ngx_max_value=9223372036854775807LL
59 | ngx_max_len='(sizeof("-9223372036854775808") - 1)'
60 | ;;
61 |
62 | *)
63 | echo
64 | echo "$0: error: can not detect $ngx_type size"
65 |
66 | echo "----------" >> $NGX_AUTOCONF_ERR
67 | cat $NGX_AUTOTEST.c >> $NGX_AUTOCONF_ERR
68 | echo "----------" >> $NGX_AUTOCONF_ERR
69 | echo $ngx_test >> $NGX_AUTOCONF_ERR
70 | echo "----------" >> $NGX_AUTOCONF_ERR
71 |
72 | exit 1
73 | esac
74 |
75 |
--------------------------------------------------------------------------------
/src/core/ngx_crc32.h:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | * Copyright (C) Igor Sysoev
4 | * Copyright (C) Nginx, Inc.
5 | */
6 |
7 |
8 | #ifndef _NGX_CRC32_H_INCLUDED_
9 | #define _NGX_CRC32_H_INCLUDED_
10 |
11 |
12 | #include
13 | #include
14 |
15 |
16 | extern uint32_t *ngx_crc32_table_short;
17 | extern uint32_t ngx_crc32_table256[];
18 |
19 |
20 | static ngx_inline uint32_t
21 | ngx_crc32_short(u_char *p, size_t len)
22 | {
23 | u_char c;
24 | uint32_t crc;
25 |
26 | crc = 0xffffffff;
27 |
28 | while (len--) {
29 | c = *p++;
30 | crc = ngx_crc32_table_short[(crc ^ (c & 0xf)) & 0xf] ^ (crc >> 4);
31 | crc = ngx_crc32_table_short[(crc ^ (c >> 4)) & 0xf] ^ (crc >> 4);
32 | }
33 |
34 | return crc ^ 0xffffffff;
35 | }
36 |
37 |
38 | static ngx_inline uint32_t
39 | ngx_crc32_long(u_char *p, size_t len)
40 | {
41 | uint32_t crc;
42 |
43 | crc = 0xffffffff;
44 |
45 | while (len--) {
46 | crc = ngx_crc32_table256[(crc ^ *p++) & 0xff] ^ (crc >> 8);
47 | }
48 |
49 | return crc ^ 0xffffffff;
50 | }
51 |
52 |
53 | #define ngx_crc32_init(crc) \
54 | crc = 0xffffffff
55 |
56 |
57 | static ngx_inline void
58 | ngx_crc32_update(uint32_t *crc, u_char *p, size_t len)
59 | {
60 | uint32_t c;
61 |
62 | c = *crc;
63 |
64 | while (len--) {
65 | c = ngx_crc32_table256[(c ^ *p++) & 0xff] ^ (c >> 8);
66 | }
67 |
68 | *crc = c;
69 | }
70 |
71 |
72 | #define ngx_crc32_final(crc) \
73 | crc ^= 0xffffffff
74 |
75 |
76 | ngx_int_t ngx_crc32_table_init(void);
77 |
78 |
79 | #endif /* _NGX_CRC32_H_INCLUDED_ */
80 |
--------------------------------------------------------------------------------
/src/os/unix/ngx_setaffinity.c:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | * Copyright (C) Nginx, Inc.
4 | */
5 |
6 |
7 | #include
8 | #include
9 |
10 |
11 | #if (NGX_HAVE_CPUSET_SETAFFINITY)
12 |
13 | #include
14 |
15 | void
16 | ngx_setaffinity(uint64_t cpu_affinity, ngx_log_t *log)
17 | {
18 | cpuset_t mask;
19 | ngx_uint_t i;
20 |
21 | ngx_log_error(NGX_LOG_NOTICE, log, 0,
22 | "cpuset_setaffinity(0x%08Xl)", cpu_affinity);
23 |
24 | CPU_ZERO(&mask);
25 | i = 0;
26 | do {
27 | if (cpu_affinity & 1) {
28 | CPU_SET(i, &mask);
29 | }
30 | i++;
31 | cpu_affinity >>= 1;
32 | } while (cpu_affinity);
33 |
34 | if (cpuset_setaffinity(CPU_LEVEL_WHICH, CPU_WHICH_PID, -1,
35 | sizeof(cpuset_t), &mask) == -1)
36 | {
37 | ngx_log_error(NGX_LOG_ALERT, log, ngx_errno,
38 | "cpuset_setaffinity() failed");
39 | }
40 | }
41 |
42 | #elif (NGX_HAVE_SCHED_SETAFFINITY)
43 |
44 | void
45 | ngx_setaffinity(uint64_t cpu_affinity, ngx_log_t *log)
46 | {
47 | cpu_set_t mask;
48 | ngx_uint_t i;
49 |
50 | ngx_log_error(NGX_LOG_NOTICE, log, 0,
51 | "sched_setaffinity(0x%08Xl)", cpu_affinity);
52 |
53 | CPU_ZERO(&mask);
54 | i = 0;
55 | do {
56 | if (cpu_affinity & 1) {
57 | CPU_SET(i, &mask);
58 | }
59 | i++;
60 | cpu_affinity >>= 1;
61 | } while (cpu_affinity);
62 |
63 | if (sched_setaffinity(0, sizeof(cpu_set_t), &mask) == -1) {
64 | ngx_log_error(NGX_LOG_ALERT, log, ngx_errno,
65 | "sched_setaffinity() failed");
66 | }
67 | }
68 |
69 | #endif
70 |
--------------------------------------------------------------------------------
/auto/lib/openssl/make:
--------------------------------------------------------------------------------
1 |
2 | # Copyright (C) Igor Sysoev
3 | # Copyright (C) Nginx, Inc.
4 |
5 |
6 | case "$CC" in
7 |
8 | cl)
9 |
10 | cat << END >> $NGX_MAKEFILE
11 |
12 | $OPENSSL/openssl/include/openssl/ssl.h: $NGX_MAKEFILE
13 | \$(MAKE) -f auto/lib/openssl/makefile.msvc \
14 | OPENSSL="$OPENSSL" OPENSSL_OPT="$OPENSSL_OPT"
15 |
16 | END
17 |
18 | ;;
19 |
20 | bcc32)
21 |
22 | ngx_opt=`echo "-DOPENSSL=\"$OPENSSL\" -DOPENSSL_OPT=\"$OPENSSL_OPT\"" \
23 | | sed -e "s/\//$ngx_regex_dirsep/g"`
24 |
25 | cat << END >> $NGX_MAKEFILE
26 |
27 | `echo "$OPENSSL\\openssl\\lib\\libeay32.lib: \
28 | $OPENSSL\\openssl\\include\\openssl\\ssl.h" \
29 | | sed -e "s/\//$ngx_regex_dirsep/g"`
30 |
31 | `echo "$OPENSSL\\openssl\\lib\\ssleay32.lib: \
32 | $OPENSSL\\openssl\\include\\openssl\\ssl.h" \
33 | | sed -e "s/\//$ngx_regex_dirsep/g"`
34 |
35 | `echo "$OPENSSL\\openssl\\include\\openssl\\ssl.h: $NGX_MAKEFILE" \
36 | | sed -e "s/\//$ngx_regex_dirsep/g"`
37 | \$(MAKE) -f auto/lib/openssl/makefile.bcc $ngx_opt
38 |
39 | END
40 |
41 | ;;
42 |
43 | *)
44 | case $OPENSSL in
45 | /*) ngx_prefix="$OPENSSL/.openssl" ;;
46 | *) ngx_prefix="$PWD/$OPENSSL/.openssl" ;;
47 | esac
48 |
49 | cat << END >> $NGX_MAKEFILE
50 |
51 | $OPENSSL/.openssl/include/openssl/ssl.h: $NGX_MAKEFILE
52 | cd $OPENSSL \\
53 | && if [ -f Makefile ]; then \$(MAKE) clean; fi \\
54 | && ./config --prefix=$ngx_prefix no-shared $OPENSSL_OPT \\
55 | && \$(MAKE) \\
56 | && \$(MAKE) install LIBDIR=lib
57 |
58 | END
59 |
60 | ;;
61 |
62 | esac
63 |
--------------------------------------------------------------------------------
/src/os/unix/ngx_time.h:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | * Copyright (C) Igor Sysoev
4 | * Copyright (C) Nginx, Inc.
5 | */
6 |
7 |
8 | #ifndef _NGX_TIME_H_INCLUDED_
9 | #define _NGX_TIME_H_INCLUDED_
10 |
11 |
12 | #include
13 | #include
14 |
15 |
16 | typedef ngx_rbtree_key_t ngx_msec_t;
17 | typedef ngx_rbtree_key_int_t ngx_msec_int_t;
18 |
19 | typedef struct tm ngx_tm_t;
20 |
21 | #define ngx_tm_sec tm_sec
22 | #define ngx_tm_min tm_min
23 | #define ngx_tm_hour tm_hour
24 | #define ngx_tm_mday tm_mday
25 | #define ngx_tm_mon tm_mon
26 | #define ngx_tm_year tm_year
27 | #define ngx_tm_wday tm_wday
28 | #define ngx_tm_isdst tm_isdst
29 |
30 | #define ngx_tm_sec_t int
31 | #define ngx_tm_min_t int
32 | #define ngx_tm_hour_t int
33 | #define ngx_tm_mday_t int
34 | #define ngx_tm_mon_t int
35 | #define ngx_tm_year_t int
36 | #define ngx_tm_wday_t int
37 |
38 |
39 | #if (NGX_HAVE_GMTOFF)
40 | #define ngx_tm_gmtoff tm_gmtoff
41 | #define ngx_tm_zone tm_zone
42 | #endif
43 |
44 |
45 | #if (NGX_SOLARIS)
46 |
47 | #define ngx_timezone(isdst) (- (isdst ? altzone : timezone) / 60)
48 |
49 | #else
50 |
51 | #define ngx_timezone(isdst) (- (isdst ? timezone + 3600 : timezone) / 60)
52 |
53 | #endif
54 |
55 |
56 | void ngx_timezone_update(void);
57 | void ngx_localtime(time_t s, ngx_tm_t *tm);
58 | void ngx_libc_localtime(time_t s, struct tm *tm);
59 | void ngx_libc_gmtime(time_t s, struct tm *tm);
60 |
61 | #define ngx_gettimeofday(tp) (void) gettimeofday(tp, NULL);
62 | #define ngx_msleep(ms) (void) usleep(ms * 1000)
63 | #define ngx_sleep(s) (void) sleep(s)
64 |
65 |
66 | #endif /* _NGX_TIME_H_INCLUDED_ */
67 |
--------------------------------------------------------------------------------
/src/core/ngx_list.h:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | * Copyright (C) Igor Sysoev
4 | * Copyright (C) Nginx, Inc.
5 | */
6 |
7 |
8 | #ifndef _NGX_LIST_H_INCLUDED_
9 | #define _NGX_LIST_H_INCLUDED_
10 |
11 |
12 | #include
13 | #include
14 |
15 |
16 | typedef struct ngx_list_part_s ngx_list_part_t;
17 |
18 | struct ngx_list_part_s {
19 | void *elts;
20 | ngx_uint_t nelts;
21 | ngx_list_part_t *next;
22 | };
23 |
24 |
25 | typedef struct {
26 | ngx_list_part_t *last;
27 | ngx_list_part_t part;
28 | size_t size;
29 | ngx_uint_t nalloc;
30 | ngx_pool_t *pool;
31 | } ngx_list_t;
32 |
33 |
34 | ngx_list_t *ngx_list_create(ngx_pool_t *pool, ngx_uint_t n, size_t size);
35 |
36 | static ngx_inline ngx_int_t
37 | ngx_list_init(ngx_list_t *list, ngx_pool_t *pool, ngx_uint_t n, size_t size)
38 | {
39 | list->part.elts = ngx_palloc(pool, n * size);
40 | if (list->part.elts == NULL) {
41 | return NGX_ERROR;
42 | }
43 |
44 | list->part.nelts = 0;
45 | list->part.next = NULL;
46 | list->last = &list->part;
47 | list->size = size;
48 | list->nalloc = n;
49 | list->pool = pool;
50 |
51 | return NGX_OK;
52 | }
53 |
54 |
55 | /*
56 | *
57 | * the iteration through the list:
58 | *
59 | * part = &list.part;
60 | * data = part->elts;
61 | *
62 | * for (i = 0 ;; i++) {
63 | *
64 | * if (i >= part->nelts) {
65 | * if (part->next == NULL) {
66 | * break;
67 | * }
68 | *
69 | * part = part->next;
70 | * data = part->elts;
71 | * i = 0;
72 | * }
73 | *
74 | * ... data[i] ...
75 | *
76 | * }
77 | */
78 |
79 |
80 | void *ngx_list_push(ngx_list_t *list);
81 |
82 |
83 | #endif /* _NGX_LIST_H_INCLUDED_ */
84 |
--------------------------------------------------------------------------------
/src/os/unix/ngx_thread.h:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | * Copyright (C) Igor Sysoev
4 | * Copyright (C) Nginx, Inc.
5 | */
6 |
7 |
8 | #ifndef _NGX_THREAD_H_INCLUDED_
9 | #define _NGX_THREAD_H_INCLUDED_
10 |
11 |
12 | #include
13 | #include
14 |
15 | #if (NGX_THREADS)
16 |
17 | #include
18 |
19 |
20 | typedef pthread_mutex_t ngx_thread_mutex_t;
21 |
22 | ngx_int_t ngx_thread_mutex_create(ngx_thread_mutex_t *mtx, ngx_log_t *log);
23 | ngx_int_t ngx_thread_mutex_destroy(ngx_thread_mutex_t *mtx, ngx_log_t *log);
24 | ngx_int_t ngx_thread_mutex_lock(ngx_thread_mutex_t *mtx, ngx_log_t *log);
25 | ngx_int_t ngx_thread_mutex_unlock(ngx_thread_mutex_t *mtx, ngx_log_t *log);
26 |
27 |
28 | typedef pthread_cond_t ngx_thread_cond_t;
29 |
30 | ngx_int_t ngx_thread_cond_create(ngx_thread_cond_t *cond, ngx_log_t *log);
31 | ngx_int_t ngx_thread_cond_destroy(ngx_thread_cond_t *cond, ngx_log_t *log);
32 | ngx_int_t ngx_thread_cond_signal(ngx_thread_cond_t *cond, ngx_log_t *log);
33 | ngx_int_t ngx_thread_cond_wait(ngx_thread_cond_t *cond, ngx_thread_mutex_t *mtx,
34 | ngx_log_t *log);
35 |
36 |
37 | #if (NGX_LINUX)
38 |
39 | typedef pid_t ngx_tid_t;
40 | #define NGX_TID_T_FMT "%P"
41 |
42 | #elif (NGX_FREEBSD)
43 |
44 | typedef uint32_t ngx_tid_t;
45 | #define NGX_TID_T_FMT "%uD"
46 |
47 | #elif (NGX_DARWIN)
48 |
49 | typedef uint64_t ngx_tid_t;
50 | #define NGX_TID_T_FMT "%uA"
51 |
52 | #else
53 |
54 | typedef uint64_t ngx_tid_t;
55 | #define NGX_TID_T_FMT "%uA"
56 |
57 | #endif
58 |
59 | ngx_tid_t ngx_thread_tid(void);
60 |
61 | #define ngx_log_tid ngx_thread_tid()
62 |
63 | #else
64 |
65 | #define ngx_log_tid 0
66 | #define NGX_TID_T_FMT "%d"
67 |
68 | #endif
69 |
70 |
71 | #endif /* _NGX_THREAD_H_INCLUDED_ */
72 |
--------------------------------------------------------------------------------
/src/os/unix/ngx_daemon.c:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | * Copyright (C) Igor Sysoev
4 | * Copyright (C) Nginx, Inc.
5 | */
6 |
7 |
8 | #include
9 | #include
10 |
11 |
12 | ngx_int_t
13 | ngx_daemon(ngx_log_t *log)
14 | {
15 | int fd;
16 |
17 | switch (fork()) {
18 | case -1:
19 | ngx_log_error(NGX_LOG_EMERG, log, ngx_errno, "fork() failed");
20 | return NGX_ERROR;
21 |
22 | case 0:
23 | break;
24 |
25 | default:
26 | exit(0);
27 | }
28 |
29 | ngx_pid = ngx_getpid();
30 |
31 | if (setsid() == -1) {
32 | ngx_log_error(NGX_LOG_EMERG, log, ngx_errno, "setsid() failed");
33 | return NGX_ERROR;
34 | }
35 |
36 | /* umask(0) makes perl programs insecure by default,
37 | * we don't need that */
38 | #if 0
39 | umask(0);
40 | #endif
41 |
42 | fd = open("/dev/null", O_RDWR);
43 | if (fd == -1) {
44 | ngx_log_error(NGX_LOG_EMERG, log, ngx_errno,
45 | "open(\"/dev/null\") failed");
46 | return NGX_ERROR;
47 | }
48 |
49 | if (dup2(fd, STDIN_FILENO) == -1) {
50 | ngx_log_error(NGX_LOG_EMERG, log, ngx_errno, "dup2(STDIN) failed");
51 | return NGX_ERROR;
52 | }
53 |
54 | if (dup2(fd, STDOUT_FILENO) == -1) {
55 | ngx_log_error(NGX_LOG_EMERG, log, ngx_errno, "dup2(STDOUT) failed");
56 | return NGX_ERROR;
57 | }
58 |
59 | #if 0
60 | if (dup2(fd, STDERR_FILENO) == -1) {
61 | ngx_log_error(NGX_LOG_EMERG, log, ngx_errno, "dup2(STDERR) failed");
62 | return NGX_ERROR;
63 | }
64 | #endif
65 |
66 | if (fd > STDERR_FILENO) {
67 | if (close(fd) == -1) {
68 | ngx_log_error(NGX_LOG_EMERG, log, ngx_errno, "close() failed");
69 | return NGX_ERROR;
70 | }
71 | }
72 |
73 | return NGX_OK;
74 | }
75 |
--------------------------------------------------------------------------------
/auto/lib/conf:
--------------------------------------------------------------------------------
1 |
2 | # Copyright (C) Igor Sysoev
3 | # Copyright (C) Nginx, Inc.
4 |
5 |
6 | if [ $USE_PCRE = YES -o $PCRE != NONE ]; then
7 | . auto/lib/pcre/conf
8 |
9 | else
10 | if [ $USE_PCRE = DISABLED -a $HTTP_REWRITE = YES ]; then
11 |
12 | cat << END
13 |
14 | $0: error: the HTTP rewrite module requires the PCRE library.
15 | You can either disable the module by using --without-http_rewrite_module
16 | option or you have to enable the PCRE support.
17 |
18 | END
19 | exit 1
20 | fi
21 | fi
22 |
23 |
24 | if [ $USE_OPENSSL = YES ]; then
25 | . auto/lib/openssl/conf
26 | fi
27 |
28 | if [ $USE_MD5 = YES ]; then
29 |
30 | if [ $USE_OPENSSL = YES ]; then
31 | have=NGX_HAVE_OPENSSL_MD5_H . auto/have
32 | have=NGX_OPENSSL_MD5 . auto/have
33 | have=NGX_HAVE_MD5 . auto/have
34 | MD5=YES
35 | MD5_LIB=OpenSSL
36 |
37 | else
38 | . auto/lib/md5/conf
39 | fi
40 |
41 | fi
42 |
43 | if [ $USE_SHA1 = YES ]; then
44 |
45 | if [ $USE_OPENSSL = YES ]; then
46 | have=NGX_HAVE_OPENSSL_SHA1_H . auto/have
47 | have=NGX_HAVE_SHA1 . auto/have
48 | SHA1=YES
49 | SHA1_LIB=OpenSSL
50 |
51 | else
52 | . auto/lib/sha1/conf
53 | fi
54 |
55 | fi
56 |
57 | if [ $USE_ZLIB = YES ]; then
58 | . auto/lib/zlib/conf
59 | fi
60 |
61 | if [ $USE_LIBXSLT = YES ]; then
62 | . auto/lib/libxslt/conf
63 | fi
64 |
65 | if [ $USE_LIBGD = YES ]; then
66 | . auto/lib/libgd/conf
67 | fi
68 |
69 | if [ $USE_PERL = YES ]; then
70 | . auto/lib/perl/conf
71 | fi
72 |
73 | if [ $HTTP_GEOIP = YES ]; then
74 | . auto/lib/geoip/conf
75 | fi
76 |
77 | if [ $NGX_GOOGLE_PERFTOOLS = YES ]; then
78 | . auto/lib/google-perftools/conf
79 | fi
80 |
81 | if [ $NGX_LIBATOMIC != NO ]; then
82 | . auto/lib/libatomic/conf
83 | fi
84 |
--------------------------------------------------------------------------------
/src/core/ngx_queue.c:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | * Copyright (C) Igor Sysoev
4 | * Copyright (C) Nginx, Inc.
5 | */
6 |
7 |
8 | #include
9 | #include
10 |
11 |
12 | /*
13 | * find the middle queue element if the queue has odd number of elements
14 | * or the first element of the queue's second part otherwise
15 | */
16 |
17 | ngx_queue_t *
18 | ngx_queue_middle(ngx_queue_t *queue)
19 | {
20 | ngx_queue_t *middle, *next;
21 |
22 | middle = ngx_queue_head(queue);
23 |
24 | if (middle == ngx_queue_last(queue)) {
25 | return middle;
26 | }
27 |
28 | next = ngx_queue_head(queue);
29 |
30 | for ( ;; ) {
31 | middle = ngx_queue_next(middle);
32 |
33 | next = ngx_queue_next(next);
34 |
35 | if (next == ngx_queue_last(queue)) {
36 | return middle;
37 | }
38 |
39 | next = ngx_queue_next(next);
40 |
41 | if (next == ngx_queue_last(queue)) {
42 | return middle;
43 | }
44 | }
45 | }
46 |
47 |
48 | /* the stable insertion sort */
49 |
50 | void
51 | ngx_queue_sort(ngx_queue_t *queue,
52 | ngx_int_t (*cmp)(const ngx_queue_t *, const ngx_queue_t *))
53 | {
54 | ngx_queue_t *q, *prev, *next;
55 |
56 | q = ngx_queue_head(queue);
57 |
58 | if (q == ngx_queue_last(queue)) {
59 | return;
60 | }
61 |
62 | for (q = ngx_queue_next(q); q != ngx_queue_sentinel(queue); q = next) {
63 |
64 | prev = ngx_queue_prev(q);
65 | next = ngx_queue_next(q);
66 |
67 | ngx_queue_remove(q);
68 |
69 | do {
70 | if (cmp(prev, q) <= 0) {
71 | break;
72 | }
73 |
74 | prev = ngx_queue_prev(prev);
75 |
76 | } while (prev != ngx_queue_sentinel(queue));
77 |
78 | ngx_queue_insert_after(prev, q);
79 | }
80 | }
81 |
--------------------------------------------------------------------------------
/auto/types/typedef:
--------------------------------------------------------------------------------
1 |
2 | # Copyright (C) Igor Sysoev
3 | # Copyright (C) Nginx, Inc.
4 |
5 |
6 | echo $ngx_n "checking for $ngx_type ...$ngx_c"
7 |
8 | cat << END >> $NGX_AUTOCONF_ERR
9 |
10 | ----------------------------------------
11 | checking for $ngx_type
12 |
13 | END
14 |
15 | ngx_found=no
16 |
17 | for ngx_try in $ngx_type $ngx_types
18 | do
19 |
20 | cat << END > $NGX_AUTOTEST.c
21 |
22 | #include
23 | #include
24 | #include
25 | #include
26 | #include
27 | #include
28 | $NGX_INCLUDE_INTTYPES_H
29 |
30 | int main() {
31 | $ngx_try i = 0;
32 | return (int) i;
33 | }
34 |
35 | END
36 |
37 | ngx_test="$CC $CC_TEST_FLAGS $CC_AUX_FLAGS \
38 | -o $NGX_AUTOTEST $NGX_AUTOTEST.c $NGX_LD_OPT $ngx_feature_libs"
39 |
40 | eval "$ngx_test >> $NGX_AUTOCONF_ERR 2>&1"
41 |
42 | if [ -x $NGX_AUTOTEST ]; then
43 | if [ $ngx_try = $ngx_type ]; then
44 | echo " found"
45 | ngx_found=yes
46 | else
47 | echo ", $ngx_try used"
48 | ngx_found=$ngx_try
49 | fi
50 | fi
51 |
52 | rm -rf $NGX_AUTOTEST*
53 |
54 | if [ $ngx_found = no ]; then
55 | echo $ngx_n " $ngx_try not found$ngx_c"
56 |
57 | echo "----------" >> $NGX_AUTOCONF_ERR
58 | cat $NGX_AUTOTEST.c >> $NGX_AUTOCONF_ERR
59 | echo "----------" >> $NGX_AUTOCONF_ERR
60 | echo $ngx_test >> $NGX_AUTOCONF_ERR
61 | echo "----------" >> $NGX_AUTOCONF_ERR
62 |
63 | else
64 | break
65 | fi
66 | done
67 |
68 | if [ $ngx_found = no ]; then
69 | echo
70 | echo "$0: error: can not define $ngx_type"
71 |
72 | exit 1
73 | fi
74 |
75 | if [ $ngx_found != yes ]; then
76 | echo "typedef $ngx_found $ngx_type;" >> $NGX_AUTO_CONFIG_H
77 | fi
78 |
--------------------------------------------------------------------------------
/src/os/unix/ngx_solaris_init.c:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | * Copyright (C) Igor Sysoev
4 | * Copyright (C) Nginx, Inc.
5 | */
6 |
7 |
8 | #include
9 | #include
10 |
11 |
12 | char ngx_solaris_sysname[20];
13 | char ngx_solaris_release[10];
14 | char ngx_solaris_version[50];
15 |
16 |
17 | static ngx_os_io_t ngx_solaris_io = {
18 | ngx_unix_recv,
19 | ngx_readv_chain,
20 | ngx_udp_unix_recv,
21 | ngx_unix_send,
22 | #if (NGX_HAVE_SENDFILE)
23 | ngx_solaris_sendfilev_chain,
24 | NGX_IO_SENDFILE
25 | #else
26 | ngx_writev_chain,
27 | 0
28 | #endif
29 | };
30 |
31 |
32 | ngx_int_t
33 | ngx_os_specific_init(ngx_log_t *log)
34 | {
35 | if (sysinfo(SI_SYSNAME, ngx_solaris_sysname, sizeof(ngx_solaris_sysname))
36 | == -1)
37 | {
38 | ngx_log_error(NGX_LOG_ALERT, log, ngx_errno,
39 | "sysinfo(SI_SYSNAME) failed");
40 | return NGX_ERROR;
41 | }
42 |
43 | if (sysinfo(SI_RELEASE, ngx_solaris_release, sizeof(ngx_solaris_release))
44 | == -1)
45 | {
46 | ngx_log_error(NGX_LOG_ALERT, log, ngx_errno,
47 | "sysinfo(SI_RELEASE) failed");
48 | return NGX_ERROR;
49 | }
50 |
51 | if (sysinfo(SI_VERSION, ngx_solaris_version, sizeof(ngx_solaris_version))
52 | == -1)
53 | {
54 | ngx_log_error(NGX_LOG_ALERT, log, ngx_errno,
55 | "sysinfo(SI_SYSNAME) failed");
56 | return NGX_ERROR;
57 | }
58 |
59 |
60 | ngx_os_io = ngx_solaris_io;
61 |
62 | return NGX_OK;
63 | }
64 |
65 |
66 | void
67 | ngx_os_specific_status(ngx_log_t *log)
68 | {
69 |
70 | ngx_log_error(NGX_LOG_NOTICE, log, 0, "OS: %s %s",
71 | ngx_solaris_sysname, ngx_solaris_release);
72 |
73 | ngx_log_error(NGX_LOG_NOTICE, log, 0, "version: %s",
74 | ngx_solaris_version);
75 | }
76 |
--------------------------------------------------------------------------------
/src/os/unix/ngx_send.c:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | * Copyright (C) Igor Sysoev
4 | * Copyright (C) Nginx, Inc.
5 | */
6 |
7 |
8 | #include
9 | #include
10 | #include
11 |
12 |
13 | ssize_t
14 | ngx_unix_send(ngx_connection_t *c, u_char *buf, size_t size)
15 | {
16 | ssize_t n;
17 | ngx_err_t err;
18 | ngx_event_t *wev;
19 |
20 | wev = c->write;
21 |
22 | #if (NGX_HAVE_KQUEUE)
23 |
24 | if ((ngx_event_flags & NGX_USE_KQUEUE_EVENT) && wev->pending_eof) {
25 | (void) ngx_connection_error(c, wev->kq_errno,
26 | "kevent() reported about an closed connection");
27 | wev->error = 1;
28 | return NGX_ERROR;
29 | }
30 |
31 | #endif
32 |
33 | for ( ;; ) {
34 | n = send(c->fd, buf, size, 0);
35 |
36 | ngx_log_debug3(NGX_LOG_DEBUG_EVENT, c->log, 0,
37 | "send: fd:%d %d of %d", c->fd, n, size);
38 |
39 | if (n > 0) {
40 | if (n < (ssize_t) size) {
41 | wev->ready = 0;
42 | }
43 |
44 | c->sent += n;
45 |
46 | return n;
47 | }
48 |
49 | err = ngx_socket_errno;
50 |
51 | if (n == 0) {
52 | ngx_log_error(NGX_LOG_ALERT, c->log, err, "send() returned zero");
53 | wev->ready = 0;
54 | return n;
55 | }
56 |
57 | if (err == NGX_EAGAIN || err == NGX_EINTR) {
58 | wev->ready = 0;
59 |
60 | ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, err,
61 | "send() not ready");
62 |
63 | if (err == NGX_EAGAIN) {
64 | return NGX_AGAIN;
65 | }
66 |
67 | } else {
68 | wev->error = 1;
69 | (void) ngx_connection_error(c, err, "send() failed");
70 | return NGX_ERROR;
71 | }
72 | }
73 | }
74 |
--------------------------------------------------------------------------------
/src/os/unix/ngx_aio_read_chain.c:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | * Copyright (C) Igor Sysoev
4 | * Copyright (C) Nginx, Inc.
5 | */
6 |
7 |
8 | #include
9 | #include
10 | #include
11 |
12 |
13 | ssize_t
14 | ngx_aio_read_chain(ngx_connection_t *c, ngx_chain_t *cl, off_t limit)
15 | {
16 | int n;
17 | u_char *buf, *prev;
18 | size_t size;
19 | ssize_t total;
20 |
21 | if (c->read->pending_eof) {
22 | c->read->ready = 0;
23 | return 0;
24 | }
25 |
26 | total = 0;
27 |
28 | while (cl) {
29 |
30 | /* we can post the single aio operation only */
31 |
32 | if (!c->read->ready) {
33 | return total ? total : NGX_AGAIN;
34 | }
35 |
36 | buf = cl->buf->last;
37 | prev = cl->buf->last;
38 | size = 0;
39 |
40 | /* coalesce the neighbouring bufs */
41 |
42 | while (cl && prev == cl->buf->last) {
43 | size += cl->buf->end - cl->buf->last;
44 | prev = cl->buf->end;
45 | cl = cl->next;
46 | }
47 |
48 | n = ngx_aio_read(c, buf, size);
49 |
50 | ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0, "aio_read: %d", n);
51 |
52 | if (n == NGX_AGAIN) {
53 | return total ? total : NGX_AGAIN;
54 | }
55 |
56 | if (n == NGX_ERROR) {
57 | return NGX_ERROR;
58 | }
59 |
60 | if (n == 0) {
61 | c->read->pending_eof = 1;
62 | if (total) {
63 | c->read->eof = 0;
64 | c->read->ready = 1;
65 | }
66 | return total;
67 | }
68 |
69 | if (n > 0) {
70 | total += n;
71 | }
72 |
73 | ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0,
74 | "aio_read total: %d", total);
75 | }
76 |
77 | return total ? total : NGX_AGAIN;
78 | }
79 |
--------------------------------------------------------------------------------
/auto/lib/libgd/conf:
--------------------------------------------------------------------------------
1 |
2 | # Copyright (C) Igor Sysoev
3 | # Copyright (C) Nginx, Inc.
4 |
5 |
6 | ngx_feature="GD library"
7 | ngx_feature_name=
8 | ngx_feature_run=no
9 | ngx_feature_incs="#include "
10 | ngx_feature_path=
11 | ngx_feature_libs="-lgd"
12 | ngx_feature_test="gdImagePtr img = gdImageCreateFromGifPtr(1, NULL);"
13 | . auto/feature
14 |
15 |
16 | if [ $ngx_found = no ]; then
17 |
18 | # FreeBSD port
19 |
20 | ngx_feature="GD library in /usr/local/"
21 | ngx_feature_path="/usr/local/include"
22 |
23 | if [ $NGX_RPATH = YES ]; then
24 | ngx_feature_libs="-R/usr/local/lib -L/usr/local/lib -lgd"
25 | else
26 | ngx_feature_libs="-L/usr/local/lib -lgd"
27 | fi
28 |
29 | . auto/feature
30 | fi
31 |
32 |
33 | if [ $ngx_found = no ]; then
34 |
35 | # NetBSD port
36 |
37 | ngx_feature="GD library in /usr/pkg/"
38 | ngx_feature_path="/usr/pkg/include"
39 |
40 | if [ $NGX_RPATH = YES ]; then
41 | ngx_feature_libs="-R/usr/pkg/lib -L/usr/pkg/lib -lgd"
42 | else
43 | ngx_feature_libs="-L/usr/pkg/lib -lgd"
44 | fi
45 |
46 | . auto/feature
47 | fi
48 |
49 |
50 | if [ $ngx_found = no ]; then
51 |
52 | # MacPorts
53 |
54 | ngx_feature="GD library in /opt/local/"
55 | ngx_feature_path="/opt/local/include"
56 |
57 | if [ $NGX_RPATH = YES ]; then
58 | ngx_feature_libs="-R/opt/local/lib -L/opt/local/lib -lgd"
59 | else
60 | ngx_feature_libs="-L/opt/local/lib -lgd"
61 | fi
62 |
63 | . auto/feature
64 | fi
65 |
66 |
67 | if [ $ngx_found = yes ]; then
68 |
69 | CORE_INCS="$CORE_INCS $ngx_feature_path"
70 | CORE_LIBS="$CORE_LIBS $ngx_feature_libs"
71 |
72 | else
73 |
74 | cat << END
75 |
76 | $0: error: the HTTP image filter module requires the GD library.
77 | You can either do not enable the module or install the libraries.
78 |
79 | END
80 |
81 | exit 1
82 |
83 | fi
84 |
--------------------------------------------------------------------------------
/auto/lib/perl/make:
--------------------------------------------------------------------------------
1 |
2 | # Copyright (C) Igor Sysoev, Alexandr Gomoliako
3 | # Copyright (C) Nginx, Inc.
4 |
5 |
6 | v=`grep 'define NGINX_VERSION' src/core/nginx.h | sed -e 's/^.*"\(.*\)".*/\1/'`
7 |
8 |
9 | cat << END >> $NGX_MAKEFILE
10 |
11 | $NGX_OBJS/src/http/modules/perl/blib/arch/auto/Nginx/Nginx.so: \\
12 | \$(CORE_DEPS) \$(HTTP_DEPS) \\
13 | src/http/modules/perl/Nginx.pm \\
14 | src/http/modules/perl/Nginx.xs \\
15 | src/http/modules/perl/ngx_http_perl_module.h \\
16 | $NGX_OBJS/src/http/modules/perl/Makefile
17 | cp -p src/http/modules/perl/Nginx.xs $NGX_OBJS/src/http/modules/perl/
18 | cp -p src/http/modules/perl/*.pm $NGX_OBJS/src/http/modules/perl/
19 |
20 | cd $NGX_OBJS/src/http/modules/perl && \$(MAKE)
21 |
22 | rm -rf blib/
23 | cp -rp $NGX_OBJS/src/http/modules/perl/blib ./
24 |
25 | rm -rf $NGX_OBJS/install_perl
26 |
27 |
28 | $NGX_OBJS/src/http/modules/perl/Makefile: \\
29 | $NGX_AUTO_CONFIG_H \\
30 | src/core/nginx.h \\
31 | src/http/modules/perl/Makefile.PL \\
32 | src/http/modules/perl/Nginx.pm \\
33 | src/http/modules/perl/Test.pm \\
34 | src/http/modules/perl/Perl.pm
35 | cp -p src/http/modules/perl/Nginx.xs $NGX_OBJS/src/http/modules/perl/
36 | cp -p src/http/modules/perl/*.pm $NGX_OBJS/src/http/modules/perl/
37 | cp -p src/http/modules/perl/typemap $NGX_OBJS/src/http/modules/perl/
38 | cp -p src/http/modules/perl/Makefile.PL $NGX_OBJS/src/http/modules/perl/
39 |
40 | cd $NGX_OBJS/src/http/modules/perl \\
41 | && NGX_PM_CFLAGS="\$(NGX_PM_CFLAGS) -g $NGX_CC_OPT" \\
42 | NGX_INCS="$CORE_INCS $NGX_OBJS $HTTP_INCS" \\
43 | NGX_DEPS="\$(CORE_DEPS) \$(HTTP_DEPS)" \\
44 | $NGX_PERL Makefile.PL \\
45 | LIB=$NGX_PERL_MODULES \\
46 | INSTALLSITEMAN3DIR=$NGX_PERL_MODULES_MAN
47 |
48 | test: $NGX_OBJS/nginx-perl
49 | PERL_DL_NONLAZY=1 $NGX_PERL "-MExtUtils::Command::MM" "-e" "test_harness(0, 'blib/lib', 'blib/arch')" t/*.t
50 |
51 | END
52 |
--------------------------------------------------------------------------------
/src/os/unix/ngx_gcc_atomic_amd64.h:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | * Copyright (C) Igor Sysoev
4 | * Copyright (C) Nginx, Inc.
5 | */
6 |
7 |
8 | #if (NGX_SMP)
9 | #define NGX_SMP_LOCK "lock;"
10 | #else
11 | #define NGX_SMP_LOCK
12 | #endif
13 |
14 |
15 | /*
16 | * "cmpxchgq r, [m]":
17 | *
18 | * if (rax == [m]) {
19 | * zf = 1;
20 | * [m] = r;
21 | * } else {
22 | * zf = 0;
23 | * rax = [m];
24 | * }
25 | *
26 | *
27 | * The "r" is any register, %rax (%r0) - %r16.
28 | * The "=a" and "a" are the %rax register.
29 | * Although we can return result in any register, we use "a" because it is
30 | * used in cmpxchgq anyway. The result is actually in %al but not in $rax,
31 | * however as the code is inlined gcc can test %al as well as %rax.
32 | *
33 | * The "cc" means that flags were changed.
34 | */
35 |
36 | static ngx_inline ngx_atomic_uint_t
37 | ngx_atomic_cmp_set(ngx_atomic_t *lock, ngx_atomic_uint_t old,
38 | ngx_atomic_uint_t set)
39 | {
40 | u_char res;
41 |
42 | __asm__ volatile (
43 |
44 | NGX_SMP_LOCK
45 | " cmpxchgq %3, %1; "
46 | " sete %0; "
47 |
48 | : "=a" (res) : "m" (*lock), "a" (old), "r" (set) : "cc", "memory");
49 |
50 | return res;
51 | }
52 |
53 |
54 | /*
55 | * "xaddq r, [m]":
56 | *
57 | * temp = [m];
58 | * [m] += r;
59 | * r = temp;
60 | *
61 | *
62 | * The "+r" is any register, %rax (%r0) - %r16.
63 | * The "cc" means that flags were changed.
64 | */
65 |
66 | static ngx_inline ngx_atomic_int_t
67 | ngx_atomic_fetch_add(ngx_atomic_t *value, ngx_atomic_int_t add)
68 | {
69 | __asm__ volatile (
70 |
71 | NGX_SMP_LOCK
72 | " xaddq %0, %1; "
73 |
74 | : "+r" (add) : "m" (*value) : "cc", "memory");
75 |
76 | return add;
77 | }
78 |
79 |
80 | #define ngx_memory_barrier() __asm__ volatile ("" ::: "memory")
81 |
82 | #define ngx_cpu_pause() __asm__ ("pause")
83 |
--------------------------------------------------------------------------------
/src/http/modules/ngx_http_ssl_module.h:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | * Copyright (C) Igor Sysoev
4 | * Copyright (C) Nginx, Inc.
5 | */
6 |
7 |
8 | #ifndef _NGX_HTTP_SSL_H_INCLUDED_
9 | #define _NGX_HTTP_SSL_H_INCLUDED_
10 |
11 |
12 | #include
13 | #include
14 | #include
15 |
16 |
17 | typedef struct {
18 | ngx_flag_t enable;
19 |
20 | ngx_ssl_t ssl;
21 |
22 | ngx_flag_t prefer_server_ciphers;
23 |
24 | ngx_uint_t protocols;
25 |
26 | ngx_uint_t verify;
27 | ngx_uint_t verify_depth;
28 |
29 | size_t buffer_size;
30 |
31 | ssize_t builtin_session_cache;
32 |
33 | time_t session_timeout;
34 |
35 | ngx_str_t certificate;
36 | ngx_str_t certificate_key;
37 | ngx_str_t dhparam;
38 | ngx_str_t ecdh_curve;
39 | ngx_str_t client_certificate;
40 | ngx_str_t trusted_certificate;
41 | ngx_str_t crl;
42 |
43 | ngx_str_t ciphers;
44 |
45 | ngx_array_t *passwords;
46 |
47 | ngx_shm_zone_t *shm_zone;
48 |
49 | ngx_flag_t session_tickets;
50 | ngx_array_t *session_ticket_keys;
51 |
52 | ngx_flag_t stapling;
53 | ngx_flag_t stapling_verify;
54 | ngx_str_t stapling_file;
55 | ngx_str_t stapling_responder;
56 |
57 | u_char *file;
58 | ngx_uint_t line;
59 | } ngx_http_ssl_srv_conf_t;
60 |
61 |
62 | extern ngx_module_t ngx_http_ssl_module;
63 |
64 |
65 | #endif /* _NGX_HTTP_SSL_H_INCLUDED_ */
66 |
--------------------------------------------------------------------------------
/src/os/unix/ngx_gcc_atomic_sparc64.h:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | * Copyright (C) Igor Sysoev
4 | * Copyright (C) Nginx, Inc.
5 | */
6 |
7 |
8 | /*
9 | * "casa [r1] 0x80, r2, r0" and
10 | * "casxa [r1] 0x80, r2, r0" do the following:
11 | *
12 | * if ([r1] == r2) {
13 | * swap(r0, [r1]);
14 | * } else {
15 | * r0 = [r1];
16 | * }
17 | *
18 | * so "r0 == r2" means that the operation was successful.
19 | *
20 | *
21 | * The "r" means the general register.
22 | * The "+r" means the general register used for both input and output.
23 | */
24 |
25 |
26 | #if (NGX_PTR_SIZE == 4)
27 | #define NGX_CASA "casa"
28 | #else
29 | #define NGX_CASA "casxa"
30 | #endif
31 |
32 |
33 | static ngx_inline ngx_atomic_uint_t
34 | ngx_atomic_cmp_set(ngx_atomic_t *lock, ngx_atomic_uint_t old,
35 | ngx_atomic_uint_t set)
36 | {
37 | __asm__ volatile (
38 |
39 | NGX_CASA " [%1] 0x80, %2, %0"
40 |
41 | : "+r" (set) : "r" (lock), "r" (old) : "memory");
42 |
43 | return (set == old);
44 | }
45 |
46 |
47 | static ngx_inline ngx_atomic_int_t
48 | ngx_atomic_fetch_add(ngx_atomic_t *value, ngx_atomic_int_t add)
49 | {
50 | ngx_atomic_uint_t old, res;
51 |
52 | old = *value;
53 |
54 | for ( ;; ) {
55 |
56 | res = old + add;
57 |
58 | __asm__ volatile (
59 |
60 | NGX_CASA " [%1] 0x80, %2, %0"
61 |
62 | : "+r" (res) : "r" (value), "r" (old) : "memory");
63 |
64 | if (res == old) {
65 | return res;
66 | }
67 |
68 | old = res;
69 | }
70 | }
71 |
72 |
73 | #if (NGX_SMP)
74 | #define ngx_memory_barrier() \
75 | __asm__ volatile ( \
76 | "membar #LoadLoad | #LoadStore | #StoreStore | #StoreLoad" \
77 | ::: "memory")
78 | #else
79 | #define ngx_memory_barrier() __asm__ volatile ("" ::: "memory")
80 | #endif
81 |
82 | #define ngx_cpu_pause()
83 |
--------------------------------------------------------------------------------
/src/os/unix/ngx_darwin_config.h:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | * Copyright (C) Igor Sysoev
4 | * Copyright (C) Nginx, Inc.
5 | */
6 |
7 |
8 | #ifndef _NGX_DARWIN_CONFIG_H_INCLUDED_
9 | #define _NGX_DARWIN_CONFIG_H_INCLUDED_
10 |
11 |
12 | #include
13 | #include
14 | #include
15 | #include
16 | #include
17 | #include /* offsetof() */
18 | #include
19 | #include
20 | #include
21 | #include
22 | #include
23 | #include
24 | #include
25 | #include
26 | #include
27 | #include
28 | #include /* statfs() */
29 |
30 | #include /* FIONBIO */
31 | #include
32 | #include
33 | #include
34 | #include
35 |
36 | #include
37 | #include
38 | #include
39 | #include
40 |
41 | #include
42 | #include
43 | #include /* TCP_NODELAY */
44 | #include
45 | #include
46 | #include
47 |
48 | #include
49 | #include
50 |
51 |
52 | #ifndef IOV_MAX
53 | #define IOV_MAX 64
54 | #endif
55 |
56 |
57 | #include
58 |
59 |
60 | #if (NGX_HAVE_POSIX_SEM)
61 | #include
62 | #endif
63 |
64 |
65 | #if (NGX_HAVE_POLL)
66 | #include
67 | #endif
68 |
69 |
70 | #if (NGX_HAVE_KQUEUE)
71 | #include
72 | #endif
73 |
74 |
75 | #define NGX_LISTEN_BACKLOG -1
76 |
77 |
78 | #ifndef NGX_HAVE_INHERITED_NONBLOCK
79 | #define NGX_HAVE_INHERITED_NONBLOCK 1
80 | #endif
81 |
82 |
83 | #ifndef NGX_HAVE_CASELESS_FILESYSTEM
84 | #define NGX_HAVE_CASELESS_FILESYSTEM 1
85 | #endif
86 |
87 |
88 | #define NGX_HAVE_OS_SPECIFIC_INIT 1
89 | #define NGX_HAVE_DEBUG_MALLOC 1
90 |
91 |
92 | extern char **environ;
93 |
94 |
95 | #endif /* _NGX_DARWIN_CONFIG_H_INCLUDED_ */
96 |
--------------------------------------------------------------------------------
/src/os/unix/ngx_alloc.c:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | * Copyright (C) Igor Sysoev
4 | * Copyright (C) Nginx, Inc.
5 | */
6 |
7 |
8 | #include
9 | #include
10 |
11 |
12 | ngx_uint_t ngx_pagesize;
13 | ngx_uint_t ngx_pagesize_shift;
14 | ngx_uint_t ngx_cacheline_size;
15 |
16 |
17 | void *
18 | ngx_alloc(size_t size, ngx_log_t *log)
19 | {
20 | void *p;
21 |
22 | p = malloc(size);
23 | if (p == NULL) {
24 | ngx_log_error(NGX_LOG_EMERG, log, ngx_errno,
25 | "malloc(%uz) failed", size);
26 | }
27 |
28 | ngx_log_debug2(NGX_LOG_DEBUG_ALLOC, log, 0, "malloc: %p:%uz", p, size);
29 |
30 | return p;
31 | }
32 |
33 |
34 | void *
35 | ngx_calloc(size_t size, ngx_log_t *log)
36 | {
37 | void *p;
38 |
39 | p = ngx_alloc(size, log);
40 |
41 | if (p) {
42 | ngx_memzero(p, size);
43 | }
44 |
45 | return p;
46 | }
47 |
48 |
49 | #if (NGX_HAVE_POSIX_MEMALIGN)
50 |
51 | void *
52 | ngx_memalign(size_t alignment, size_t size, ngx_log_t *log)
53 | {
54 | void *p;
55 | int err;
56 |
57 | err = posix_memalign(&p, alignment, size);
58 |
59 | if (err) {
60 | ngx_log_error(NGX_LOG_EMERG, log, err,
61 | "posix_memalign(%uz, %uz) failed", alignment, size);
62 | p = NULL;
63 | }
64 |
65 | ngx_log_debug3(NGX_LOG_DEBUG_ALLOC, log, 0,
66 | "posix_memalign: %p:%uz @%uz", p, size, alignment);
67 |
68 | return p;
69 | }
70 |
71 | #elif (NGX_HAVE_MEMALIGN)
72 |
73 | void *
74 | ngx_memalign(size_t alignment, size_t size, ngx_log_t *log)
75 | {
76 | void *p;
77 |
78 | p = memalign(alignment, size);
79 | if (p == NULL) {
80 | ngx_log_error(NGX_LOG_EMERG, log, ngx_errno,
81 | "memalign(%uz, %uz) failed", alignment, size);
82 | }
83 |
84 | ngx_log_debug3(NGX_LOG_DEBUG_ALLOC, log, 0,
85 | "memalign: %p:%uz @%uz", p, size, alignment);
86 |
87 | return p;
88 | }
89 |
90 | #endif
91 |
--------------------------------------------------------------------------------
/src/event/ngx_event_posted.h:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | * Copyright (C) Igor Sysoev
4 | * Copyright (C) Nginx, Inc.
5 | */
6 |
7 |
8 | #ifndef _NGX_EVENT_POSTED_H_INCLUDED_
9 | #define _NGX_EVENT_POSTED_H_INCLUDED_
10 |
11 |
12 | #include
13 | #include
14 | #include
15 |
16 |
17 | #define ngx_post_event(ev, q) \
18 | \
19 | if (!(ev)->posted) { \
20 | (ev)->posted = 1; \
21 | ngx_queue_insert_tail(q, &(ev)->queue); \
22 | \
23 | ngx_log_debug1(NGX_LOG_DEBUG_CORE, (ev)->log, 0, "post event %p", ev);\
24 | \
25 | } else { \
26 | ngx_log_debug1(NGX_LOG_DEBUG_CORE, (ev)->log, 0, \
27 | "update posted event %p", ev); \
28 | }
29 |
30 |
31 | #define ngx_delete_posted_event(ev) \
32 | \
33 | (ev)->posted = 0; \
34 | ngx_queue_remove(&(ev)->queue); \
35 | \
36 | ngx_log_debug1(NGX_LOG_DEBUG_CORE, (ev)->log, 0, \
37 | "delete posted event %p", ev);
38 |
39 |
40 |
41 | void ngx_event_process_posted(ngx_cycle_t *cycle, ngx_queue_t *posted);
42 |
43 |
44 | extern ngx_queue_t ngx_posted_accept_events;
45 | extern ngx_queue_t ngx_posted_events;
46 |
47 |
48 | #endif /* _NGX_EVENT_POSTED_H_INCLUDED_ */
49 |
--------------------------------------------------------------------------------
/src/os/unix/ngx_user.c:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | * Copyright (C) Igor Sysoev
4 | * Copyright (C) Nginx, Inc.
5 | */
6 |
7 |
8 | #include
9 | #include
10 |
11 |
12 | /*
13 | * Solaris has thread-safe crypt()
14 | * Linux has crypt_r(); "struct crypt_data" is more than 128K
15 | * FreeBSD needs the mutex to protect crypt()
16 | *
17 | * TODO:
18 | * ngx_crypt_init() to init mutex
19 | */
20 |
21 |
22 | #if (NGX_CRYPT)
23 |
24 | #if (NGX_HAVE_GNU_CRYPT_R)
25 |
26 | ngx_int_t
27 | ngx_libc_crypt(ngx_pool_t *pool, u_char *key, u_char *salt, u_char **encrypted)
28 | {
29 | char *value;
30 | size_t len;
31 | struct crypt_data cd;
32 |
33 | cd.initialized = 0;
34 | #ifdef __GLIBC__
35 | /* work around the glibc bug */
36 | cd.current_salt[0] = ~salt[0];
37 | #endif
38 |
39 | value = crypt_r((char *) key, (char *) salt, &cd);
40 |
41 | if (value) {
42 | len = ngx_strlen(value) + 1;
43 |
44 | *encrypted = ngx_pnalloc(pool, len);
45 | if (*encrypted == NULL) {
46 | return NGX_ERROR;
47 | }
48 |
49 | ngx_memcpy(*encrypted, value, len);
50 | return NGX_OK;
51 | }
52 |
53 | ngx_log_error(NGX_LOG_CRIT, pool->log, ngx_errno, "crypt_r() failed");
54 |
55 | return NGX_ERROR;
56 | }
57 |
58 | #else
59 |
60 | ngx_int_t
61 | ngx_libc_crypt(ngx_pool_t *pool, u_char *key, u_char *salt, u_char **encrypted)
62 | {
63 | char *value;
64 | size_t len;
65 | ngx_err_t err;
66 |
67 | value = crypt((char *) key, (char *) salt);
68 |
69 | if (value) {
70 | len = ngx_strlen(value) + 1;
71 |
72 | *encrypted = ngx_pnalloc(pool, len);
73 | if (*encrypted == NULL) {
74 | return NGX_ERROR;
75 | }
76 |
77 | ngx_memcpy(*encrypted, value, len);
78 | return NGX_OK;
79 | }
80 |
81 | err = ngx_errno;
82 |
83 | ngx_log_error(NGX_LOG_CRIT, pool->log, err, "crypt() failed");
84 |
85 | return NGX_ERROR;
86 | }
87 |
88 | #endif
89 |
90 | #endif /* NGX_CRYPT */
91 |
--------------------------------------------------------------------------------
/src/os/unix/ngx_time.c:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | * Copyright (C) Igor Sysoev
4 | * Copyright (C) Nginx, Inc.
5 | */
6 |
7 |
8 | #include
9 | #include
10 |
11 |
12 | /*
13 | * FreeBSD does not test /etc/localtime change, however, we can workaround it
14 | * by calling tzset() with TZ and then without TZ to update timezone.
15 | * The trick should work since FreeBSD 2.1.0.
16 | *
17 | * Linux does not test /etc/localtime change in localtime(),
18 | * but may stat("/etc/localtime") several times in every strftime(),
19 | * therefore we use it to update timezone.
20 | *
21 | * Solaris does not test /etc/TIMEZONE change too and no workaround available.
22 | */
23 |
24 | void
25 | ngx_timezone_update(void)
26 | {
27 | #if (NGX_FREEBSD)
28 |
29 | if (getenv("TZ")) {
30 | return;
31 | }
32 |
33 | putenv("TZ=UTC");
34 |
35 | tzset();
36 |
37 | unsetenv("TZ");
38 |
39 | tzset();
40 |
41 | #elif (NGX_LINUX)
42 | time_t s;
43 | struct tm *t, t_r;
44 | char buf[4];
45 |
46 | s = time(0);
47 |
48 | t = localtime_r(&s, &t_r);
49 |
50 | strftime(buf, 4, "%H", t);
51 |
52 | #endif
53 | }
54 |
55 |
56 | void
57 | ngx_localtime(time_t s, ngx_tm_t *tm)
58 | {
59 | #if (NGX_HAVE_LOCALTIME_R)
60 | (void) localtime_r(&s, tm);
61 |
62 | #else
63 | ngx_tm_t *t;
64 |
65 | t = localtime(&s);
66 | *tm = *t;
67 |
68 | #endif
69 |
70 | tm->ngx_tm_mon++;
71 | tm->ngx_tm_year += 1900;
72 | }
73 |
74 |
75 | void
76 | ngx_libc_localtime(time_t s, struct tm *tm)
77 | {
78 | #if (NGX_HAVE_LOCALTIME_R)
79 | (void) localtime_r(&s, tm);
80 |
81 | #else
82 | struct tm *t;
83 |
84 | t = localtime(&s);
85 | *tm = *t;
86 |
87 | #endif
88 | }
89 |
90 |
91 | void
92 | ngx_libc_gmtime(time_t s, struct tm *tm)
93 | {
94 | #if (NGX_HAVE_LOCALTIME_R)
95 | (void) gmtime_r(&s, tm);
96 |
97 | #else
98 | struct tm *t;
99 |
100 | t = gmtime(&s);
101 | *tm = *t;
102 |
103 | #endif
104 | }
105 |
--------------------------------------------------------------------------------
/src/event/ngx_event_connect.h:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | * Copyright (C) Igor Sysoev
4 | * Copyright (C) Nginx, Inc.
5 | */
6 |
7 |
8 | #ifndef _NGX_EVENT_CONNECT_H_INCLUDED_
9 | #define _NGX_EVENT_CONNECT_H_INCLUDED_
10 |
11 |
12 | #include
13 | #include
14 | #include
15 |
16 |
17 | #define NGX_PEER_KEEPALIVE 1
18 | #define NGX_PEER_NEXT 2
19 | #define NGX_PEER_FAILED 4
20 |
21 |
22 | typedef struct ngx_peer_connection_s ngx_peer_connection_t;
23 |
24 | typedef ngx_int_t (*ngx_event_get_peer_pt)(ngx_peer_connection_t *pc,
25 | void *data);
26 | typedef void (*ngx_event_free_peer_pt)(ngx_peer_connection_t *pc, void *data,
27 | ngx_uint_t state);
28 | #if (NGX_SSL)
29 |
30 | typedef ngx_int_t (*ngx_event_set_peer_session_pt)(ngx_peer_connection_t *pc,
31 | void *data);
32 | typedef void (*ngx_event_save_peer_session_pt)(ngx_peer_connection_t *pc,
33 | void *data);
34 | #endif
35 |
36 |
37 | struct ngx_peer_connection_s {
38 | ngx_connection_t *connection;
39 |
40 | struct sockaddr *sockaddr;
41 | socklen_t socklen;
42 | ngx_str_t *name;
43 |
44 | ngx_uint_t tries;
45 | ngx_msec_t start_time;
46 |
47 | ngx_event_get_peer_pt get;
48 | ngx_event_free_peer_pt free;
49 | void *data;
50 |
51 | #if (NGX_SSL)
52 | ngx_event_set_peer_session_pt set_session;
53 | ngx_event_save_peer_session_pt save_session;
54 | #endif
55 |
56 | ngx_addr_t *local;
57 |
58 | int rcvbuf;
59 |
60 | ngx_log_t *log;
61 |
62 | unsigned cached:1;
63 |
64 | /* ngx_connection_log_error_e */
65 | unsigned log_error:2;
66 | };
67 |
68 |
69 | ngx_int_t ngx_event_connect_peer(ngx_peer_connection_t *pc);
70 | ngx_int_t ngx_event_get_peer(ngx_peer_connection_t *pc, void *data);
71 |
72 |
73 | #endif /* _NGX_EVENT_CONNECT_H_INCLUDED_ */
74 |
--------------------------------------------------------------------------------
/auto/lib/sha1/conf:
--------------------------------------------------------------------------------
1 |
2 | # Copyright (C) Igor Sysoev
3 | # Copyright (C) Nginx, Inc.
4 |
5 |
6 | if [ $SHA1 != NONE ]; then
7 |
8 | have=NGX_HAVE_SHA1 . auto/have
9 | CORE_INCS="$CORE_INCS $SHA1"
10 |
11 | case "$NGX_CC_NAME" in
12 |
13 | msvc* | owc* | bcc)
14 | LINK_DEPS="$LINK_DEPS $SHA1/sha1.lib"
15 | CORE_LIBS="$CORE_LIBS $SHA1/sha1.lib"
16 | ;;
17 |
18 | icc*)
19 | LINK_DEPS="$LINK_DEPS $SHA1/libsha.a"
20 |
21 | # to allow -ipo optimization we link with the *.o but not library
22 | CORE_LIBS="$CORE_LIBS $SHA1/sha1_dgst.o"
23 |
24 | if [ $SHA1_ASM = YES ]; then
25 | CORE_LIBS="$CORE_LIBS $SHA1/asm/sx86-elf.o"
26 | fi
27 | ;;
28 |
29 | *)
30 | LINK_DEPS="$LINK_DEPS $SHA1/libsha.a"
31 | CORE_LIBS="$CORE_LIBS $SHA1/libsha.a"
32 | #CORE_LIBS="$CORE_LIBS -L $SHA1 -lsha"
33 | ;;
34 |
35 | esac
36 |
37 | else
38 |
39 | if [ "$NGX_PLATFORM" != win32 ]; then
40 |
41 | SHA1=NO
42 |
43 | # FreeBSD
44 |
45 | ngx_feature="sha1 in system md library"
46 | ngx_feature_name=NGX_HAVE_SHA1
47 | ngx_feature_run=no
48 | ngx_feature_incs="#include "
49 | ngx_feature_path=
50 | ngx_feature_libs="-lmd"
51 | ngx_feature_test="SHA_CTX sha1; SHA1_Init(&sha1)"
52 | . auto/feature
53 |
54 | ngx_sha1_lib="system md"
55 |
56 | if [ $ngx_found = no ]; then
57 |
58 | # OpenSSL crypto library
59 |
60 | ngx_feature="sha1 in system OpenSSL crypto library"
61 | ngx_feature_incs="#include "
62 | ngx_feature_libs="-lcrypto"
63 | . auto/feature
64 |
65 | ngx_sha1_lib="system crypto"
66 |
67 | if [ $ngx_found = yes ]; then
68 | have=NGX_HAVE_OPENSSL_SHA1_H . auto/have
69 | fi
70 | fi
71 |
72 | if [ $ngx_found = yes ]; then
73 | CORE_LIBS="$CORE_LIBS $ngx_feature_libs"
74 | SHA1=YES
75 | SHA1_LIB=$ngx_sha1_lib
76 | fi
77 | fi
78 |
79 | fi
80 |
--------------------------------------------------------------------------------
/src/core/ngx_proxy_protocol.c:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | * Copyright (C) Roman Arutyunyan
4 | * Copyright (C) Nginx, Inc.
5 | */
6 |
7 |
8 | #include
9 | #include
10 |
11 |
12 | u_char *
13 | ngx_proxy_protocol_parse(ngx_connection_t *c, u_char *buf, u_char *last)
14 | {
15 | size_t len;
16 | u_char ch, *p, *addr;
17 |
18 | p = buf;
19 | len = last - buf;
20 |
21 | if (len < 8 || ngx_strncmp(p, "PROXY ", 6) != 0) {
22 | goto invalid;
23 | }
24 |
25 | p += 6;
26 | len -= 6;
27 |
28 | if (len >= 7 && ngx_strncmp(p, "UNKNOWN", 7) == 0) {
29 | ngx_log_debug0(NGX_LOG_DEBUG_CORE, c->log, 0,
30 | "PROXY protocol unknown protocol");
31 | p += 7;
32 | goto skip;
33 | }
34 |
35 | if (len < 5 || ngx_strncmp(p, "TCP", 3) != 0
36 | || (p[3] != '4' && p[3] != '6') || p[4] != ' ')
37 | {
38 | goto invalid;
39 | }
40 |
41 | p += 5;
42 | addr = p;
43 |
44 | for ( ;; ) {
45 | if (p == last) {
46 | goto invalid;
47 | }
48 |
49 | ch = *p++;
50 |
51 | if (ch == ' ') {
52 | break;
53 | }
54 |
55 | if (ch != ':' && ch != '.'
56 | && (ch < 'a' || ch > 'f')
57 | && (ch < 'A' || ch > 'F')
58 | && (ch < '0' || ch > '9'))
59 | {
60 | goto invalid;
61 | }
62 | }
63 |
64 | len = p - addr - 1;
65 | c->proxy_protocol_addr.data = ngx_pnalloc(c->pool, len);
66 |
67 | if (c->proxy_protocol_addr.data == NULL) {
68 | return NULL;
69 | }
70 |
71 | ngx_memcpy(c->proxy_protocol_addr.data, addr, len);
72 | c->proxy_protocol_addr.len = len;
73 |
74 | ngx_log_debug1(NGX_LOG_DEBUG_CORE, c->log, 0,
75 | "PROXY protocol address: \"%V\"", &c->proxy_protocol_addr);
76 |
77 | skip:
78 |
79 | for ( /* void */ ; p < last - 1; p++) {
80 | if (p[0] == CR && p[1] == LF) {
81 | return p + 2;
82 | }
83 | }
84 |
85 | invalid:
86 |
87 | ngx_log_error(NGX_LOG_ERR, c->log, 0,
88 | "broken header: \"%*s\"", (size_t) (last - buf), buf);
89 |
90 | return NULL;
91 | }
92 |
--------------------------------------------------------------------------------
/src/os/unix/ngx_linux_init.c:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | * Copyright (C) Igor Sysoev
4 | * Copyright (C) Nginx, Inc.
5 | */
6 |
7 |
8 | #include
9 | #include
10 |
11 |
12 | u_char ngx_linux_kern_ostype[50];
13 | u_char ngx_linux_kern_osrelease[50];
14 |
15 | int ngx_linux_rtsig_max;
16 |
17 |
18 | static ngx_os_io_t ngx_linux_io = {
19 | ngx_unix_recv,
20 | ngx_readv_chain,
21 | ngx_udp_unix_recv,
22 | ngx_unix_send,
23 | #if (NGX_HAVE_SENDFILE)
24 | ngx_linux_sendfile_chain,
25 | NGX_IO_SENDFILE
26 | #else
27 | ngx_writev_chain,
28 | 0
29 | #endif
30 | };
31 |
32 |
33 | ngx_int_t
34 | ngx_os_specific_init(ngx_log_t *log)
35 | {
36 | struct utsname u;
37 |
38 | if (uname(&u) == -1) {
39 | ngx_log_error(NGX_LOG_ALERT, log, ngx_errno, "uname() failed");
40 | return NGX_ERROR;
41 | }
42 |
43 | (void) ngx_cpystrn(ngx_linux_kern_ostype, (u_char *) u.sysname,
44 | sizeof(ngx_linux_kern_ostype));
45 |
46 | (void) ngx_cpystrn(ngx_linux_kern_osrelease, (u_char *) u.release,
47 | sizeof(ngx_linux_kern_osrelease));
48 |
49 | #if (NGX_HAVE_RTSIG)
50 | {
51 | int name[2];
52 | size_t len;
53 | ngx_err_t err;
54 |
55 | name[0] = CTL_KERN;
56 | name[1] = KERN_RTSIGMAX;
57 | len = sizeof(ngx_linux_rtsig_max);
58 |
59 | if (sysctl(name, 2, &ngx_linux_rtsig_max, &len, NULL, 0) == -1) {
60 | err = ngx_errno;
61 |
62 | if (err != NGX_ENOTDIR && err != NGX_ENOSYS) {
63 | ngx_log_error(NGX_LOG_ALERT, log, err,
64 | "sysctl(KERN_RTSIGMAX) failed");
65 |
66 | return NGX_ERROR;
67 | }
68 |
69 | ngx_linux_rtsig_max = 0;
70 | }
71 |
72 | }
73 | #endif
74 |
75 | ngx_os_io = ngx_linux_io;
76 |
77 | return NGX_OK;
78 | }
79 |
80 |
81 | void
82 | ngx_os_specific_status(ngx_log_t *log)
83 | {
84 | ngx_log_error(NGX_LOG_NOTICE, log, 0, "OS: %s %s",
85 | ngx_linux_kern_ostype, ngx_linux_kern_osrelease);
86 |
87 | #if (NGX_HAVE_RTSIG)
88 | ngx_log_error(NGX_LOG_NOTICE, log, 0, "sysctl(KERN_RTSIGMAX): %d",
89 | ngx_linux_rtsig_max);
90 | #endif
91 | }
92 |
--------------------------------------------------------------------------------
/src/os/unix/ngx_socket.c:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | * Copyright (C) Igor Sysoev
4 | * Copyright (C) Nginx, Inc.
5 | */
6 |
7 |
8 | #include
9 | #include
10 |
11 |
12 | /*
13 | * ioctl(FIONBIO) sets a non-blocking mode with the single syscall
14 | * while fcntl(F_SETFL, O_NONBLOCK) needs to learn the current state
15 | * using fcntl(F_GETFL).
16 | *
17 | * ioctl() and fcntl() are syscalls at least in FreeBSD 2.x, Linux 2.2
18 | * and Solaris 7.
19 | *
20 | * ioctl() in Linux 2.4 and 2.6 uses BKL, however, fcntl(F_SETFL) uses it too.
21 | */
22 |
23 |
24 | #if (NGX_HAVE_FIONBIO)
25 |
26 | int
27 | ngx_nonblocking(ngx_socket_t s)
28 | {
29 | int nb;
30 |
31 | nb = 1;
32 |
33 | return ioctl(s, FIONBIO, &nb);
34 | }
35 |
36 |
37 | int
38 | ngx_blocking(ngx_socket_t s)
39 | {
40 | int nb;
41 |
42 | nb = 0;
43 |
44 | return ioctl(s, FIONBIO, &nb);
45 | }
46 |
47 | #endif
48 |
49 |
50 | #if (NGX_FREEBSD)
51 |
52 | int
53 | ngx_tcp_nopush(ngx_socket_t s)
54 | {
55 | int tcp_nopush;
56 |
57 | tcp_nopush = 1;
58 |
59 | return setsockopt(s, IPPROTO_TCP, TCP_NOPUSH,
60 | (const void *) &tcp_nopush, sizeof(int));
61 | }
62 |
63 |
64 | int
65 | ngx_tcp_push(ngx_socket_t s)
66 | {
67 | int tcp_nopush;
68 |
69 | tcp_nopush = 0;
70 |
71 | return setsockopt(s, IPPROTO_TCP, TCP_NOPUSH,
72 | (const void *) &tcp_nopush, sizeof(int));
73 | }
74 |
75 | #elif (NGX_LINUX)
76 |
77 |
78 | int
79 | ngx_tcp_nopush(ngx_socket_t s)
80 | {
81 | int cork;
82 |
83 | cork = 1;
84 |
85 | return setsockopt(s, IPPROTO_TCP, TCP_CORK,
86 | (const void *) &cork, sizeof(int));
87 | }
88 |
89 |
90 | int
91 | ngx_tcp_push(ngx_socket_t s)
92 | {
93 | int cork;
94 |
95 | cork = 0;
96 |
97 | return setsockopt(s, IPPROTO_TCP, TCP_CORK,
98 | (const void *) &cork, sizeof(int));
99 | }
100 |
101 | #else
102 |
103 | int
104 | ngx_tcp_nopush(ngx_socket_t s)
105 | {
106 | return 0;
107 | }
108 |
109 |
110 | int
111 | ngx_tcp_push(ngx_socket_t s)
112 | {
113 | return 0;
114 | }
115 |
116 | #endif
117 |
--------------------------------------------------------------------------------
/src/os/unix/ngx_thread_cond.c:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | * Copyright (C) Igor Sysoev
4 | * Copyright (C) Nginx, Inc.
5 | */
6 |
7 |
8 | #include
9 | #include
10 |
11 |
12 | ngx_int_t
13 | ngx_thread_cond_create(ngx_thread_cond_t *cond, ngx_log_t *log)
14 | {
15 | ngx_err_t err;
16 |
17 | err = pthread_cond_init(cond, NULL);
18 | if (err == 0) {
19 | ngx_log_debug1(NGX_LOG_DEBUG_CORE, log, 0,
20 | "pthread_cond_init(%p)", cond);
21 | return NGX_OK;
22 | }
23 |
24 | ngx_log_error(NGX_LOG_EMERG, log, err, "pthread_cond_init() failed");
25 | return NGX_ERROR;
26 | }
27 |
28 |
29 | ngx_int_t
30 | ngx_thread_cond_destroy(ngx_thread_cond_t *cond, ngx_log_t *log)
31 | {
32 | ngx_err_t err;
33 |
34 | err = pthread_cond_destroy(cond);
35 | if (err == 0) {
36 | ngx_log_debug1(NGX_LOG_DEBUG_CORE, log, 0,
37 | "pthread_cond_destroy(%p)", cond);
38 | return NGX_OK;
39 | }
40 |
41 | ngx_log_error(NGX_LOG_EMERG, log, err, "pthread_cond_destroy() failed");
42 | return NGX_ERROR;
43 | }
44 |
45 |
46 | ngx_int_t
47 | ngx_thread_cond_signal(ngx_thread_cond_t *cond, ngx_log_t *log)
48 | {
49 | ngx_err_t err;
50 |
51 | err = pthread_cond_signal(cond);
52 | if (err == 0) {
53 | ngx_log_debug1(NGX_LOG_DEBUG_CORE, log, 0,
54 | "pthread_cond_signal(%p)", cond);
55 | return NGX_OK;
56 | }
57 |
58 | ngx_log_error(NGX_LOG_EMERG, log, err, "pthread_cond_signal() failed");
59 | return NGX_ERROR;
60 | }
61 |
62 |
63 | ngx_int_t
64 | ngx_thread_cond_wait(ngx_thread_cond_t *cond, ngx_thread_mutex_t *mtx,
65 | ngx_log_t *log)
66 | {
67 | ngx_err_t err;
68 |
69 | ngx_log_debug1(NGX_LOG_DEBUG_CORE, log, 0,
70 | "pthread_cond_wait(%p) enter", cond);
71 |
72 | err = pthread_cond_wait(cond, mtx);
73 |
74 | #if 0
75 | ngx_time_update();
76 | #endif
77 |
78 | if (err == 0) {
79 | ngx_log_debug1(NGX_LOG_DEBUG_CORE, log, 0,
80 | "pthread_cond_wait(%p) exit", cond);
81 | return NGX_OK;
82 | }
83 |
84 | ngx_log_error(NGX_LOG_ALERT, log, err, "pthread_cond_wait() failed");
85 |
86 | return NGX_ERROR;
87 | }
88 |
--------------------------------------------------------------------------------
/src/os/unix/ngx_process.h:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | * Copyright (C) Igor Sysoev
4 | * Copyright (C) Nginx, Inc.
5 | */
6 |
7 |
8 | #ifndef _NGX_PROCESS_H_INCLUDED_
9 | #define _NGX_PROCESS_H_INCLUDED_
10 |
11 |
12 | #include
13 | #include
14 |
15 |
16 | typedef pid_t ngx_pid_t;
17 |
18 | #define NGX_INVALID_PID -1
19 |
20 | typedef void (*ngx_spawn_proc_pt) (ngx_cycle_t *cycle, void *data);
21 |
22 | typedef struct {
23 | ngx_pid_t pid;
24 | int status;
25 | ngx_socket_t channel[2];
26 |
27 | ngx_spawn_proc_pt proc;
28 | void *data;
29 | char *name;
30 |
31 | unsigned respawn:1;
32 | unsigned just_spawn:1;
33 | unsigned detached:1;
34 | unsigned exiting:1;
35 | unsigned exited:1;
36 | } ngx_process_t;
37 |
38 |
39 | typedef struct {
40 | char *path;
41 | char *name;
42 | char *const *argv;
43 | char *const *envp;
44 | } ngx_exec_ctx_t;
45 |
46 |
47 | #define NGX_MAX_PROCESSES 1024
48 |
49 | #define NGX_PROCESS_NORESPAWN -1
50 | #define NGX_PROCESS_JUST_SPAWN -2
51 | #define NGX_PROCESS_RESPAWN -3
52 | #define NGX_PROCESS_JUST_RESPAWN -4
53 | #define NGX_PROCESS_DETACHED -5
54 |
55 |
56 | #define ngx_getpid getpid
57 |
58 | #ifndef ngx_log_pid
59 | #define ngx_log_pid ngx_pid
60 | #endif
61 |
62 |
63 | ngx_pid_t ngx_spawn_process(ngx_cycle_t *cycle,
64 | ngx_spawn_proc_pt proc, void *data, char *name, ngx_int_t respawn);
65 | ngx_pid_t ngx_execute(ngx_cycle_t *cycle, ngx_exec_ctx_t *ctx);
66 | ngx_int_t ngx_init_signals(ngx_log_t *log);
67 | void ngx_debug_point(void);
68 |
69 |
70 | #if (NGX_HAVE_SCHED_YIELD)
71 | #define ngx_sched_yield() sched_yield()
72 | #else
73 | #define ngx_sched_yield() usleep(1)
74 | #endif
75 |
76 |
77 | extern int ngx_argc;
78 | extern char **ngx_argv;
79 | extern char **ngx_os_argv;
80 |
81 | extern ngx_pid_t ngx_pid;
82 | extern ngx_socket_t ngx_channel;
83 | extern ngx_int_t ngx_process_slot;
84 | extern ngx_int_t ngx_last_process;
85 | extern ngx_process_t ngx_processes[NGX_MAX_PROCESSES];
86 |
87 |
88 | #endif /* _NGX_PROCESS_H_INCLUDED_ */
89 |
--------------------------------------------------------------------------------
/auto/lib/md5/make:
--------------------------------------------------------------------------------
1 |
2 | # Copyright (C) Igor Sysoev
3 | # Copyright (C) Nginx, Inc.
4 |
5 |
6 | case "$NGX_CC_NAME" in
7 |
8 | msvc*)
9 | ngx_makefile=makefile.msvc
10 | ngx_opt="CPU_OPT=\"$CPU_OPT\" LIBC=$LIBC MD5_ASM=$MD5_ASM"
11 | ngx_md5="MD5=\"$MD5\""
12 | ;;
13 |
14 | owc*)
15 | ngx_makefile=makefile.owc
16 | ngx_opt="CPU_OPT=\"$CPU_OPT\""
17 | ngx_md5=`echo MD5=\"$MD5\" | sed -e "s/\//$ngx_regex_dirsep/g"`
18 | ;;
19 |
20 | bcc)
21 | ngx_makefile=makefile.bcc
22 | ngx_opt="-DCPU_OPT=\"$CPU_OPT\" -DMD5_ASM=$MD5_ASM"
23 | ngx_md5=`echo \-DMD5=\"$MD5\" | sed -e "s/\//$ngx_regex_dirsep/g"`
24 | ;;
25 |
26 | esac
27 |
28 |
29 | done=NO
30 |
31 |
32 | case "$NGX_PLATFORM" in
33 |
34 | win32)
35 | cat << END >> $NGX_MAKEFILE
36 |
37 | `echo "$MD5/md5.lib: $NGX_MAKEFILE" | sed -e "s/\//$ngx_regex_dirsep/g"`
38 | \$(MAKE) -f auto/lib/md5/$ngx_makefile $ngx_opt $ngx_md5
39 |
40 | END
41 |
42 | done=YES
43 | ;;
44 |
45 | SunOS:*:i86pc)
46 | if [ $MD5_ASM = YES ]; then
47 |
48 | cat << END >> $NGX_MAKEFILE
49 |
50 | $MD5/libmd5.a: $NGX_MAKEFILE
51 | cd $MD5 \\
52 | && \$(MAKE) CFLAGS="$MD5_OPT -DSOL -DMD5_ASM -DL_ENDIAN" \\
53 | CC="\$(CC)" CPP="\$(CPP)" \\
54 | MD5_ASM_OBJ=asm/mx86-sol.o clean libmd5.a
55 |
56 | END
57 |
58 | done=YES
59 | fi
60 | ;;
61 |
62 | # FreeBSD: i386
63 | # Linux: i686
64 |
65 | *:i386 | *:i686)
66 | if [ $MD5_ASM = YES ]; then
67 |
68 | cat << END >> $NGX_MAKEFILE
69 |
70 | $MD5/libmd5.a: $NGX_MAKEFILE
71 | cd $MD5 \\
72 | && \$(MAKE) CFLAGS="$MD5_OPT -DELF -DMD5_ASM -DL_ENDIAN" \\
73 | CC="\$(CC)" CPP="\$(CPP)" \\
74 | MD5_ASM_OBJ=asm/mx86-elf.o clean libmd5.a
75 |
76 | END
77 |
78 | done=YES
79 | fi
80 | ;;
81 |
82 | esac
83 |
84 |
85 | if [ $done = NO ]; then
86 |
87 | cat << END >> $NGX_MAKEFILE
88 |
89 | $MD5/libmd5.a: $NGX_MAKEFILE
90 | cd $MD5 \\
91 | && \$(MAKE) CFLAGS="$MD5_OPT" \\
92 | CC="\$(CC)" MD5_ASM_OBJ= clean libmd5.a
93 |
94 | END
95 |
96 | fi
97 |
--------------------------------------------------------------------------------
/src/os/unix/ngx_errno.c:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | * Copyright (C) Igor Sysoev
4 | * Copyright (C) Nginx, Inc.
5 | */
6 |
7 |
8 | #include
9 | #include
10 |
11 |
12 | /*
13 | * The strerror() messages are copied because:
14 | *
15 | * 1) strerror() and strerror_r() functions are not Async-Signal-Safe,
16 | * therefore, they cannot be used in signal handlers;
17 | *
18 | * 2) a direct sys_errlist[] array may be used instead of these functions,
19 | * but Linux linker warns about its usage:
20 | *
21 | * warning: `sys_errlist' is deprecated; use `strerror' or `strerror_r' instead
22 | * warning: `sys_nerr' is deprecated; use `strerror' or `strerror_r' instead
23 | *
24 | * causing false bug reports.
25 | */
26 |
27 |
28 | static ngx_str_t *ngx_sys_errlist;
29 | static ngx_str_t ngx_unknown_error = ngx_string("Unknown error");
30 |
31 |
32 | u_char *
33 | ngx_strerror(ngx_err_t err, u_char *errstr, size_t size)
34 | {
35 | ngx_str_t *msg;
36 |
37 | msg = ((ngx_uint_t) err < NGX_SYS_NERR) ? &ngx_sys_errlist[err]:
38 | &ngx_unknown_error;
39 | size = ngx_min(size, msg->len);
40 |
41 | return ngx_cpymem(errstr, msg->data, size);
42 | }
43 |
44 |
45 | ngx_int_t
46 | ngx_strerror_init(void)
47 | {
48 | char *msg;
49 | u_char *p;
50 | size_t len;
51 | ngx_err_t err;
52 |
53 | /*
54 | * ngx_strerror() is not ready to work at this stage, therefore,
55 | * malloc() is used and possible errors are logged using strerror().
56 | */
57 |
58 | len = NGX_SYS_NERR * sizeof(ngx_str_t);
59 |
60 | ngx_sys_errlist = malloc(len);
61 | if (ngx_sys_errlist == NULL) {
62 | goto failed;
63 | }
64 |
65 | for (err = 0; err < NGX_SYS_NERR; err++) {
66 | msg = strerror(err);
67 | len = ngx_strlen(msg);
68 |
69 | p = malloc(len);
70 | if (p == NULL) {
71 | goto failed;
72 | }
73 |
74 | ngx_memcpy(p, msg, len);
75 | ngx_sys_errlist[err].len = len;
76 | ngx_sys_errlist[err].data = p;
77 | }
78 |
79 | return NGX_OK;
80 |
81 | failed:
82 |
83 | err = errno;
84 | ngx_log_stderr(0, "malloc(%uz) failed (%d: %s)", len, err, strerror(err));
85 |
86 | return NGX_ERROR;
87 | }
88 |
--------------------------------------------------------------------------------
/auto/lib/sha1/make:
--------------------------------------------------------------------------------
1 |
2 | # Copyright (C) Igor Sysoev
3 | # Copyright (C) Nginx, Inc.
4 |
5 |
6 | case "$NGX_CC_NAME" in
7 |
8 | msvc*)
9 | ngx_makefile=makefile.msvc
10 | ngx_opt="CPU_OPT=\"$CPU_OPT\" LIBC=$LIBC SHA1_ASM=$SHA1_ASM"
11 | ngx_sha1="SHA1=\"$SHA1\""
12 | ;;
13 |
14 | owc*)
15 | ngx_makefile=makefile.owc
16 | ngx_opt="CPU_OPT=\"$CPU_OPT\""
17 | ngx_sha1=`echo SHA1=\"$SHA1\" | sed -e "s/\//$ngx_regex_dirsep/g"`
18 | ;;
19 |
20 | bcc)
21 | ngx_makefile=makefile.bcc
22 | ngx_opt="-DCPU_OPT=\"$CPU_OPT\" -DSHA1_ASM=$SHA1_ASM"
23 | ngx_sha1=`echo \-DSHA1=\"$SHA1\" | sed -e "s/\//$ngx_regex_dirsep/g"`
24 | ;;
25 |
26 | esac
27 |
28 |
29 | done=NO
30 |
31 |
32 | case "$NGX_PLATFORM" in
33 |
34 | win32)
35 | cat << END >> $NGX_MAKEFILE
36 |
37 | `echo "$SHA1/sha1.lib: $NGX_MAKEFILE" | sed -e "s/\//$ngx_regex_dirsep/g"`
38 | \$(MAKE) -f auto/lib/sha1/$ngx_makefile $ngx_opt $ngx_sha1
39 |
40 | END
41 |
42 | done=YES
43 | ;;
44 |
45 | SunOS:*:i86pc)
46 | if [ $SHA1_ASM = YES ]; then
47 |
48 | cat << END >> $NGX_MAKEFILE
49 |
50 | $SHA1/libsha.a: $NGX_MAKEFILE
51 | cd $SHA1 \\
52 | && \$(MAKE) CFLAGS="$SHA1_OPT -DSOL -DSHA1_ASM -DL_ENDIAN" \\
53 | CC="\$(CC)" CPP="\$(CPP)" \\
54 | SHA_ASM_OBJ=asm/sx86-sol.o clean libsha.a
55 |
56 | END
57 |
58 | done=YES
59 | fi
60 | ;;
61 |
62 | # FreeBSD: i386
63 | # Linux: i686
64 |
65 | *:i386 | *:i686)
66 | if [ $SHA1_ASM = YES ]; then
67 |
68 | cat << END >> $NGX_MAKEFILE
69 |
70 | $SHA1/libsha.a: $NGX_MAKEFILE
71 | cd $SHA1 \\
72 | && \$(MAKE) CFLAGS="$SHA1_OPT -DELF -DSHA1_ASM -DL_ENDIAN" \\
73 | CC="\$(CC)" CPP="\$(CPP)" \\
74 | SHA_ASM_OBJ=asm/sx86-elf.o clean libsha.a
75 |
76 | END
77 |
78 | done=YES
79 | fi
80 | ;;
81 |
82 | esac
83 |
84 |
85 | if [ $done = NO ]; then
86 |
87 | cat << END >> $NGX_MAKEFILE
88 |
89 | $SHA1/libsha.a: $NGX_MAKEFILE
90 | cd $SHA1 \\
91 | && \$(MAKE) CFLAGS="$SHA1_OPT" \\
92 | CC="\$(CC)" SHA_ASM_OBJ= clean libsha.a
93 |
94 | END
95 |
96 | fi
97 |
--------------------------------------------------------------------------------
/src/os/unix/ngx_errno.h:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | * Copyright (C) Igor Sysoev
4 | * Copyright (C) Nginx, Inc.
5 | */
6 |
7 |
8 | #ifndef _NGX_ERRNO_H_INCLUDED_
9 | #define _NGX_ERRNO_H_INCLUDED_
10 |
11 |
12 | #include
13 | #include
14 |
15 |
16 | typedef int ngx_err_t;
17 |
18 | #define NGX_EPERM EPERM
19 | #define NGX_ENOENT ENOENT
20 | #define NGX_ENOPATH ENOENT
21 | #define NGX_ESRCH ESRCH
22 | #define NGX_EINTR EINTR
23 | #define NGX_ECHILD ECHILD
24 | #define NGX_ENOMEM ENOMEM
25 | #define NGX_EACCES EACCES
26 | #define NGX_EBUSY EBUSY
27 | #define NGX_EEXIST EEXIST
28 | #define NGX_EXDEV EXDEV
29 | #define NGX_ENOTDIR ENOTDIR
30 | #define NGX_EISDIR EISDIR
31 | #define NGX_EINVAL EINVAL
32 | #define NGX_ENFILE ENFILE
33 | #define NGX_EMFILE EMFILE
34 | #define NGX_ENOSPC ENOSPC
35 | #define NGX_EPIPE EPIPE
36 | #define NGX_EINPROGRESS EINPROGRESS
37 | #define NGX_ENOPROTOOPT ENOPROTOOPT
38 | #define NGX_EOPNOTSUPP EOPNOTSUPP
39 | #define NGX_EADDRINUSE EADDRINUSE
40 | #define NGX_ECONNABORTED ECONNABORTED
41 | #define NGX_ECONNRESET ECONNRESET
42 | #define NGX_ENOTCONN ENOTCONN
43 | #define NGX_ETIMEDOUT ETIMEDOUT
44 | #define NGX_ECONNREFUSED ECONNREFUSED
45 | #define NGX_ENAMETOOLONG ENAMETOOLONG
46 | #define NGX_ENETDOWN ENETDOWN
47 | #define NGX_ENETUNREACH ENETUNREACH
48 | #define NGX_EHOSTDOWN EHOSTDOWN
49 | #define NGX_EHOSTUNREACH EHOSTUNREACH
50 | #define NGX_ENOSYS ENOSYS
51 | #define NGX_ECANCELED ECANCELED
52 | #define NGX_EILSEQ EILSEQ
53 | #define NGX_ENOMOREFILES 0
54 | #define NGX_ELOOP ELOOP
55 | #define NGX_EBADF EBADF
56 |
57 | #if (NGX_HAVE_OPENAT)
58 | #define NGX_EMLINK EMLINK
59 | #endif
60 |
61 | #if (__hpux__)
62 | #define NGX_EAGAIN EWOULDBLOCK
63 | #else
64 | #define NGX_EAGAIN EAGAIN
65 | #endif
66 |
67 |
68 | #define ngx_errno errno
69 | #define ngx_socket_errno errno
70 | #define ngx_set_errno(err) errno = err
71 | #define ngx_set_socket_errno(err) errno = err
72 |
73 |
74 | u_char *ngx_strerror(ngx_err_t err, u_char *errstr, size_t size);
75 | ngx_int_t ngx_strerror_init(void);
76 |
77 |
78 | #endif /* _NGX_ERRNO_H_INCLUDED_ */
79 |
--------------------------------------------------------------------------------
/auto/lib/geoip/conf:
--------------------------------------------------------------------------------
1 |
2 | # Copyright (C) Igor Sysoev
3 | # Copyright (C) Nginx, Inc.
4 |
5 |
6 | ngx_feature="GeoIP library"
7 | ngx_feature_name=
8 | ngx_feature_run=no
9 | ngx_feature_incs="#include "
10 | ngx_feature_path=
11 | ngx_feature_libs="-lGeoIP"
12 | ngx_feature_test="GeoIP_open(NULL, 0)"
13 | . auto/feature
14 |
15 |
16 | if [ $ngx_found = no ]; then
17 |
18 | # FreeBSD port
19 |
20 | ngx_feature="GeoIP library in /usr/local/"
21 | ngx_feature_path="/usr/local/include"
22 |
23 | if [ $NGX_RPATH = YES ]; then
24 | ngx_feature_libs="-R/usr/local/lib -L/usr/local/lib -lGeoIP"
25 | else
26 | ngx_feature_libs="-L/usr/local/lib -lGeoIP"
27 | fi
28 |
29 | . auto/feature
30 | fi
31 |
32 |
33 | if [ $ngx_found = no ]; then
34 |
35 | # NetBSD port
36 |
37 | ngx_feature="GeoIP library in /usr/pkg/"
38 | ngx_feature_path="/usr/pkg/include"
39 |
40 | if [ $NGX_RPATH = YES ]; then
41 | ngx_feature_libs="-R/usr/pkg/lib -L/usr/pkg/lib -lGeoIP"
42 | else
43 | ngx_feature_libs="-L/usr/pkg/lib -lGeoIP"
44 | fi
45 |
46 | . auto/feature
47 | fi
48 |
49 |
50 | if [ $ngx_found = no ]; then
51 |
52 | # MacPorts
53 |
54 | ngx_feature="GeoIP library in /opt/local/"
55 | ngx_feature_path="/opt/local/include"
56 |
57 | if [ $NGX_RPATH = YES ]; then
58 | ngx_feature_libs="-R/opt/local/lib -L/opt/local/lib -lGeoIP"
59 | else
60 | ngx_feature_libs="-L/opt/local/lib -lGeoIP"
61 | fi
62 |
63 | . auto/feature
64 | fi
65 |
66 |
67 | if [ $ngx_found = yes ]; then
68 |
69 | CORE_INCS="$CORE_INCS $ngx_feature_path"
70 | CORE_LIBS="$CORE_LIBS $ngx_feature_libs"
71 |
72 | if [ $NGX_IPV6 = YES ]; then
73 | ngx_feature="GeoIP IPv6 support"
74 | ngx_feature_name="NGX_HAVE_GEOIP_V6"
75 | ngx_feature_run=no
76 | ngx_feature_incs="#include
77 | #include "
78 | #ngx_feature_path=
79 | #ngx_feature_libs=
80 | ngx_feature_test="printf(\"%d\", GEOIP_CITY_EDITION_REV0_V6);"
81 | . auto/feature
82 | fi
83 |
84 | else
85 |
86 | cat << END
87 |
88 | $0: error: the GeoIP module requires the GeoIP library.
89 | You can either do not enable the module or install the library.
90 |
91 | END
92 |
93 | exit 1
94 | fi
95 |
--------------------------------------------------------------------------------
/Makefile.PL:
--------------------------------------------------------------------------------
1 | #!/usr/bin/perl
2 |
3 | # Copyright 2011 Alexandr Gomoliako
4 |
5 | # TODO
6 | # - by default build with all core modules that don't have external
7 | # dependencies;
8 | # - honour PREFIX from PERL_MM_OPT;
9 | # - use $ENV{AUTOMATED_TESTING} to detect cpantesters/travis;
10 |
11 | use strict;
12 |
13 | use Config;
14 |
15 | my @args;
16 |
17 | push @args, '--prefix=' . $Config{siteprefix} . "/nginx-perl"
18 | if $Config{siteprefix} ;
19 |
20 | push @args, '--sbin-path=' . ( $Config{installsitebin} ||
21 | $Config{installsitescript} ||
22 | $Config{sitebin} ||
23 | $Config{sitescript} )
24 |
25 | if $Config{installsitebin} ||
26 | $Config{installsitescript} ||
27 | $Config{sitebin} ||
28 | $Config{sitescript} ;
29 |
30 |
31 | # ignoring MakeMaker's options
32 |
33 | shift @ARGV
34 | while @ARGV && $ARGV[0] !~ /^--/;
35 |
36 |
37 | unless (@ARGV) {
38 | # disabling pcre / building statically for automatic testing
39 |
40 | my @PCRE_INCLUDE =
41 | grep { -e "$_/pcre.h" }
42 | qw( /usr/include
43 | /usr/local/include
44 | /usr/pkg/include
45 | /use/include/pcre
46 | /opt/local/include );
47 |
48 | push @args, '--with-pcre=pcre'
49 | if -e 'pcre' && !@PCRE_INCLUDE;
50 |
51 | push @args, '--without-http_rewrite_module',
52 | '--without-pcre'
53 | if !-e 'pcre' && !@PCRE_INCLUDE;
54 |
55 |
56 | # disabling zlib / building statically for automatic testing
57 |
58 | my @ZLIB_INCLUDE =
59 | grep { -e "$_/zlib.h" }
60 | qw( /usr/include
61 | /usr/local/include
62 | /usr/pkg/include
63 | /use/include/pcre
64 | /opt/local/include );
65 |
66 | push @args, '--with-zlib=zlib'
67 | if -e 'zlib' && !@ZLIB_INCLUDE;
68 |
69 | push @args, '--without-http_gzip_module'
70 | if !-e 'zlib' && !@ZLIB_INCLUDE;
71 | }
72 |
73 | # our perl interpreter
74 |
75 | push @args, '--with-perl=' . $^X;
76 |
77 |
78 | exec './configure', @args, @ARGV;
79 |
80 |
81 |
--------------------------------------------------------------------------------
/auto/lib/zlib/conf:
--------------------------------------------------------------------------------
1 |
2 | # Copyright (C) Igor Sysoev
3 | # Copyright (C) Nginx, Inc.
4 |
5 |
6 | if [ $ZLIB != NONE ]; then
7 | CORE_INCS="$CORE_INCS $ZLIB"
8 |
9 | case "$NGX_CC_NAME" in
10 |
11 | msvc* | owc* | bcc)
12 | have=NGX_ZLIB . auto/have
13 | LINK_DEPS="$LINK_DEPS $ZLIB/zlib.lib"
14 | CORE_LIBS="$CORE_LIBS $ZLIB/zlib.lib"
15 | ;;
16 |
17 | icc*)
18 | have=NGX_ZLIB . auto/have
19 | LINK_DEPS="$LINK_DEPS $ZLIB/libz.a"
20 |
21 | # to allow -ipo optimization we link with the *.o but not library
22 | CORE_LIBS="$CORE_LIBS $ZLIB/adler32.o"
23 | CORE_LIBS="$CORE_LIBS $ZLIB/crc32.o"
24 | CORE_LIBS="$CORE_LIBS $ZLIB/deflate.o"
25 | CORE_LIBS="$CORE_LIBS $ZLIB/trees.o"
26 | CORE_LIBS="$CORE_LIBS $ZLIB/zutil.o"
27 | CORE_LIBS="$CORE_LIBS $ZLIB/compress.o"
28 |
29 | if [ $ZLIB_ASM != NO ]; then
30 | CORE_LIBS="$CORE_LIBS $ZLIB/match.o"
31 | fi
32 | ;;
33 |
34 | *)
35 | have=NGX_ZLIB . auto/have
36 | LINK_DEPS="$LINK_DEPS $ZLIB/libz.a"
37 | CORE_LIBS="$CORE_LIBS $ZLIB/libz.a"
38 | #CORE_LIBS="$CORE_LIBS -L $ZLIB -lz"
39 | ;;
40 |
41 | esac
42 |
43 | else
44 |
45 | if [ "$NGX_PLATFORM" != win32 ]; then
46 | ZLIB=NO
47 |
48 | # FreeBSD, Solaris, Linux
49 |
50 | ngx_feature="zlib library"
51 | ngx_feature_name="NGX_ZLIB"
52 | ngx_feature_run=no
53 | ngx_feature_incs="#include "
54 | ngx_feature_path=
55 | ngx_feature_libs="-lz"
56 | ngx_feature_test="z_stream z; deflate(&z, Z_NO_FLUSH)"
57 | . auto/feature
58 |
59 |
60 | if [ $ngx_found = yes ]; then
61 | CORE_LIBS="$CORE_LIBS $ngx_feature_libs"
62 | ZLIB=YES
63 | ngx_found=no
64 | fi
65 | fi
66 |
67 | if [ $ZLIB != YES ]; then
68 | cat << END
69 |
70 | $0: error: the HTTP gzip module requires the zlib library.
71 | You can either disable the module by using --without-http_gzip_module
72 | option, or install the zlib library into the system, or build the zlib library
73 | statically from the source with nginx by using --with-zlib= option.
74 |
75 | END
76 | exit 1
77 | fi
78 |
79 | fi
80 |
--------------------------------------------------------------------------------
/auto/cc/owc:
--------------------------------------------------------------------------------
1 |
2 | # Copyright (C) Igor Sysoev
3 | # Copyright (C) Nginx, Inc.
4 |
5 |
6 | # Open Watcom C 1.0, 1.2, 1.3
7 |
8 | # optimizations
9 |
10 | # maximize speed
11 | CFLAGS="$CFLAGS -ot"
12 | # reorder instructions for best pipeline usage
13 | CFLAGS="$CFLAGS -op"
14 | # inline intrinsic functions
15 | CFLAGS="$CFLAGS -oi"
16 | # inline expansion
17 | CFLAGS="$CFLAGS -oe"
18 | # disable stack checking calls
19 | CFLAGS="$CFLAGS -s"
20 |
21 | case $CPU in
22 | pentium)
23 | # optimize for Pentium and Athlon
24 | # register-based arguments passing conventions
25 | CPU_OPT="-5r"
26 | # stack-based arguments passing conventions
27 | #CPU_OPT="-5s"
28 | ;;
29 |
30 | pentiumpro)
31 | # optimize for Pentium Pro, Pentium II and Pentium III
32 | # register-based arguments passing conventions
33 | CPU_OPT="-6r"
34 | # stack-based arguments passing conventions
35 | #CPU_OPT="-6s"
36 | ;;
37 | esac
38 |
39 | CFLAGS="$CFLAGS $CPU_OPT"
40 |
41 |
42 | # warnings
43 |
44 | # maximum level
45 | CFLAGS="$CFLAGS -wx"
46 | #CFLAGS="$CFLAGS -w3"
47 |
48 | # stop on warning
49 | CFLAGS="$CFLAGS -we"
50 |
51 | # built target is NT
52 | CFLAGS="$CFLAGS -bt=nt"
53 |
54 | # multithreaded
55 | CFLAGS="$CFLAGS -bm"
56 |
57 | # debug
58 | CFLAGS="$CFLAGS -d2"
59 |
60 | # quiet
61 | CFLAGS="$CFLAGS -zq"
62 |
63 | # Open Watcom C 1.2
64 | have=NGX_HAVE_C99_VARIADIC_MACROS . auto/have
65 |
66 |
67 | # the precompiled headers
68 | #CORE_DEPS="$CORE_DEPS $NGX_OBJS/ngx_config.pch"
69 | #NGX_PCH="$NGX_OBJS/ngx_config.pch"
70 | #NGX_BUILD_PCH="-fhq=$NGX_OBJS/ngx_config.pch"
71 | #NGX_USE_PCH="-fh=$NGX_OBJS/ngx_config.pch"
72 |
73 |
74 | # the link flags, built target is NT GUI mode application
75 | #CORE_LINK="$CORE_LINK -l=nt_win"
76 |
77 |
78 | # the resource file
79 | NGX_RCC="wrc \$(CORE_INCS) -fo=$NGX_OBJS/nginx.res "
80 | NGX_RCC="$NGX_RCC $NGX_WIN32_RC $NGX_OBJS/nginx.exe"
81 |
82 |
83 | ngx_include_opt="-i="
84 | ngx_objout="-fo"
85 | ngx_binout="-fe="
86 | ngx_objext="obj"
87 | ngx_binext=".exe"
88 |
89 | ngx_regex_dirsep='\\'
90 | ngx_dirsep="\\"
91 |
92 | ngx_long_start=' '
93 | ngx_long_end=' '
94 | ngx_long_regex_cont=' \&\
95 | '
96 | ngx_long_cont=' &
97 | '
98 |
99 | ngx_regex_cont=' \&\
100 | '
101 | ngx_cont=' &
102 | '
103 | ngx_tab=' &
104 | '
105 |
--------------------------------------------------------------------------------
/src/event/ngx_event_timer.h:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | * Copyright (C) Igor Sysoev
4 | * Copyright (C) Nginx, Inc.
5 | */
6 |
7 |
8 | #ifndef _NGX_EVENT_TIMER_H_INCLUDED_
9 | #define _NGX_EVENT_TIMER_H_INCLUDED_
10 |
11 |
12 | #include
13 | #include
14 | #include
15 |
16 |
17 | #define NGX_TIMER_INFINITE (ngx_msec_t) -1
18 |
19 | #define NGX_TIMER_LAZY_DELAY 300
20 |
21 |
22 | ngx_int_t ngx_event_timer_init(ngx_log_t *log);
23 | ngx_msec_t ngx_event_find_timer(void);
24 | void ngx_event_expire_timers(void);
25 | void ngx_event_cancel_timers(void);
26 |
27 |
28 | extern ngx_rbtree_t ngx_event_timer_rbtree;
29 |
30 |
31 | static ngx_inline void
32 | ngx_event_del_timer(ngx_event_t *ev)
33 | {
34 | ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ev->log, 0,
35 | "event timer del: %d: %M",
36 | ngx_event_ident(ev->data), ev->timer.key);
37 |
38 | ngx_rbtree_delete(&ngx_event_timer_rbtree, &ev->timer);
39 |
40 | #if (NGX_DEBUG)
41 | ev->timer.left = NULL;
42 | ev->timer.right = NULL;
43 | ev->timer.parent = NULL;
44 | #endif
45 |
46 | ev->timer_set = 0;
47 | }
48 |
49 |
50 | static ngx_inline void
51 | ngx_event_add_timer(ngx_event_t *ev, ngx_msec_t timer)
52 | {
53 | ngx_msec_t key;
54 | ngx_msec_int_t diff;
55 |
56 | key = ngx_current_msec + timer;
57 |
58 | if (ev->timer_set) {
59 |
60 | /*
61 | * Use a previous timer value if difference between it and a new
62 | * value is less than NGX_TIMER_LAZY_DELAY milliseconds: this allows
63 | * to minimize the rbtree operations for fast connections.
64 | */
65 |
66 | diff = (ngx_msec_int_t) (key - ev->timer.key);
67 |
68 | if (ngx_abs(diff) < NGX_TIMER_LAZY_DELAY) {
69 | ngx_log_debug3(NGX_LOG_DEBUG_EVENT, ev->log, 0,
70 | "event timer: %d, old: %M, new: %M",
71 | ngx_event_ident(ev->data), ev->timer.key, key);
72 | return;
73 | }
74 |
75 | ngx_del_timer(ev);
76 | }
77 |
78 | ev->timer.key = key;
79 |
80 | ngx_log_debug3(NGX_LOG_DEBUG_EVENT, ev->log, 0,
81 | "event timer add: %d: %M:%M",
82 | ngx_event_ident(ev->data), timer, ev->timer.key);
83 |
84 | ngx_rbtree_insert(&ngx_event_timer_rbtree, &ev->timer);
85 |
86 | ev->timer_set = 1;
87 | }
88 |
89 |
90 | #endif /* _NGX_EVENT_TIMER_H_INCLUDED_ */
91 |
--------------------------------------------------------------------------------
/auto/cc/clang:
--------------------------------------------------------------------------------
1 |
2 | # Copyright (C) Nginx, Inc.
3 |
4 |
5 | # clang
6 |
7 |
8 | NGX_CLANG_VER=`$CC -v 2>&1 | grep '\(clang\|LLVM\) version' 2>&1 \
9 | | sed -e 's/^.* version \(.*\)/\1/'`
10 |
11 | echo " + clang version: $NGX_CLANG_VER"
12 |
13 | have=NGX_COMPILER value="\"clang $NGX_CLANG_VER\"" . auto/define
14 |
15 |
16 | CC_TEST_FLAGS="-pipe"
17 |
18 |
19 | # optimizations
20 |
21 | #NGX_CLANG_OPT="-O2"
22 | #NGX_CLANG_OPT="-Oz"
23 | NGX_CLANG_OPT="-O"
24 |
25 | case $CPU in
26 | pentium)
27 | # optimize for Pentium
28 | CPU_OPT="-march=pentium"
29 | NGX_CPU_CACHE_LINE=32
30 | ;;
31 |
32 | pentiumpro | pentium3)
33 | # optimize for Pentium Pro, Pentium II and Pentium III
34 | CPU_OPT="-march=pentiumpro"
35 | NGX_CPU_CACHE_LINE=32
36 | ;;
37 |
38 | pentium4)
39 | # optimize for Pentium 4
40 | CPU_OPT="-march=pentium4"
41 | NGX_CPU_CACHE_LINE=128
42 | ;;
43 |
44 | athlon)
45 | # optimize for Athlon
46 | CPU_OPT="-march=athlon"
47 | NGX_CPU_CACHE_LINE=64
48 | ;;
49 |
50 | opteron)
51 | # optimize for Opteron
52 | CPU_OPT="-march=opteron"
53 | NGX_CPU_CACHE_LINE=64
54 | ;;
55 |
56 | esac
57 |
58 | CC_AUX_FLAGS="$CC_AUX_FLAGS $CPU_OPT"
59 |
60 |
61 | CFLAGS="$CFLAGS -pipe $CPU_OPT"
62 |
63 | if [ ".$PCRE_OPT" = "." ]; then
64 | PCRE_OPT="-O2 -pipe $CPU_OPT"
65 | else
66 | PCRE_OPT="$PCRE_OPT -pipe"
67 | fi
68 |
69 | if [ ".$MD5_OPT" = "." ]; then
70 | MD5_OPT="-O2 -pipe $CPU_OPT"
71 | else
72 | MD5_OPT="$MD5_OPT -pipe"
73 | fi
74 |
75 | if [ ".$ZLIB_OPT" = "." ]; then
76 | ZLIB_OPT="-O2 -pipe $CPU_OPT"
77 | else
78 | ZLIB_OPT="$ZLIB_OPT -pipe"
79 | fi
80 |
81 |
82 | # warnings
83 |
84 | CFLAGS="$CFLAGS $NGX_CLANG_OPT -Wall -Wextra -Wpointer-arith"
85 | CFLAGS="$CFLAGS -Wconditional-uninitialized"
86 | #CFLAGS="$CFLAGS -Wmissing-prototypes"
87 |
88 | # we have a lot of unused function arguments
89 | CFLAGS="$CFLAGS -Wno-unused-parameter"
90 |
91 | # deprecated system OpenSSL library on OS X
92 | if [ "$NGX_SYSTEM" = "Darwin" ]; then
93 | CFLAGS="$CFLAGS -Wno-deprecated-declarations"
94 | fi
95 |
96 | # stop on warning
97 | CFLAGS="$CFLAGS -Werror"
98 |
99 | # debug
100 | CFLAGS="$CFLAGS -g"
101 |
102 | if [ ".$CPP" = "." ]; then
103 | CPP="$CC -E"
104 | fi
105 |
--------------------------------------------------------------------------------
/auto/lib/openssl/conf:
--------------------------------------------------------------------------------
1 |
2 | # Copyright (C) Igor Sysoev
3 | # Copyright (C) Nginx, Inc.
4 |
5 |
6 | if [ $OPENSSL != NONE ]; then
7 |
8 | case "$CC" in
9 |
10 | cl | bcc32)
11 | have=NGX_OPENSSL . auto/have
12 | have=NGX_SSL . auto/have
13 |
14 | CFLAGS="$CFLAGS -DNO_SYS_TYPES_H"
15 |
16 | CORE_INCS="$CORE_INCS $OPENSSL/openssl/include"
17 | CORE_DEPS="$CORE_DEPS $OPENSSL/openssl/include/openssl/ssl.h"
18 | CORE_LIBS="$CORE_LIBS $OPENSSL/openssl/lib/ssleay32.lib"
19 | CORE_LIBS="$CORE_LIBS $OPENSSL/openssl/lib/libeay32.lib"
20 |
21 | # libeay32.lib requires gdi32.lib
22 | CORE_LIBS="$CORE_LIBS gdi32.lib"
23 | # OpenSSL 1.0.0 requires crypt32.lib
24 | CORE_LIBS="$CORE_LIBS crypt32.lib"
25 | ;;
26 |
27 | *)
28 | have=NGX_OPENSSL . auto/have
29 | have=NGX_SSL . auto/have
30 |
31 | CORE_INCS="$CORE_INCS $OPENSSL/.openssl/include"
32 | CORE_DEPS="$CORE_DEPS $OPENSSL/.openssl/include/openssl/ssl.h"
33 | CORE_LIBS="$CORE_LIBS $OPENSSL/.openssl/lib/libssl.a"
34 | CORE_LIBS="$CORE_LIBS $OPENSSL/.openssl/lib/libcrypto.a"
35 | CORE_LIBS="$CORE_LIBS $NGX_LIBDL"
36 |
37 | if [ "$NGX_PLATFORM" = win32 ]; then
38 | CORE_LIBS="$CORE_LIBS -lgdi32 -lcrypt32 -lws2_32"
39 | fi
40 | ;;
41 | esac
42 |
43 | else
44 |
45 | if [ "$NGX_PLATFORM" != win32 ]; then
46 |
47 | OPENSSL=NO
48 |
49 | ngx_feature="OpenSSL library"
50 | ngx_feature_name="NGX_OPENSSL"
51 | ngx_feature_run=no
52 | ngx_feature_incs="#include "
53 | ngx_feature_path=
54 | ngx_feature_libs="-lssl -lcrypto"
55 | ngx_feature_test="SSL_library_init()"
56 | . auto/feature
57 |
58 | if [ $ngx_found = yes ]; then
59 | have=NGX_SSL . auto/have
60 | CORE_LIBS="$CORE_LIBS $ngx_feature_libs $NGX_LIBDL"
61 | OPENSSL=YES
62 | fi
63 | fi
64 |
65 | if [ $OPENSSL != YES ]; then
66 |
67 | cat << END
68 |
69 | $0: error: SSL modules require the OpenSSL library.
70 | You can either do not enable the modules, or install the OpenSSL library
71 | into the system, or build the OpenSSL library statically from the source
72 | with nginx by using --with-openssl= option.
73 |
74 | END
75 | exit 1
76 | fi
77 |
78 | fi
79 |
--------------------------------------------------------------------------------
/src/os/unix/ngx_solaris_config.h:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | * Copyright (C) Igor Sysoev
4 | * Copyright (C) Nginx, Inc.
5 | */
6 |
7 |
8 | #ifndef _NGX_SOLARIS_CONFIG_H_INCLUDED_
9 | #define _NGX_SOLARIS_CONFIG_H_INCLUDED_
10 |
11 |
12 | #ifndef _REENTRANT
13 | #define _REENTRANT
14 | #endif
15 |
16 | #define _FILE_OFFSET_BITS 64 /* must be before */
17 |
18 | #include
19 | #include
20 | #include
21 | #include
22 | #include /* offsetof() */
23 | #include
24 | #include
25 | #include
26 | #include
27 | #include
28 | #include
29 | #include
30 | #include
31 | #include
32 | #include
33 | #include
34 | #include /* statvfs() */
35 |
36 | #include /* FIONBIO */
37 | #include
38 | #include
39 | #include
40 |
41 | #include
42 | #include
43 | #include
44 | #include
45 |
46 | #include
47 | #include
48 | #include /* TCP_NODELAY */
49 | #include
50 | #include
51 | #include
52 |
53 | #include
54 | #include 