├── config ├── ngx_pch.c └── ngx_auto_headers.h ├── lib ├── zlib │ ├── contrib │ │ ├── blast │ │ │ ├── test.txt │ │ │ ├── README │ │ │ ├── test.pk │ │ │ └── Makefile │ │ ├── infback9 │ │ │ ├── README │ │ │ ├── infback9.h │ │ │ └── inflate9.h │ │ ├── README.contrib │ │ ├── puff │ │ │ ├── zeros.raw │ │ │ ├── puff.h │ │ │ └── Makefile │ │ ├── masmx64 │ │ │ ├── bld_ml64.bat │ │ │ └── readme.txt │ │ ├── dotzlib │ │ │ ├── DotZLib.chm │ │ │ ├── DotZLib │ │ │ │ ├── Deflater.cs │ │ │ │ ├── DotZLib.cs │ │ │ │ ├── Inflater.cs │ │ │ │ ├── CodecBase.cs │ │ │ │ ├── GZipStream.cs │ │ │ │ ├── ChecksumImpl.cs │ │ │ │ └── CircularBuffer.cs │ │ │ ├── DotZLib.sln │ │ │ ├── DotZLib.build │ │ │ └── LICENSE_1_0.txt │ │ ├── masmx86 │ │ │ ├── bld_ml32.bat │ │ │ └── readme.txt │ │ ├── minizip │ │ │ ├── MiniZip64_Changes.txt │ │ │ ├── minizip.pc.in │ │ │ ├── Makefile │ │ │ ├── mztools.h │ │ │ ├── configure.ac │ │ │ ├── iowin32.h │ │ │ ├── make_vms.com │ │ │ ├── Makefile.am │ │ │ ├── minizip.1 │ │ │ └── miniunzip.1 │ │ ├── delphi │ │ │ └── ZLibConst.pas │ │ ├── testzlib │ │ │ └── testzlib.txt │ │ ├── untgz │ │ │ ├── Makefile │ │ │ └── Makefile.msc │ │ ├── iostream3 │ │ │ ├── TODO │ │ │ ├── README │ │ │ └── test.cc │ │ ├── ada │ │ │ └── zlib.gpr │ │ ├── iostream │ │ │ └── test.cpp │ │ ├── iostream2 │ │ │ └── zstream_test.cpp │ │ ├── vstudio │ │ │ ├── vc10 │ │ │ │ ├── miniunz.vcxproj.filters │ │ │ │ ├── minizip.vcxproj.filters │ │ │ │ ├── testzlibdll.vcxproj.filters │ │ │ │ └── zlib.rc │ │ │ ├── vc11 │ │ │ │ └── zlib.rc │ │ │ └── vc9 │ │ │ │ └── zlib.rc │ │ └── asm686 │ │ │ └── README.686 │ ├── zlib.lib │ ├── ChangeLog │ ├── zlib.3.pdf │ ├── Makefile │ ├── win32 │ │ ├── VisualC.txt │ │ ├── zlib1.rc │ │ └── zlib.def │ ├── old │ │ ├── README │ │ ├── os2 │ │ │ └── zlib.def │ │ ├── descrip.mms │ │ └── Makefile.emx │ ├── nintendods │ │ └── README │ ├── zlib.pc.in │ ├── zlib.pc.cmakein │ ├── inffast.h │ ├── gzclose.c │ ├── zlib.map │ ├── watcom │ │ ├── watcom_l.mak │ │ └── watcom_f.mak │ ├── msdos │ │ └── Makefile.emx │ ├── examples │ │ └── README.examples │ ├── amiga │ │ ├── Makefile.sas │ │ └── Makefile.pup │ ├── uncompr.c │ └── INDEX └── pcre │ ├── pcre.lib │ ├── ChangeLog │ ├── COPYING │ ├── NON-UNIX-USE │ ├── libpcrecpp.pc.in │ ├── libpcreposix.pc.in │ ├── libpcre.pc.in │ ├── libpcre16.pc.in │ ├── libpcre32.pc.in │ ├── makevp_c.txt │ ├── makevp_l.txt │ ├── cmake │ ├── FindEditline.cmake │ ├── FindReadline.cmake │ └── COPYING-CMAKE-SCRIPTS │ ├── Detrail │ ├── AUTHORS │ ├── CheckMan │ ├── config-cmake.h.in │ ├── pcre_stringpiece.cc │ ├── pcre16_get.c │ └── pcre16_ucd.c ├── src ├── http │ ├── modules │ │ ├── perl │ │ │ ├── typemap │ │ │ ├── Makefile.PL │ │ │ └── ngx_http_perl_module.h │ │ └── ngx_http_ssl_module.h │ └── v2 │ │ ├── ngx_http_v2_huff_encode.c │ │ └── ngx_http_v2_module.h ├── os │ ├── win32 │ │ ├── nginx.ico │ │ ├── nginx.rc │ │ ├── ngx_user.c │ │ ├── ngx_user.h │ │ ├── ngx_socket.c │ │ ├── ngx_thread.h │ │ ├── ngx_alloc.h │ │ ├── ngx_stat.c │ │ ├── ngx_thread.c │ │ ├── ngx_shmem.h │ │ ├── nginx_icon16.xpm │ │ ├── ngx_alloc.c │ │ ├── ngx_process_cycle.h │ │ ├── ngx_time.h │ │ ├── ngx_errno.c │ │ ├── ngx_time.c │ │ ├── ngx_atomic.h │ │ └── ngx_process.h │ └── unix │ │ ├── ngx_linux.h │ │ ├── ngx_solaris.h │ │ ├── ngx_user.h │ │ ├── ngx_setaffinity.h │ │ ├── ngx_darwin.h │ │ ├── ngx_shmem.h │ │ ├── ngx_freebsd.h │ │ ├── ngx_channel.h │ │ ├── ngx_sunpro_sparc64.il │ │ ├── ngx_alloc.h │ │ ├── ngx_setproctitle.h │ │ ├── ngx_sunpro_amd64.il │ │ ├── ngx_sunpro_x86.il │ │ ├── ngx_linux_init.c │ │ ├── ngx_thread_id.c │ │ ├── ngx_sunpro_atomic_sparc64.h │ │ ├── ngx_socket.h │ │ ├── ngx_setaffinity.c │ │ ├── ngx_daemon.c │ │ ├── ngx_process_cycle.h │ │ ├── ngx_time.h │ │ ├── ngx_thread.h │ │ ├── ngx_solaris_init.c │ │ ├── ngx_send.c │ │ ├── ngx_gcc_atomic_amd64.h │ │ ├── ngx_gcc_atomic_sparc64.h │ │ ├── ngx_darwin_config.h │ │ ├── ngx_alloc.c │ │ ├── ngx_time.c │ │ ├── ngx_user.c │ │ ├── ngx_socket.c │ │ ├── ngx_thread_cond.c │ │ ├── ngx_process.h │ │ └── ngx_errno.c ├── core │ ├── ngx_murmurhash.h │ ├── ngx_crypt.h │ ├── ngx_rwlock.h │ ├── ngx_parse.h │ ├── ngx_parse_time.h │ ├── ngx_sha1.h │ ├── nginx.h │ ├── ngx_proxy_protocol.h │ ├── ngx_crc.h │ ├── ngx_syslog.h │ ├── ngx_murmurhash.c │ ├── ngx_thread_pool.h │ ├── ngx_spinlock.c │ ├── ngx_md5.h │ ├── ngx_shmtx.h │ ├── ngx_array.h │ ├── ngx_list.c │ ├── ngx_times.h │ ├── ngx_regex.h │ ├── ngx_slab.h │ ├── ngx_radix_tree.h │ ├── ngx_crc32.h │ ├── ngx_list.h │ └── ngx_queue.c ├── mysql │ └── config ├── event │ ├── modules │ │ └── ngx_iocp_module.h │ ├── ngx_event_posted.c │ ├── ngx_event_posted.h │ └── ngx_event_connect.h ├── misc │ └── ngx_cpp_test_module.cpp ├── mail │ ├── ngx_mail_pop3_module.h │ ├── ngx_mail_imap_module.h │ ├── ngx_mail_smtp_module.h │ └── ngx_mail_ssl_module.h └── stream │ └── ngx_stream_ssl_module.h ├── README.md ├── Makefile ├── root └── conf │ ├── scgi_params │ ├── uwsgi_params │ ├── fastcgi_params │ └── fastcgi.conf └── NGINX.sln /config/ngx_pch.c: -------------------------------------------------------------------------------- 1 | #include -------------------------------------------------------------------------------- /lib/zlib/contrib/blast/test.txt: -------------------------------------------------------------------------------- 1 | AIAIAIAIAIAIA -------------------------------------------------------------------------------- /src/http/modules/perl/typemap: -------------------------------------------------------------------------------- 1 | TYPEMAP 2 | 3 | nginx T_PTROBJ 4 | -------------------------------------------------------------------------------- /lib/zlib/contrib/infback9/README: -------------------------------------------------------------------------------- 1 | See infback9.h for what this is and how to use it. 2 | -------------------------------------------------------------------------------- /config/ngx_auto_headers.h: -------------------------------------------------------------------------------- 1 | 2 | 3 | #ifndef NGX_WIN32 4 | #define NGX_WIN32 1 5 | #endif 6 | 7 | -------------------------------------------------------------------------------- /lib/pcre/pcre.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tumtumtum/nginx-visualstudio/HEAD/lib/pcre/pcre.lib -------------------------------------------------------------------------------- /lib/zlib/zlib.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tumtumtum/nginx-visualstudio/HEAD/lib/zlib/zlib.lib -------------------------------------------------------------------------------- /lib/pcre/ChangeLog: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tumtumtum/nginx-visualstudio/HEAD/lib/pcre/ChangeLog -------------------------------------------------------------------------------- /lib/zlib/ChangeLog: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tumtumtum/nginx-visualstudio/HEAD/lib/zlib/ChangeLog -------------------------------------------------------------------------------- /lib/zlib/zlib.3.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tumtumtum/nginx-visualstudio/HEAD/lib/zlib/zlib.3.pdf -------------------------------------------------------------------------------- /src/os/win32/nginx.ico: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tumtumtum/nginx-visualstudio/HEAD/src/os/win32/nginx.ico -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | Visual Studio 2015 solution and project for compiling and debugging nginx on windows with no fuss. 2 | -------------------------------------------------------------------------------- /lib/zlib/contrib/blast/README: -------------------------------------------------------------------------------- 1 | Read blast.h for purpose and usage. 2 | 3 | Mark Adler 4 | madler@alumni.caltech.edu 5 | -------------------------------------------------------------------------------- /lib/zlib/contrib/README.contrib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tumtumtum/nginx-visualstudio/HEAD/lib/zlib/contrib/README.contrib -------------------------------------------------------------------------------- /lib/zlib/contrib/blast/test.pk: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tumtumtum/nginx-visualstudio/HEAD/lib/zlib/contrib/blast/test.pk -------------------------------------------------------------------------------- /lib/zlib/contrib/puff/zeros.raw: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tumtumtum/nginx-visualstudio/HEAD/lib/zlib/contrib/puff/zeros.raw -------------------------------------------------------------------------------- /lib/pcre/COPYING: -------------------------------------------------------------------------------- 1 | PCRE LICENCE 2 | 3 | Please see the file LICENCE in the PCRE distribution for licensing details. 4 | 5 | End 6 | -------------------------------------------------------------------------------- /lib/zlib/contrib/masmx64/bld_ml64.bat: -------------------------------------------------------------------------------- 1 | ml64.exe /Flinffasx64 /c /Zi inffasx64.asm 2 | ml64.exe /Flgvmat64 /c /Zi gvmat64.asm 3 | -------------------------------------------------------------------------------- /lib/zlib/Makefile: -------------------------------------------------------------------------------- 1 | all: 2 | -@echo "Please use ./configure first. Thank you." 3 | 4 | distclean: 5 | make -f Makefile.in distclean 6 | -------------------------------------------------------------------------------- /lib/zlib/contrib/dotzlib/DotZLib.chm: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tumtumtum/nginx-visualstudio/HEAD/lib/zlib/contrib/dotzlib/DotZLib.chm -------------------------------------------------------------------------------- /lib/zlib/contrib/masmx86/bld_ml32.bat: -------------------------------------------------------------------------------- 1 | ml /coff /Zi /c /Flmatch686.lst match686.asm 2 | ml /coff /Zi /c /Flinffas32.lst inffas32.asm 3 | -------------------------------------------------------------------------------- /lib/zlib/contrib/dotzlib/DotZLib/Deflater.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tumtumtum/nginx-visualstudio/HEAD/lib/zlib/contrib/dotzlib/DotZLib/Deflater.cs -------------------------------------------------------------------------------- /lib/zlib/contrib/dotzlib/DotZLib/DotZLib.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tumtumtum/nginx-visualstudio/HEAD/lib/zlib/contrib/dotzlib/DotZLib/DotZLib.cs -------------------------------------------------------------------------------- /lib/zlib/contrib/dotzlib/DotZLib/Inflater.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tumtumtum/nginx-visualstudio/HEAD/lib/zlib/contrib/dotzlib/DotZLib/Inflater.cs -------------------------------------------------------------------------------- /lib/zlib/contrib/dotzlib/DotZLib/CodecBase.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tumtumtum/nginx-visualstudio/HEAD/lib/zlib/contrib/dotzlib/DotZLib/CodecBase.cs -------------------------------------------------------------------------------- /lib/zlib/contrib/dotzlib/DotZLib/GZipStream.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tumtumtum/nginx-visualstudio/HEAD/lib/zlib/contrib/dotzlib/DotZLib/GZipStream.cs -------------------------------------------------------------------------------- /lib/zlib/win32/VisualC.txt: -------------------------------------------------------------------------------- 1 | 2 | To build zlib using the Microsoft Visual C++ environment, 3 | use the appropriate project from the projects/ directory. 4 | -------------------------------------------------------------------------------- /lib/zlib/contrib/dotzlib/DotZLib/ChecksumImpl.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tumtumtum/nginx-visualstudio/HEAD/lib/zlib/contrib/dotzlib/DotZLib/ChecksumImpl.cs -------------------------------------------------------------------------------- /src/os/win32/nginx.rc: -------------------------------------------------------------------------------- 1 | 2 | // Copyright (C) Igor Sysoev 3 | // Copyright (C) Nginx, Inc. 4 | 5 | 6 | nginx icon discardable "src\\os\\win32\\nginx.ico" 7 | -------------------------------------------------------------------------------- /lib/zlib/contrib/dotzlib/DotZLib/CircularBuffer.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tumtumtum/nginx-visualstudio/HEAD/lib/zlib/contrib/dotzlib/DotZLib/CircularBuffer.cs -------------------------------------------------------------------------------- /lib/zlib/old/README: -------------------------------------------------------------------------------- 1 | This directory contains files that have not been updated for zlib 1.2.x 2 | 3 | (Volunteers are encouraged to help clean this up. Thanks.) 4 | -------------------------------------------------------------------------------- /lib/zlib/contrib/minizip/MiniZip64_Changes.txt: -------------------------------------------------------------------------------- 1 | 2 | MiniZip 1.1 was derrived from MiniZip at version 1.01f 3 | 4 | Change in 1.0 (Okt 2009) 5 | - **TODO - Add history** 6 | 7 | -------------------------------------------------------------------------------- /lib/zlib/contrib/blast/Makefile: -------------------------------------------------------------------------------- 1 | blast: blast.c blast.h 2 | cc -DTEST -o blast blast.c 3 | 4 | test: blast 5 | blast < test.pk | cmp - test.txt 6 | 7 | clean: 8 | rm -f blast blast.o 9 | -------------------------------------------------------------------------------- /src/http/v2/ngx_http_v2_huff_encode.c: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | * Copyright (C) Nginx, Inc. 4 | * Copyright (C) Valentin V. Bartenev 5 | */ 6 | 7 | 8 | #include 9 | #include 10 | #include 11 | -------------------------------------------------------------------------------- /lib/zlib/nintendods/README: -------------------------------------------------------------------------------- 1 | This Makefile requires devkitARM (http://www.devkitpro.org/category/devkitarm/) and works inside "contrib/nds". It is based on a devkitARM template. 2 | 3 | Eduardo Costa 4 | January 3, 2009 5 | 6 | -------------------------------------------------------------------------------- /lib/pcre/NON-UNIX-USE: -------------------------------------------------------------------------------- 1 | Compiling PCRE on non-Unix systems 2 | ---------------------------------- 3 | 4 | This has been renamed to better reflect its contents. Please see the file 5 | NON-AUTOTOOLS-BUILD for details of how to build PCRE without using autotools. 6 | 7 | #### 8 | -------------------------------------------------------------------------------- /lib/zlib/contrib/delphi/ZLibConst.pas: -------------------------------------------------------------------------------- 1 | unit ZLibConst; 2 | 3 | interface 4 | 5 | resourcestring 6 | sTargetBufferTooSmall = 'ZLib error: target buffer may be too small'; 7 | sInvalidStreamOp = 'Invalid stream operation'; 8 | 9 | implementation 10 | 11 | end. 12 | -------------------------------------------------------------------------------- /lib/zlib/contrib/testzlib/testzlib.txt: -------------------------------------------------------------------------------- 1 | To build testzLib with Visual Studio 2005: 2 | 3 | copy to a directory file from : 4 | - root of zLib tree 5 | - contrib/testzlib 6 | - contrib/masmx86 7 | - contrib/masmx64 8 | - contrib/vstudio/vc7 9 | 10 | and open testzlib8.sln -------------------------------------------------------------------------------- /lib/zlib/contrib/untgz/Makefile: -------------------------------------------------------------------------------- 1 | CC=cc 2 | CFLAGS=-g 3 | 4 | untgz: untgz.o ../../libz.a 5 | $(CC) $(CFLAGS) -o untgz untgz.o -L../.. -lz 6 | 7 | untgz.o: untgz.c ../../zlib.h 8 | $(CC) $(CFLAGS) -c -I../.. untgz.c 9 | 10 | ../../libz.a: 11 | cd ../..; ./configure; make 12 | 13 | clean: 14 | rm -f untgz untgz.o *~ 15 | -------------------------------------------------------------------------------- /lib/zlib/zlib.pc.in: -------------------------------------------------------------------------------- 1 | prefix=@prefix@ 2 | exec_prefix=@exec_prefix@ 3 | libdir=@libdir@ 4 | sharedlibdir=@sharedlibdir@ 5 | includedir=@includedir@ 6 | 7 | Name: zlib 8 | Description: zlib compression library 9 | Version: @VERSION@ 10 | 11 | Requires: 12 | Libs: -L${libdir} -L${sharedlibdir} -lz 13 | Cflags: -I${includedir} 14 | -------------------------------------------------------------------------------- /lib/zlib/contrib/minizip/minizip.pc.in: -------------------------------------------------------------------------------- 1 | prefix=@prefix@ 2 | exec_prefix=@exec_prefix@ 3 | libdir=@libdir@ 4 | includedir=@includedir@/minizip 5 | 6 | Name: minizip 7 | Description: Minizip zip file manipulation library 8 | Requires: 9 | Version: @PACKAGE_VERSION@ 10 | Libs: -L${libdir} -lminizip 11 | Libs.private: -lz 12 | Cflags: -I${includedir} 13 | -------------------------------------------------------------------------------- /src/os/unix/ngx_linux.h: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | * Copyright (C) Igor Sysoev 4 | * Copyright (C) Nginx, Inc. 5 | */ 6 | 7 | 8 | #ifndef _NGX_LINUX_H_INCLUDED_ 9 | #define _NGX_LINUX_H_INCLUDED_ 10 | 11 | 12 | ngx_chain_t *ngx_linux_sendfile_chain(ngx_connection_t *c, ngx_chain_t *in, 13 | off_t limit); 14 | 15 | 16 | #endif /* _NGX_LINUX_H_INCLUDED_ */ 17 | -------------------------------------------------------------------------------- /lib/pcre/libpcrecpp.pc.in: -------------------------------------------------------------------------------- 1 | # Package Information for pkg-config 2 | 3 | prefix=@prefix@ 4 | exec_prefix=@exec_prefix@ 5 | libdir=@libdir@ 6 | includedir=@includedir@ 7 | 8 | Name: libpcrecpp 9 | Description: PCRECPP - C++ wrapper for PCRE 10 | Version: @PACKAGE_VERSION@ 11 | Libs: -L${libdir} -lpcre -lpcrecpp 12 | Cflags: -I${includedir} @PCRE_STATIC_CFLAG@ 13 | -------------------------------------------------------------------------------- /src/os/unix/ngx_solaris.h: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | * Copyright (C) Igor Sysoev 4 | * Copyright (C) Nginx, Inc. 5 | */ 6 | 7 | 8 | #ifndef _NGX_SOLARIS_H_INCLUDED_ 9 | #define _NGX_SOLARIS_H_INCLUDED_ 10 | 11 | 12 | ngx_chain_t *ngx_solaris_sendfilev_chain(ngx_connection_t *c, ngx_chain_t *in, 13 | off_t limit); 14 | 15 | 16 | #endif /* _NGX_SOLARIS_H_INCLUDED_ */ 17 | -------------------------------------------------------------------------------- /lib/zlib/zlib.pc.cmakein: -------------------------------------------------------------------------------- 1 | prefix=@CMAKE_INSTALL_PREFIX@ 2 | exec_prefix=@CMAKE_INSTALL_PREFIX@ 3 | libdir=@INSTALL_LIB_DIR@ 4 | sharedlibdir=@INSTALL_LIB_DIR@ 5 | includedir=@INSTALL_INC_DIR@ 6 | 7 | Name: zlib 8 | Description: zlib compression library 9 | Version: @VERSION@ 10 | 11 | Requires: 12 | Libs: -L${libdir} -L${sharedlibdir} -lz 13 | Cflags: -I${includedir} 14 | -------------------------------------------------------------------------------- /lib/zlib/contrib/untgz/Makefile.msc: -------------------------------------------------------------------------------- 1 | CC=cl 2 | CFLAGS=-MD 3 | 4 | untgz.exe: untgz.obj ..\..\zlib.lib 5 | $(CC) $(CFLAGS) untgz.obj ..\..\zlib.lib 6 | 7 | untgz.obj: untgz.c ..\..\zlib.h 8 | $(CC) $(CFLAGS) -c -I..\.. untgz.c 9 | 10 | ..\..\zlib.lib: 11 | cd ..\.. 12 | $(MAKE) -f win32\makefile.msc 13 | cd contrib\untgz 14 | 15 | clean: 16 | -del untgz.obj 17 | -del untgz.exe 18 | -------------------------------------------------------------------------------- /src/core/ngx_murmurhash.h: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | * Copyright (C) Igor Sysoev 4 | * Copyright (C) Nginx, Inc. 5 | */ 6 | 7 | 8 | #ifndef _NGX_MURMURHASH_H_INCLUDED_ 9 | #define _NGX_MURMURHASH_H_INCLUDED_ 10 | 11 | 12 | #include 13 | #include 14 | 15 | 16 | uint32_t ngx_murmur_hash2(u_char *data, size_t len); 17 | 18 | 19 | #endif /* _NGX_MURMURHASH_H_INCLUDED_ */ 20 | -------------------------------------------------------------------------------- /Makefile: -------------------------------------------------------------------------------- 1 | 2 | default: build 3 | 4 | clean: 5 | rm -rf Makefile objs 6 | 7 | build: 8 | $(MAKE) -f objs/Makefile 9 | $(MAKE) -f objs/Makefile manpage 10 | 11 | install: 12 | $(MAKE) -f objs/Makefile install 13 | 14 | upgrade: 15 | /nginx.exe -t 16 | 17 | kill -USR2 `cat /logs/nginx.pid` 18 | sleep 1 19 | test -f /logs/nginx.pid.oldbin 20 | 21 | kill -QUIT `cat /logs/nginx.pid.oldbin` 22 | -------------------------------------------------------------------------------- /lib/pcre/libpcreposix.pc.in: -------------------------------------------------------------------------------- 1 | # Package Information for pkg-config 2 | 3 | prefix=@prefix@ 4 | exec_prefix=@exec_prefix@ 5 | libdir=@libdir@ 6 | includedir=@includedir@ 7 | 8 | Name: libpcreposix 9 | Description: PCREPosix - Posix compatible interface to libpcre 10 | Version: @PACKAGE_VERSION@ 11 | Libs: -L${libdir} -lpcreposix 12 | Cflags: -I${includedir} @PCRE_STATIC_CFLAG@ 13 | Requires.private: libpcre 14 | -------------------------------------------------------------------------------- /src/mysql/config: -------------------------------------------------------------------------------- 1 | 2 | ngx_addon_name=ngx_mysql 3 | 4 | HTTP_MODULES="$HTTP_MODULES ngx_http_mysql_test_module" 5 | 6 | HTTP_INCS="$HTTP_INCS $ngx_addon_dir" 7 | HTTP_DEPS="$HTTP_DEPS $ngx_addon_dir/ngx_mysql.h" 8 | #CORE_LIBS="$CORE_LIBS -lmd" 9 | 10 | USE_SHA1=YES 11 | 12 | NGX_ADDON_SRCS="$NGX_ADDON_SRCS $ngx_addon_dir/ngx_mysql.c" 13 | NGX_ADDON_SRCS="$NGX_ADDON_SRCS $ngx_addon_dir/ngx_http_mysql_test.c" 14 | -------------------------------------------------------------------------------- /src/core/ngx_crypt.h: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | * Copyright (C) Igor Sysoev 4 | * Copyright (C) Nginx, Inc. 5 | */ 6 | 7 | 8 | #ifndef _NGX_CRYPT_H_INCLUDED_ 9 | #define _NGX_CRYPT_H_INCLUDED_ 10 | 11 | 12 | #include 13 | #include 14 | 15 | 16 | ngx_int_t ngx_crypt(ngx_pool_t *pool, u_char *key, u_char *salt, 17 | u_char **encrypted); 18 | 19 | 20 | #endif /* _NGX_CRYPT_H_INCLUDED_ */ 21 | -------------------------------------------------------------------------------- /lib/pcre/libpcre.pc.in: -------------------------------------------------------------------------------- 1 | # Package Information for pkg-config 2 | 3 | prefix=@prefix@ 4 | exec_prefix=@exec_prefix@ 5 | libdir=@libdir@ 6 | includedir=@includedir@ 7 | 8 | Name: libpcre 9 | Description: PCRE - Perl compatible regular expressions C library with 8 bit character support 10 | Version: @PACKAGE_VERSION@ 11 | Libs: -L${libdir} -lpcre 12 | Libs.private: @PTHREAD_CFLAGS@ @PTHREAD_LIBS@ 13 | Cflags: -I${includedir} @PCRE_STATIC_CFLAG@ 14 | -------------------------------------------------------------------------------- /lib/pcre/libpcre16.pc.in: -------------------------------------------------------------------------------- 1 | # Package Information for pkg-config 2 | 3 | prefix=@prefix@ 4 | exec_prefix=@exec_prefix@ 5 | libdir=@libdir@ 6 | includedir=@includedir@ 7 | 8 | Name: libpcre16 9 | Description: PCRE - Perl compatible regular expressions C library with 16 bit character support 10 | Version: @PACKAGE_VERSION@ 11 | Libs: -L${libdir} -lpcre16 12 | Libs.private: @PTHREAD_CFLAGS@ @PTHREAD_LIBS@ 13 | Cflags: -I${includedir} @PCRE_STATIC_CFLAG@ 14 | -------------------------------------------------------------------------------- /lib/pcre/libpcre32.pc.in: -------------------------------------------------------------------------------- 1 | # Package Information for pkg-config 2 | 3 | prefix=@prefix@ 4 | exec_prefix=@exec_prefix@ 5 | libdir=@libdir@ 6 | includedir=@includedir@ 7 | 8 | Name: libpcre32 9 | Description: PCRE - Perl compatible regular expressions C library with 32 bit character support 10 | Version: @PACKAGE_VERSION@ 11 | Libs: -L${libdir} -lpcre32 12 | Libs.private: @PTHREAD_CFLAGS@ @PTHREAD_LIBS@ 13 | Cflags: -I${includedir} @PCRE_STATIC_CFLAG@ 14 | -------------------------------------------------------------------------------- /lib/pcre/makevp_c.txt: -------------------------------------------------------------------------------- 1 | pcre_byte_order.c 2 | pcre_chartables.c 3 | pcre_compile.c 4 | pcre_config.c 5 | pcre_dfa_exec.c 6 | pcre_exec.c 7 | pcre_fullinfo.c 8 | pcre_get.c 9 | pcre_globals.c 10 | pcre_jit_compile.c 11 | pcre_maketables.c 12 | pcre_newline.c 13 | pcre_ord2utf8.c 14 | pcre_refcount.c 15 | pcre_string_utils.c 16 | pcre_study.c 17 | pcre_tables.c 18 | pcre_ucd.c 19 | pcre_valid_utf8.c 20 | pcre_version.c 21 | pcre_xclass.c 22 | -------------------------------------------------------------------------------- /src/os/win32/ngx_user.c: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) Igor Sysoev 3 | * Copyright (C) Nginx, Inc. 4 | */ 5 | 6 | 7 | #include 8 | #include 9 | 10 | 11 | #if (NGX_CRYPT) 12 | 13 | ngx_int_t 14 | ngx_libc_crypt(ngx_pool_t *pool, u_char *key, u_char *salt, u_char **encrypted) 15 | { 16 | /* STUB: a plain text password */ 17 | 18 | *encrypted = key; 19 | 20 | return NGX_OK; 21 | } 22 | 23 | #endif /* NGX_CRYPT */ 24 | -------------------------------------------------------------------------------- /src/event/modules/ngx_iocp_module.h: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | * Copyright (C) Igor Sysoev 4 | * Copyright (C) Nginx, Inc. 5 | */ 6 | 7 | 8 | #ifndef _NGX_IOCP_MODULE_H_INCLUDED_ 9 | #define _NGX_IOCP_MODULE_H_INCLUDED_ 10 | 11 | 12 | typedef struct { 13 | int threads; 14 | int post_acceptex; 15 | int acceptex_read; 16 | } ngx_iocp_conf_t; 17 | 18 | 19 | extern ngx_module_t ngx_iocp_module; 20 | 21 | 22 | #endif /* _NGX_IOCP_MODULE_H_INCLUDED_ */ 23 | -------------------------------------------------------------------------------- /src/core/ngx_rwlock.h: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | * Copyright (C) Ruslan Ermilov 4 | * Copyright (C) Nginx, Inc. 5 | */ 6 | 7 | 8 | #ifndef _NGX_RWLOCK_H_INCLUDED_ 9 | #define _NGX_RWLOCK_H_INCLUDED_ 10 | 11 | 12 | #include 13 | #include 14 | 15 | 16 | void ngx_rwlock_wlock(ngx_atomic_t *lock); 17 | void ngx_rwlock_rlock(ngx_atomic_t *lock); 18 | void ngx_rwlock_unlock(ngx_atomic_t *lock); 19 | 20 | 21 | #endif /* _NGX_RWLOCK_H_INCLUDED_ */ 22 | -------------------------------------------------------------------------------- /src/core/ngx_parse.h: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | * Copyright (C) Igor Sysoev 4 | * Copyright (C) Nginx, Inc. 5 | */ 6 | 7 | 8 | #ifndef _NGX_PARSE_H_INCLUDED_ 9 | #define _NGX_PARSE_H_INCLUDED_ 10 | 11 | 12 | #include 13 | #include 14 | 15 | 16 | ssize_t ngx_parse_size(ngx_str_t *line); 17 | off_t ngx_parse_offset(ngx_str_t *line); 18 | ngx_int_t ngx_parse_time(ngx_str_t *line, ngx_uint_t is_sec); 19 | 20 | 21 | #endif /* _NGX_PARSE_H_INCLUDED_ */ 22 | -------------------------------------------------------------------------------- /lib/zlib/inffast.h: -------------------------------------------------------------------------------- 1 | /* inffast.h -- header to use inffast.c 2 | * Copyright (C) 1995-2003, 2010 Mark Adler 3 | * For conditions of distribution and use, see copyright notice in zlib.h 4 | */ 5 | 6 | /* WARNING: this file should *not* be used by applications. It is 7 | part of the implementation of the compression library and is 8 | subject to change. Applications should only use zlib.h. 9 | */ 10 | 11 | void ZLIB_INTERNAL inflate_fast OF((z_streamp strm, unsigned start)); 12 | -------------------------------------------------------------------------------- /src/os/unix/ngx_user.h: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | * Copyright (C) Igor Sysoev 4 | * Copyright (C) Nginx, Inc. 5 | */ 6 | 7 | 8 | #ifndef _NGX_USER_H_INCLUDED_ 9 | #define _NGX_USER_H_INCLUDED_ 10 | 11 | 12 | #include 13 | #include 14 | 15 | 16 | typedef uid_t ngx_uid_t; 17 | typedef gid_t ngx_gid_t; 18 | 19 | 20 | ngx_int_t ngx_libc_crypt(ngx_pool_t *pool, u_char *key, u_char *salt, 21 | u_char **encrypted); 22 | 23 | 24 | #endif /* _NGX_USER_H_INCLUDED_ */ 25 | -------------------------------------------------------------------------------- /src/core/ngx_parse_time.h: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | * Copyright (C) Igor Sysoev 4 | * Copyright (C) Nginx, Inc. 5 | */ 6 | 7 | 8 | #ifndef _NGX_PARSE_TIME_H_INCLUDED_ 9 | #define _NGX_PARSE_TIME_H_INCLUDED_ 10 | 11 | 12 | #include 13 | #include 14 | 15 | 16 | time_t ngx_parse_http_time(u_char *value, size_t len); 17 | 18 | /* compatibility */ 19 | #define ngx_http_parse_time(value, len) ngx_parse_http_time(value, len) 20 | 21 | 22 | #endif /* _NGX_PARSE_TIME_H_INCLUDED_ */ 23 | -------------------------------------------------------------------------------- /src/os/unix/ngx_setaffinity.h: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | * Copyright (C) Nginx, Inc. 4 | */ 5 | 6 | #ifndef _NGX_SETAFFINITY_H_INCLUDED_ 7 | #define _NGX_SETAFFINITY_H_INCLUDED_ 8 | 9 | 10 | #if (NGX_HAVE_SCHED_SETAFFINITY || NGX_HAVE_CPUSET_SETAFFINITY) 11 | 12 | #define NGX_HAVE_CPU_AFFINITY 1 13 | 14 | void ngx_setaffinity(uint64_t cpu_affinity, ngx_log_t *log); 15 | 16 | #else 17 | 18 | #define ngx_setaffinity(cpu_affinity, log) 19 | 20 | #endif 21 | 22 | 23 | #endif /* _NGX_SETAFFINITY_H_INCLUDED_ */ 24 | -------------------------------------------------------------------------------- /src/os/win32/ngx_user.h: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | * Copyright (C) Igor Sysoev 4 | * Copyright (C) Nginx, Inc. 5 | */ 6 | 7 | 8 | #ifndef _NGX_USER_H_INCLUDED_ 9 | #define _NGX_USER_H_INCLUDED_ 10 | 11 | 12 | #include 13 | #include 14 | 15 | 16 | /* STUB */ 17 | #define ngx_uid_t ngx_int_t 18 | #define ngx_gid_t ngx_int_t 19 | 20 | 21 | ngx_int_t ngx_libc_crypt(ngx_pool_t *pool, u_char *key, u_char *salt, 22 | u_char **encrypted); 23 | 24 | 25 | #endif /* _NGX_USER_H_INCLUDED_ */ 26 | -------------------------------------------------------------------------------- /src/os/win32/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 | int 13 | ngx_nonblocking(ngx_socket_t s) 14 | { 15 | unsigned long nb = 1; 16 | 17 | return ioctlsocket(s, FIONBIO, &nb); 18 | } 19 | 20 | 21 | int 22 | ngx_blocking(ngx_socket_t s) 23 | { 24 | unsigned long nb = 0; 25 | 26 | return ioctlsocket(s, FIONBIO, &nb); 27 | } 28 | 29 | 30 | int 31 | ngx_tcp_push(ngx_socket_t s) 32 | { 33 | return 0; 34 | } 35 | -------------------------------------------------------------------------------- /lib/zlib/contrib/iostream3/TODO: -------------------------------------------------------------------------------- 1 | Possible upgrades to gzfilebuf: 2 | 3 | - The ability to do putback (e.g. putbackfail) 4 | 5 | - The ability to seek (zlib supports this, but could be slow/tricky) 6 | 7 | - Simultaneous read/write access (does it make sense?) 8 | 9 | - Support for ios_base::ate open mode 10 | 11 | - Locale support? 12 | 13 | - Check public interface to see which calls give problems 14 | (due to dependence on library internals) 15 | 16 | - Override operator<<(ostream&, gzfilebuf*) to allow direct copying 17 | of stream buffer to stream ( i.e. os << is.rdbuf(); ) 18 | -------------------------------------------------------------------------------- /src/os/unix/ngx_darwin.h: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | * Copyright (C) Igor Sysoev 4 | * Copyright (C) Nginx, Inc. 5 | */ 6 | 7 | 8 | #ifndef _NGX_DARWIN_H_INCLUDED_ 9 | #define _NGX_DARWIN_H_INCLUDED_ 10 | 11 | 12 | void ngx_debug_init(void); 13 | ngx_chain_t *ngx_darwin_sendfile_chain(ngx_connection_t *c, ngx_chain_t *in, 14 | off_t limit); 15 | 16 | extern int ngx_darwin_kern_osreldate; 17 | extern int ngx_darwin_hw_ncpu; 18 | extern u_long ngx_darwin_net_inet_tcp_sendspace; 19 | 20 | extern ngx_uint_t ngx_debug_malloc; 21 | 22 | 23 | #endif /* _NGX_DARWIN_H_INCLUDED_ */ 24 | -------------------------------------------------------------------------------- /lib/zlib/contrib/minizip/Makefile: -------------------------------------------------------------------------------- 1 | CC=cc 2 | CFLAGS=-O -I../.. 3 | 4 | UNZ_OBJS = miniunz.o unzip.o ioapi.o ../../libz.a 5 | ZIP_OBJS = minizip.o zip.o ioapi.o ../../libz.a 6 | 7 | .c.o: 8 | $(CC) -c $(CFLAGS) $*.c 9 | 10 | all: miniunz minizip 11 | 12 | miniunz: $(UNZ_OBJS) 13 | $(CC) $(CFLAGS) -o $@ $(UNZ_OBJS) 14 | 15 | minizip: $(ZIP_OBJS) 16 | $(CC) $(CFLAGS) -o $@ $(ZIP_OBJS) 17 | 18 | test: miniunz minizip 19 | ./minizip test readme.txt 20 | ./miniunz -l test.zip 21 | mv readme.txt readme.old 22 | ./miniunz test.zip 23 | 24 | clean: 25 | /bin/rm -f *.o *~ minizip miniunz 26 | -------------------------------------------------------------------------------- /src/core/ngx_sha1.h: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | * Copyright (C) Igor Sysoev 4 | * Copyright (C) Nginx, Inc. 5 | */ 6 | 7 | 8 | #ifndef _NGX_SHA1_H_INCLUDED_ 9 | #define _NGX_SHA1_H_INCLUDED_ 10 | 11 | 12 | #include 13 | #include 14 | 15 | 16 | #if (NGX_HAVE_OPENSSL_SHA1_H) 17 | #include 18 | #else 19 | #include 20 | #endif 21 | 22 | 23 | typedef SHA_CTX ngx_sha1_t; 24 | 25 | 26 | #define ngx_sha1_init SHA1_Init 27 | #define ngx_sha1_update SHA1_Update 28 | #define ngx_sha1_final SHA1_Final 29 | 30 | 31 | #endif /* _NGX_SHA1_H_INCLUDED_ */ 32 | -------------------------------------------------------------------------------- /src/core/nginx.h: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | * Copyright (C) Igor Sysoev 4 | * Copyright (C) Nginx, Inc. 5 | */ 6 | 7 | 8 | #ifndef _NGINX_H_INCLUDED_ 9 | #define _NGINX_H_INCLUDED_ 10 | 11 | 12 | #define nginx_version 1009011 13 | #define NGINX_VERSION "1.9.11" 14 | #define NGINX_VER "nginx/" NGINX_VERSION 15 | 16 | #ifdef NGX_BUILD 17 | #define NGINX_VER_BUILD NGINX_VER " (" NGX_BUILD ")" 18 | #else 19 | #define NGINX_VER_BUILD NGINX_VER 20 | #endif 21 | 22 | #define NGINX_VAR "NGINX" 23 | #define NGX_OLDPID_EXT ".oldbin" 24 | 25 | 26 | #endif /* _NGINX_H_INCLUDED_ */ 27 | -------------------------------------------------------------------------------- /src/core/ngx_proxy_protocol.h: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | * Copyright (C) Roman Arutyunyan 4 | * Copyright (C) Nginx, Inc. 5 | */ 6 | 7 | 8 | #ifndef _NGX_PROXY_PROTOCOL_H_INCLUDED_ 9 | #define _NGX_PROXY_PROTOCOL_H_INCLUDED_ 10 | 11 | 12 | #include 13 | #include 14 | 15 | 16 | #define NGX_PROXY_PROTOCOL_MAX_HEADER 107 17 | 18 | 19 | u_char *ngx_proxy_protocol_read(ngx_connection_t *c, u_char *buf, 20 | u_char *last); 21 | u_char *ngx_proxy_protocol_write(ngx_connection_t *c, u_char *buf, 22 | u_char *last); 23 | 24 | 25 | #endif /* _NGX_PROXY_PROTOCOL_H_INCLUDED_ */ 26 | -------------------------------------------------------------------------------- /lib/zlib/contrib/ada/zlib.gpr: -------------------------------------------------------------------------------- 1 | project Zlib is 2 | 3 | for Languages use ("Ada"); 4 | for Source_Dirs use ("."); 5 | for Object_Dir use "."; 6 | for Main use ("test.adb", "mtest.adb", "read.adb", "buffer_demo"); 7 | 8 | package Compiler is 9 | for Default_Switches ("ada") use ("-gnatwcfilopru", "-gnatVcdfimorst", "-gnatyabcefhiklmnoprst"); 10 | end Compiler; 11 | 12 | package Linker is 13 | for Default_Switches ("ada") use ("-lz"); 14 | end Linker; 15 | 16 | package Builder is 17 | for Default_Switches ("ada") use ("-s", "-gnatQ"); 18 | end Builder; 19 | 20 | end Zlib; 21 | -------------------------------------------------------------------------------- /src/os/unix/ngx_shmem.h: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | * Copyright (C) Igor Sysoev 4 | * Copyright (C) Nginx, Inc. 5 | */ 6 | 7 | 8 | #ifndef _NGX_SHMEM_H_INCLUDED_ 9 | #define _NGX_SHMEM_H_INCLUDED_ 10 | 11 | 12 | #include 13 | #include 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 | -------------------------------------------------------------------------------- /src/os/win32/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 | 16 | typedef HANDLE ngx_tid_t; 17 | typedef DWORD ngx_thread_value_t; 18 | 19 | 20 | ngx_err_t ngx_create_thread(ngx_tid_t *tid, 21 | ngx_thread_value_t (__stdcall *func)(void *arg), void *arg, ngx_log_t *log); 22 | 23 | #define ngx_log_tid GetCurrentThreadId() 24 | #define NGX_TID_T_FMT "%ud" 25 | 26 | 27 | #endif /* _NGX_THREAD_H_INCLUDED_ */ 28 | -------------------------------------------------------------------------------- /lib/zlib/contrib/iostream/test.cpp: -------------------------------------------------------------------------------- 1 | 2 | #include "zfstream.h" 3 | 4 | int main() { 5 | 6 | // Construct a stream object with this filebuffer. Anything sent 7 | // to this stream will go to standard out. 8 | gzofstream os( 1, ios::out ); 9 | 10 | // This text is getting compressed and sent to stdout. 11 | // To prove this, run 'test | zcat'. 12 | os << "Hello, Mommy" << endl; 13 | 14 | os << setcompressionlevel( Z_NO_COMPRESSION ); 15 | os << "hello, hello, hi, ho!" << endl; 16 | 17 | setcompressionlevel( os, Z_DEFAULT_COMPRESSION ) 18 | << "I'm compressing again" << endl; 19 | 20 | os.close(); 21 | 22 | return 0; 23 | 24 | } 25 | -------------------------------------------------------------------------------- /src/os/win32/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 | #define ngx_memalign(alignment, size, log) ngx_alloc(size, log) 21 | 22 | extern ngx_uint_t ngx_pagesize; 23 | extern ngx_uint_t ngx_pagesize_shift; 24 | extern ngx_uint_t ngx_cacheline_size; 25 | 26 | 27 | #endif /* _NGX_ALLOC_H_INCLUDED_ */ 28 | -------------------------------------------------------------------------------- /src/os/win32/ngx_stat.c: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | * Copyright (C) Igor Sysoev 4 | * Copyright (C) Nginx, Inc. 5 | */ 6 | 7 | 8 | #include 9 | #include 10 | 11 | 12 | int ngx_file_type(char *file, ngx_file_info_t *sb) 13 | { 14 | sb->dwFileAttributes = GetFileAttributes(file); 15 | 16 | if (sb->dwFileAttributes == INVALID_FILE_ATTRIBUTES) { 17 | return -1; 18 | } 19 | 20 | return 0; 21 | } 22 | 23 | /* 24 | int ngx_stat(char *file, ngx_stat_t *sb) 25 | { 26 | *sb = GetFileAttributes(file); 27 | 28 | if (*sb == INVALID_FILE_ATTRIBUTES) { 29 | return -1; 30 | } 31 | 32 | return 0; 33 | } 34 | */ 35 | -------------------------------------------------------------------------------- /lib/pcre/makevp_l.txt: -------------------------------------------------------------------------------- 1 | +pcre_byte_order.obj & 2 | +pcre_chartables.obj & 3 | +pcre_compile.obj & 4 | +pcre_config.obj & 5 | +pcre_dfa_exec.obj & 6 | +pcre_exec.obj & 7 | +pcre_fullinfo.obj & 8 | +pcre_get.obj & 9 | +pcre_globals.obj & 10 | +pcre_jit_compile.obj & 11 | +pcre_maketables.obj & 12 | +pcre_newline.obj & 13 | +pcre_ord2utf8.obj & 14 | +pcre_refcount.obj & 15 | +pcre_string_utils.obj & 16 | +pcre_study.obj & 17 | +pcre_tables.obj & 18 | +pcre_ucd.obj & 19 | +pcre_valid_utf8.obj & 20 | +pcre_version.obj & 21 | +pcre_xclass.obj 22 | -------------------------------------------------------------------------------- /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 | -------------------------------------------------------------------------------- /root/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 REQUEST_SCHEME $scheme; 12 | scgi_param HTTPS $https if_not_empty; 13 | 14 | scgi_param REMOTE_ADDR $remote_addr; 15 | scgi_param REMOTE_PORT $remote_port; 16 | scgi_param SERVER_PORT $server_port; 17 | scgi_param SERVER_NAME $server_name; 18 | -------------------------------------------------------------------------------- /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 | -------------------------------------------------------------------------------- /root/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 REQUEST_SCHEME $scheme; 12 | uwsgi_param HTTPS $https if_not_empty; 13 | 14 | uwsgi_param REMOTE_ADDR $remote_addr; 15 | uwsgi_param REMOTE_PORT $remote_port; 16 | uwsgi_param SERVER_PORT $server_port; 17 | uwsgi_param SERVER_NAME $server_name; 18 | -------------------------------------------------------------------------------- /lib/pcre/cmake/FindEditline.cmake: -------------------------------------------------------------------------------- 1 | # Modified from FindReadline.cmake (PH Feb 2012) 2 | 3 | if(EDITLINE_INCLUDE_DIR AND EDITLINE_LIBRARY AND NCURSES_LIBRARY) 4 | set(EDITLINE_FOUND TRUE) 5 | else(EDITLINE_INCLUDE_DIR AND EDITLINE_LIBRARY AND NCURSES_LIBRARY) 6 | FIND_PATH(EDITLINE_INCLUDE_DIR readline.h 7 | /usr/include/editline 8 | /usr/include/edit/readline 9 | /usr/include/readline 10 | ) 11 | 12 | FIND_LIBRARY(EDITLINE_LIBRARY NAMES edit) 13 | include(FindPackageHandleStandardArgs) 14 | FIND_PACKAGE_HANDLE_STANDARD_ARGS(Editline DEFAULT_MSG EDITLINE_INCLUDE_DIR EDITLINE_LIBRARY ) 15 | 16 | MARK_AS_ADVANCED(EDITLINE_INCLUDE_DIR EDITLINE_LIBRARY) 17 | endif(EDITLINE_INCLUDE_DIR AND EDITLINE_LIBRARY AND NCURSES_LIBRARY) 18 | -------------------------------------------------------------------------------- /src/os/win32/ngx_thread.c: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | * Copyright (C) Igor Sysoev 4 | * Copyright (C) Nginx, Inc. 5 | */ 6 | 7 | 8 | #include 9 | #include 10 | 11 | 12 | ngx_err_t 13 | ngx_create_thread(ngx_tid_t *tid, 14 | ngx_thread_value_t (__stdcall *func)(void *arg), void *arg, ngx_log_t *log) 15 | { 16 | u_long id; 17 | ngx_err_t err; 18 | 19 | *tid = CreateThread(NULL, 0, func, arg, 0, &id); 20 | 21 | if (*tid != NULL) { 22 | ngx_log_error(NGX_LOG_NOTICE, log, 0, 23 | "create thread " NGX_TID_T_FMT, id); 24 | return 0; 25 | } 26 | 27 | err = ngx_errno; 28 | ngx_log_error(NGX_LOG_ALERT, log, err, "CreateThread() failed"); 29 | return err; 30 | } 31 | -------------------------------------------------------------------------------- /src/os/win32/ngx_shmem.h: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | * Copyright (C) Igor Sysoev 4 | * Copyright (C) Nginx, Inc. 5 | */ 6 | 7 | 8 | #ifndef _NGX_SHMEM_H_INCLUDED_ 9 | #define _NGX_SHMEM_H_INCLUDED_ 10 | 11 | 12 | #include 13 | #include 14 | 15 | 16 | typedef struct { 17 | u_char *addr; 18 | size_t size; 19 | ngx_str_t name; 20 | HANDLE handle; 21 | ngx_log_t *log; 22 | ngx_uint_t exists; /* unsigned exists:1; */ 23 | } ngx_shm_t; 24 | 25 | 26 | ngx_int_t ngx_shm_alloc(ngx_shm_t *shm); 27 | ngx_int_t ngx_shm_remap(ngx_shm_t *shm, u_char *addr); 28 | void ngx_shm_free(ngx_shm_t *shm); 29 | 30 | extern ngx_uint_t ngx_allocation_granularity; 31 | 32 | 33 | #endif /* _NGX_SHMEM_H_INCLUDED_ */ 34 | -------------------------------------------------------------------------------- /lib/zlib/gzclose.c: -------------------------------------------------------------------------------- 1 | /* gzclose.c -- zlib gzclose() function 2 | * Copyright (C) 2004, 2010 Mark Adler 3 | * For conditions of distribution and use, see copyright notice in zlib.h 4 | */ 5 | 6 | #include "gzguts.h" 7 | 8 | /* gzclose() is in a separate file so that it is linked in only if it is used. 9 | That way the other gzclose functions can be used instead to avoid linking in 10 | unneeded compression or decompression routines. */ 11 | int ZEXPORT gzclose(file) 12 | gzFile file; 13 | { 14 | #ifndef NO_GZCOMPRESS 15 | gz_statep state; 16 | 17 | if (file == NULL) 18 | return Z_STREAM_ERROR; 19 | state = (gz_statep)file; 20 | 21 | return state->mode == GZ_READ ? gzclose_r(file) : gzclose_w(file); 22 | #else 23 | return gzclose_r(file); 24 | #endif 25 | } 26 | -------------------------------------------------------------------------------- /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 | -------------------------------------------------------------------------------- /lib/pcre/Detrail: -------------------------------------------------------------------------------- 1 | #!/usr/bin/perl 2 | 3 | # This is a script for removing trailing whitespace from lines in files that 4 | # are listed on the command line. 5 | 6 | # This subroutine does the work for one file. 7 | 8 | sub detrail { 9 | my($file) = $_[0]; 10 | my($changed) = 0; 11 | open(IN, "$file") || die "Can't open $file for input"; 12 | @lines = ; 13 | close(IN); 14 | foreach (@lines) 15 | { 16 | if (/\s+\n$/) 17 | { 18 | s/\s+\n$/\n/; 19 | $changed = 1; 20 | } 21 | } 22 | if ($changed) 23 | { 24 | open(OUT, ">$file") || die "Can't open $file for output"; 25 | print OUT @lines; 26 | close(OUT); 27 | } 28 | } 29 | 30 | # This is the main program 31 | 32 | $, = ""; # Output field separator 33 | for ($i = 0; $i < @ARGV; $i++) { &detrail($ARGV[$i]); } 34 | 35 | # End 36 | -------------------------------------------------------------------------------- /src/os/win32/nginx_icon16.xpm: -------------------------------------------------------------------------------- 1 | /* XPM */ 2 | static char * nginx_xpm[] = { 3 | "16 16 2 2", 4 | /* colors */ 5 | " c none", 6 | "GG c #009900", 7 | /* pixels */ 8 | " ", 9 | " GGGGGGGGGGGGGGGG ", 10 | " GGGGGGGGGGGGGGGG ", 11 | " GGGGGGGGGGGGGGGGGGGG ", 12 | " GGGGGG GGGGGG ", 13 | " GGGGGG GGGGGG ", 14 | " GGGGGG ", 15 | " GGGGGG GGGGGGGGGGGGGGGG ", 16 | " GGGGGG GGGGGGGGGGGGGGGGGG ", 17 | " GGGGGG GGGGGGGGGGGGGG ", 18 | " GGGGGG GGGGGG ", 19 | " GGGGGG GGGGGG ", 20 | " GGGGGGGGGGGGGGGGGGGG ", 21 | " GGGGGGGGGGGGGGGG ", 22 | " GGGGGGGGGGGGGGGG ", 23 | " " 24 | }; 25 | -------------------------------------------------------------------------------- /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 | -------------------------------------------------------------------------------- /lib/zlib/contrib/iostream2/zstream_test.cpp: -------------------------------------------------------------------------------- 1 | #include "zstream.h" 2 | #include 3 | #include 4 | #include 5 | 6 | void main() { 7 | char h[256] = "Hello"; 8 | char* g = "Goodbye"; 9 | ozstream out("temp.gz"); 10 | out < "This works well" < h < g; 11 | out.close(); 12 | 13 | izstream in("temp.gz"); // read it back 14 | char *x = read_string(in), *y = new char[256], z[256]; 15 | in > y > z; 16 | in.close(); 17 | cout << x << endl << y << endl << z << endl; 18 | 19 | out.open("temp.gz"); // try ascii output; zcat temp.gz to see the results 20 | out << setw(50) << setfill('#') << setprecision(20) << x << endl << y << endl << z << endl; 21 | out << z << endl << y << endl << x << endl; 22 | out << 1.1234567890123456789 << endl; 23 | 24 | delete[] x; delete[] y; 25 | } 26 | -------------------------------------------------------------------------------- /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 | unsigned busy:1; 20 | unsigned nohostname:1; 21 | } ngx_syslog_peer_t; 22 | 23 | 24 | char *ngx_syslog_process_conf(ngx_conf_t *cf, ngx_syslog_peer_t *peer); 25 | u_char *ngx_syslog_add_header(ngx_syslog_peer_t *peer, u_char *buf); 26 | void ngx_syslog_writer(ngx_log_t *log, ngx_uint_t level, u_char *buf, 27 | size_t len); 28 | ssize_t ngx_syslog_send(ngx_syslog_peer_t *peer, u_char *buf, size_t len); 29 | 30 | 31 | #endif /* _NGX_SYSLOG_H_INCLUDED_ */ 32 | -------------------------------------------------------------------------------- /lib/zlib/contrib/minizip/mztools.h: -------------------------------------------------------------------------------- 1 | /* 2 | Additional tools for Minizip 3 | Code: Xavier Roche '2004 4 | License: Same as ZLIB (www.gzip.org) 5 | */ 6 | 7 | #ifndef _zip_tools_H 8 | #define _zip_tools_H 9 | 10 | #ifdef __cplusplus 11 | extern "C" { 12 | #endif 13 | 14 | #ifndef _ZLIB_H 15 | #include "zlib.h" 16 | #endif 17 | 18 | #include "unzip.h" 19 | 20 | /* Repair a ZIP file (missing central directory) 21 | file: file to recover 22 | fileOut: output file after recovery 23 | fileOutTmp: temporary file name used for recovery 24 | */ 25 | extern int ZEXPORT unzRepair(const char* file, 26 | const char* fileOut, 27 | const char* fileOutTmp, 28 | uLong* nRecovered, 29 | uLong* bytesRecovered); 30 | 31 | 32 | #ifdef __cplusplus 33 | } 34 | #endif 35 | 36 | 37 | #endif 38 | -------------------------------------------------------------------------------- /src/os/win32/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 *ngx_alloc(size_t size, ngx_log_t *log) 18 | { 19 | void *p; 20 | 21 | p = malloc(size); 22 | if (p == NULL) { 23 | ngx_log_error(NGX_LOG_EMERG, log, ngx_errno, 24 | "malloc(%uz) failed", size); 25 | } 26 | 27 | ngx_log_debug2(NGX_LOG_DEBUG_ALLOC, log, 0, "malloc: %p:%uz", p, size); 28 | 29 | return p; 30 | } 31 | 32 | 33 | void *ngx_calloc(size_t size, ngx_log_t *log) 34 | { 35 | void *p; 36 | 37 | p = ngx_alloc(size, log); 38 | 39 | if (p) { 40 | ngx_memzero(p, size); 41 | } 42 | 43 | return p; 44 | } 45 | -------------------------------------------------------------------------------- /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 | -------------------------------------------------------------------------------- /lib/zlib/contrib/minizip/configure.ac: -------------------------------------------------------------------------------- 1 | # -*- Autoconf -*- 2 | # Process this file with autoconf to produce a configure script. 3 | 4 | AC_INIT([minizip], [1.2.8], [bugzilla.redhat.com]) 5 | AC_CONFIG_SRCDIR([minizip.c]) 6 | AM_INIT_AUTOMAKE([foreign]) 7 | LT_INIT 8 | 9 | AC_MSG_CHECKING([whether to build example programs]) 10 | AC_ARG_ENABLE([demos], AC_HELP_STRING([--enable-demos], [build example programs])) 11 | AM_CONDITIONAL([COND_DEMOS], [test "$enable_demos" = yes]) 12 | if test "$enable_demos" = yes 13 | then 14 | AC_MSG_RESULT([yes]) 15 | else 16 | AC_MSG_RESULT([no]) 17 | fi 18 | 19 | case "${host}" in 20 | *-mingw* | mingw*) 21 | WIN32="yes" 22 | ;; 23 | *) 24 | ;; 25 | esac 26 | AM_CONDITIONAL([WIN32], [test "${WIN32}" = "yes"]) 27 | 28 | 29 | AC_SUBST([HAVE_UNISTD_H], [0]) 30 | AC_CHECK_HEADER([unistd.h], [HAVE_UNISTD_H=1], []) 31 | AC_CONFIG_FILES([Makefile minizip.pc]) 32 | AC_OUTPUT 33 | -------------------------------------------------------------------------------- /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 | -------------------------------------------------------------------------------- /lib/zlib/contrib/minizip/iowin32.h: -------------------------------------------------------------------------------- 1 | /* iowin32.h -- IO base function header for compress/uncompress .zip 2 | Version 1.1, February 14h, 2010 3 | part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html ) 4 | 5 | Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html ) 6 | 7 | Modifications for Zip64 support 8 | Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com ) 9 | 10 | For more info read MiniZip_info.txt 11 | 12 | */ 13 | 14 | #include 15 | 16 | 17 | #ifdef __cplusplus 18 | extern "C" { 19 | #endif 20 | 21 | void fill_win32_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def)); 22 | void fill_win32_filefunc64 OF((zlib_filefunc64_def* pzlib_filefunc_def)); 23 | void fill_win32_filefunc64A OF((zlib_filefunc64_def* pzlib_filefunc_def)); 24 | void fill_win32_filefunc64W OF((zlib_filefunc64_def* pzlib_filefunc_def)); 25 | 26 | #ifdef __cplusplus 27 | } 28 | #endif 29 | -------------------------------------------------------------------------------- /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 | -------------------------------------------------------------------------------- /lib/zlib/contrib/masmx86/readme.txt: -------------------------------------------------------------------------------- 1 | 2 | Summary 3 | ------- 4 | This directory contains ASM implementations of the functions 5 | longest_match() and inflate_fast(). 6 | 7 | 8 | Use instructions 9 | ---------------- 10 | Assemble using MASM, and copy the object files into the zlib source 11 | directory, then run the appropriate makefile, as suggested below. You can 12 | donwload MASM from here: 13 | 14 | http://www.microsoft.com/downloads/details.aspx?displaylang=en&FamilyID=7a1c9da0-0510-44a2-b042-7ef370530c64 15 | 16 | You can also get objects files here: 17 | 18 | http://www.winimage.com/zLibDll/zlib124_masm_obj.zip 19 | 20 | Build instructions 21 | ------------------ 22 | * With Microsoft C and MASM: 23 | nmake -f win32/Makefile.msc LOC="-DASMV -DASMINF" OBJA="match686.obj inffas32.obj" 24 | 25 | * With Borland C and TASM: 26 | make -f win32/Makefile.bor LOCAL_ZLIB="-DASMV -DASMINF" OBJA="match686.obj inffas32.obj" OBJPA="+match686c.obj+match686.obj+inffas32.obj" 27 | 28 | -------------------------------------------------------------------------------- /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 | -------------------------------------------------------------------------------- /lib/zlib/contrib/dotzlib/DotZLib.sln: -------------------------------------------------------------------------------- 1 | Microsoft Visual Studio Solution File, Format Version 8.00 2 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DotZLib", "DotZLib\DotZLib.csproj", "{BB1EE0B1-1808-46CB-B786-949D91117FC5}" 3 | ProjectSection(ProjectDependencies) = postProject 4 | EndProjectSection 5 | EndProject 6 | Global 7 | GlobalSection(SolutionConfiguration) = preSolution 8 | Debug = Debug 9 | Release = Release 10 | EndGlobalSection 11 | GlobalSection(ProjectConfiguration) = postSolution 12 | {BB1EE0B1-1808-46CB-B786-949D91117FC5}.Debug.ActiveCfg = Debug|.NET 13 | {BB1EE0B1-1808-46CB-B786-949D91117FC5}.Debug.Build.0 = Debug|.NET 14 | {BB1EE0B1-1808-46CB-B786-949D91117FC5}.Release.ActiveCfg = Release|.NET 15 | {BB1EE0B1-1808-46CB-B786-949D91117FC5}.Release.Build.0 = Release|.NET 16 | EndGlobalSection 17 | GlobalSection(ExtensibilityGlobals) = postSolution 18 | EndGlobalSection 19 | GlobalSection(ExtensibilityAddIns) = postSolution 20 | EndGlobalSection 21 | EndGlobal 22 | -------------------------------------------------------------------------------- /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 | -------------------------------------------------------------------------------- /NGINX.sln: -------------------------------------------------------------------------------- 1 | 2 | Microsoft Visual Studio Solution File, Format Version 12.00 3 | # Visual Studio 14 4 | VisualStudioVersion = 14.0.24720.0 5 | MinimumVisualStudioVersion = 10.0.40219.1 6 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "NGINX", "NGINX.vcxproj", "{D18B976A-0569-4BEC-8A4A-FFBFF436E92D}" 7 | EndProject 8 | Global 9 | GlobalSection(SolutionConfigurationPlatforms) = preSolution 10 | Debug|x86 = Debug|x86 11 | Release|x86 = Release|x86 12 | EndGlobalSection 13 | GlobalSection(ProjectConfigurationPlatforms) = postSolution 14 | {D18B976A-0569-4BEC-8A4A-FFBFF436E92D}.Debug|x86.ActiveCfg = Debug|Win32 15 | {D18B976A-0569-4BEC-8A4A-FFBFF436E92D}.Debug|x86.Build.0 = Debug|Win32 16 | {D18B976A-0569-4BEC-8A4A-FFBFF436E92D}.Release|x86.ActiveCfg = Release|Win32 17 | {D18B976A-0569-4BEC-8A4A-FFBFF436E92D}.Release|x86.Build.0 = Release|Win32 18 | EndGlobalSection 19 | GlobalSection(SolutionProperties) = preSolution 20 | HideSolutionNode = FALSE 21 | EndGlobalSection 22 | EndGlobal 23 | -------------------------------------------------------------------------------- /lib/zlib/old/os2/zlib.def: -------------------------------------------------------------------------------- 1 | ; 2 | ; Slightly modified version of ../nt/zlib.dnt :-) 3 | ; 4 | 5 | LIBRARY Z 6 | DESCRIPTION "Zlib compression library for OS/2" 7 | CODE PRELOAD MOVEABLE DISCARDABLE 8 | DATA PRELOAD MOVEABLE MULTIPLE 9 | 10 | EXPORTS 11 | adler32 12 | compress 13 | crc32 14 | deflate 15 | deflateCopy 16 | deflateEnd 17 | deflateInit2_ 18 | deflateInit_ 19 | deflateParams 20 | deflateReset 21 | deflateSetDictionary 22 | gzclose 23 | gzdopen 24 | gzerror 25 | gzflush 26 | gzopen 27 | gzread 28 | gzwrite 29 | inflate 30 | inflateEnd 31 | inflateInit2_ 32 | inflateInit_ 33 | inflateReset 34 | inflateSetDictionary 35 | inflateSync 36 | uncompress 37 | zlibVersion 38 | gzprintf 39 | gzputc 40 | gzgetc 41 | gzseek 42 | gzrewind 43 | gztell 44 | gzeof 45 | gzsetparams 46 | zError 47 | inflateSyncPoint 48 | get_crc_table 49 | compress2 50 | gzputs 51 | gzgets 52 | -------------------------------------------------------------------------------- /lib/zlib/contrib/minizip/make_vms.com: -------------------------------------------------------------------------------- 1 | $ if f$search("ioapi.h_orig") .eqs. "" then copy ioapi.h ioapi.h_orig 2 | $ open/write zdef vmsdefs.h 3 | $ copy sys$input: zdef 4 | $ deck 5 | #define unix 6 | #define fill_zlib_filefunc64_32_def_from_filefunc32 fillzffunc64from 7 | #define Write_Zip64EndOfCentralDirectoryLocator Write_Zip64EoDLocator 8 | #define Write_Zip64EndOfCentralDirectoryRecord Write_Zip64EoDRecord 9 | #define Write_EndOfCentralDirectoryRecord Write_EoDRecord 10 | $ eod 11 | $ close zdef 12 | $ copy vmsdefs.h,ioapi.h_orig ioapi.h 13 | $ cc/include=[--]/prefix=all ioapi.c 14 | $ cc/include=[--]/prefix=all miniunz.c 15 | $ cc/include=[--]/prefix=all unzip.c 16 | $ cc/include=[--]/prefix=all minizip.c 17 | $ cc/include=[--]/prefix=all zip.c 18 | $ link miniunz,unzip,ioapi,[--]libz.olb/lib 19 | $ link minizip,zip,ioapi,[--]libz.olb/lib 20 | $ mcr []minizip test minizip_info.txt 21 | $ mcr []miniunz -l test.zip 22 | $ rename minizip_info.txt; minizip_info.txt_old 23 | $ mcr []miniunz test.zip 24 | $ delete test.zip;* 25 | $exit 26 | -------------------------------------------------------------------------------- /lib/zlib/contrib/vstudio/vc10/miniunz.vcxproj.filters: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | {048af943-022b-4db6-beeb-a54c34774ee2} 6 | cpp;c;cxx;def;odl;idl;hpj;bat;asm 7 | 8 | 9 | {c1d600d2-888f-4aea-b73e-8b0dd9befa0c} 10 | h;hpp;hxx;hm;inl;inc 11 | 12 | 13 | {0844199a-966b-4f19-81db-1e0125e141b9} 14 | rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe 15 | 16 | 17 | 18 | 19 | Source Files 20 | 21 | 22 | -------------------------------------------------------------------------------- /lib/zlib/contrib/vstudio/vc10/minizip.vcxproj.filters: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | {c0419b40-bf50-40da-b153-ff74215b79de} 6 | cpp;c;cxx;def;odl;idl;hpj;bat;asm 7 | 8 | 9 | {bb87b070-735b-478e-92ce-7383abb2f36c} 10 | h;hpp;hxx;hm;inl;inc 11 | 12 | 13 | {f46ab6a6-548f-43cb-ae96-681abb5bd5db} 14 | rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe 15 | 16 | 17 | 18 | 19 | Source Files 20 | 21 | 22 | -------------------------------------------------------------------------------- /lib/zlib/contrib/minizip/Makefile.am: -------------------------------------------------------------------------------- 1 | lib_LTLIBRARIES = libminizip.la 2 | 3 | if COND_DEMOS 4 | bin_PROGRAMS = miniunzip minizip 5 | endif 6 | 7 | zlib_top_srcdir = $(top_srcdir)/../.. 8 | zlib_top_builddir = $(top_builddir)/../.. 9 | 10 | AM_CPPFLAGS = -I$(zlib_top_srcdir) 11 | AM_LDFLAGS = -L$(zlib_top_builddir) 12 | 13 | if WIN32 14 | iowin32_src = iowin32.c 15 | iowin32_h = iowin32.h 16 | endif 17 | 18 | libminizip_la_SOURCES = \ 19 | ioapi.c \ 20 | mztools.c \ 21 | unzip.c \ 22 | zip.c \ 23 | ${iowin32_src} 24 | 25 | libminizip_la_LDFLAGS = $(AM_LDFLAGS) -version-info 1:0:0 -lz 26 | 27 | minizip_includedir = $(includedir)/minizip 28 | minizip_include_HEADERS = \ 29 | crypt.h \ 30 | ioapi.h \ 31 | mztools.h \ 32 | unzip.h \ 33 | zip.h \ 34 | ${iowin32_h} 35 | 36 | pkgconfigdir = $(libdir)/pkgconfig 37 | pkgconfig_DATA = minizip.pc 38 | 39 | EXTRA_PROGRAMS = miniunzip minizip 40 | 41 | miniunzip_SOURCES = miniunz.c 42 | miniunzip_LDADD = libminizip.la 43 | 44 | minizip_SOURCES = minizip.c 45 | minizip_LDADD = libminizip.la -lz 46 | -------------------------------------------------------------------------------- /lib/zlib/contrib/vstudio/vc10/testzlibdll.vcxproj.filters: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | {fa61a89f-93fc-4c89-b29e-36224b7592f4} 6 | cpp;c;cxx;def;odl;idl;hpj;bat;asm 7 | 8 | 9 | {d4b85da0-2ba2-4934-b57f-e2584e3848ee} 10 | h;hpp;hxx;hm;inl;inc 11 | 12 | 13 | {e573e075-00bd-4a7d-bd67-a8cc9bfc5aca} 14 | rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe 15 | 16 | 17 | 18 | 19 | Source Files 20 | 21 | 22 | -------------------------------------------------------------------------------- /lib/pcre/AUTHORS: -------------------------------------------------------------------------------- 1 | THE MAIN PCRE LIBRARY 2 | --------------------- 3 | 4 | Written by: Philip Hazel 5 | Email local part: ph10 6 | Email domain: cam.ac.uk 7 | 8 | University of Cambridge Computing Service, 9 | Cambridge, England. 10 | 11 | Copyright (c) 1997-2015 University of Cambridge 12 | All rights reserved 13 | 14 | 15 | PCRE JUST-IN-TIME COMPILATION SUPPORT 16 | ------------------------------------- 17 | 18 | Written by: Zoltan Herczeg 19 | Email local part: hzmester 20 | Emain domain: freemail.hu 21 | 22 | Copyright(c) 2010-2015 Zoltan Herczeg 23 | All rights reserved. 24 | 25 | 26 | STACK-LESS JUST-IN-TIME COMPILER 27 | -------------------------------- 28 | 29 | Written by: Zoltan Herczeg 30 | Email local part: hzmester 31 | Emain domain: freemail.hu 32 | 33 | Copyright(c) 2009-2015 Zoltan Herczeg 34 | All rights reserved. 35 | 36 | 37 | THE C++ WRAPPER LIBRARY 38 | ----------------------- 39 | 40 | Written by: Google Inc. 41 | 42 | Copyright (c) 2007-2012 Google Inc 43 | All rights reserved 44 | 45 | #### 46 | -------------------------------------------------------------------------------- /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 | -------------------------------------------------------------------------------- /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 | -------------------------------------------------------------------------------- /lib/zlib/contrib/vstudio/vc10/zlib.rc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #define IDR_VERSION1 1 4 | IDR_VERSION1 VERSIONINFO MOVEABLE IMPURE LOADONCALL DISCARDABLE 5 | FILEVERSION 1,2,8,0 6 | PRODUCTVERSION 1,2,8,0 7 | FILEFLAGSMASK VS_FFI_FILEFLAGSMASK 8 | FILEFLAGS 0 9 | FILEOS VOS_DOS_WINDOWS32 10 | FILETYPE VFT_DLL 11 | FILESUBTYPE 0 // not used 12 | BEGIN 13 | BLOCK "StringFileInfo" 14 | BEGIN 15 | BLOCK "040904E4" 16 | //language ID = U.S. English, char set = Windows, Multilingual 17 | 18 | BEGIN 19 | VALUE "FileDescription", "zlib data compression and ZIP file I/O library\0" 20 | VALUE "FileVersion", "1.2.8\0" 21 | VALUE "InternalName", "zlib\0" 22 | VALUE "OriginalFilename", "zlibwapi.dll\0" 23 | VALUE "ProductName", "ZLib.DLL\0" 24 | VALUE "Comments","DLL support by Alessandro Iacopetti & Gilles Vollant\0" 25 | VALUE "LegalCopyright", "(C) 1995-2013 Jean-loup Gailly & Mark Adler\0" 26 | END 27 | END 28 | BLOCK "VarFileInfo" 29 | BEGIN 30 | VALUE "Translation", 0x0409, 1252 31 | END 32 | END 33 | -------------------------------------------------------------------------------- /lib/zlib/contrib/vstudio/vc11/zlib.rc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #define IDR_VERSION1 1 4 | IDR_VERSION1 VERSIONINFO MOVEABLE IMPURE LOADONCALL DISCARDABLE 5 | FILEVERSION 1,2,8,0 6 | PRODUCTVERSION 1,2,8,0 7 | FILEFLAGSMASK VS_FFI_FILEFLAGSMASK 8 | FILEFLAGS 0 9 | FILEOS VOS_DOS_WINDOWS32 10 | FILETYPE VFT_DLL 11 | FILESUBTYPE 0 // not used 12 | BEGIN 13 | BLOCK "StringFileInfo" 14 | BEGIN 15 | BLOCK "040904E4" 16 | //language ID = U.S. English, char set = Windows, Multilingual 17 | 18 | BEGIN 19 | VALUE "FileDescription", "zlib data compression and ZIP file I/O library\0" 20 | VALUE "FileVersion", "1.2.8\0" 21 | VALUE "InternalName", "zlib\0" 22 | VALUE "OriginalFilename", "zlibwapi.dll\0" 23 | VALUE "ProductName", "ZLib.DLL\0" 24 | VALUE "Comments","DLL support by Alessandro Iacopetti & Gilles Vollant\0" 25 | VALUE "LegalCopyright", "(C) 1995-2013 Jean-loup Gailly & Mark Adler\0" 26 | END 27 | END 28 | BLOCK "VarFileInfo" 29 | BEGIN 30 | VALUE "Translation", 0x0409, 1252 31 | END 32 | END 33 | -------------------------------------------------------------------------------- /lib/zlib/contrib/vstudio/vc9/zlib.rc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #define IDR_VERSION1 1 4 | IDR_VERSION1 VERSIONINFO MOVEABLE IMPURE LOADONCALL DISCARDABLE 5 | FILEVERSION 1,2,8,0 6 | PRODUCTVERSION 1,2,8,0 7 | FILEFLAGSMASK VS_FFI_FILEFLAGSMASK 8 | FILEFLAGS 0 9 | FILEOS VOS_DOS_WINDOWS32 10 | FILETYPE VFT_DLL 11 | FILESUBTYPE 0 // not used 12 | BEGIN 13 | BLOCK "StringFileInfo" 14 | BEGIN 15 | BLOCK "040904E4" 16 | //language ID = U.S. English, char set = Windows, Multilingual 17 | 18 | BEGIN 19 | VALUE "FileDescription", "zlib data compression and ZIP file I/O library\0" 20 | VALUE "FileVersion", "1.2.8\0" 21 | VALUE "InternalName", "zlib\0" 22 | VALUE "OriginalFilename", "zlibwapi.dll\0" 23 | VALUE "ProductName", "ZLib.DLL\0" 24 | VALUE "Comments","DLL support by Alessandro Iacopetti & Gilles Vollant\0" 25 | VALUE "LegalCopyright", "(C) 1995-2013 Jean-loup Gailly & Mark Adler\0" 26 | END 27 | END 28 | BLOCK "VarFileInfo" 29 | BEGIN 30 | VALUE "Translation", 0x0409, 1252 31 | END 32 | END 33 | -------------------------------------------------------------------------------- /root/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 REQUEST_SCHEME $scheme; 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/stream/ngx_stream_ssl_module.h: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | * Copyright (C) Igor Sysoev 4 | * Copyright (C) Nginx, Inc. 5 | */ 6 | 7 | 8 | #ifndef _NGX_STREAM_SSL_H_INCLUDED_ 9 | #define _NGX_STREAM_SSL_H_INCLUDED_ 10 | 11 | 12 | #include 13 | #include 14 | #include 15 | 16 | 17 | typedef struct { 18 | ngx_msec_t handshake_timeout; 19 | 20 | ngx_flag_t prefer_server_ciphers; 21 | 22 | ngx_ssl_t ssl; 23 | 24 | ngx_uint_t protocols; 25 | 26 | ssize_t builtin_session_cache; 27 | 28 | time_t session_timeout; 29 | 30 | ngx_str_t certificate; 31 | ngx_str_t certificate_key; 32 | ngx_str_t dhparam; 33 | ngx_str_t ecdh_curve; 34 | 35 | ngx_str_t ciphers; 36 | 37 | ngx_array_t *passwords; 38 | 39 | ngx_shm_zone_t *shm_zone; 40 | 41 | ngx_flag_t session_tickets; 42 | ngx_array_t *session_ticket_keys; 43 | } ngx_stream_ssl_conf_t; 44 | 45 | 46 | extern ngx_module_t ngx_stream_ssl_module; 47 | 48 | 49 | #endif /* _NGX_STREAM_SSL_H_INCLUDED_ */ 50 | -------------------------------------------------------------------------------- /src/http/modules/perl/Makefile.PL: -------------------------------------------------------------------------------- 1 | 2 | # Copyright (C) Igor Sysoev 3 | # Copyright (C) Nginx, Inc. 4 | 5 | use 5.006001; 6 | use ExtUtils::MakeMaker; 7 | 8 | WriteMakefile( 9 | NAME => 'nginx', 10 | VERSION_FROM => 'nginx.pm', # finds $VERSION 11 | PREREQ_PM => {}, # e.g., Module::Name => 1.1 12 | 13 | ABSTRACT_FROM => 'nginx.pm', # retrieve abstract from module 14 | AUTHOR => 'Igor Sysoev', 15 | 16 | CCFLAGS => "$ENV{NGX_PM_CFLAGS}", 17 | OPTIMIZE => '-O', 18 | 19 | INC => join(" ", map { 20 | m#^/# ? "-I $_" : "-I ../../../../../$_" 21 | } (split /\s+/, $ENV{NGX_INCS})), 22 | 23 | depend => { 24 | 'nginx.c' => join(" ", map { 25 | m#^/# ? $_ : "../../../../../$_" 26 | } (split(/\s+/, $ENV{NGX_DEPS}), 27 | "src/http/modules/perl/ngx_http_perl_module.h")) 28 | }, 29 | 30 | PM => { 31 | 'nginx.pm' => '$(INST_LIBDIR)/nginx.pm' 32 | } 33 | ); 34 | -------------------------------------------------------------------------------- /src/os/win32/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_PROCESS_SINGLE 0 17 | #define NGX_PROCESS_MASTER 1 18 | #define NGX_PROCESS_SIGNALLER 2 19 | #define NGX_PROCESS_WORKER 3 20 | 21 | 22 | void ngx_master_process_cycle(ngx_cycle_t *cycle); 23 | void ngx_single_process_cycle(ngx_cycle_t *cycle); 24 | void ngx_close_handle(HANDLE h); 25 | 26 | 27 | extern ngx_uint_t ngx_process; 28 | extern ngx_uint_t ngx_worker; 29 | extern ngx_pid_t ngx_pid; 30 | extern ngx_uint_t ngx_exiting; 31 | 32 | extern sig_atomic_t ngx_quit; 33 | extern sig_atomic_t ngx_terminate; 34 | extern sig_atomic_t ngx_reopen; 35 | 36 | extern ngx_uint_t ngx_inherited; 37 | extern ngx_pid_t ngx_new_binary; 38 | 39 | 40 | extern HANDLE ngx_master_process_event; 41 | extern char ngx_master_process_event_name[]; 42 | 43 | 44 | #endif /* _NGX_PROCESS_CYCLE_H_INCLUDED_ */ 45 | -------------------------------------------------------------------------------- /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 | -------------------------------------------------------------------------------- /src/http/v2/ngx_http_v2_module.h: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | * Copyright (C) Nginx, Inc. 4 | * Copyright (C) Valentin V. Bartenev 5 | */ 6 | 7 | 8 | #ifndef _NGX_HTTP_V2_MODULE_H_INCLUDED_ 9 | #define _NGX_HTTP_V2_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_v2_main_conf_t; 21 | 22 | 23 | typedef struct { 24 | size_t pool_size; 25 | ngx_uint_t concurrent_streams; 26 | size_t max_field_size; 27 | size_t max_header_size; 28 | ngx_uint_t streams_index_mask; 29 | ngx_msec_t recv_timeout; 30 | ngx_msec_t idle_timeout; 31 | } ngx_http_v2_srv_conf_t; 32 | 33 | 34 | typedef struct { 35 | size_t chunk_size; 36 | } ngx_http_v2_loc_conf_t; 37 | 38 | 39 | extern ngx_module_t ngx_http_v2_module; 40 | 41 | 42 | #endif /* _NGX_HTTP_V2_MODULE_H_INCLUDED_ */ 43 | -------------------------------------------------------------------------------- /root/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 REQUEST_SCHEME $scheme; 14 | fastcgi_param HTTPS $https if_not_empty; 15 | 16 | fastcgi_param GATEWAY_INTERFACE CGI/1.1; 17 | fastcgi_param SERVER_SOFTWARE nginx/$nginx_version; 18 | 19 | fastcgi_param REMOTE_ADDR $remote_addr; 20 | fastcgi_param REMOTE_PORT $remote_port; 21 | fastcgi_param SERVER_ADDR $server_addr; 22 | fastcgi_param SERVER_PORT $server_port; 23 | fastcgi_param SERVER_NAME $server_name; 24 | 25 | # PHP only, required if PHP was built with --enable-force-cgi-redirect 26 | fastcgi_param REDIRECT_STATUS 200; 27 | -------------------------------------------------------------------------------- /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 | -------------------------------------------------------------------------------- /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 | -------------------------------------------------------------------------------- /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 | -------------------------------------------------------------------------------- /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 | -------------------------------------------------------------------------------- /lib/zlib/win32/zlib1.rc: -------------------------------------------------------------------------------- 1 | #include 2 | #include "../zlib.h" 3 | 4 | #ifdef GCC_WINDRES 5 | VS_VERSION_INFO VERSIONINFO 6 | #else 7 | VS_VERSION_INFO VERSIONINFO MOVEABLE IMPURE LOADONCALL DISCARDABLE 8 | #endif 9 | FILEVERSION ZLIB_VER_MAJOR,ZLIB_VER_MINOR,ZLIB_VER_REVISION,0 10 | PRODUCTVERSION ZLIB_VER_MAJOR,ZLIB_VER_MINOR,ZLIB_VER_REVISION,0 11 | FILEFLAGSMASK VS_FFI_FILEFLAGSMASK 12 | #ifdef _DEBUG 13 | FILEFLAGS 1 14 | #else 15 | FILEFLAGS 0 16 | #endif 17 | FILEOS VOS__WINDOWS32 18 | FILETYPE VFT_DLL 19 | FILESUBTYPE 0 // not used 20 | BEGIN 21 | BLOCK "StringFileInfo" 22 | BEGIN 23 | BLOCK "040904E4" 24 | //language ID = U.S. English, char set = Windows, Multilingual 25 | BEGIN 26 | VALUE "FileDescription", "zlib data compression library\0" 27 | VALUE "FileVersion", ZLIB_VERSION "\0" 28 | VALUE "InternalName", "zlib1.dll\0" 29 | VALUE "LegalCopyright", "(C) 1995-2013 Jean-loup Gailly & Mark Adler\0" 30 | VALUE "OriginalFilename", "zlib1.dll\0" 31 | VALUE "ProductName", "zlib\0" 32 | VALUE "ProductVersion", ZLIB_VERSION "\0" 33 | VALUE "Comments", "For more information visit http://www.zlib.net/\0" 34 | END 35 | END 36 | BLOCK "VarFileInfo" 37 | BEGIN 38 | VALUE "Translation", 0x0409, 1252 39 | END 40 | END 41 | -------------------------------------------------------------------------------- /lib/zlib/contrib/dotzlib/DotZLib.build: -------------------------------------------------------------------------------- 1 | 2 | 3 | A .Net wrapper library around ZLib1.dll 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | -------------------------------------------------------------------------------- /lib/zlib/contrib/masmx64/readme.txt: -------------------------------------------------------------------------------- 1 | Summary 2 | ------- 3 | This directory contains ASM implementations of the functions 4 | longest_match() and inflate_fast(), for 64 bits x86 (both AMD64 and Intel EM64t), 5 | for use with Microsoft Macro Assembler (x64) for AMD64 and Microsoft C++ 64 bits. 6 | 7 | gvmat64.asm is written by Gilles Vollant (2005), by using Brian Raiter 686/32 bits 8 | assembly optimized version from Jean-loup Gailly original longest_match function 9 | 10 | inffasx64.asm and inffas8664.c were written by Chris Anderson, by optimizing 11 | original function from Mark Adler 12 | 13 | Use instructions 14 | ---------------- 15 | Assemble the .asm files using MASM and put the object files into the zlib source 16 | directory. You can also get object files here: 17 | 18 | http://www.winimage.com/zLibDll/zlib124_masm_obj.zip 19 | 20 | define ASMV and ASMINF in your project. Include inffas8664.c in your source tree, 21 | and inffasx64.obj and gvmat64.obj as object to link. 22 | 23 | 24 | Build instructions 25 | ------------------ 26 | run bld_64.bat with Microsoft Macro Assembler (x64) for AMD64 (ml64.exe) 27 | 28 | ml64.exe is given with Visual Studio 2005, Windows 2003 server DDK 29 | 30 | You can get Windows 2003 server DDK with ml64 and cl for AMD64 from 31 | http://www.microsoft.com/whdc/devtools/ddk/default.mspx for low price) 32 | -------------------------------------------------------------------------------- /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 | 16 | static ngx_os_io_t ngx_linux_io = { 17 | ngx_unix_recv, 18 | ngx_readv_chain, 19 | ngx_udp_unix_recv, 20 | ngx_unix_send, 21 | #if (NGX_HAVE_SENDFILE) 22 | ngx_linux_sendfile_chain, 23 | NGX_IO_SENDFILE 24 | #else 25 | ngx_writev_chain, 26 | 0 27 | #endif 28 | }; 29 | 30 | 31 | ngx_int_t 32 | ngx_os_specific_init(ngx_log_t *log) 33 | { 34 | struct utsname u; 35 | 36 | if (uname(&u) == -1) { 37 | ngx_log_error(NGX_LOG_ALERT, log, ngx_errno, "uname() failed"); 38 | return NGX_ERROR; 39 | } 40 | 41 | (void) ngx_cpystrn(ngx_linux_kern_ostype, (u_char *) u.sysname, 42 | sizeof(ngx_linux_kern_ostype)); 43 | 44 | (void) ngx_cpystrn(ngx_linux_kern_osrelease, (u_char *) u.release, 45 | sizeof(ngx_linux_kern_osrelease)); 46 | 47 | ngx_os_io = ngx_linux_io; 48 | 49 | return NGX_OK; 50 | } 51 | 52 | 53 | void 54 | ngx_os_specific_status(ngx_log_t *log) 55 | { 56 | ngx_log_error(NGX_LOG_NOTICE, log, 0, "OS: %s %s", 57 | ngx_linux_kern_ostype, ngx_linux_kern_osrelease); 58 | } 59 | -------------------------------------------------------------------------------- /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 | -------------------------------------------------------------------------------- /lib/pcre/cmake/FindReadline.cmake: -------------------------------------------------------------------------------- 1 | # from http://websvn.kde.org/trunk/KDE/kdeedu/cmake/modules/FindReadline.cmake 2 | # http://websvn.kde.org/trunk/KDE/kdeedu/cmake/modules/COPYING-CMAKE-SCRIPTS 3 | # --> BSD licensed 4 | # 5 | # GNU Readline library finder 6 | if(READLINE_INCLUDE_DIR AND READLINE_LIBRARY AND NCURSES_LIBRARY) 7 | set(READLINE_FOUND TRUE) 8 | else(READLINE_INCLUDE_DIR AND READLINE_LIBRARY AND NCURSES_LIBRARY) 9 | FIND_PATH(READLINE_INCLUDE_DIR readline/readline.h 10 | /usr/include/readline 11 | ) 12 | 13 | # 2008-04-22 The next clause used to read like this: 14 | # 15 | # FIND_LIBRARY(READLINE_LIBRARY NAMES readline) 16 | # FIND_LIBRARY(NCURSES_LIBRARY NAMES ncurses ) 17 | # include(FindPackageHandleStandardArgs) 18 | # FIND_PACKAGE_HANDLE_STANDARD_ARGS(Readline DEFAULT_MSG NCURSES_LIBRARY READLINE_INCLUDE_DIR READLINE_LIBRARY ) 19 | # 20 | # I was advised to modify it such that it will find an ncurses library if 21 | # required, but not if one was explicitly given, that is, it allows the 22 | # default to be overridden. PH 23 | 24 | FIND_LIBRARY(READLINE_LIBRARY NAMES readline) 25 | include(FindPackageHandleStandardArgs) 26 | FIND_PACKAGE_HANDLE_STANDARD_ARGS(Readline DEFAULT_MSG READLINE_INCLUDE_DIR READLINE_LIBRARY ) 27 | 28 | MARK_AS_ADVANCED(READLINE_INCLUDE_DIR READLINE_LIBRARY) 29 | endif(READLINE_INCLUDE_DIR AND READLINE_LIBRARY AND NCURSES_LIBRARY) 30 | -------------------------------------------------------------------------------- /src/os/win32/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 SYSTEMTIME ngx_tm_t; 20 | typedef FILETIME ngx_mtime_t; 21 | 22 | #define ngx_tm_sec wSecond 23 | #define ngx_tm_min wMinute 24 | #define ngx_tm_hour wHour 25 | #define ngx_tm_mday wDay 26 | #define ngx_tm_mon wMonth 27 | #define ngx_tm_year wYear 28 | #define ngx_tm_wday wDayOfWeek 29 | 30 | #define ngx_tm_sec_t u_short 31 | #define ngx_tm_min_t u_short 32 | #define ngx_tm_hour_t u_short 33 | #define ngx_tm_mday_t u_short 34 | #define ngx_tm_mon_t u_short 35 | #define ngx_tm_year_t u_short 36 | #define ngx_tm_wday_t u_short 37 | 38 | 39 | #define ngx_msleep Sleep 40 | 41 | #define NGX_HAVE_GETTIMEZONE 1 42 | 43 | #define ngx_timezone_update() 44 | 45 | ngx_int_t ngx_gettimezone(void); 46 | void ngx_libc_localtime(time_t s, struct tm *tm); 47 | void ngx_libc_gmtime(time_t s, struct tm *tm); 48 | void ngx_gettimeofday(struct timeval *tp); 49 | 50 | 51 | #endif /* _NGX_TIME_H_INCLUDED_ */ 52 | -------------------------------------------------------------------------------- /lib/pcre/cmake/COPYING-CMAKE-SCRIPTS: -------------------------------------------------------------------------------- 1 | Redistribution and use in source and binary forms, with or without 2 | modification, are permitted provided that the following conditions 3 | are met: 4 | 5 | 1. Redistributions of source code must retain the copyright 6 | notice, this list of conditions and the following disclaimer. 7 | 2. Redistributions in binary form must reproduce the copyright 8 | notice, this list of conditions and the following disclaimer in the 9 | documentation and/or other materials provided with the distribution. 10 | 3. The name of the author may not be used to endorse or promote products 11 | derived from this software without specific prior written permission. 12 | 13 | THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 14 | IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 15 | OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 16 | IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 17 | INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 18 | NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 19 | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 20 | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 21 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 22 | THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 23 | -------------------------------------------------------------------------------- /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 | -------------------------------------------------------------------------------- /lib/zlib/contrib/dotzlib/LICENSE_1_0.txt: -------------------------------------------------------------------------------- 1 | Boost Software License - Version 1.0 - August 17th, 2003 2 | 3 | Permission is hereby granted, free of charge, to any person or organization 4 | obtaining a copy of the software and accompanying documentation covered by 5 | this license (the "Software") to use, reproduce, display, distribute, 6 | execute, and transmit the Software, and to prepare derivative works of the 7 | Software, and to permit third-parties to whom the Software is furnished to 8 | do so, all subject to the following: 9 | 10 | The copyright notices in the Software and this entire statement, including 11 | the above license grant, this restriction and the following disclaimer, 12 | must be included in all copies of the Software, in whole or in part, and 13 | all derivative works of the Software, unless such copies or derivative 14 | works are solely in the form of machine-executable object code generated by 15 | a source language processor. 16 | 17 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 18 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 19 | FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT 20 | SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE 21 | FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, 22 | ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 23 | DEALINGS IN THE SOFTWARE. -------------------------------------------------------------------------------- /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 | -------------------------------------------------------------------------------- /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 | -------------------------------------------------------------------------------- /lib/zlib/contrib/puff/puff.h: -------------------------------------------------------------------------------- 1 | /* puff.h 2 | Copyright (C) 2002-2013 Mark Adler, all rights reserved 3 | version 2.3, 21 Jan 2013 4 | 5 | This software is provided 'as-is', without any express or implied 6 | warranty. In no event will the author be held liable for any damages 7 | arising from the use of this software. 8 | 9 | Permission is granted to anyone to use this software for any purpose, 10 | including commercial applications, and to alter it and redistribute it 11 | freely, subject to the following restrictions: 12 | 13 | 1. The origin of this software must not be misrepresented; you must not 14 | claim that you wrote the original software. If you use this software 15 | in a product, an acknowledgment in the product documentation would be 16 | appreciated but is not required. 17 | 2. Altered source versions must be plainly marked as such, and must not be 18 | misrepresented as being the original software. 19 | 3. This notice may not be removed or altered from any source distribution. 20 | 21 | Mark Adler madler@alumni.caltech.edu 22 | */ 23 | 24 | 25 | /* 26 | * See puff.c for purpose and usage. 27 | */ 28 | #ifndef NIL 29 | # define NIL ((unsigned char *)0) /* for no output option */ 30 | #endif 31 | 32 | int puff(unsigned char *dest, /* pointer to destination pointer */ 33 | unsigned long *destlen, /* amount of output space */ 34 | const unsigned char *source, /* pointer to source data pointer */ 35 | unsigned long *sourcelen); /* amount of input available */ 36 | -------------------------------------------------------------------------------- /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 | -------------------------------------------------------------------------------- /lib/zlib/zlib.map: -------------------------------------------------------------------------------- 1 | ZLIB_1.2.0 { 2 | global: 3 | compressBound; 4 | deflateBound; 5 | inflateBack; 6 | inflateBackEnd; 7 | inflateBackInit_; 8 | inflateCopy; 9 | local: 10 | deflate_copyright; 11 | inflate_copyright; 12 | inflate_fast; 13 | inflate_table; 14 | zcalloc; 15 | zcfree; 16 | z_errmsg; 17 | gz_error; 18 | gz_intmax; 19 | _*; 20 | }; 21 | 22 | ZLIB_1.2.0.2 { 23 | gzclearerr; 24 | gzungetc; 25 | zlibCompileFlags; 26 | } ZLIB_1.2.0; 27 | 28 | ZLIB_1.2.0.8 { 29 | deflatePrime; 30 | } ZLIB_1.2.0.2; 31 | 32 | ZLIB_1.2.2 { 33 | adler32_combine; 34 | crc32_combine; 35 | deflateSetHeader; 36 | inflateGetHeader; 37 | } ZLIB_1.2.0.8; 38 | 39 | ZLIB_1.2.2.3 { 40 | deflateTune; 41 | gzdirect; 42 | } ZLIB_1.2.2; 43 | 44 | ZLIB_1.2.2.4 { 45 | inflatePrime; 46 | } ZLIB_1.2.2.3; 47 | 48 | ZLIB_1.2.3.3 { 49 | adler32_combine64; 50 | crc32_combine64; 51 | gzopen64; 52 | gzseek64; 53 | gztell64; 54 | inflateUndermine; 55 | } ZLIB_1.2.2.4; 56 | 57 | ZLIB_1.2.3.4 { 58 | inflateReset2; 59 | inflateMark; 60 | } ZLIB_1.2.3.3; 61 | 62 | ZLIB_1.2.3.5 { 63 | gzbuffer; 64 | gzoffset; 65 | gzoffset64; 66 | gzclose_r; 67 | gzclose_w; 68 | } ZLIB_1.2.3.4; 69 | 70 | ZLIB_1.2.5.1 { 71 | deflatePending; 72 | } ZLIB_1.2.3.5; 73 | 74 | ZLIB_1.2.5.2 { 75 | deflateResetKeep; 76 | gzgetc_; 77 | inflateResetKeep; 78 | } ZLIB_1.2.5.1; 79 | 80 | ZLIB_1.2.7.1 { 81 | inflateGetDictionary; 82 | gzvprintf; 83 | } ZLIB_1.2.5.2; 84 | -------------------------------------------------------------------------------- /lib/zlib/watcom/watcom_l.mak: -------------------------------------------------------------------------------- 1 | # Makefile for zlib 2 | # OpenWatcom large model 3 | # Last updated: 28-Dec-2005 4 | 5 | # To use, do "wmake -f watcom_l.mak" 6 | 7 | C_SOURCE = adler32.c compress.c crc32.c deflate.c & 8 | gzclose.c gzlib.c gzread.c gzwrite.c & 9 | infback.c inffast.c inflate.c inftrees.c & 10 | trees.c uncompr.c zutil.c 11 | 12 | OBJS = adler32.obj compress.obj crc32.obj deflate.obj & 13 | gzclose.obj gzlib.obj gzread.obj gzwrite.obj & 14 | infback.obj inffast.obj inflate.obj inftrees.obj & 15 | trees.obj uncompr.obj zutil.obj 16 | 17 | CC = wcc 18 | LINKER = wcl 19 | CFLAGS = -zq -ml -s -bt=dos -oilrtfm -fr=nul -wx 20 | ZLIB_LIB = zlib_l.lib 21 | 22 | .C.OBJ: 23 | $(CC) $(CFLAGS) $[@ 24 | 25 | all: $(ZLIB_LIB) example.exe minigzip.exe 26 | 27 | $(ZLIB_LIB): $(OBJS) 28 | wlib -b -c $(ZLIB_LIB) -+adler32.obj -+compress.obj -+crc32.obj 29 | wlib -b -c $(ZLIB_LIB) -+gzclose.obj -+gzlib.obj -+gzread.obj -+gzwrite.obj 30 | wlib -b -c $(ZLIB_LIB) -+deflate.obj -+infback.obj 31 | wlib -b -c $(ZLIB_LIB) -+inffast.obj -+inflate.obj -+inftrees.obj 32 | wlib -b -c $(ZLIB_LIB) -+trees.obj -+uncompr.obj -+zutil.obj 33 | 34 | example.exe: $(ZLIB_LIB) example.obj 35 | $(LINKER) -fe=example.exe example.obj $(ZLIB_LIB) 36 | 37 | minigzip.exe: $(ZLIB_LIB) minigzip.obj 38 | $(LINKER) -fe=minigzip.exe minigzip.obj $(ZLIB_LIB) 39 | 40 | clean: .SYMBOLIC 41 | del *.obj 42 | del $(ZLIB_LIB) 43 | @echo Cleaning done 44 | -------------------------------------------------------------------------------- /src/http/modules/perl/ngx_http_perl_module.h: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | * Copyright (C) Igor Sysoev 4 | * Copyright (C) Nginx, Inc. 5 | */ 6 | 7 | 8 | #ifndef _NGX_HTTP_PERL_MODULE_H_INCLUDED_ 9 | #define _NGX_HTTP_PERL_MODULE_H_INCLUDED_ 10 | 11 | 12 | #include 13 | #include 14 | #include 15 | #include 16 | 17 | #include 18 | #include 19 | 20 | 21 | typedef ngx_http_request_t *nginx; 22 | 23 | typedef struct { 24 | ngx_str_t filename; 25 | ngx_str_t redirect_uri; 26 | ngx_str_t redirect_args; 27 | 28 | SV *next; 29 | 30 | ngx_uint_t done; /* unsigned done:1; */ 31 | 32 | ngx_array_t *variables; /* array of ngx_http_perl_var_t */ 33 | 34 | #if (NGX_HTTP_SSI) 35 | ngx_http_ssi_ctx_t *ssi; 36 | #endif 37 | } ngx_http_perl_ctx_t; 38 | 39 | 40 | typedef struct { 41 | ngx_uint_t hash; 42 | ngx_str_t name; 43 | ngx_str_t value; 44 | } ngx_http_perl_var_t; 45 | 46 | 47 | extern ngx_module_t ngx_http_perl_module; 48 | 49 | 50 | /* 51 | * workaround for "unused variable `Perl___notused'" warning 52 | * when building with perl 5.6.1 53 | */ 54 | #ifndef PERL_IMPLICIT_CONTEXT 55 | #undef dTHXa 56 | #define dTHXa(a) 57 | #endif 58 | 59 | 60 | extern void boot_DynaLoader(pTHX_ CV* cv); 61 | 62 | 63 | void ngx_http_perl_handle_request(ngx_http_request_t *r); 64 | void ngx_http_perl_sleep_handler(ngx_http_request_t *r); 65 | 66 | 67 | #endif /* _NGX_HTTP_PERL_MODULE_H_INCLUDED_ */ 68 | -------------------------------------------------------------------------------- /lib/zlib/watcom/watcom_f.mak: -------------------------------------------------------------------------------- 1 | # Makefile for zlib 2 | # OpenWatcom flat model 3 | # Last updated: 28-Dec-2005 4 | 5 | # To use, do "wmake -f watcom_f.mak" 6 | 7 | C_SOURCE = adler32.c compress.c crc32.c deflate.c & 8 | gzclose.c gzlib.c gzread.c gzwrite.c & 9 | infback.c inffast.c inflate.c inftrees.c & 10 | trees.c uncompr.c zutil.c 11 | 12 | OBJS = adler32.obj compress.obj crc32.obj deflate.obj & 13 | gzclose.obj gzlib.obj gzread.obj gzwrite.obj & 14 | infback.obj inffast.obj inflate.obj inftrees.obj & 15 | trees.obj uncompr.obj zutil.obj 16 | 17 | CC = wcc386 18 | LINKER = wcl386 19 | CFLAGS = -zq -mf -3r -fp3 -s -bt=dos -oilrtfm -fr=nul -wx 20 | ZLIB_LIB = zlib_f.lib 21 | 22 | .C.OBJ: 23 | $(CC) $(CFLAGS) $[@ 24 | 25 | all: $(ZLIB_LIB) example.exe minigzip.exe 26 | 27 | $(ZLIB_LIB): $(OBJS) 28 | wlib -b -c $(ZLIB_LIB) -+adler32.obj -+compress.obj -+crc32.obj 29 | wlib -b -c $(ZLIB_LIB) -+gzclose.obj -+gzlib.obj -+gzread.obj -+gzwrite.obj 30 | wlib -b -c $(ZLIB_LIB) -+deflate.obj -+infback.obj 31 | wlib -b -c $(ZLIB_LIB) -+inffast.obj -+inflate.obj -+inftrees.obj 32 | wlib -b -c $(ZLIB_LIB) -+trees.obj -+uncompr.obj -+zutil.obj 33 | 34 | example.exe: $(ZLIB_LIB) example.obj 35 | $(LINKER) -ldos32a -fe=example.exe example.obj $(ZLIB_LIB) 36 | 37 | minigzip.exe: $(ZLIB_LIB) minigzip.obj 38 | $(LINKER) -ldos32a -fe=minigzip.exe minigzip.obj $(ZLIB_LIB) 39 | 40 | clean: .SYMBOLIC 41 | del *.obj 42 | del $(ZLIB_LIB) 43 | @echo Cleaning done 44 | -------------------------------------------------------------------------------- /src/os/win32/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 | u_char * 13 | ngx_strerror(ngx_err_t err, u_char *errstr, size_t size) 14 | { 15 | u_int len; 16 | static u_long lang = MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US); 17 | 18 | if (size == 0) { 19 | return errstr; 20 | } 21 | 22 | len = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, 23 | NULL, err, lang, (char *) errstr, size, NULL); 24 | 25 | if (len == 0 && lang && GetLastError() == ERROR_RESOURCE_LANG_NOT_FOUND) { 26 | 27 | /* 28 | * Try to use English messages first and fallback to a language, 29 | * based on locale: non-English Windows have no English messages 30 | * at all. This way allows to use English messages at least on 31 | * Windows with MUI. 32 | */ 33 | 34 | lang = 0; 35 | 36 | len = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, 37 | NULL, err, lang, (char *) errstr, size, NULL); 38 | } 39 | 40 | if (len == 0) { 41 | return ngx_snprintf(errstr, size, 42 | "FormatMessage() error:(%d)", GetLastError()); 43 | } 44 | 45 | /* remove ".\r\n\0" */ 46 | while (errstr[len] == '\0' || errstr[len] == CR 47 | || errstr[len] == LF || errstr[len] == '.') 48 | { 49 | --len; 50 | } 51 | 52 | return &errstr[++len]; 53 | } 54 | 55 | 56 | ngx_int_t 57 | ngx_strerror_init(void) 58 | { 59 | return NGX_OK; 60 | } 61 | -------------------------------------------------------------------------------- /lib/zlib/contrib/iostream3/README: -------------------------------------------------------------------------------- 1 | These classes provide a C++ stream interface to the zlib library. It allows you 2 | to do things like: 3 | 4 | gzofstream outf("blah.gz"); 5 | outf << "These go into the gzip file " << 123 << endl; 6 | 7 | It does this by deriving a specialized stream buffer for gzipped files, which is 8 | the way Stroustrup would have done it. :-> 9 | 10 | The gzifstream and gzofstream classes were originally written by Kevin Ruland 11 | and made available in the zlib contrib/iostream directory. The older version still 12 | compiles under gcc 2.xx, but not under gcc 3.xx, which sparked the development of 13 | this version. 14 | 15 | The new classes are as standard-compliant as possible, closely following the 16 | approach of the standard library's fstream classes. It compiles under gcc versions 17 | 3.2 and 3.3, but not under gcc 2.xx. This is mainly due to changes in the standard 18 | library naming scheme. The new version of gzifstream/gzofstream/gzfilebuf differs 19 | from the previous one in the following respects: 20 | - added showmanyc 21 | - added setbuf, with support for unbuffered output via setbuf(0,0) 22 | - a few bug fixes of stream behavior 23 | - gzipped output file opened with default compression level instead of maximum level 24 | - setcompressionlevel()/strategy() members replaced by single setcompression() 25 | 26 | The code is provided "as is", with the permission to use, copy, modify, distribute 27 | and sell it for any purpose without fee. 28 | 29 | Ludwig Schwardt 30 | 31 | 32 | DSP Lab 33 | Electrical & Electronic Engineering Department 34 | University of Stellenbosch 35 | South Africa 36 | -------------------------------------------------------------------------------- /lib/zlib/contrib/minizip/minizip.1: -------------------------------------------------------------------------------- 1 | .\" Hey, EMACS: -*- nroff -*- 2 | .TH minizip 1 "May 2, 2001" 3 | .\" Please adjust this date whenever revising the manpage. 4 | .\" 5 | .\" Some roff macros, for reference: 6 | .\" .nh disable hyphenation 7 | .\" .hy enable hyphenation 8 | .\" .ad l left justify 9 | .\" .ad b justify to both left and right margins 10 | .\" .nf disable filling 11 | .\" .fi enable filling 12 | .\" .br insert line break 13 | .\" .sp insert n+1 empty lines 14 | .\" for manpage-specific macros, see man(7) 15 | .SH NAME 16 | minizip - create ZIP archives 17 | .SH SYNOPSIS 18 | .B minizip 19 | .RI [ -o ] 20 | zipfile [ " files" ... ] 21 | .SH DESCRIPTION 22 | .B minizip 23 | is a simple tool which allows the creation of compressed file archives 24 | in the ZIP format used by the MS-DOS utility PKZIP. It was written as 25 | a demonstration of the 26 | .IR zlib (3) 27 | library and therefore lack many of the features of the 28 | .IR zip (1) 29 | program. 30 | .SH OPTIONS 31 | The first argument supplied is the name of the ZIP archive to create or 32 | .RI -o 33 | in which case it is ignored and the second argument treated as the 34 | name of the ZIP file. If the ZIP file already exists it will be 35 | overwritten. 36 | .PP 37 | Subsequent arguments specify a list of files to place in the ZIP 38 | archive. If none are specified then an empty archive will be created. 39 | .SH SEE ALSO 40 | .BR miniunzip (1), 41 | .BR zlib (3), 42 | .BR zip (1). 43 | .SH AUTHOR 44 | This program was written by Gilles Vollant. This manual page was 45 | written by Mark Brown . 46 | 47 | -------------------------------------------------------------------------------- /lib/zlib/contrib/iostream3/test.cc: -------------------------------------------------------------------------------- 1 | /* 2 | * Test program for gzifstream and gzofstream 3 | * 4 | * by Ludwig Schwardt 5 | * original version by Kevin Ruland 6 | */ 7 | 8 | #include "zfstream.h" 9 | #include // for cout 10 | 11 | int main() { 12 | 13 | gzofstream outf; 14 | gzifstream inf; 15 | char buf[80]; 16 | 17 | outf.open("test1.txt.gz"); 18 | outf << "The quick brown fox sidestepped the lazy canine\n" 19 | << 1.3 << "\nPlan " << 9 << std::endl; 20 | outf.close(); 21 | std::cout << "Wrote the following message to 'test1.txt.gz' (check with zcat or zless):\n" 22 | << "The quick brown fox sidestepped the lazy canine\n" 23 | << 1.3 << "\nPlan " << 9 << std::endl; 24 | 25 | std::cout << "\nReading 'test1.txt.gz' (buffered) produces:\n"; 26 | inf.open("test1.txt.gz"); 27 | while (inf.getline(buf,80,'\n')) { 28 | std::cout << buf << "\t(" << inf.rdbuf()->in_avail() << " chars left in buffer)\n"; 29 | } 30 | inf.close(); 31 | 32 | outf.rdbuf()->pubsetbuf(0,0); 33 | outf.open("test2.txt.gz"); 34 | outf << setcompression(Z_NO_COMPRESSION) 35 | << "The quick brown fox sidestepped the lazy canine\n" 36 | << 1.3 << "\nPlan " << 9 << std::endl; 37 | outf.close(); 38 | std::cout << "\nWrote the same message to 'test2.txt.gz' in uncompressed form"; 39 | 40 | std::cout << "\nReading 'test2.txt.gz' (unbuffered) produces:\n"; 41 | inf.rdbuf()->pubsetbuf(0,0); 42 | inf.open("test2.txt.gz"); 43 | while (inf.getline(buf,80,'\n')) { 44 | std::cout << buf << "\t(" << inf.rdbuf()->in_avail() << " chars left in buffer)\n"; 45 | } 46 | inf.close(); 47 | 48 | return 0; 49 | 50 | } 51 | -------------------------------------------------------------------------------- /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 | -------------------------------------------------------------------------------- /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); 37 | 38 | fd = open("/dev/null", O_RDWR); 39 | if (fd == -1) { 40 | ngx_log_error(NGX_LOG_EMERG, log, ngx_errno, 41 | "open(\"/dev/null\") failed"); 42 | return NGX_ERROR; 43 | } 44 | 45 | if (dup2(fd, STDIN_FILENO) == -1) { 46 | ngx_log_error(NGX_LOG_EMERG, log, ngx_errno, "dup2(STDIN) failed"); 47 | return NGX_ERROR; 48 | } 49 | 50 | if (dup2(fd, STDOUT_FILENO) == -1) { 51 | ngx_log_error(NGX_LOG_EMERG, log, ngx_errno, "dup2(STDOUT) failed"); 52 | return NGX_ERROR; 53 | } 54 | 55 | #if 0 56 | if (dup2(fd, STDERR_FILENO) == -1) { 57 | ngx_log_error(NGX_LOG_EMERG, log, ngx_errno, "dup2(STDERR) failed"); 58 | return NGX_ERROR; 59 | } 60 | #endif 61 | 62 | if (fd > STDERR_FILENO) { 63 | if (close(fd) == -1) { 64 | ngx_log_error(NGX_LOG_EMERG, log, ngx_errno, "close() failed"); 65 | return NGX_ERROR; 66 | } 67 | } 68 | 69 | return NGX_OK; 70 | } 71 | -------------------------------------------------------------------------------- /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_uint_t ngx_worker; 43 | extern ngx_pid_t ngx_pid; 44 | extern ngx_pid_t ngx_new_binary; 45 | extern ngx_uint_t ngx_inherited; 46 | extern ngx_uint_t ngx_daemonized; 47 | extern ngx_uint_t ngx_exiting; 48 | 49 | extern sig_atomic_t ngx_reap; 50 | extern sig_atomic_t ngx_sigio; 51 | extern sig_atomic_t ngx_sigalrm; 52 | extern sig_atomic_t ngx_quit; 53 | extern sig_atomic_t ngx_debug_quit; 54 | extern sig_atomic_t ngx_terminate; 55 | extern sig_atomic_t ngx_noaccept; 56 | extern sig_atomic_t ngx_reconfigure; 57 | extern sig_atomic_t ngx_reopen; 58 | extern sig_atomic_t ngx_change_binary; 59 | 60 | 61 | #endif /* _NGX_PROCESS_CYCLE_H_INCLUDED_ */ 62 | -------------------------------------------------------------------------------- /lib/zlib/old/descrip.mms: -------------------------------------------------------------------------------- 1 | # descrip.mms: MMS description file for building zlib on VMS 2 | # written by Martin P.J. Zinser 3 | 4 | cc_defs = 5 | c_deb = 6 | 7 | .ifdef __DECC__ 8 | pref = /prefix=all 9 | .endif 10 | 11 | OBJS = adler32.obj, compress.obj, crc32.obj, gzio.obj, uncompr.obj,\ 12 | deflate.obj, trees.obj, zutil.obj, inflate.obj, infblock.obj,\ 13 | inftrees.obj, infcodes.obj, infutil.obj, inffast.obj 14 | 15 | CFLAGS= $(C_DEB) $(CC_DEFS) $(PREF) 16 | 17 | all : example.exe minigzip.exe 18 | @ write sys$output " Example applications available" 19 | libz.olb : libz.olb($(OBJS)) 20 | @ write sys$output " libz available" 21 | 22 | example.exe : example.obj libz.olb 23 | link example,libz.olb/lib 24 | 25 | minigzip.exe : minigzip.obj libz.olb 26 | link minigzip,libz.olb/lib,x11vms:xvmsutils.olb/lib 27 | 28 | clean : 29 | delete *.obj;*,libz.olb;* 30 | 31 | 32 | # Other dependencies. 33 | adler32.obj : zutil.h zlib.h zconf.h 34 | compress.obj : zlib.h zconf.h 35 | crc32.obj : zutil.h zlib.h zconf.h 36 | deflate.obj : deflate.h zutil.h zlib.h zconf.h 37 | example.obj : zlib.h zconf.h 38 | gzio.obj : zutil.h zlib.h zconf.h 39 | infblock.obj : zutil.h zlib.h zconf.h infblock.h inftrees.h infcodes.h infutil.h 40 | infcodes.obj : zutil.h zlib.h zconf.h inftrees.h infutil.h infcodes.h inffast.h 41 | inffast.obj : zutil.h zlib.h zconf.h inftrees.h infutil.h inffast.h 42 | inflate.obj : zutil.h zlib.h zconf.h infblock.h 43 | inftrees.obj : zutil.h zlib.h zconf.h inftrees.h 44 | infutil.obj : zutil.h zlib.h zconf.h inftrees.h infutil.h 45 | minigzip.obj : zlib.h zconf.h 46 | trees.obj : deflate.h zutil.h zlib.h zconf.h 47 | uncompr.obj : zlib.h zconf.h 48 | zutil.obj : zutil.h zlib.h zconf.h 49 | -------------------------------------------------------------------------------- /lib/zlib/contrib/infback9/infback9.h: -------------------------------------------------------------------------------- 1 | /* infback9.h -- header for using inflateBack9 functions 2 | * Copyright (C) 2003 Mark Adler 3 | * For conditions of distribution and use, see copyright notice in zlib.h 4 | */ 5 | 6 | /* 7 | * This header file and associated patches provide a decoder for PKWare's 8 | * undocumented deflate64 compression method (method 9). Use with infback9.c, 9 | * inftree9.h, inftree9.c, and inffix9.h. These patches are not supported. 10 | * This should be compiled with zlib, since it uses zutil.h and zutil.o. 11 | * This code has not yet been tested on 16-bit architectures. See the 12 | * comments in zlib.h for inflateBack() usage. These functions are used 13 | * identically, except that there is no windowBits parameter, and a 64K 14 | * window must be provided. Also if int's are 16 bits, then a zero for 15 | * the third parameter of the "out" function actually means 65536UL. 16 | * zlib.h must be included before this header file. 17 | */ 18 | 19 | #ifdef __cplusplus 20 | extern "C" { 21 | #endif 22 | 23 | ZEXTERN int ZEXPORT inflateBack9 OF((z_stream FAR *strm, 24 | in_func in, void FAR *in_desc, 25 | out_func out, void FAR *out_desc)); 26 | ZEXTERN int ZEXPORT inflateBack9End OF((z_stream FAR *strm)); 27 | ZEXTERN int ZEXPORT inflateBack9Init_ OF((z_stream FAR *strm, 28 | unsigned char FAR *window, 29 | const char *version, 30 | int stream_size)); 31 | #define inflateBack9Init(strm, window) \ 32 | inflateBack9Init_((strm), (window), \ 33 | ZLIB_VERSION, sizeof(z_stream)) 34 | 35 | #ifdef __cplusplus 36 | } 37 | #endif 38 | -------------------------------------------------------------------------------- /lib/zlib/msdos/Makefile.emx: -------------------------------------------------------------------------------- 1 | # Makefile for zlib. Modified for emx 0.9c by Chr. Spieler, 6/17/98. 2 | # Copyright (C) 1995-1998 Jean-loup Gailly. 3 | # For conditions of distribution and use, see copyright notice in zlib.h 4 | 5 | # To compile, or to compile and test, type: 6 | # 7 | # make -fmakefile.emx; make test -fmakefile.emx 8 | # 9 | 10 | CC=gcc 11 | 12 | #CFLAGS=-MMD -O 13 | #CFLAGS=-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7 14 | #CFLAGS=-MMD -g -DDEBUG 15 | CFLAGS=-MMD -O3 $(BUTT) -Wall -Wwrite-strings -Wpointer-arith -Wconversion \ 16 | -Wstrict-prototypes -Wmissing-prototypes 17 | 18 | # If cp.exe is available, replace "copy /Y" with "cp -fp" . 19 | CP=copy /Y 20 | # If gnu install.exe is available, replace $(CP) with ginstall. 21 | INSTALL=$(CP) 22 | # The default value of RM is "rm -f." If "rm.exe" is found, comment out: 23 | RM=del 24 | LDLIBS=-L. -lzlib 25 | LD=$(CC) -s -o 26 | LDSHARED=$(CC) 27 | 28 | INCL=zlib.h zconf.h 29 | LIBS=zlib.a 30 | 31 | AR=ar rcs 32 | 33 | prefix=/usr/local 34 | exec_prefix = $(prefix) 35 | 36 | OBJS = adler32.o compress.o crc32.o gzclose.o gzlib.o gzread.o gzwrite.o \ 37 | uncompr.o deflate.o trees.o zutil.o inflate.o infback.o inftrees.o inffast.o 38 | 39 | TEST_OBJS = example.o minigzip.o 40 | 41 | all: example.exe minigzip.exe 42 | 43 | test: all 44 | ./example 45 | echo hello world | .\minigzip | .\minigzip -d 46 | 47 | %.o : %.c 48 | $(CC) $(CFLAGS) -c $< -o $@ 49 | 50 | zlib.a: $(OBJS) 51 | $(AR) $@ $(OBJS) 52 | 53 | %.exe : %.o $(LIBS) 54 | $(LD) $@ $< $(LDLIBS) 55 | 56 | 57 | .PHONY : clean 58 | 59 | clean: 60 | $(RM) *.d 61 | $(RM) *.o 62 | $(RM) *.exe 63 | $(RM) zlib.a 64 | $(RM) foo.gz 65 | 66 | DEPS := $(wildcard *.d) 67 | ifneq ($(DEPS),) 68 | include $(DEPS) 69 | endif 70 | -------------------------------------------------------------------------------- /lib/zlib/old/Makefile.emx: -------------------------------------------------------------------------------- 1 | # Makefile for zlib. Modified for emx/rsxnt by Chr. Spieler, 6/16/98. 2 | # Copyright (C) 1995-1998 Jean-loup Gailly. 3 | # For conditions of distribution and use, see copyright notice in zlib.h 4 | 5 | # To compile, or to compile and test, type: 6 | # 7 | # make -fmakefile.emx; make test -fmakefile.emx 8 | # 9 | 10 | CC=gcc -Zwin32 11 | 12 | #CFLAGS=-MMD -O 13 | #CFLAGS=-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7 14 | #CFLAGS=-MMD -g -DDEBUG 15 | CFLAGS=-MMD -O3 $(BUTT) -Wall -Wwrite-strings -Wpointer-arith -Wconversion \ 16 | -Wstrict-prototypes -Wmissing-prototypes 17 | 18 | # If cp.exe is available, replace "copy /Y" with "cp -fp" . 19 | CP=copy /Y 20 | # If gnu install.exe is available, replace $(CP) with ginstall. 21 | INSTALL=$(CP) 22 | # The default value of RM is "rm -f." If "rm.exe" is found, comment out: 23 | RM=del 24 | LDLIBS=-L. -lzlib 25 | LD=$(CC) -s -o 26 | LDSHARED=$(CC) 27 | 28 | INCL=zlib.h zconf.h 29 | LIBS=zlib.a 30 | 31 | AR=ar rcs 32 | 33 | prefix=/usr/local 34 | exec_prefix = $(prefix) 35 | 36 | OBJS = adler32.o compress.o crc32.o deflate.o gzclose.o gzlib.o gzread.o \ 37 | gzwrite.o infback.o inffast.o inflate.o inftrees.o trees.o uncompr.o zutil.o 38 | 39 | TEST_OBJS = example.o minigzip.o 40 | 41 | all: example.exe minigzip.exe 42 | 43 | test: all 44 | ./example 45 | echo hello world | .\minigzip | .\minigzip -d 46 | 47 | %.o : %.c 48 | $(CC) $(CFLAGS) -c $< -o $@ 49 | 50 | zlib.a: $(OBJS) 51 | $(AR) $@ $(OBJS) 52 | 53 | %.exe : %.o $(LIBS) 54 | $(LD) $@ $< $(LDLIBS) 55 | 56 | 57 | .PHONY : clean 58 | 59 | clean: 60 | $(RM) *.d 61 | $(RM) *.o 62 | $(RM) *.exe 63 | $(RM) zlib.a 64 | $(RM) foo.gz 65 | 66 | DEPS := $(wildcard *.d) 67 | ifneq ($(DEPS),) 68 | include $(DEPS) 69 | endif 70 | -------------------------------------------------------------------------------- /lib/pcre/CheckMan: -------------------------------------------------------------------------------- 1 | #! /usr/bin/perl 2 | 3 | # A script to scan PCRE's man pages to check for typos in the control 4 | # sequences. I use only a small set of the available repertoire, so it is 5 | # straightforward to check that nothing else has slipped in by mistake. This 6 | # script should be called in the doc directory. 7 | 8 | $yield = 0; 9 | 10 | while (scalar(@ARGV) > 0) 11 | { 12 | $line = 0; 13 | $file = shift @ARGV; 14 | 15 | open (IN, $file) || die "Failed to open $file\n"; 16 | 17 | while () 18 | { 19 | $line++; 20 | if (/^\s*$/) 21 | { 22 | printf "Empty line $line of $file\n"; 23 | $yield = 1; 24 | } 25 | elsif (/^\./) 26 | { 27 | if (!/^\.\s*$| 28 | ^\.B\s+\S| 29 | ^\.TH\s\S| 30 | ^\.SH\s\S| 31 | ^\.SS\s\S| 32 | ^\.TP(?:\s?\d+)?\s*$| 33 | ^\.SM\s*$| 34 | ^\.br\s*$| 35 | ^\.rs\s*$| 36 | ^\.sp\s*$| 37 | ^\.nf\s*$| 38 | ^\.fi\s*$| 39 | ^\.P\s*$| 40 | ^\.PP\s*$| 41 | ^\.\\"(?:\ HREF)?\s*$| 42 | ^\.\\"\sHTML\s\s*$| 43 | ^\.\\"\sHTML\s<\/a>\s*$| 44 | ^\.\\"\s<\/a>\s*$| 45 | ^\.\\"\sJOINSH\s*$| 46 | ^\.\\"\sJOIN\s*$/x 47 | ) 48 | { 49 | printf "Bad control line $line of $file\n"; 50 | $yield = 1; 51 | } 52 | } 53 | else 54 | { 55 | if (/\\[^ef]|\\f[^IBP]/) 56 | { 57 | printf "Bad backslash in line $line of $file\n"; 58 | $yield = 1; 59 | } 60 | } 61 | } 62 | 63 | close(IN); 64 | } 65 | 66 | exit $yield; 67 | # End 68 | -------------------------------------------------------------------------------- /lib/zlib/win32/zlib.def: -------------------------------------------------------------------------------- 1 | ; zlib data compression library 2 | EXPORTS 3 | ; basic functions 4 | zlibVersion 5 | deflate 6 | deflateEnd 7 | inflate 8 | inflateEnd 9 | ; advanced functions 10 | deflateSetDictionary 11 | deflateCopy 12 | deflateReset 13 | deflateParams 14 | deflateTune 15 | deflateBound 16 | deflatePending 17 | deflatePrime 18 | deflateSetHeader 19 | inflateSetDictionary 20 | inflateGetDictionary 21 | inflateSync 22 | inflateCopy 23 | inflateReset 24 | inflateReset2 25 | inflatePrime 26 | inflateMark 27 | inflateGetHeader 28 | inflateBack 29 | inflateBackEnd 30 | zlibCompileFlags 31 | ; utility functions 32 | compress 33 | compress2 34 | compressBound 35 | uncompress 36 | gzopen 37 | gzdopen 38 | gzbuffer 39 | gzsetparams 40 | gzread 41 | gzwrite 42 | gzprintf 43 | gzvprintf 44 | gzputs 45 | gzgets 46 | gzputc 47 | gzgetc 48 | gzungetc 49 | gzflush 50 | gzseek 51 | gzrewind 52 | gztell 53 | gzoffset 54 | gzeof 55 | gzdirect 56 | gzclose 57 | gzclose_r 58 | gzclose_w 59 | gzerror 60 | gzclearerr 61 | ; large file functions 62 | gzopen64 63 | gzseek64 64 | gztell64 65 | gzoffset64 66 | adler32_combine64 67 | crc32_combine64 68 | ; checksum functions 69 | adler32 70 | crc32 71 | adler32_combine 72 | crc32_combine 73 | ; various hacks, don't look :) 74 | deflateInit_ 75 | deflateInit2_ 76 | inflateInit_ 77 | inflateInit2_ 78 | inflateBackInit_ 79 | gzgetc_ 80 | zError 81 | inflateSyncPoint 82 | get_crc_table 83 | inflateUndermine 84 | inflateResetKeep 85 | deflateResetKeep 86 | gzopen_w 87 | -------------------------------------------------------------------------------- /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 | -------------------------------------------------------------------------------- /lib/pcre/config-cmake.h.in: -------------------------------------------------------------------------------- 1 | /* config.h for CMake builds */ 2 | 3 | #cmakedefine HAVE_DIRENT_H 1 4 | #cmakedefine HAVE_SYS_STAT_H 1 5 | #cmakedefine HAVE_SYS_TYPES_H 1 6 | #cmakedefine HAVE_UNISTD_H 1 7 | #cmakedefine HAVE_WINDOWS_H 1 8 | #cmakedefine HAVE_STDINT_H 1 9 | #cmakedefine HAVE_INTTYPES_H 1 10 | 11 | #cmakedefine HAVE_TYPE_TRAITS_H 1 12 | #cmakedefine HAVE_BITS_TYPE_TRAITS_H 1 13 | 14 | #cmakedefine HAVE_BCOPY 1 15 | #cmakedefine HAVE_MEMMOVE 1 16 | #cmakedefine HAVE_STRERROR 1 17 | #cmakedefine HAVE_STRTOLL 1 18 | #cmakedefine HAVE_STRTOQ 1 19 | #cmakedefine HAVE__STRTOI64 1 20 | 21 | #cmakedefine PCRE_STATIC 1 22 | 23 | #cmakedefine SUPPORT_PCRE8 1 24 | #cmakedefine SUPPORT_PCRE16 1 25 | #cmakedefine SUPPORT_PCRE32 1 26 | #cmakedefine SUPPORT_JIT 1 27 | #cmakedefine SUPPORT_PCREGREP_JIT 1 28 | #cmakedefine SUPPORT_UTF 1 29 | #cmakedefine SUPPORT_UCP 1 30 | #cmakedefine EBCDIC 1 31 | #cmakedefine EBCDIC_NL25 1 32 | #cmakedefine BSR_ANYCRLF 1 33 | #cmakedefine NO_RECURSE 1 34 | 35 | #cmakedefine HAVE_LONG_LONG 1 36 | #cmakedefine HAVE_UNSIGNED_LONG_LONG 1 37 | 38 | #cmakedefine SUPPORT_LIBBZ2 1 39 | #cmakedefine SUPPORT_LIBZ 1 40 | #cmakedefine SUPPORT_LIBEDIT 1 41 | #cmakedefine SUPPORT_LIBREADLINE 1 42 | 43 | #cmakedefine SUPPORT_VALGRIND 1 44 | #cmakedefine SUPPORT_GCOV 1 45 | 46 | #define NEWLINE @NEWLINE@ 47 | #define POSIX_MALLOC_THRESHOLD @PCRE_POSIX_MALLOC_THRESHOLD@ 48 | #define LINK_SIZE @PCRE_LINK_SIZE@ 49 | #define PARENS_NEST_LIMIT @PCRE_PARENS_NEST_LIMIT@ 50 | #define MATCH_LIMIT @PCRE_MATCH_LIMIT@ 51 | #define MATCH_LIMIT_RECURSION @PCRE_MATCH_LIMIT_RECURSION@ 52 | #define PCREGREP_BUFSIZE @PCREGREP_BUFSIZE@ 53 | 54 | #define MAX_NAME_SIZE 32 55 | #define MAX_NAME_COUNT 10000 56 | 57 | /* end config.h for CMake builds */ 58 | -------------------------------------------------------------------------------- /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/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 | -------------------------------------------------------------------------------- /lib/zlib/contrib/asm686/README.686: -------------------------------------------------------------------------------- 1 | This is a patched version of zlib, modified to use 2 | Pentium-Pro-optimized assembly code in the deflation algorithm. The 3 | files changed/added by this patch are: 4 | 5 | README.686 6 | match.S 7 | 8 | The speedup that this patch provides varies, depending on whether the 9 | compiler used to build the original version of zlib falls afoul of the 10 | PPro's speed traps. My own tests show a speedup of around 10-20% at 11 | the default compression level, and 20-30% using -9, against a version 12 | compiled using gcc 2.7.2.3. Your mileage may vary. 13 | 14 | Note that this code has been tailored for the PPro/PII in particular, 15 | and will not perform particuarly well on a Pentium. 16 | 17 | If you are using an assembler other than GNU as, you will have to 18 | translate match.S to use your assembler's syntax. (Have fun.) 19 | 20 | Brian Raiter 21 | breadbox@muppetlabs.com 22 | April, 1998 23 | 24 | 25 | Added for zlib 1.1.3: 26 | 27 | The patches come from 28 | http://www.muppetlabs.com/~breadbox/software/assembly.html 29 | 30 | To compile zlib with this asm file, copy match.S to the zlib directory 31 | then do: 32 | 33 | CFLAGS="-O3 -DASMV" ./configure 34 | make OBJA=match.o 35 | 36 | 37 | Update: 38 | 39 | I've been ignoring these assembly routines for years, believing that 40 | gcc's generated code had caught up with it sometime around gcc 2.95 41 | and the major rearchitecting of the Pentium 4. However, I recently 42 | learned that, despite what I believed, this code still has some life 43 | in it. On the Pentium 4 and AMD64 chips, it continues to run about 8% 44 | faster than the code produced by gcc 4.1. 45 | 46 | In acknowledgement of its continuing usefulness, I've altered the 47 | license to match that of the rest of zlib. Share and Enjoy! 48 | 49 | Brian Raiter 50 | breadbox@muppetlabs.com 51 | April, 2007 52 | -------------------------------------------------------------------------------- /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/win32/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 | void 13 | ngx_gettimeofday(struct timeval *tp) 14 | { 15 | uint64_t intervals; 16 | FILETIME ft; 17 | 18 | GetSystemTimeAsFileTime(&ft); 19 | 20 | /* 21 | * A file time is a 64-bit value that represents the number 22 | * of 100-nanosecond intervals that have elapsed since 23 | * January 1, 1601 12:00 A.M. UTC. 24 | * 25 | * Between January 1, 1970 (Epoch) and January 1, 1601 there were 26 | * 134744 days, 27 | * 11644473600 seconds or 28 | * 11644473600,000,000,0 100-nanosecond intervals. 29 | * 30 | * See also MSKB Q167296. 31 | */ 32 | 33 | intervals = ((uint64_t) ft.dwHighDateTime << 32) | ft.dwLowDateTime; 34 | intervals -= 116444736000000000; 35 | 36 | tp->tv_sec = (long) (intervals / 10000000); 37 | tp->tv_usec = (long) ((intervals % 10000000) / 10); 38 | } 39 | 40 | 41 | void 42 | ngx_libc_localtime(time_t s, struct tm *tm) 43 | { 44 | struct tm *t; 45 | 46 | t = localtime(&s); 47 | *tm = *t; 48 | } 49 | 50 | 51 | void 52 | ngx_libc_gmtime(time_t s, struct tm *tm) 53 | { 54 | struct tm *t; 55 | 56 | t = gmtime(&s); 57 | *tm = *t; 58 | } 59 | 60 | 61 | ngx_int_t 62 | ngx_gettimezone(void) 63 | { 64 | u_long n; 65 | TIME_ZONE_INFORMATION tz; 66 | 67 | n = GetTimeZoneInformation(&tz); 68 | 69 | switch (n) { 70 | 71 | case TIME_ZONE_ID_UNKNOWN: 72 | return -tz.Bias; 73 | 74 | case TIME_ZONE_ID_STANDARD: 75 | return -(tz.Bias + tz.StandardBias); 76 | 77 | case TIME_ZONE_ID_DAYLIGHT: 78 | return -(tz.Bias + tz.DaylightBias); 79 | 80 | default: /* TIME_ZONE_ID_INVALID */ 81 | return 0; 82 | } 83 | } 84 | -------------------------------------------------------------------------------- /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/win32/ngx_atomic.h: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | * Copyright (C) Igor Sysoev 4 | * Copyright (C) Nginx, Inc. 5 | */ 6 | 7 | 8 | #ifndef _NGX_ATOMIC_H_INCLUDED_ 9 | #define _NGX_ATOMIC_H_INCLUDED_ 10 | 11 | 12 | #include 13 | #include 14 | 15 | 16 | #define NGX_HAVE_ATOMIC_OPS 1 17 | 18 | typedef int32_t ngx_atomic_int_t; 19 | typedef uint32_t ngx_atomic_uint_t; 20 | typedef volatile ngx_atomic_uint_t ngx_atomic_t; 21 | #define NGX_ATOMIC_T_LEN (sizeof("-2147483648") - 1) 22 | 23 | 24 | #if defined( __WATCOMC__ ) || defined( __BORLANDC__ ) || defined(__GNUC__) \ 25 | || ( _MSC_VER >= 1300 ) 26 | 27 | /* the new SDK headers */ 28 | 29 | #define ngx_atomic_cmp_set(lock, old, set) \ 30 | ((ngx_atomic_uint_t) InterlockedCompareExchange((long *) lock, set, old) \ 31 | == old) 32 | 33 | #else 34 | 35 | /* the old MS VC6.0SP2 SDK headers */ 36 | 37 | #define ngx_atomic_cmp_set(lock, old, set) \ 38 | (InterlockedCompareExchange((void **) lock, (void *) set, (void *) old) \ 39 | == (void *) old) 40 | 41 | #endif 42 | 43 | 44 | #define ngx_atomic_fetch_add(p, add) InterlockedExchangeAdd((long *) p, add) 45 | 46 | 47 | #define ngx_memory_barrier() 48 | 49 | 50 | #if defined( __BORLANDC__ ) || ( __WATCOMC__ < 1230 ) 51 | 52 | /* 53 | * Borland C++ 5.5 (tasm32) and Open Watcom C prior to 1.3 54 | * do not understand the "pause" instruction 55 | */ 56 | 57 | #define ngx_cpu_pause() 58 | #else 59 | #define ngx_cpu_pause() __asm { pause } 60 | #endif 61 | 62 | 63 | void ngx_spinlock(ngx_atomic_t *lock, ngx_atomic_int_t value, ngx_uint_t spin); 64 | 65 | #define ngx_trylock(lock) (*(lock) == 0 && ngx_atomic_cmp_set(lock, 0, 1)) 66 | #define ngx_unlock(lock) *(lock) = 0 67 | 68 | 69 | #endif /* _NGX_ATOMIC_H_INCLUDED_ */ 70 | -------------------------------------------------------------------------------- /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 | -------------------------------------------------------------------------------- /lib/zlib/examples/README.examples: -------------------------------------------------------------------------------- 1 | This directory contains examples of the use of zlib and other relevant 2 | programs and documentation. 3 | 4 | enough.c 5 | calculation and justification of ENOUGH parameter in inftrees.h 6 | - calculates the maximum table space used in inflate tree 7 | construction over all possible Huffman codes 8 | 9 | fitblk.c 10 | compress just enough input to nearly fill a requested output size 11 | - zlib isn't designed to do this, but fitblk does it anyway 12 | 13 | gun.c 14 | uncompress a gzip file 15 | - illustrates the use of inflateBack() for high speed file-to-file 16 | decompression using call-back functions 17 | - is approximately twice as fast as gzip -d 18 | - also provides Unix uncompress functionality, again twice as fast 19 | 20 | gzappend.c 21 | append to a gzip file 22 | - illustrates the use of the Z_BLOCK flush parameter for inflate() 23 | - illustrates the use of deflatePrime() to start at any bit 24 | 25 | gzjoin.c 26 | join gzip files without recalculating the crc or recompressing 27 | - illustrates the use of the Z_BLOCK flush parameter for inflate() 28 | - illustrates the use of crc32_combine() 29 | 30 | gzlog.c 31 | gzlog.h 32 | efficiently and robustly maintain a message log file in gzip format 33 | - illustrates use of raw deflate, Z_PARTIAL_FLUSH, deflatePrime(), 34 | and deflateSetDictionary() 35 | - illustrates use of a gzip header extra field 36 | 37 | zlib_how.html 38 | painfully comprehensive description of zpipe.c (see below) 39 | - describes in excruciating detail the use of deflate() and inflate() 40 | 41 | zpipe.c 42 | reads and writes zlib streams from stdin to stdout 43 | - illustrates the proper use of deflate() and inflate() 44 | - deeply commented in zlib_how.html (see above) 45 | 46 | zran.c 47 | index a zlib or gzip stream and randomly access it 48 | - illustrates the use of Z_BLOCK, inflatePrime(), and 49 | inflateSetDictionary() to provide random access 50 | -------------------------------------------------------------------------------- /lib/pcre/pcre_stringpiece.cc: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2005, Google Inc. 2 | // All rights reserved. 3 | // 4 | // Redistribution and use in source and binary forms, with or without 5 | // modification, are permitted provided that the following conditions are 6 | // met: 7 | // 8 | // * Redistributions of source code must retain the above copyright 9 | // notice, this list of conditions and the following disclaimer. 10 | // * Redistributions in binary form must reproduce the above 11 | // copyright notice, this list of conditions and the following disclaimer 12 | // in the documentation and/or other materials provided with the 13 | // distribution. 14 | // * Neither the name of Google Inc. nor the names of its 15 | // contributors may be used to endorse or promote products derived from 16 | // this software without specific prior written permission. 17 | // 18 | // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19 | // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20 | // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21 | // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22 | // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23 | // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24 | // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28 | // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 | // 30 | // Author: wilsonh@google.com (Wilson Hsieh) 31 | // 32 | 33 | #ifdef HAVE_CONFIG_H 34 | #include "config.h" 35 | #endif 36 | 37 | #include 38 | #include "pcrecpp_internal.h" 39 | #include "pcre_stringpiece.h" 40 | 41 | std::ostream& operator<<(std::ostream& o, const pcrecpp::StringPiece& piece) { 42 | return (o << piece.as_string()); 43 | } 44 | -------------------------------------------------------------------------------- /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 | -------------------------------------------------------------------------------- /lib/zlib/contrib/puff/Makefile: -------------------------------------------------------------------------------- 1 | CFLAGS=-O 2 | 3 | puff: puff.o pufftest.o 4 | 5 | puff.o: puff.h 6 | 7 | pufftest.o: puff.h 8 | 9 | test: puff 10 | puff zeros.raw 11 | 12 | puft: puff.c puff.h pufftest.o 13 | cc -fprofile-arcs -ftest-coverage -o puft puff.c pufftest.o 14 | 15 | # puff full coverage test (should say 100%) 16 | cov: puft 17 | @rm -f *.gcov *.gcda 18 | @puft -w zeros.raw 2>&1 | cat > /dev/null 19 | @echo '04' | xxd -r -p | puft 2> /dev/null || test $$? -eq 2 20 | @echo '00' | xxd -r -p | puft 2> /dev/null || test $$? -eq 2 21 | @echo '00 00 00 00 00' | xxd -r -p | puft 2> /dev/null || test $$? -eq 254 22 | @echo '00 01 00 fe ff' | xxd -r -p | puft 2> /dev/null || test $$? -eq 2 23 | @echo '01 01 00 fe ff 0a' | xxd -r -p | puft -f 2>&1 | cat > /dev/null 24 | @echo '02 7e ff ff' | xxd -r -p | puft 2> /dev/null || test $$? -eq 246 25 | @echo '02' | xxd -r -p | puft 2> /dev/null || test $$? -eq 2 26 | @echo '04 80 49 92 24 49 92 24 0f b4 ff ff c3 04' | xxd -r -p | puft 2> /dev/null || test $$? -eq 2 27 | @echo '04 80 49 92 24 49 92 24 71 ff ff 93 11 00' | xxd -r -p | puft 2> /dev/null || test $$? -eq 249 28 | @echo '04 c0 81 08 00 00 00 00 20 7f eb 0b 00 00' | xxd -r -p | puft 2> /dev/null || test $$? -eq 246 29 | @echo '0b 00 00' | xxd -r -p | puft -f 2>&1 | cat > /dev/null 30 | @echo '1a 07' | xxd -r -p | puft 2> /dev/null || test $$? -eq 246 31 | @echo '0c c0 81 00 00 00 00 00 90 ff 6b 04' | xxd -r -p | puft 2> /dev/null || test $$? -eq 245 32 | @puft -f zeros.raw 2>&1 | cat > /dev/null 33 | @echo 'fc 00 00' | xxd -r -p | puft 2> /dev/null || test $$? -eq 253 34 | @echo '04 00 fe ff' | xxd -r -p | puft 2> /dev/null || test $$? -eq 252 35 | @echo '04 00 24 49' | xxd -r -p | puft 2> /dev/null || test $$? -eq 251 36 | @echo '04 80 49 92 24 49 92 24 0f b4 ff ff c3 84' | xxd -r -p | puft 2> /dev/null || test $$? -eq 248 37 | @echo '04 00 24 e9 ff ff' | xxd -r -p | puft 2> /dev/null || test $$? -eq 250 38 | @echo '04 00 24 e9 ff 6d' | xxd -r -p | puft 2> /dev/null || test $$? -eq 247 39 | @gcov -n puff.c 40 | 41 | clean: 42 | rm -f puff puft *.o *.gc* 43 | -------------------------------------------------------------------------------- /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; 44 | char buf[4]; 45 | 46 | s = time(0); 47 | 48 | t = localtime(&s); 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/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 | -------------------------------------------------------------------------------- /lib/zlib/contrib/minizip/miniunzip.1: -------------------------------------------------------------------------------- 1 | .\" Hey, EMACS: -*- nroff -*- 2 | .TH miniunzip 1 "Nov 7, 2001" 3 | .\" Please adjust this date whenever revising the manpage. 4 | .\" 5 | .\" Some roff macros, for reference: 6 | .\" .nh disable hyphenation 7 | .\" .hy enable hyphenation 8 | .\" .ad l left justify 9 | .\" .ad b justify to both left and right margins 10 | .\" .nf disable filling 11 | .\" .fi enable filling 12 | .\" .br insert line break 13 | .\" .sp insert n+1 empty lines 14 | .\" for manpage-specific macros, see man(7) 15 | .SH NAME 16 | miniunzip - uncompress and examine ZIP archives 17 | .SH SYNOPSIS 18 | .B miniunzip 19 | .RI [ -exvlo ] 20 | zipfile [ files_to_extract ] [-d tempdir] 21 | .SH DESCRIPTION 22 | .B minizip 23 | is a simple tool which allows the extraction of compressed file 24 | archives in the ZIP format used by the MS-DOS utility PKZIP. It was 25 | written as a demonstration of the 26 | .IR zlib (3) 27 | library and therefore lack many of the features of the 28 | .IR unzip (1) 29 | program. 30 | .SH OPTIONS 31 | A number of options are supported. With the exception of 32 | .BI \-d\ tempdir 33 | these must be supplied before any 34 | other arguments and are: 35 | .TP 36 | .BI \-l\ ,\ \-\-v 37 | List the files in the archive without extracting them. 38 | .TP 39 | .B \-o 40 | Overwrite files without prompting for confirmation. 41 | .TP 42 | .B \-x 43 | Extract files (default). 44 | .PP 45 | The 46 | .I zipfile 47 | argument is the name of the archive to process. The next argument can be used 48 | to specify a single file to extract from the archive. 49 | 50 | Lastly, the following option can be specified at the end of the command-line: 51 | .TP 52 | .BI \-d\ tempdir 53 | Extract the archive in the directory 54 | .I tempdir 55 | rather than the current directory. 56 | .SH SEE ALSO 57 | .BR minizip (1), 58 | .BR zlib (3), 59 | .BR unzip (1). 60 | .SH AUTHOR 61 | This program was written by Gilles Vollant. This manual page was 62 | written by Mark Brown . The -d tempdir option 63 | was added by Dirk Eddelbuettel . 64 | -------------------------------------------------------------------------------- /lib/zlib/amiga/Makefile.sas: -------------------------------------------------------------------------------- 1 | # SMakefile for zlib 2 | # Modified from the standard UNIX Makefile Copyright Jean-loup Gailly 3 | # Osma Ahvenlampi 4 | # Amiga, SAS/C 6.56 & Smake 5 | 6 | CC=sc 7 | CFLAGS=OPT 8 | #CFLAGS=OPT CPU=68030 9 | #CFLAGS=DEBUG=LINE 10 | LDFLAGS=LIB z.lib 11 | 12 | SCOPTIONS=OPTSCHED OPTINLINE OPTALIAS OPTTIME OPTINLOCAL STRMERGE \ 13 | NOICONS PARMS=BOTH NOSTACKCHECK UTILLIB NOVERSION ERRORREXX \ 14 | DEF=POSTINC 15 | 16 | OBJS = adler32.o compress.o crc32.o gzclose.o gzlib.o gzread.o gzwrite.o \ 17 | uncompr.o deflate.o trees.o zutil.o inflate.o infback.o inftrees.o inffast.o 18 | 19 | TEST_OBJS = example.o minigzip.o 20 | 21 | all: SCOPTIONS example minigzip 22 | 23 | check: test 24 | test: all 25 | example 26 | echo hello world | minigzip | minigzip -d 27 | 28 | install: z.lib 29 | copy clone zlib.h zconf.h INCLUDE: 30 | copy clone z.lib LIB: 31 | 32 | z.lib: $(OBJS) 33 | oml z.lib r $(OBJS) 34 | 35 | example: example.o z.lib 36 | $(CC) $(CFLAGS) LINK TO $@ example.o $(LDFLAGS) 37 | 38 | minigzip: minigzip.o z.lib 39 | $(CC) $(CFLAGS) LINK TO $@ minigzip.o $(LDFLAGS) 40 | 41 | mostlyclean: clean 42 | clean: 43 | -delete force quiet example minigzip *.o z.lib foo.gz *.lnk SCOPTIONS 44 | 45 | SCOPTIONS: Makefile.sas 46 | copy to $@ 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 | -------------------------------------------------------------------------------- /src/os/win32/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 | typedef DWORD ngx_pid_t; 13 | #define NGX_INVALID_PID 0 14 | 15 | 16 | #define ngx_getpid GetCurrentProcessId 17 | #define ngx_log_pid ngx_pid 18 | 19 | 20 | #define NGX_PROCESS_SYNC_NAME \ 21 | (sizeof("ngx_cache_manager_mutex_") + NGX_INT32_LEN) 22 | 23 | 24 | typedef struct { 25 | HANDLE handle; 26 | ngx_pid_t pid; 27 | char *name; 28 | 29 | HANDLE term; 30 | HANDLE quit; 31 | HANDLE reopen; 32 | 33 | u_char term_event[NGX_PROCESS_SYNC_NAME]; 34 | u_char quit_event[NGX_PROCESS_SYNC_NAME]; 35 | u_char reopen_event[NGX_PROCESS_SYNC_NAME]; 36 | 37 | unsigned just_spawn:1; 38 | unsigned exiting:1; 39 | } ngx_process_t; 40 | 41 | 42 | typedef struct { 43 | char *path; 44 | char *name; 45 | char *args; 46 | char *const *argv; 47 | char *const *envp; 48 | HANDLE child; 49 | } ngx_exec_ctx_t; 50 | 51 | 52 | ngx_pid_t ngx_spawn_process(ngx_cycle_t *cycle, char *name, ngx_int_t respawn); 53 | ngx_pid_t ngx_execute(ngx_cycle_t *cycle, ngx_exec_ctx_t *ctx); 54 | 55 | #define ngx_debug_point() 56 | #define ngx_sched_yield() SwitchToThread() 57 | 58 | 59 | #define NGX_MAX_PROCESSES (MAXIMUM_WAIT_OBJECTS - 4) 60 | 61 | #define NGX_PROCESS_RESPAWN -2 62 | #define NGX_PROCESS_JUST_RESPAWN -3 63 | 64 | 65 | extern int ngx_argc; 66 | extern char **ngx_argv; 67 | extern char **ngx_os_argv; 68 | 69 | extern ngx_int_t ngx_last_process; 70 | extern ngx_process_t ngx_processes[NGX_MAX_PROCESSES]; 71 | 72 | extern ngx_pid_t ngx_pid; 73 | 74 | 75 | #endif /* _NGX_PROCESS_H_INCLUDED_ */ 76 | -------------------------------------------------------------------------------- /lib/zlib/contrib/infback9/inflate9.h: -------------------------------------------------------------------------------- 1 | /* inflate9.h -- internal inflate state definition 2 | * Copyright (C) 1995-2003 Mark Adler 3 | * For conditions of distribution and use, see copyright notice in zlib.h 4 | */ 5 | 6 | /* WARNING: this file should *not* be used by applications. It is 7 | part of the implementation of the compression library and is 8 | subject to change. Applications should only use zlib.h. 9 | */ 10 | 11 | /* Possible inflate modes between inflate() calls */ 12 | typedef enum { 13 | TYPE, /* i: waiting for type bits, including last-flag bit */ 14 | STORED, /* i: waiting for stored size (length and complement) */ 15 | TABLE, /* i: waiting for dynamic block table lengths */ 16 | LEN, /* i: waiting for length/lit code */ 17 | DONE, /* finished check, done -- remain here until reset */ 18 | BAD /* got a data error -- remain here until reset */ 19 | } inflate_mode; 20 | 21 | /* 22 | State transitions between above modes - 23 | 24 | (most modes can go to the BAD mode -- not shown for clarity) 25 | 26 | Read deflate blocks: 27 | TYPE -> STORED or TABLE or LEN or DONE 28 | STORED -> TYPE 29 | TABLE -> LENLENS -> CODELENS -> LEN 30 | Read deflate codes: 31 | LEN -> LEN or TYPE 32 | */ 33 | 34 | /* state maintained between inflate() calls. Approximately 7K bytes. */ 35 | struct inflate_state { 36 | /* sliding window */ 37 | unsigned char FAR *window; /* allocated sliding window, if needed */ 38 | /* dynamic table building */ 39 | unsigned ncode; /* number of code length code lengths */ 40 | unsigned nlen; /* number of length code lengths */ 41 | unsigned ndist; /* number of distance code lengths */ 42 | unsigned have; /* number of code lengths in lens[] */ 43 | code FAR *next; /* next available space in codes[] */ 44 | unsigned short lens[320]; /* temporary storage for code lengths */ 45 | unsigned short work[288]; /* work area for code table building */ 46 | code codes[ENOUGH]; /* space for code tables */ 47 | }; 48 | -------------------------------------------------------------------------------- /lib/zlib/uncompr.c: -------------------------------------------------------------------------------- 1 | /* uncompr.c -- decompress a memory buffer 2 | * Copyright (C) 1995-2003, 2010 Jean-loup Gailly. 3 | * For conditions of distribution and use, see copyright notice in zlib.h 4 | */ 5 | 6 | /* @(#) $Id$ */ 7 | 8 | #define ZLIB_INTERNAL 9 | #include "zlib.h" 10 | 11 | /* =========================================================================== 12 | Decompresses the source buffer into the destination buffer. sourceLen is 13 | the byte length of the source buffer. Upon entry, destLen is the total 14 | size of the destination buffer, which must be large enough to hold the 15 | entire uncompressed data. (The size of the uncompressed data must have 16 | been saved previously by the compressor and transmitted to the decompressor 17 | by some mechanism outside the scope of this compression library.) 18 | Upon exit, destLen is the actual size of the compressed buffer. 19 | 20 | uncompress returns Z_OK if success, Z_MEM_ERROR if there was not 21 | enough memory, Z_BUF_ERROR if there was not enough room in the output 22 | buffer, or Z_DATA_ERROR if the input data was corrupted. 23 | */ 24 | int ZEXPORT uncompress (dest, destLen, source, sourceLen) 25 | Bytef *dest; 26 | uLongf *destLen; 27 | const Bytef *source; 28 | uLong sourceLen; 29 | { 30 | z_stream stream; 31 | int err; 32 | 33 | stream.next_in = (z_const Bytef *)source; 34 | stream.avail_in = (uInt)sourceLen; 35 | /* Check for source > 64K on 16-bit machine: */ 36 | if ((uLong)stream.avail_in != sourceLen) return Z_BUF_ERROR; 37 | 38 | stream.next_out = dest; 39 | stream.avail_out = (uInt)*destLen; 40 | if ((uLong)stream.avail_out != *destLen) return Z_BUF_ERROR; 41 | 42 | stream.zalloc = (alloc_func)0; 43 | stream.zfree = (free_func)0; 44 | 45 | err = inflateInit(&stream); 46 | if (err != Z_OK) return err; 47 | 48 | err = inflate(&stream, Z_FINISH); 49 | if (err != Z_STREAM_END) { 50 | inflateEnd(&stream); 51 | if (err == Z_NEED_DICT || (err == Z_BUF_ERROR && stream.avail_in == 0)) 52 | return Z_DATA_ERROR; 53 | return err; 54 | } 55 | *destLen = stream.total_out; 56 | 57 | err = inflateEnd(&stream); 58 | return err; 59 | } 60 | -------------------------------------------------------------------------------- /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 | -------------------------------------------------------------------------------- /lib/zlib/INDEX: -------------------------------------------------------------------------------- 1 | CMakeLists.txt cmake build file 2 | ChangeLog history of changes 3 | FAQ Frequently Asked Questions about zlib 4 | INDEX this file 5 | Makefile dummy Makefile that tells you to ./configure 6 | Makefile.in template for Unix Makefile 7 | README guess what 8 | configure configure script for Unix 9 | make_vms.com makefile for VMS 10 | test/example.c zlib usages examples for build testing 11 | test/minigzip.c minimal gzip-like functionality for build testing 12 | test/infcover.c inf*.c code coverage for build coverage testing 13 | treebuild.xml XML description of source file dependencies 14 | zconf.h.cmakein zconf.h template for cmake 15 | zconf.h.in zconf.h template for configure 16 | zlib.3 Man page for zlib 17 | zlib.3.pdf Man page in PDF format 18 | zlib.map Linux symbol information 19 | zlib.pc.in Template for pkg-config descriptor 20 | zlib.pc.cmakein zlib.pc template for cmake 21 | zlib2ansi perl script to convert source files for C++ compilation 22 | 23 | amiga/ makefiles for Amiga SAS C 24 | as400/ makefiles for AS/400 25 | doc/ documentation for formats and algorithms 26 | msdos/ makefiles for MSDOS 27 | nintendods/ makefile for Nintendo DS 28 | old/ makefiles for various architectures and zlib documentation 29 | files that have not yet been updated for zlib 1.2.x 30 | qnx/ makefiles for QNX 31 | watcom/ makefiles for OpenWatcom 32 | win32/ makefiles for Windows 33 | 34 | zlib public header files (required for library use): 35 | zconf.h 36 | zlib.h 37 | 38 | private source files used to build the zlib library: 39 | adler32.c 40 | compress.c 41 | crc32.c 42 | crc32.h 43 | deflate.c 44 | deflate.h 45 | gzclose.c 46 | gzguts.h 47 | gzlib.c 48 | gzread.c 49 | gzwrite.c 50 | infback.c 51 | inffast.c 52 | inffast.h 53 | inffixed.h 54 | inflate.c 55 | inflate.h 56 | inftrees.c 57 | inftrees.h 58 | trees.c 59 | trees.h 60 | uncompr.c 61 | zutil.c 62 | zutil.h 63 | 64 | source files for sample programs 65 | See examples/README.examples 66 | 67 | unsupported contributions by third parties 68 | See contrib/README.contrib 69 | -------------------------------------------------------------------------------- /lib/zlib/amiga/Makefile.pup: -------------------------------------------------------------------------------- 1 | # Amiga powerUP (TM) Makefile 2 | # makefile for libpng and SAS C V6.58/7.00 PPC compiler 3 | # Copyright (C) 1998 by Andreas R. Kleinert 4 | 5 | LIBNAME = libzip.a 6 | 7 | CC = scppc 8 | CFLAGS = NOSTKCHK NOSINT OPTIMIZE OPTGO OPTPEEP OPTINLOCAL OPTINL \ 9 | OPTLOOP OPTRDEP=8 OPTDEP=8 OPTCOMP=8 NOVER 10 | AR = ppc-amigaos-ar cr 11 | RANLIB = ppc-amigaos-ranlib 12 | LD = ppc-amigaos-ld -r 13 | LDFLAGS = -o 14 | LDLIBS = LIB:scppc.a LIB:end.o 15 | RM = delete quiet 16 | 17 | OBJS = adler32.o compress.o crc32.o gzclose.o gzlib.o gzread.o gzwrite.o \ 18 | uncompr.o deflate.o trees.o zutil.o inflate.o infback.o inftrees.o inffast.o 19 | 20 | TEST_OBJS = example.o minigzip.o 21 | 22 | all: example minigzip 23 | 24 | check: test 25 | test: all 26 | example 27 | echo hello world | minigzip | minigzip -d 28 | 29 | $(LIBNAME): $(OBJS) 30 | $(AR) $@ $(OBJS) 31 | -$(RANLIB) $@ 32 | 33 | example: example.o $(LIBNAME) 34 | $(LD) $(LDFLAGS) $@ LIB:c_ppc.o $@.o $(LIBNAME) $(LDLIBS) 35 | 36 | minigzip: minigzip.o $(LIBNAME) 37 | $(LD) $(LDFLAGS) $@ LIB:c_ppc.o $@.o $(LIBNAME) $(LDLIBS) 38 | 39 | mostlyclean: clean 40 | clean: 41 | $(RM) *.o example minigzip $(LIBNAME) foo.gz 42 | 43 | zip: 44 | zip -ul9 zlib README ChangeLog Makefile Make????.??? Makefile.?? \ 45 | descrip.mms *.[ch] 46 | 47 | tgz: 48 | cd ..; tar cfz zlib/zlib.tgz zlib/README zlib/ChangeLog zlib/Makefile \ 49 | zlib/Make????.??? zlib/Makefile.?? zlib/descrip.mms zlib/*.[ch] 50 | 51 | # DO NOT DELETE THIS LINE -- make depend depends on it. 52 | 53 | adler32.o: zlib.h zconf.h 54 | compress.o: zlib.h zconf.h 55 | crc32.o: crc32.h zlib.h zconf.h 56 | deflate.o: deflate.h zutil.h zlib.h zconf.h 57 | example.o: zlib.h zconf.h 58 | gzclose.o: zlib.h zconf.h gzguts.h 59 | gzlib.o: zlib.h zconf.h gzguts.h 60 | gzread.o: zlib.h zconf.h gzguts.h 61 | gzwrite.o: zlib.h zconf.h gzguts.h 62 | inffast.o: zutil.h zlib.h zconf.h inftrees.h inflate.h inffast.h 63 | inflate.o: zutil.h zlib.h zconf.h inftrees.h inflate.h inffast.h 64 | infback.o: zutil.h zlib.h zconf.h inftrees.h inflate.h inffast.h 65 | inftrees.o: zutil.h zlib.h zconf.h inftrees.h 66 | minigzip.o: zlib.h zconf.h 67 | trees.o: deflate.h zutil.h zlib.h zconf.h trees.h 68 | uncompr.o: zlib.h zconf.h 69 | zutil.o: zutil.h zlib.h zconf.h 70 | -------------------------------------------------------------------------------- /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 | -------------------------------------------------------------------------------- /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 | -------------------------------------------------------------------------------- /lib/pcre/pcre16_get.c: -------------------------------------------------------------------------------- 1 | /************************************************* 2 | * Perl-Compatible Regular Expressions * 3 | *************************************************/ 4 | 5 | /* PCRE is a library of functions to support regular expressions whose syntax 6 | and semantics are as close as possible to those of the Perl 5 language. 7 | 8 | Written by Philip Hazel 9 | Copyright (c) 1997-2012 University of Cambridge 10 | 11 | ----------------------------------------------------------------------------- 12 | Redistribution and use in source and binary forms, with or without 13 | modification, are permitted provided that the following conditions are met: 14 | 15 | * Redistributions of source code must retain the above copyright notice, 16 | this list of conditions and the following disclaimer. 17 | 18 | * Redistributions in binary form must reproduce the above copyright 19 | notice, this list of conditions and the following disclaimer in the 20 | documentation and/or other materials provided with the distribution. 21 | 22 | * Neither the name of the University of Cambridge nor the names of its 23 | contributors may be used to endorse or promote products derived from 24 | this software without specific prior written permission. 25 | 26 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 27 | AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 28 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 29 | ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 30 | LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 31 | CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 32 | SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 33 | INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 34 | CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 35 | ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 36 | POSSIBILITY OF SUCH DAMAGE. 37 | ----------------------------------------------------------------------------- 38 | */ 39 | 40 | /* Generate code with 16 bit character support. */ 41 | #define COMPILE_PCRE16 42 | 43 | #include "pcre_get.c" 44 | 45 | /* End of pcre16_get.c */ 46 | -------------------------------------------------------------------------------- /lib/pcre/pcre16_ucd.c: -------------------------------------------------------------------------------- 1 | /************************************************* 2 | * Perl-Compatible Regular Expressions * 3 | *************************************************/ 4 | 5 | /* PCRE is a library of functions to support regular expressions whose syntax 6 | and semantics are as close as possible to those of the Perl 5 language. 7 | 8 | Written by Philip Hazel 9 | Copyright (c) 1997-2012 University of Cambridge 10 | 11 | ----------------------------------------------------------------------------- 12 | Redistribution and use in source and binary forms, with or without 13 | modification, are permitted provided that the following conditions are met: 14 | 15 | * Redistributions of source code must retain the above copyright notice, 16 | this list of conditions and the following disclaimer. 17 | 18 | * Redistributions in binary form must reproduce the above copyright 19 | notice, this list of conditions and the following disclaimer in the 20 | documentation and/or other materials provided with the distribution. 21 | 22 | * Neither the name of the University of Cambridge nor the names of its 23 | contributors may be used to endorse or promote products derived from 24 | this software without specific prior written permission. 25 | 26 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 27 | AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 28 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 29 | ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 30 | LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 31 | CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 32 | SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 33 | INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 34 | CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 35 | ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 36 | POSSIBILITY OF SUCH DAMAGE. 37 | ----------------------------------------------------------------------------- 38 | */ 39 | 40 | /* Generate code with 16 bit character support. */ 41 | #define COMPILE_PCRE16 42 | 43 | #include "pcre_ucd.c" 44 | 45 | /* End of pcre16_ucd.c */ 46 | --------------------------------------------------------------------------------