Compare commits
32 Commits
quic
...
stable-1.1
| Author | SHA1 | Date |
|---|---|---|
Maxim Dounin
|
cd77112843 | |
|
Maxim Dounin
|
668544d45f | |
|
Maxim Dounin
|
e749093a79 | |
|
Maxim Dounin
|
c88dcb8feb | |
|
Maxim Dounin
|
f5cc8c42e1 | |
|
Maxim Dounin
|
93ed5b65ed | |
|
Maxim Dounin
|
98f36d7a37 | |
|
Maxim Dounin
|
9c8a86bc9e | |
|
Maxim Dounin
|
843593a7a1 | |
|
Maxim Dounin
|
e4be6e9d4d | |
|
Maxim Dounin
|
704c86a23b | |
|
Maxim Dounin
|
253e6f3ead | |
|
Maxim Dounin
|
52b6141b16 | |
|
Maxim Dounin
|
fa02cacff8 | |
|
Maxim Dounin
|
fdbb12cb01 | |
|
Maxim Dounin
|
aa8c49d43e | |
|
Maxim Dounin
|
31ad23c40d | |
Roman Arutyunyan
|
a7a34f2019 | |
|
Maxim Dounin
|
434b9d68ec | |
Sergey Kandaurov
|
9437578786 | |
|
Maxim Dounin
|
3f247c4b87 | |
|
Maxim Dounin
|
d61dda3f77 | |
|
Maxim Dounin
|
3455e7ceb7 | |
|
Maxim Dounin
|
bc44cde25c | |
Ruslan Ermilov
|
416bbdcff3 | |
|
Ruslan Ermilov
|
5f1bba7d82 | |
|
Roman Arutyunyan
|
07b5f8e603 | |
|
Maxim Dounin
|
b4b96440a6 | |
|
Maxim Dounin
|
78c1327437 | |
|
Maxim Dounin
|
6f27a99d54 | |
|
Maxim Dounin
|
8c010c56f5 | |
|
Maxim Dounin
|
2f9748ef7b |
389
README
389
README
|
|
@ -1,389 +0,0 @@
|
|||
Experimental QUIC support for nginx
|
||||
-----------------------------------
|
||||
|
||||
1. Introduction
|
||||
2. Building from sources
|
||||
3. Configuration
|
||||
4. Directives
|
||||
5. Clients
|
||||
6. Troubleshooting
|
||||
7. Contributing
|
||||
8. Links
|
||||
|
||||
1. Introduction
|
||||
|
||||
This is an experimental QUIC [1] / HTTP/3 [2] support for nginx.
|
||||
|
||||
The code is developed in a separate "quic" branch available
|
||||
at https://hg.nginx.org/nginx-quic. Currently it is based
|
||||
on nginx mainline 1.23.x. We merge new nginx releases into
|
||||
this branch regularly.
|
||||
|
||||
The project code base is under the same BSD license as nginx.
|
||||
|
||||
The code is currently at a beta level of quality, however
|
||||
there are several production deployments with it.
|
||||
|
||||
NGINX Development Team is working on improving HTTP/3 support to
|
||||
integrate it into the main NGINX codebase. Thus, expect further
|
||||
updates of this code, including features, changes in behaviour,
|
||||
bug fixes, and refactoring. NGINX Development team will be
|
||||
grateful for any feedback and code submissions.
|
||||
|
||||
Please contact NGINX Development Team via nginx-devel mailing list [3].
|
||||
|
||||
What works now:
|
||||
|
||||
IETF QUIC version 1 is supported. Internet drafts are no longer supported.
|
||||
|
||||
nginx should be able to respond to HTTP/3 requests over QUIC and
|
||||
it should be possible to upload and download big files without errors.
|
||||
|
||||
+ The handshake completes successfully
|
||||
+ One endpoint can update keys and its peer responds correctly
|
||||
+ 0-RTT data is being received and acted on
|
||||
+ Connection is established using TLS Resume Ticket
|
||||
+ A handshake that includes a Retry packet completes successfully
|
||||
+ Stream data is being exchanged and ACK'ed
|
||||
+ An H3 transaction succeeded
|
||||
+ One or both endpoints insert entries into dynamic table and
|
||||
subsequently reference them from header blocks
|
||||
+ Version Negotiation packet is sent to client with unknown version
|
||||
+ Lost packets are detected and retransmitted properly
|
||||
+ Clients may migrate to new address
|
||||
|
||||
2. Building from sources
|
||||
|
||||
The build is configured using the configure command.
|
||||
Refer to http://nginx.org/en/docs/configure.html for details.
|
||||
|
||||
When configuring nginx, it's possible to enable QUIC and HTTP/3
|
||||
using the following new configuration options:
|
||||
|
||||
--with-http_v3_module - enable QUIC and HTTP/3
|
||||
--with-stream_quic_module - enable QUIC in Stream
|
||||
|
||||
A library that provides QUIC support is recommended to build nginx, there
|
||||
are several of those available on the market:
|
||||
+ BoringSSL [4]
|
||||
+ LibreSSL [5]
|
||||
+ QuicTLS [6]
|
||||
|
||||
Alternatively, nginx can be configured with OpenSSL compatibility
|
||||
layer, which emulates BoringSSL QUIC API for OpenSSL. This mode is
|
||||
enabled by default if native QUIC support is not detected.
|
||||
0-RTT is not supported in OpenSSL compatibility mode.
|
||||
|
||||
Clone the NGINX QUIC repository
|
||||
|
||||
$ hg clone -b quic https://hg.nginx.org/nginx-quic
|
||||
$ cd nginx-quic
|
||||
|
||||
Use the following command to configure nginx with BoringSSL [4]
|
||||
|
||||
$ ./auto/configure --with-debug --with-http_v3_module \
|
||||
--with-cc-opt="-I../boringssl/include" \
|
||||
--with-ld-opt="-L../boringssl/build/ssl \
|
||||
-L../boringssl/build/crypto"
|
||||
$ make
|
||||
|
||||
Alternatively, nginx can be configured with QuicTLS [6]
|
||||
|
||||
$ ./auto/configure --with-debug --with-http_v3_module \
|
||||
--with-cc-opt="-I../quictls/build/include" \
|
||||
--with-ld-opt="-L../quictls/build/lib"
|
||||
|
||||
Alternatively, nginx can be configured with a modern version
|
||||
of LibreSSL [7]
|
||||
|
||||
$ ./auto/configure --with-debug --with-http_v3_module \
|
||||
--with-cc-opt="-I../libressl/build/include" \
|
||||
--with-ld-opt="-L../libressl/build/lib"
|
||||
|
||||
3. Configuration
|
||||
|
||||
The HTTP "listen" directive got a new option "quic" which enables
|
||||
QUIC as client transport protocol instead of TCP.
|
||||
|
||||
The Stream "listen" directive got a new option "quic" which enables
|
||||
QUIC as client transport protocol instead of TCP or plain UDP.
|
||||
|
||||
Along with "quic", it's also possible to specify "reuseport"
|
||||
option [8] to make it work properly with multiple workers.
|
||||
|
||||
To enable address validation:
|
||||
|
||||
quic_retry on;
|
||||
|
||||
To enable 0-RTT:
|
||||
|
||||
ssl_early_data on;
|
||||
|
||||
Make sure that TLS 1.3 is configured which is required for QUIC:
|
||||
|
||||
ssl_protocols TLSv1.3;
|
||||
|
||||
To enable GSO (Generic Segmentation Offloading):
|
||||
|
||||
quic_gso on;
|
||||
|
||||
To limit maximum UDP payload size on receive path:
|
||||
|
||||
quic_mtu <size>;
|
||||
|
||||
To set host key for various tokens:
|
||||
|
||||
quic_host_key <filename>;
|
||||
|
||||
|
||||
By default, GSO Linux-specific optimization [10] is disabled.
|
||||
Enable it in case a corresponding network interface is configured to
|
||||
support GSO.
|
||||
|
||||
A number of directives were added that configure HTTP/3:
|
||||
|
||||
http3
|
||||
http3_hq
|
||||
http3_stream_buffer_size
|
||||
http3_max_concurrent_pushes
|
||||
http3_max_concurrent_streams
|
||||
http3_push
|
||||
http3_push_preload
|
||||
|
||||
In http, an additional variable is available: $http3.
|
||||
The value of $http3 is "h3" for HTTP/3 connections,
|
||||
"hq" for hq connections, or an empty string otherwise.
|
||||
|
||||
In stream, an additional variable is available: $quic.
|
||||
The value of $quic is "quic" if QUIC connection is used,
|
||||
or an empty string otherwise.
|
||||
|
||||
Example configuration:
|
||||
|
||||
http {
|
||||
log_format quic '$remote_addr - $remote_user [$time_local] '
|
||||
'"$request" $status $body_bytes_sent '
|
||||
'"$http_referer" "$http_user_agent" "$http3"';
|
||||
|
||||
access_log logs/access.log quic;
|
||||
|
||||
server {
|
||||
# for better compatibility it's recommended
|
||||
# to use the same port for quic and https
|
||||
listen 8443 quic reuseport;
|
||||
listen 8443 ssl;
|
||||
|
||||
ssl_certificate certs/example.com.crt;
|
||||
ssl_certificate_key certs/example.com.key;
|
||||
ssl_protocols TLSv1.3;
|
||||
|
||||
location / {
|
||||
# required for browsers to direct them into quic port
|
||||
add_header Alt-Svc 'h3=":8443"; ma=86400';
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
4. Directives
|
||||
|
||||
Syntax: quic_bpf on | off;
|
||||
Default: quic_bpf off;
|
||||
Context: main
|
||||
|
||||
Enables routing of QUIC packets using eBPF.
|
||||
When enabled, this allows to support QUIC connection migration.
|
||||
The directive is only supported on Linux 5.7+.
|
||||
|
||||
|
||||
Syntax: quic_retry on | off;
|
||||
Default: quic_retry off;
|
||||
Context: http | stream, server
|
||||
|
||||
Enables the QUIC Address Validation feature. This includes:
|
||||
- sending a new token in a Retry packet or a NEW_TOKEN frame
|
||||
- validating a token received in the Initial packet
|
||||
|
||||
|
||||
Syntax: quic_gso on | off;
|
||||
Default: quic_gso off;
|
||||
Context: http | stream, server
|
||||
|
||||
Enables sending in optimized batch mode using segmentation offloading.
|
||||
Optimized sending is only supported on Linux featuring UDP_SEGMENT.
|
||||
|
||||
|
||||
Syntax: quic_mtu size;
|
||||
Default: quic_mtu 65527;
|
||||
Context: http | stream, server
|
||||
|
||||
Sets the QUIC max_udp_payload_size transport parameter value.
|
||||
This is the maximum UDP payload that we are willing to receive.
|
||||
|
||||
|
||||
Syntax: quic_host_key file;
|
||||
Default: -
|
||||
Context: http | stream, server
|
||||
|
||||
Specifies a file with the secret key used to encrypt stateless reset and
|
||||
address validation tokens. By default, a randomly generated key is used.
|
||||
|
||||
|
||||
Syntax: quic_active_connection_id_limit number;
|
||||
Default: quic_active_connection_id_limit 2;
|
||||
Context: http | stream, server
|
||||
|
||||
Sets the QUIC active_connection_id_limit transport parameter value.
|
||||
This is the maximum number of connection IDs we are willing to store.
|
||||
|
||||
|
||||
Syntax: quic_timeout time;
|
||||
Default: quic_timeout 60s;
|
||||
Context: stream, server
|
||||
|
||||
Defines a timeout used to negotiate the QUIC idle timeout.
|
||||
In the http module, it is taken from the keepalive_timeout directive.
|
||||
|
||||
|
||||
Syntax: quic_stream_buffer_size size;
|
||||
Default: quic_stream_buffer_size 64k;
|
||||
Context: stream, server
|
||||
|
||||
Syntax: http3_stream_buffer_size size;
|
||||
Default: http3_stream_buffer_size 64k;
|
||||
Context: http, server
|
||||
|
||||
Sets buffer size for reading and writing of the QUIC STREAM payload.
|
||||
The buffer size is used to calculate initial flow control limits
|
||||
in the following QUIC transport parameters:
|
||||
- initial_max_data
|
||||
- initial_max_stream_data_bidi_local
|
||||
- initial_max_stream_data_bidi_remote
|
||||
- initial_max_stream_data_uni
|
||||
|
||||
|
||||
Syntax: http3_max_concurrent_pushes number;
|
||||
Default: http3_max_concurrent_pushes 10;
|
||||
Context: http, server
|
||||
|
||||
Limits the maximum number of concurrent push requests in a connection.
|
||||
|
||||
|
||||
Syntax: http3_max_concurrent_streams number;
|
||||
Default: http3_max_concurrent_streams 128;
|
||||
Context: http, server
|
||||
|
||||
Sets the maximum number of concurrent HTTP/3 streams in a connection.
|
||||
|
||||
|
||||
Syntax: http3_push uri | off;
|
||||
Default: http3_push off;
|
||||
Context: http, server, location
|
||||
|
||||
Pre-emptively sends (pushes) a request to the specified uri along with
|
||||
the response to the original request. Only relative URIs with absolute
|
||||
path will be processed, for example:
|
||||
|
||||
http3_push /static/css/main.css;
|
||||
|
||||
The uri value can contain variables.
|
||||
|
||||
Several http3_push directives can be specified on the same configuration
|
||||
level. The off parameter cancels the effect of the http3_push directives
|
||||
inherited from the previous configuration level.
|
||||
|
||||
|
||||
Syntax: http3_push_preload on | off;
|
||||
Default: http3_push_preload off;
|
||||
Context: http, server, location
|
||||
|
||||
Enables automatic conversion of preload links specified in the “Link”
|
||||
response header fields into push requests.
|
||||
|
||||
|
||||
Syntax: http3 on | off;
|
||||
Default: http3 on;
|
||||
Context: http, server
|
||||
|
||||
Enables HTTP/3 protocol negotiation.
|
||||
|
||||
|
||||
Syntax: http3_hq on | off;
|
||||
Default: http3_hq off;
|
||||
Context: http, server
|
||||
|
||||
Enables HTTP/0.9 protocol negotiation used in QUIC interoperability tests.
|
||||
|
||||
5. Clients
|
||||
|
||||
* Browsers
|
||||
|
||||
Known to work: Firefox 90+ and Chrome 92+ (QUIC version 1)
|
||||
|
||||
Beware of strange issues: sometimes browser may decide to ignore QUIC
|
||||
Cache clearing/restart might help. Always check access.log and
|
||||
error.log to make sure the browser is using HTTP/3 and not TCP https.
|
||||
|
||||
* Console clients
|
||||
|
||||
Known to work: ngtcp2, firefox's neqo and chromium's console clients:
|
||||
|
||||
$ examples/client 127.0.0.1 8443 https://example.com:8443/index.html
|
||||
|
||||
$ ./neqo-client https://127.0.0.1:8443/
|
||||
|
||||
$ chromium-build/out/my_build/quic_client http://example.com:8443
|
||||
|
||||
|
||||
In case everyhing is right, the access log should show something like:
|
||||
|
||||
127.0.0.1 - - [24/Apr/2020:11:27:29 +0300] "GET / HTTP/3" 200 805 "-"
|
||||
"nghttp3/ngtcp2 client" "quic"
|
||||
|
||||
|
||||
6. Troubleshooting
|
||||
|
||||
Here are some tips that may help to identify problems:
|
||||
|
||||
+ Ensure nginx is built with proper SSL library that supports QUIC
|
||||
|
||||
+ Ensure nginx is using the proper SSL library in runtime
|
||||
(`nginx -V` shows what it's using)
|
||||
|
||||
+ Ensure a client is actually sending requests over QUIC
|
||||
(see "Clients" section about browsers and cache)
|
||||
|
||||
We recommend to start with simple console client like ngtcp2
|
||||
to ensure the server is configured properly before trying
|
||||
with real browsers that may be very picky with certificates,
|
||||
for example.
|
||||
|
||||
+ Build nginx with debug support [9] and check the debug log.
|
||||
It should contain all details about connection and why it
|
||||
failed. All related messages contain "quic " prefix and can
|
||||
be easily filtered out.
|
||||
|
||||
+ For a deeper investigation, please enable additional debugging
|
||||
in src/event/quic/ngx_event_quic_connection.h:
|
||||
|
||||
#define NGX_QUIC_DEBUG_PACKETS
|
||||
#define NGX_QUIC_DEBUG_FRAMES
|
||||
#define NGX_QUIC_DEBUG_ALLOC
|
||||
#define NGX_QUIC_DEBUG_CRYPTO
|
||||
|
||||
7. Contributing
|
||||
|
||||
Please refer to
|
||||
http://nginx.org/en/docs/contributing_changes.html
|
||||
|
||||
8. Links
|
||||
|
||||
[1] https://datatracker.ietf.org/doc/html/rfc9000
|
||||
[2] https://datatracker.ietf.org/doc/html/rfc9114
|
||||
[3] https://mailman.nginx.org/mailman/listinfo/nginx-devel
|
||||
[4] https://boringssl.googlesource.com/boringssl/
|
||||
[5] https://www.libressl.org/
|
||||
[6] https://github.com/quictls/openssl
|
||||
[7] https://github.com/libressl-portable/portable/releases/tag/v3.6.0
|
||||
[8] https://nginx.org/en/docs/http/ngx_http_core_module.html#listen
|
||||
[9] https://nginx.org/en/docs/debugging_log.html
|
||||
[10] http://vger.kernel.org/lpc_net2018_talks/willemdebruijn-lpc2018-udpgso-paper-DRAFT-1.pdf
|
||||
|
|
@ -6,8 +6,7 @@
|
|||
|
||||
|
||||
NGX_CLANG_VER=`$CC -v 2>&1 | grep 'version' 2>&1 \
|
||||
| sed -n -e 's/^.*clang version \(.*\)/\1/p' \
|
||||
-e 's/^.*LLVM version \(.*\)/\1/p'`
|
||||
| sed -e 's/^.* version \(.*\)/\1/'`
|
||||
|
||||
echo " + clang version: $NGX_CLANG_VER"
|
||||
|
||||
|
|
|
|||
|
|
@ -117,7 +117,7 @@ else
|
|||
. auto/cc/acc
|
||||
;;
|
||||
|
||||
msvc)
|
||||
msvc*)
|
||||
# MSVC++ 6.0 SP2, MSVC++ Toolkit 2003
|
||||
|
||||
. auto/cc/msvc
|
||||
|
|
|
|||
21
auto/cc/msvc
21
auto/cc/msvc
|
|
@ -11,8 +11,8 @@
|
|||
# MSVC 2015 (14.0) cl 19.00
|
||||
|
||||
|
||||
NGX_MSVC_VER=`$NGX_WINE $CC 2>&1 | grep 'C/C++.* [0-9][0-9]*\.[0-9]' 2>&1 \
|
||||
| sed -e 's/^.* \([0-9][0-9]*\.[0-9].*\)/\1/'`
|
||||
NGX_MSVC_VER=`$NGX_WINE $CC 2>&1 | grep 'Compiler Version' 2>&1 \
|
||||
| sed -e 's/^.* Version \(.*\)/\1/'`
|
||||
|
||||
echo " + cl version: $NGX_MSVC_VER"
|
||||
|
||||
|
|
@ -22,21 +22,6 @@ have=NGX_COMPILER value="\"cl $NGX_MSVC_VER\"" . auto/define
|
|||
ngx_msvc_ver=`echo $NGX_MSVC_VER | sed -e 's/^\([0-9]*\).*/\1/'`
|
||||
|
||||
|
||||
# detect x64 builds
|
||||
|
||||
case "$NGX_MSVC_VER" in
|
||||
|
||||
*x64)
|
||||
NGX_MACHINE=amd64
|
||||
;;
|
||||
|
||||
*)
|
||||
NGX_MACHINE=i386
|
||||
;;
|
||||
|
||||
esac
|
||||
|
||||
|
||||
# optimizations
|
||||
|
||||
# maximize speed, equivalent to -Og -Oi -Ot -Oy -Ob2 -Gs -GF -Gy
|
||||
|
|
@ -123,7 +108,7 @@ CORE_LIBS="$CORE_LIBS kernel32.lib user32.lib"
|
|||
# msvc under Wine issues
|
||||
# C1902: Program database manager mismatch; please check your installation
|
||||
if [ -z "$NGX_WINE" ]; then
|
||||
CFLAGS="$CFLAGS -Zi -Fd$NGX_OBJS/nginx.pdb"
|
||||
CFLAGS="$CFLAGS -Zi"
|
||||
CORE_LINK="$CORE_LINK -debug"
|
||||
fi
|
||||
|
||||
|
|
|
|||
|
|
@ -44,7 +44,6 @@ if test -z "$NGX_PLATFORM"; then
|
|||
else
|
||||
echo "building for $NGX_PLATFORM"
|
||||
NGX_SYSTEM=$NGX_PLATFORM
|
||||
NGX_MACHINE=i386
|
||||
fi
|
||||
|
||||
. auto/cc/conf
|
||||
|
|
@ -88,10 +87,6 @@ have=NGX_PID_PATH value="\"$NGX_PID_PATH\"" . auto/define
|
|||
have=NGX_LOCK_PATH value="\"$NGX_LOCK_PATH\"" . auto/define
|
||||
have=NGX_ERROR_LOG_PATH value="\"$NGX_ERROR_LOG_PATH\"" . auto/define
|
||||
|
||||
if [ ".$NGX_ERROR_LOG_PATH" = "." ]; then
|
||||
have=NGX_ERROR_LOG_STDERR . auto/have
|
||||
fi
|
||||
|
||||
have=NGX_HTTP_LOG_PATH value="\"$NGX_HTTP_LOG_PATH\"" . auto/define
|
||||
have=NGX_HTTP_CLIENT_TEMP_PATH value="\"$NGX_HTTP_CLIENT_TEMP_PATH\""
|
||||
. auto/define
|
||||
|
|
|
|||
|
|
@ -48,6 +48,4 @@ default: build
|
|||
|
||||
clean:
|
||||
rm -rf Makefile $NGX_OBJS
|
||||
|
||||
.PHONY: default clean
|
||||
END
|
||||
|
|
|
|||
|
|
@ -215,6 +215,4 @@ upgrade:
|
|||
test -f $NGX_PID_PATH.oldbin
|
||||
|
||||
kill -QUIT \`cat $NGX_PID_PATH.oldbin\`
|
||||
|
||||
.PHONY: build install modules upgrade
|
||||
END
|
||||
|
|
|
|||
|
|
@ -9,8 +9,7 @@
|
|||
ngx_feature_incs=
|
||||
ngx_feature_path=
|
||||
ngx_feature_libs="-lprofiler"
|
||||
ngx_feature_test="void ProfilerStop(void);
|
||||
ProfilerStop()"
|
||||
ngx_feature_test="ProfilerStop()"
|
||||
. auto/feature
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -9,8 +9,7 @@
|
|||
ngx_feature_incs="#include <gd.h>"
|
||||
ngx_feature_path=
|
||||
ngx_feature_libs="-lgd"
|
||||
ngx_feature_test="gdImagePtr img = gdImageCreateFromGifPtr(1, NULL);
|
||||
(void) img"
|
||||
ngx_feature_test="gdImagePtr img = gdImageCreateFromGifPtr(1, NULL);"
|
||||
. auto/feature
|
||||
|
||||
|
||||
|
|
@ -77,8 +76,7 @@ if [ $ngx_found = yes ]; then
|
|||
|
||||
ngx_feature="GD WebP support"
|
||||
ngx_feature_name="NGX_HAVE_GD_WEBP"
|
||||
ngx_feature_test="gdImagePtr img = gdImageCreateFromWebpPtr(1, NULL);
|
||||
(void) img"
|
||||
ngx_feature_test="gdImagePtr img = gdImageCreateFromWebpPtr(1, NULL);"
|
||||
. auto/feature
|
||||
|
||||
else
|
||||
|
|
|
|||
|
|
@ -16,8 +16,8 @@
|
|||
ngx_feature_libs="-lxml2 -lxslt"
|
||||
ngx_feature_test="xmlParserCtxtPtr ctxt = NULL;
|
||||
xsltStylesheetPtr sheet = NULL;
|
||||
xmlDocPtr doc = NULL;
|
||||
xmlParseChunk(ctxt, NULL, 0, 0);
|
||||
xmlDocPtr doc;
|
||||
doc = xmlParseChunk(ctxt, NULL, 0, 0);
|
||||
xsltApplyStylesheet(sheet, doc, NULL);"
|
||||
. auto/feature
|
||||
|
||||
|
|
|
|||
|
|
@ -5,17 +5,12 @@
|
|||
|
||||
if [ $OPENSSL != NONE ]; then
|
||||
|
||||
have=NGX_OPENSSL . auto/have
|
||||
have=NGX_SSL . auto/have
|
||||
|
||||
if [ $USE_OPENSSL_QUIC = YES ]; then
|
||||
have=NGX_QUIC . auto/have
|
||||
have=NGX_QUIC_OPENSSL_COMPAT . auto/have
|
||||
fi
|
||||
|
||||
case "$CC" in
|
||||
|
||||
cl | bcc32)
|
||||
have=NGX_OPENSSL . auto/have
|
||||
have=NGX_SSL . auto/have
|
||||
|
||||
CFLAGS="$CFLAGS -DNO_SYS_TYPES_H"
|
||||
|
||||
CORE_INCS="$CORE_INCS $OPENSSL/openssl/include"
|
||||
|
|
@ -38,6 +33,9 @@ if [ $OPENSSL != NONE ]; then
|
|||
;;
|
||||
|
||||
*)
|
||||
have=NGX_OPENSSL . auto/have
|
||||
have=NGX_SSL . auto/have
|
||||
|
||||
CORE_INCS="$CORE_INCS $OPENSSL/.openssl/include"
|
||||
CORE_DEPS="$CORE_DEPS $OPENSSL/.openssl/include/openssl/ssl.h"
|
||||
CORE_LIBS="$CORE_LIBS $OPENSSL/.openssl/lib/libssl.a"
|
||||
|
|
@ -125,35 +123,6 @@ else
|
|||
CORE_INCS="$CORE_INCS $ngx_feature_path"
|
||||
CORE_LIBS="$CORE_LIBS $ngx_feature_libs"
|
||||
OPENSSL=YES
|
||||
|
||||
if [ $USE_OPENSSL_QUIC = YES ]; then
|
||||
|
||||
ngx_feature="OpenSSL QUIC support"
|
||||
ngx_feature_name="NGX_QUIC"
|
||||
ngx_feature_test="SSL_set_quic_method(NULL, NULL)"
|
||||
. auto/feature
|
||||
|
||||
if [ $ngx_found = no ]; then
|
||||
have=NGX_QUIC_OPENSSL_COMPAT . auto/have
|
||||
|
||||
ngx_feature="OpenSSL QUIC compatibility"
|
||||
ngx_feature_test="SSL_CTX_add_custom_ext(NULL, 0, 0,
|
||||
NULL, NULL, NULL, NULL, NULL)"
|
||||
. auto/feature
|
||||
fi
|
||||
|
||||
if [ $ngx_found = no ]; then
|
||||
cat << END
|
||||
|
||||
$0: error: certain modules require OpenSSL QUIC support.
|
||||
You can either do not enable the modules, or install the OpenSSL library with
|
||||
QUIC support into the system, or build the OpenSSL library with QUIC support
|
||||
statically from the source with nginx by using --with-openssl=<path> option.
|
||||
|
||||
END
|
||||
exit 1
|
||||
fi
|
||||
fi
|
||||
fi
|
||||
fi
|
||||
|
||||
|
|
|
|||
|
|
@ -7,24 +7,11 @@ case "$CC" in
|
|||
|
||||
cl)
|
||||
|
||||
case "$NGX_MACHINE" in
|
||||
|
||||
amd64)
|
||||
OPENSSL_TARGET=VC-WIN64A
|
||||
;;
|
||||
|
||||
*)
|
||||
OPENSSL_TARGET=VC-WIN32
|
||||
;;
|
||||
|
||||
esac
|
||||
|
||||
cat << END >> $NGX_MAKEFILE
|
||||
|
||||
$OPENSSL/openssl/include/openssl/ssl.h: $NGX_MAKEFILE
|
||||
\$(MAKE) -f auto/lib/openssl/makefile.msvc \
|
||||
OPENSSL="$OPENSSL" OPENSSL_OPT="$OPENSSL_OPT" \
|
||||
OPENSSL_TARGET="$OPENSSL_TARGET"
|
||||
OPENSSL="$OPENSSL" OPENSSL_OPT="$OPENSSL_OPT"
|
||||
|
||||
END
|
||||
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
all:
|
||||
cd $(OPENSSL)
|
||||
|
||||
perl Configure $(OPENSSL_TARGET) no-shared no-threads \
|
||||
perl Configure VC-WIN32 no-shared \
|
||||
--prefix="%cd%/openssl" \
|
||||
--openssldir="%cd%/openssl/ssl" \
|
||||
$(OPENSSL_OPT)
|
||||
|
|
|
|||
|
|
@ -4,62 +4,87 @@
|
|||
|
||||
|
||||
if [ $PCRE != NONE ]; then
|
||||
CORE_INCS="$CORE_INCS $PCRE"
|
||||
|
||||
if [ -f $PCRE/src/pcre2.h.generic ]; then
|
||||
case "$NGX_CC_NAME" in
|
||||
|
||||
PCRE_LIBRARY=PCRE2
|
||||
|
||||
have=NGX_PCRE . auto/have
|
||||
have=NGX_PCRE2 . auto/have
|
||||
|
||||
if [ "$NGX_PLATFORM" = win32 ]; then
|
||||
have=PCRE2_STATIC . auto/have
|
||||
fi
|
||||
|
||||
CORE_INCS="$CORE_INCS $PCRE/src/"
|
||||
CORE_DEPS="$CORE_DEPS $PCRE/src/pcre2.h"
|
||||
|
||||
case "$NGX_CC_NAME" in
|
||||
|
||||
msvc)
|
||||
LINK_DEPS="$LINK_DEPS $PCRE/src/pcre2-8.lib"
|
||||
CORE_LIBS="$CORE_LIBS $PCRE/src/pcre2-8.lib"
|
||||
;;
|
||||
|
||||
*)
|
||||
LINK_DEPS="$LINK_DEPS $PCRE/.libs/libpcre2-8.a"
|
||||
CORE_LIBS="$CORE_LIBS $PCRE/.libs/libpcre2-8.a"
|
||||
;;
|
||||
|
||||
esac
|
||||
|
||||
else
|
||||
|
||||
PCRE_LIBRARY=PCRE
|
||||
|
||||
have=NGX_PCRE . auto/have
|
||||
|
||||
if [ "$NGX_PLATFORM" = win32 ]; then
|
||||
msvc | owc | bcc)
|
||||
have=NGX_PCRE . auto/have
|
||||
have=PCRE_STATIC . auto/have
|
||||
fi
|
||||
CORE_DEPS="$CORE_DEPS $PCRE/pcre.h"
|
||||
LINK_DEPS="$LINK_DEPS $PCRE/pcre.lib"
|
||||
CORE_LIBS="$CORE_LIBS $PCRE/pcre.lib"
|
||||
;;
|
||||
|
||||
CORE_INCS="$CORE_INCS $PCRE"
|
||||
CORE_DEPS="$CORE_DEPS $PCRE/pcre.h"
|
||||
icc)
|
||||
have=NGX_PCRE . auto/have
|
||||
CORE_DEPS="$CORE_DEPS $PCRE/pcre.h"
|
||||
|
||||
case "$NGX_CC_NAME" in
|
||||
LINK_DEPS="$LINK_DEPS $PCRE/.libs/libpcre.a"
|
||||
|
||||
msvc | owc | bcc)
|
||||
LINK_DEPS="$LINK_DEPS $PCRE/pcre.lib"
|
||||
CORE_LIBS="$CORE_LIBS $PCRE/pcre.lib"
|
||||
;;
|
||||
echo $ngx_n "checking for PCRE library ...$ngx_c"
|
||||
|
||||
*)
|
||||
LINK_DEPS="$LINK_DEPS $PCRE/.libs/libpcre.a"
|
||||
CORE_LIBS="$CORE_LIBS $PCRE/.libs/libpcre.a"
|
||||
;;
|
||||
if [ -f $PCRE/pcre.h ]; then
|
||||
ngx_pcre_ver=`grep PCRE_MAJOR $PCRE/pcre.h \
|
||||
| sed -e 's/^.*PCRE_MAJOR.* \(.*\)$/\1/'`
|
||||
|
||||
else if [ -f $PCRE/configure.in ]; then
|
||||
ngx_pcre_ver=`grep PCRE_MAJOR= $PCRE/configure.in \
|
||||
| sed -e 's/^.*=\(.*\)$/\1/'`
|
||||
|
||||
else
|
||||
ngx_pcre_ver=`grep pcre_major, $PCRE/configure.ac \
|
||||
| sed -e 's/^.*pcre_major,.*\[\(.*\)\].*$/\1/'`
|
||||
fi
|
||||
fi
|
||||
|
||||
echo " $ngx_pcre_ver major version found"
|
||||
|
||||
# to allow -ipo optimization we link with the *.o but not library
|
||||
|
||||
case "$ngx_pcre_ver" in
|
||||
4|5)
|
||||
CORE_LIBS="$CORE_LIBS $PCRE/pcre.o"
|
||||
;;
|
||||
|
||||
6)
|
||||
CORE_LIBS="$CORE_LIBS $PCRE/pcre_chartables.o"
|
||||
CORE_LIBS="$CORE_LIBS $PCRE/pcre_compile.o"
|
||||
CORE_LIBS="$CORE_LIBS $PCRE/pcre_exec.o"
|
||||
CORE_LIBS="$CORE_LIBS $PCRE/pcre_fullinfo.o"
|
||||
CORE_LIBS="$CORE_LIBS $PCRE/pcre_globals.o"
|
||||
CORE_LIBS="$CORE_LIBS $PCRE/pcre_tables.o"
|
||||
CORE_LIBS="$CORE_LIBS $PCRE/pcre_try_flipped.o"
|
||||
;;
|
||||
|
||||
*)
|
||||
CORE_LIBS="$CORE_LIBS $PCRE/pcre_chartables.o"
|
||||
CORE_LIBS="$CORE_LIBS $PCRE/pcre_compile.o"
|
||||
CORE_LIBS="$CORE_LIBS $PCRE/pcre_exec.o"
|
||||
CORE_LIBS="$CORE_LIBS $PCRE/pcre_fullinfo.o"
|
||||
CORE_LIBS="$CORE_LIBS $PCRE/pcre_globals.o"
|
||||
CORE_LIBS="$CORE_LIBS $PCRE/pcre_tables.o"
|
||||
CORE_LIBS="$CORE_LIBS $PCRE/pcre_try_flipped.o"
|
||||
CORE_LIBS="$CORE_LIBS $PCRE/pcre_newline.o"
|
||||
;;
|
||||
|
||||
esac
|
||||
;;
|
||||
|
||||
*)
|
||||
have=NGX_PCRE . auto/have
|
||||
|
||||
if [ "$NGX_PLATFORM" = win32 ]; then
|
||||
have=PCRE_STATIC . auto/have
|
||||
fi
|
||||
|
||||
CORE_DEPS="$CORE_DEPS $PCRE/pcre.h"
|
||||
LINK_DEPS="$LINK_DEPS $PCRE/.libs/libpcre.a"
|
||||
CORE_LIBS="$CORE_LIBS $PCRE/.libs/libpcre.a"
|
||||
;;
|
||||
|
||||
esac
|
||||
|
||||
esac
|
||||
fi
|
||||
|
||||
if [ $PCRE_JIT = YES ]; then
|
||||
have=NGX_HAVE_PCRE_JIT . auto/have
|
||||
|
|
@ -69,48 +94,8 @@ if [ $PCRE != NONE ]; then
|
|||
else
|
||||
|
||||
if [ "$NGX_PLATFORM" != win32 ]; then
|
||||
|
||||
PCRE=NO
|
||||
fi
|
||||
|
||||
if [ $PCRE = NO -a $PCRE2 != DISABLED ]; then
|
||||
|
||||
ngx_feature="PCRE2 library"
|
||||
ngx_feature_name="NGX_PCRE2"
|
||||
ngx_feature_run=no
|
||||
ngx_feature_incs="#define PCRE2_CODE_UNIT_WIDTH 8
|
||||
#include <pcre2.h>"
|
||||
ngx_feature_path=
|
||||
ngx_feature_libs="-lpcre2-8"
|
||||
ngx_feature_test="pcre2_code *re;
|
||||
re = pcre2_compile(NULL, 0, 0, NULL, NULL, NULL);
|
||||
if (re == NULL) return 1"
|
||||
. auto/feature
|
||||
|
||||
if [ $ngx_found = no ]; then
|
||||
|
||||
# pcre2-config
|
||||
|
||||
ngx_pcre2_prefix=`pcre2-config --prefix 2>/dev/null`
|
||||
|
||||
if [ -n "$ngx_pcre2_prefix" ]; then
|
||||
ngx_feature="PCRE2 library in $ngx_pcre2_prefix"
|
||||
ngx_feature_path=`pcre2-config --cflags \
|
||||
| sed -n -e 's/.*-I *\([^ ][^ ]*\).*/\1/p'`
|
||||
ngx_feature_libs=`pcre2-config --libs8`
|
||||
. auto/feature
|
||||
fi
|
||||
fi
|
||||
|
||||
if [ $ngx_found = yes ]; then
|
||||
have=NGX_PCRE . auto/have
|
||||
CORE_INCS="$CORE_INCS $ngx_feature_path"
|
||||
CORE_LIBS="$CORE_LIBS $ngx_feature_libs"
|
||||
PCRE=YES
|
||||
PCRE_LIBRARY=PCRE2
|
||||
fi
|
||||
fi
|
||||
|
||||
if [ $PCRE = NO ]; then
|
||||
|
||||
ngx_feature="PCRE library"
|
||||
ngx_feature_name="NGX_PCRE"
|
||||
|
|
@ -186,7 +171,6 @@ else
|
|||
CORE_INCS="$CORE_INCS $ngx_feature_path"
|
||||
CORE_LIBS="$CORE_LIBS $ngx_feature_libs"
|
||||
PCRE=YES
|
||||
PCRE_LIBRARY=PCRE
|
||||
fi
|
||||
|
||||
if [ $PCRE = YES ]; then
|
||||
|
|
|
|||
|
|
@ -3,138 +3,36 @@
|
|||
# Copyright (C) Nginx, Inc.
|
||||
|
||||
|
||||
if [ $PCRE_LIBRARY = PCRE2 ]; then
|
||||
case "$NGX_CC_NAME" in
|
||||
|
||||
# PCRE2
|
||||
msvc)
|
||||
ngx_makefile=makefile.msvc
|
||||
ngx_opt="CPU_OPT=\"$CPU_OPT\" LIBC=$LIBC"
|
||||
ngx_pcre="PCRE=\"$PCRE\""
|
||||
;;
|
||||
|
||||
if [ $NGX_CC_NAME = msvc ]; then
|
||||
owc)
|
||||
ngx_makefile=makefile.owc
|
||||
ngx_opt="CPU_OPT=\"$CPU_OPT\""
|
||||
ngx_pcre=`echo PCRE=\"$PCRE\" | sed -e "s/\//$ngx_regex_dirsep/g"`
|
||||
;;
|
||||
|
||||
# With PCRE2, it is not possible to compile all sources.
|
||||
# Since list of source files changes between versions, we
|
||||
# test files which might not be present.
|
||||
bcc)
|
||||
ngx_makefile=makefile.bcc
|
||||
ngx_opt="-DCPU_OPT=\"$CPU_OPT\""
|
||||
ngx_pcre=`echo \-DPCRE=\"$PCRE\" | sed -e "s/\//$ngx_regex_dirsep/g"`
|
||||
;;
|
||||
|
||||
ngx_pcre_srcs="pcre2_auto_possess.c \
|
||||
pcre2_chartables.c \
|
||||
pcre2_compile.c \
|
||||
pcre2_config.c \
|
||||
pcre2_context.c \
|
||||
pcre2_dfa_match.c \
|
||||
pcre2_error.c \
|
||||
pcre2_jit_compile.c \
|
||||
pcre2_maketables.c \
|
||||
pcre2_match.c \
|
||||
pcre2_match_data.c \
|
||||
pcre2_newline.c \
|
||||
pcre2_ord2utf.c \
|
||||
pcre2_pattern_info.c \
|
||||
pcre2_string_utils.c \
|
||||
pcre2_study.c \
|
||||
pcre2_substitute.c \
|
||||
pcre2_substring.c \
|
||||
pcre2_tables.c \
|
||||
pcre2_ucd.c \
|
||||
pcre2_valid_utf.c \
|
||||
pcre2_xclass.c"
|
||||
*)
|
||||
ngx_makefile=
|
||||
;;
|
||||
|
||||
ngx_pcre_test="pcre2_convert.c \
|
||||
pcre2_extuni.c \
|
||||
pcre2_find_bracket.c \
|
||||
pcre2_script_run.c \
|
||||
pcre2_serialize.c"
|
||||
|
||||
for ngx_src in $ngx_pcre_test
|
||||
do
|
||||
if [ -f $PCRE/src/$ngx_src ]; then
|
||||
ngx_pcre_srcs="$ngx_pcre_srcs $ngx_src"
|
||||
fi
|
||||
done
|
||||
|
||||
ngx_pcre_objs=`echo $ngx_pcre_srcs \
|
||||
| sed -e "s#\([^ ]*\.\)c#\1$ngx_objext#g"`
|
||||
|
||||
ngx_pcre_srcs=`echo $ngx_pcre_srcs \
|
||||
| sed -e "s/ *\([^ ][^ ]*\)/$ngx_regex_cont\1/g"`
|
||||
ngx_pcre_objs=`echo $ngx_pcre_objs \
|
||||
| sed -e "s/ *\([^ ][^ ]*\)/$ngx_regex_cont\1/g"`
|
||||
|
||||
cat << END >> $NGX_MAKEFILE
|
||||
|
||||
PCRE_CFLAGS = -O2 -Ob1 -Oi -Gs $LIBC $CPU_OPT
|
||||
PCRE_FLAGS = -DHAVE_CONFIG_H -DPCRE2_STATIC -DPCRE2_CODE_UNIT_WIDTH=8 \\
|
||||
-DHAVE_MEMMOVE
|
||||
|
||||
PCRE_SRCS = $ngx_pcre_srcs
|
||||
PCRE_OBJS = $ngx_pcre_objs
|
||||
|
||||
$PCRE/src/pcre2.h:
|
||||
cd $PCRE/src \\
|
||||
&& copy /y config.h.generic config.h \\
|
||||
&& copy /y pcre2.h.generic pcre2.h \\
|
||||
&& copy /y pcre2_chartables.c.dist pcre2_chartables.c
|
||||
|
||||
$PCRE/src/pcre2-8.lib: $PCRE/src/pcre2.h $NGX_MAKEFILE
|
||||
cd $PCRE/src \\
|
||||
&& cl -nologo -c \$(PCRE_CFLAGS) -I . \$(PCRE_FLAGS) \$(PCRE_SRCS) \\
|
||||
&& link -lib -out:pcre2-8.lib -verbose:lib \$(PCRE_OBJS)
|
||||
|
||||
END
|
||||
|
||||
else
|
||||
|
||||
cat << END >> $NGX_MAKEFILE
|
||||
|
||||
$PCRE/src/pcre2.h: $PCRE/Makefile
|
||||
|
||||
$PCRE/Makefile: $NGX_MAKEFILE
|
||||
cd $PCRE \\
|
||||
&& if [ -f Makefile ]; then \$(MAKE) distclean; fi \\
|
||||
&& CC="\$(CC)" CFLAGS="$PCRE_OPT" \\
|
||||
./configure --disable-shared $PCRE_CONF_OPT
|
||||
|
||||
$PCRE/.libs/libpcre2-8.a: $PCRE/Makefile
|
||||
cd $PCRE \\
|
||||
&& \$(MAKE) libpcre2-8.la
|
||||
|
||||
END
|
||||
|
||||
fi
|
||||
esac
|
||||
|
||||
|
||||
else
|
||||
if [ -n "$ngx_makefile" ]; then
|
||||
|
||||
# PCRE
|
||||
|
||||
case "$NGX_CC_NAME" in
|
||||
|
||||
msvc)
|
||||
ngx_makefile=makefile.msvc
|
||||
ngx_opt="CPU_OPT=\"$CPU_OPT\" LIBC=$LIBC"
|
||||
ngx_pcre="PCRE=\"$PCRE\""
|
||||
;;
|
||||
|
||||
owc)
|
||||
ngx_makefile=makefile.owc
|
||||
ngx_opt="CPU_OPT=\"$CPU_OPT\""
|
||||
ngx_pcre=`echo PCRE=\"$PCRE\" | sed -e "s/\//$ngx_regex_dirsep/g"`
|
||||
;;
|
||||
|
||||
bcc)
|
||||
ngx_makefile=makefile.bcc
|
||||
ngx_opt="-DCPU_OPT=\"$CPU_OPT\""
|
||||
ngx_pcre=`echo \-DPCRE=\"$PCRE\" \
|
||||
| sed -e "s/\//$ngx_regex_dirsep/g"`
|
||||
;;
|
||||
|
||||
*)
|
||||
ngx_makefile=
|
||||
;;
|
||||
|
||||
esac
|
||||
|
||||
|
||||
if [ -n "$ngx_makefile" ]; then
|
||||
|
||||
cat << END >> $NGX_MAKEFILE
|
||||
cat << END >> $NGX_MAKEFILE
|
||||
|
||||
`echo "$PCRE/pcre.lib: $PCRE/pcre.h $NGX_MAKEFILE" \
|
||||
| sed -e "s/\//$ngx_regex_dirsep/g"`
|
||||
|
|
@ -145,9 +43,9 @@ else
|
|||
|
||||
END
|
||||
|
||||
else
|
||||
else
|
||||
|
||||
cat << END >> $NGX_MAKEFILE
|
||||
cat << END >> $NGX_MAKEFILE
|
||||
|
||||
$PCRE/pcre.h: $PCRE/Makefile
|
||||
|
||||
|
|
@ -163,6 +61,4 @@ $PCRE/.libs/libpcre.a: $PCRE/Makefile
|
|||
|
||||
END
|
||||
|
||||
fi
|
||||
|
||||
fi
|
||||
|
|
|
|||
20
auto/make
20
auto/make
|
|
@ -6,10 +6,9 @@
|
|||
echo "creating $NGX_MAKEFILE"
|
||||
|
||||
mkdir -p $NGX_OBJS/src/core $NGX_OBJS/src/event $NGX_OBJS/src/event/modules \
|
||||
$NGX_OBJS/src/event/quic \
|
||||
$NGX_OBJS/src/os/unix $NGX_OBJS/src/os/win32 \
|
||||
$NGX_OBJS/src/http $NGX_OBJS/src/http/v2 $NGX_OBJS/src/http/v3 \
|
||||
$NGX_OBJS/src/http/modules $NGX_OBJS/src/http/modules/perl \
|
||||
$NGX_OBJS/src/http $NGX_OBJS/src/http/v2 $NGX_OBJS/src/http/modules \
|
||||
$NGX_OBJS/src/http/modules/perl \
|
||||
$NGX_OBJS/src/mail \
|
||||
$NGX_OBJS/src/stream \
|
||||
$NGX_OBJS/src/misc
|
||||
|
|
@ -230,7 +229,7 @@ build: binary modules manpage
|
|||
binary: $NGX_OBJS${ngx_dirsep}nginx$ngx_binext
|
||||
|
||||
$NGX_OBJS${ngx_dirsep}nginx$ngx_binext: $ngx_deps$ngx_spacer
|
||||
\$(LINK) $ngx_long_start$ngx_binout$NGX_OBJS${ngx_dirsep}nginx$ngx_binext$ngx_long_cont$ngx_objs$ngx_libs$ngx_link$ngx_main_link
|
||||
\$(LINK) $ngx_long_start$ngx_binout$NGX_OBJS${ngx_dirsep}nginx$ngx_long_cont$ngx_objs$ngx_libs$ngx_link$ngx_main_link
|
||||
$ngx_rcc
|
||||
$ngx_long_end
|
||||
|
||||
|
|
@ -314,7 +313,7 @@ $ngx_obj: \$(CORE_DEPS) \$(HTTP_DEPS)$ngx_cont$ngx_src
|
|||
END
|
||||
|
||||
fi
|
||||
done
|
||||
done
|
||||
|
||||
fi
|
||||
|
||||
|
|
@ -344,7 +343,7 @@ $ngx_obj: \$(CORE_DEPS) \$(MAIL_DEPS)$ngx_cont$ngx_src
|
|||
$ngx_cc$ngx_tab$ngx_objout$ngx_obj$ngx_tab$ngx_src$NGX_AUX
|
||||
|
||||
END
|
||||
done
|
||||
done
|
||||
|
||||
fi
|
||||
|
||||
|
|
@ -374,7 +373,7 @@ $ngx_obj: \$(CORE_DEPS) \$(STREAM_DEPS)$ngx_cont$ngx_src
|
|||
$ngx_cc$ngx_tab$ngx_objout$ngx_obj$ngx_tab$ngx_src$NGX_AUX
|
||||
|
||||
END
|
||||
done
|
||||
done
|
||||
|
||||
fi
|
||||
|
||||
|
|
@ -400,7 +399,7 @@ $ngx_obj: \$(CORE_DEPS) $ngx_cont$ngx_src
|
|||
$ngx_cc$ngx_tab$ngx_objout$ngx_obj$ngx_tab$ngx_src$NGX_AUX
|
||||
|
||||
END
|
||||
done
|
||||
done
|
||||
|
||||
fi
|
||||
|
||||
|
|
@ -432,7 +431,7 @@ $ngx_obj: \$(ADDON_DEPS)$ngx_cont$ngx_src
|
|||
$ngx_cc$ngx_tab$ngx_objout$ngx_obj$ngx_tab$ngx_src$NGX_AUX
|
||||
|
||||
END
|
||||
done
|
||||
done
|
||||
|
||||
fi
|
||||
|
||||
|
|
@ -503,7 +502,6 @@ fi
|
|||
for ngx_module in $DYNAMIC_MODULES
|
||||
do
|
||||
eval ngx_module_srcs="\$${ngx_module}_SRCS"
|
||||
eval ngx_module_shrd="\$${ngx_module}_SHRD"
|
||||
eval eval ngx_module_libs="\\\"\$${ngx_module}_LIBS\\\""
|
||||
|
||||
eval ngx_module_modules="\$${ngx_module}_MODULES"
|
||||
|
|
@ -569,7 +567,7 @@ END
|
|||
| sed -e "s/\(.*\.\)c/\1$ngx_objext/"`
|
||||
|
||||
ngx_module_objs=
|
||||
for ngx_src in $ngx_module_srcs $ngx_module_shrd
|
||||
for ngx_src in $ngx_module_srcs
|
||||
do
|
||||
case "$ngx_src" in
|
||||
src/*)
|
||||
|
|
|
|||
44
auto/module
44
auto/module
|
|
@ -17,6 +17,7 @@ if [ "$ngx_module_link" = DYNAMIC ]; then
|
|||
done
|
||||
|
||||
DYNAMIC_MODULES="$DYNAMIC_MODULES $ngx_module"
|
||||
eval ${ngx_module}_SRCS=\"$ngx_module_srcs\"
|
||||
|
||||
eval ${ngx_module}_MODULES=\"$ngx_module_name\"
|
||||
|
||||
|
|
@ -30,30 +31,6 @@ if [ "$ngx_module_link" = DYNAMIC ]; then
|
|||
eval ${ngx_module}_ORDER=\"$ngx_module_order\"
|
||||
fi
|
||||
|
||||
srcs=
|
||||
shrd=
|
||||
for src in $ngx_module_srcs
|
||||
do
|
||||
found=no
|
||||
for old in $DYNAMIC_MODULES_SRCS
|
||||
do
|
||||
if [ $src = $old ]; then
|
||||
found=yes
|
||||
break
|
||||
fi
|
||||
done
|
||||
|
||||
if [ $found = no ]; then
|
||||
srcs="$srcs $src"
|
||||
else
|
||||
shrd="$shrd $src"
|
||||
fi
|
||||
done
|
||||
eval ${ngx_module}_SRCS=\"$srcs\"
|
||||
eval ${ngx_module}_SHRD=\"$shrd\"
|
||||
|
||||
DYNAMIC_MODULES_SRCS="$DYNAMIC_MODULES_SRCS $srcs"
|
||||
|
||||
if test -n "$ngx_module_incs"; then
|
||||
CORE_INCS="$CORE_INCS $ngx_module_incs"
|
||||
fi
|
||||
|
|
@ -130,24 +107,7 @@ elif [ "$ngx_module_link" = ADDON ]; then
|
|||
eval ${ngx_module_type}_MODULES=\"\$${ngx_module_type}_MODULES \
|
||||
$ngx_module_name\"
|
||||
|
||||
srcs=
|
||||
for src in $ngx_module_srcs
|
||||
do
|
||||
found=no
|
||||
for old in $NGX_ADDON_SRCS
|
||||
do
|
||||
if [ $src = $old ]; then
|
||||
found=yes
|
||||
break
|
||||
fi
|
||||
done
|
||||
|
||||
if [ $found = no ]; then
|
||||
srcs="$srcs $src"
|
||||
fi
|
||||
done
|
||||
|
||||
NGX_ADDON_SRCS="$NGX_ADDON_SRCS $srcs"
|
||||
NGX_ADDON_SRCS="$NGX_ADDON_SRCS $ngx_module_srcs"
|
||||
|
||||
if test -n "$ngx_module_incs"; then
|
||||
eval ${ngx_var}_INCS=\"\$${ngx_var}_INCS $ngx_module_incs\"
|
||||
|
|
|
|||
168
auto/modules
168
auto/modules
|
|
@ -102,8 +102,18 @@ if [ $HTTP = YES ]; then
|
|||
fi
|
||||
|
||||
|
||||
if [ $HTTP_V2 = YES -o $HTTP_V3 = YES ]; then
|
||||
HTTP_SRCS="$HTTP_SRCS $HTTP_HUFF_SRCS"
|
||||
if [ $HTTP_SSI = YES ]; then
|
||||
HTTP_POSTPONE=YES
|
||||
fi
|
||||
|
||||
|
||||
if [ $HTTP_SLICE = YES ]; then
|
||||
HTTP_POSTPONE=YES
|
||||
fi
|
||||
|
||||
|
||||
if [ $HTTP_ADDITION = YES ]; then
|
||||
HTTP_POSTPONE=YES
|
||||
fi
|
||||
|
||||
|
||||
|
|
@ -124,7 +134,6 @@ if [ $HTTP = YES ]; then
|
|||
# ngx_http_header_filter
|
||||
# ngx_http_chunked_filter
|
||||
# ngx_http_v2_filter
|
||||
# ngx_http_v3_filter
|
||||
# ngx_http_range_header_filter
|
||||
# ngx_http_gzip_filter
|
||||
# ngx_http_postpone_filter
|
||||
|
|
@ -157,7 +166,6 @@ if [ $HTTP = YES ]; then
|
|||
ngx_http_header_filter_module \
|
||||
ngx_http_chunked_filter_module \
|
||||
ngx_http_v2_filter_module \
|
||||
ngx_http_v3_filter_module \
|
||||
ngx_http_range_header_filter_module \
|
||||
ngx_http_gzip_filter_module \
|
||||
ngx_http_postpone_filter_module \
|
||||
|
|
@ -219,17 +227,6 @@ if [ $HTTP = YES ]; then
|
|||
. auto/module
|
||||
fi
|
||||
|
||||
if [ $HTTP_V3 = YES ]; then
|
||||
ngx_module_name=ngx_http_v3_filter_module
|
||||
ngx_module_incs=
|
||||
ngx_module_deps=
|
||||
ngx_module_srcs=src/http/v3/ngx_http_v3_filter_module.c
|
||||
ngx_module_libs=
|
||||
ngx_module_link=$HTTP_V3
|
||||
|
||||
. auto/module
|
||||
fi
|
||||
|
||||
if :; then
|
||||
ngx_module_name=ngx_http_range_header_filter_module
|
||||
ngx_module_incs=
|
||||
|
|
@ -255,13 +252,13 @@ if [ $HTTP = YES ]; then
|
|||
. auto/module
|
||||
fi
|
||||
|
||||
if :; then
|
||||
if [ $HTTP_POSTPONE = YES ]; then
|
||||
ngx_module_name=ngx_http_postpone_filter_module
|
||||
ngx_module_incs=
|
||||
ngx_module_deps=
|
||||
ngx_module_srcs=src/http/ngx_http_postpone_filter_module.c
|
||||
ngx_module_libs=
|
||||
ngx_module_link=YES
|
||||
ngx_module_link=$HTTP_POSTPONE
|
||||
|
||||
. auto/module
|
||||
fi
|
||||
|
|
@ -432,6 +429,8 @@ if [ $HTTP = YES ]; then
|
|||
ngx_module_srcs="src/http/v2/ngx_http_v2.c \
|
||||
src/http/v2/ngx_http_v2_table.c \
|
||||
src/http/v2/ngx_http_v2_encode.c \
|
||||
src/http/v2/ngx_http_v2_huff_decode.c \
|
||||
src/http/v2/ngx_http_v2_huff_encode.c \
|
||||
src/http/v2/ngx_http_v2_module.c"
|
||||
ngx_module_libs=
|
||||
ngx_module_link=$HTTP_V2
|
||||
|
|
@ -439,33 +438,6 @@ if [ $HTTP = YES ]; then
|
|||
. auto/module
|
||||
fi
|
||||
|
||||
if [ $HTTP_V3 = YES ]; then
|
||||
USE_OPENSSL_QUIC=YES
|
||||
HTTP_SSL=YES
|
||||
|
||||
have=NGX_HTTP_V3 . auto/have
|
||||
have=NGX_HTTP_HEADERS . auto/have
|
||||
|
||||
ngx_module_name=ngx_http_v3_module
|
||||
ngx_module_incs=src/http/v3
|
||||
ngx_module_deps="src/http/v3/ngx_http_v3.h \
|
||||
src/http/v3/ngx_http_v3_encode.h \
|
||||
src/http/v3/ngx_http_v3_parse.h \
|
||||
src/http/v3/ngx_http_v3_table.h \
|
||||
src/http/v3/ngx_http_v3_uni.h"
|
||||
ngx_module_srcs="src/http/v3/ngx_http_v3.c \
|
||||
src/http/v3/ngx_http_v3_encode.c \
|
||||
src/http/v3/ngx_http_v3_parse.c \
|
||||
src/http/v3/ngx_http_v3_table.c \
|
||||
src/http/v3/ngx_http_v3_uni.c \
|
||||
src/http/v3/ngx_http_v3_request.c \
|
||||
src/http/v3/ngx_http_v3_module.c"
|
||||
ngx_module_libs=
|
||||
ngx_module_link=$HTTP_V3
|
||||
|
||||
. auto/module
|
||||
fi
|
||||
|
||||
if :; then
|
||||
ngx_module_name=ngx_http_static_module
|
||||
ngx_module_incs=
|
||||
|
|
@ -906,17 +878,6 @@ if [ $HTTP = YES ]; then
|
|||
. auto/module
|
||||
fi
|
||||
|
||||
if [ $HTTP_UPSTREAM_RANDOM = YES ]; then
|
||||
ngx_module_name=ngx_http_upstream_random_module
|
||||
ngx_module_incs=
|
||||
ngx_module_deps=
|
||||
ngx_module_srcs=src/http/modules/ngx_http_upstream_random_module.c
|
||||
ngx_module_libs=
|
||||
ngx_module_link=$HTTP_UPSTREAM_RANDOM
|
||||
|
||||
. auto/module
|
||||
fi
|
||||
|
||||
if [ $HTTP_UPSTREAM_KEEPALIVE = YES ]; then
|
||||
ngx_module_name=ngx_http_upstream_keepalive_module
|
||||
ngx_module_incs=
|
||||
|
|
@ -1028,12 +989,6 @@ if [ $MAIL != NO ]; then
|
|||
ngx_module_srcs=src/mail/ngx_mail_proxy_module.c
|
||||
|
||||
. auto/module
|
||||
|
||||
ngx_module_name=ngx_mail_realip_module
|
||||
ngx_module_deps=
|
||||
ngx_module_srcs=src/mail/ngx_mail_realip_module.c
|
||||
|
||||
. auto/module
|
||||
fi
|
||||
|
||||
|
||||
|
|
@ -1075,20 +1030,6 @@ if [ $STREAM != NO ]; then
|
|||
|
||||
ngx_module_incs=
|
||||
|
||||
if [ $STREAM_QUIC = YES ]; then
|
||||
USE_OPENSSL_QUIC=YES
|
||||
have=NGX_STREAM_QUIC . auto/have
|
||||
STREAM_SSL=YES
|
||||
|
||||
ngx_module_name=ngx_stream_quic_module
|
||||
ngx_module_deps=src/stream/ngx_stream_quic_module.h
|
||||
ngx_module_srcs=src/stream/ngx_stream_quic_module.c
|
||||
ngx_module_libs=
|
||||
ngx_module_link=$STREAM_QUIC
|
||||
|
||||
. auto/module
|
||||
fi
|
||||
|
||||
if [ $STREAM_SSL = YES ]; then
|
||||
USE_OPENSSL=YES
|
||||
have=NGX_STREAM_SSL . auto/have
|
||||
|
|
@ -1182,16 +1123,6 @@ if [ $STREAM != NO ]; then
|
|||
. auto/module
|
||||
fi
|
||||
|
||||
if [ $STREAM_SET = YES ]; then
|
||||
ngx_module_name=ngx_stream_set_module
|
||||
ngx_module_deps=
|
||||
ngx_module_srcs=src/stream/ngx_stream_set_module.c
|
||||
ngx_module_libs=
|
||||
ngx_module_link=$STREAM_SET
|
||||
|
||||
. auto/module
|
||||
fi
|
||||
|
||||
if [ $STREAM_UPSTREAM_HASH = YES ]; then
|
||||
ngx_module_name=ngx_stream_upstream_hash_module
|
||||
ngx_module_deps=
|
||||
|
|
@ -1212,16 +1143,6 @@ if [ $STREAM != NO ]; then
|
|||
. auto/module
|
||||
fi
|
||||
|
||||
if [ $STREAM_UPSTREAM_RANDOM = YES ]; then
|
||||
ngx_module_name=ngx_stream_upstream_random_module
|
||||
ngx_module_deps=
|
||||
ngx_module_srcs=src/stream/ngx_stream_upstream_random_module.c
|
||||
ngx_module_libs=
|
||||
ngx_module_link=$STREAM_UPSTREAM_RANDOM
|
||||
|
||||
. auto/module
|
||||
fi
|
||||
|
||||
if [ $STREAM_UPSTREAM_ZONE = YES ]; then
|
||||
have=NGX_STREAM_UPSTREAM_ZONE . auto/have
|
||||
|
||||
|
|
@ -1326,63 +1247,6 @@ if [ $USE_OPENSSL = YES ]; then
|
|||
fi
|
||||
|
||||
|
||||
if [ $USE_OPENSSL_QUIC = YES ]; then
|
||||
ngx_module_type=CORE
|
||||
ngx_module_name=ngx_quic_module
|
||||
ngx_module_incs=
|
||||
ngx_module_deps="src/event/quic/ngx_event_quic.h \
|
||||
src/event/quic/ngx_event_quic_transport.h \
|
||||
src/event/quic/ngx_event_quic_protection.h \
|
||||
src/event/quic/ngx_event_quic_connection.h \
|
||||
src/event/quic/ngx_event_quic_frames.h \
|
||||
src/event/quic/ngx_event_quic_connid.h \
|
||||
src/event/quic/ngx_event_quic_migration.h \
|
||||
src/event/quic/ngx_event_quic_streams.h \
|
||||
src/event/quic/ngx_event_quic_ssl.h \
|
||||
src/event/quic/ngx_event_quic_tokens.h \
|
||||
src/event/quic/ngx_event_quic_ack.h \
|
||||
src/event/quic/ngx_event_quic_output.h \
|
||||
src/event/quic/ngx_event_quic_socket.h \
|
||||
src/event/quic/ngx_event_quic_openssl_compat.h"
|
||||
ngx_module_srcs="src/event/quic/ngx_event_quic.c \
|
||||
src/event/quic/ngx_event_quic_udp.c \
|
||||
src/event/quic/ngx_event_quic_transport.c \
|
||||
src/event/quic/ngx_event_quic_protection.c \
|
||||
src/event/quic/ngx_event_quic_frames.c \
|
||||
src/event/quic/ngx_event_quic_connid.c \
|
||||
src/event/quic/ngx_event_quic_migration.c \
|
||||
src/event/quic/ngx_event_quic_streams.c \
|
||||
src/event/quic/ngx_event_quic_ssl.c \
|
||||
src/event/quic/ngx_event_quic_tokens.c \
|
||||
src/event/quic/ngx_event_quic_ack.c \
|
||||
src/event/quic/ngx_event_quic_output.c \
|
||||
src/event/quic/ngx_event_quic_socket.c \
|
||||
src/event/quic/ngx_event_quic_openssl_compat.c"
|
||||
|
||||
ngx_module_libs=
|
||||
ngx_module_link=YES
|
||||
ngx_module_order=
|
||||
|
||||
. auto/module
|
||||
|
||||
if [ $QUIC_BPF = YES -a $SO_COOKIE_FOUND = YES ]; then
|
||||
ngx_module_type=CORE
|
||||
ngx_module_name=ngx_quic_bpf_module
|
||||
ngx_module_incs=
|
||||
ngx_module_deps=
|
||||
ngx_module_srcs="src/event/quic/ngx_event_quic_bpf.c \
|
||||
src/event/quic/ngx_event_quic_bpf_code.c"
|
||||
ngx_module_libs=
|
||||
ngx_module_link=YES
|
||||
ngx_module_order=
|
||||
|
||||
. auto/module
|
||||
|
||||
have=NGX_QUIC_BPF . auto/have
|
||||
fi
|
||||
fi
|
||||
|
||||
|
||||
if [ $USE_PCRE = YES ]; then
|
||||
ngx_module_type=CORE
|
||||
ngx_module_name=ngx_regex_module
|
||||
|
|
|
|||
34
auto/options
34
auto/options
|
|
@ -45,8 +45,6 @@ USE_THREADS=NO
|
|||
|
||||
NGX_FILE_AIO=NO
|
||||
|
||||
QUIC_BPF=NO
|
||||
|
||||
HTTP=YES
|
||||
|
||||
NGX_HTTP_LOG_PATH=
|
||||
|
|
@ -61,8 +59,8 @@ HTTP_CHARSET=YES
|
|||
HTTP_GZIP=YES
|
||||
HTTP_SSL=NO
|
||||
HTTP_V2=NO
|
||||
HTTP_V3=NO
|
||||
HTTP_SSI=YES
|
||||
HTTP_POSTPONE=NO
|
||||
HTTP_REALIP=NO
|
||||
HTTP_XSLT=NO
|
||||
HTTP_IMAGE_FILTER=NO
|
||||
|
|
@ -104,7 +102,6 @@ HTTP_GZIP_STATIC=NO
|
|||
HTTP_UPSTREAM_HASH=YES
|
||||
HTTP_UPSTREAM_IP_HASH=YES
|
||||
HTTP_UPSTREAM_LEAST_CONN=YES
|
||||
HTTP_UPSTREAM_RANDOM=YES
|
||||
HTTP_UPSTREAM_KEEPALIVE=YES
|
||||
HTTP_UPSTREAM_ZONE=YES
|
||||
|
||||
|
|
@ -119,7 +116,6 @@ MAIL_SMTP=YES
|
|||
|
||||
STREAM=NO
|
||||
STREAM_SSL=NO
|
||||
STREAM_QUIC=NO
|
||||
STREAM_REALIP=NO
|
||||
STREAM_LIMIT_CONN=YES
|
||||
STREAM_ACCESS=YES
|
||||
|
|
@ -128,18 +124,14 @@ STREAM_GEOIP=NO
|
|||
STREAM_MAP=YES
|
||||
STREAM_SPLIT_CLIENTS=YES
|
||||
STREAM_RETURN=YES
|
||||
STREAM_SET=YES
|
||||
STREAM_UPSTREAM_HASH=YES
|
||||
STREAM_UPSTREAM_LEAST_CONN=YES
|
||||
STREAM_UPSTREAM_RANDOM=YES
|
||||
STREAM_UPSTREAM_ZONE=YES
|
||||
STREAM_SSL_PREREAD=NO
|
||||
|
||||
DYNAMIC_MODULES=
|
||||
DYNAMIC_MODULES_SRCS=
|
||||
|
||||
NGX_ADDONS=
|
||||
NGX_ADDON_SRCS=
|
||||
NGX_ADDON_DEPS=
|
||||
DYNAMIC_ADDONS=
|
||||
|
||||
|
|
@ -150,10 +142,8 @@ PCRE=NONE
|
|||
PCRE_OPT=
|
||||
PCRE_CONF_OPT=
|
||||
PCRE_JIT=NO
|
||||
PCRE2=YES
|
||||
|
||||
USE_OPENSSL=NO
|
||||
USE_OPENSSL_QUIC=NO
|
||||
OPENSSL=NONE
|
||||
|
||||
USE_ZLIB=NO
|
||||
|
|
@ -171,8 +161,6 @@ USE_GEOIP=NO
|
|||
NGX_GOOGLE_PERFTOOLS=NO
|
||||
NGX_CPP_TEST=NO
|
||||
|
||||
SO_COOKIE_FOUND=NO
|
||||
|
||||
NGX_LIBATOMIC=NO
|
||||
|
||||
NGX_CPU_CACHE_LINE=
|
||||
|
|
@ -218,8 +206,6 @@ do
|
|||
|
||||
--with-file-aio) NGX_FILE_AIO=YES ;;
|
||||
|
||||
--without-quic_bpf_module) QUIC_BPF=NONE ;;
|
||||
|
||||
--with-ipv6)
|
||||
NGX_POST_CONF_MSG="$NGX_POST_CONF_MSG
|
||||
$0: warning: the \"--with-ipv6\" option is deprecated"
|
||||
|
|
@ -237,7 +223,6 @@ $0: warning: the \"--with-ipv6\" option is deprecated"
|
|||
|
||||
--with-http_ssl_module) HTTP_SSL=YES ;;
|
||||
--with-http_v2_module) HTTP_V2=YES ;;
|
||||
--with-http_v3_module) HTTP_V3=YES ;;
|
||||
--with-http_realip_module) HTTP_REALIP=YES ;;
|
||||
--with-http_addition_module) HTTP_ADDITION=YES ;;
|
||||
--with-http_xslt_module) HTTP_XSLT=YES ;;
|
||||
|
|
@ -288,8 +273,6 @@ $0: warning: the \"--with-ipv6\" option is deprecated"
|
|||
--without-http_upstream_ip_hash_module) HTTP_UPSTREAM_IP_HASH=NO ;;
|
||||
--without-http_upstream_least_conn_module)
|
||||
HTTP_UPSTREAM_LEAST_CONN=NO ;;
|
||||
--without-http_upstream_random_module)
|
||||
HTTP_UPSTREAM_RANDOM=NO ;;
|
||||
--without-http_upstream_keepalive_module) HTTP_UPSTREAM_KEEPALIVE=NO ;;
|
||||
--without-http_upstream_zone_module) HTTP_UPSTREAM_ZONE=NO ;;
|
||||
|
||||
|
|
@ -324,7 +307,6 @@ use the \"--with-mail_ssl_module\" option instead"
|
|||
--with-stream) STREAM=YES ;;
|
||||
--with-stream=dynamic) STREAM=DYNAMIC ;;
|
||||
--with-stream_ssl_module) STREAM_SSL=YES ;;
|
||||
--with-stream_quic_module) STREAM_QUIC=YES ;;
|
||||
--with-stream_realip_module) STREAM_REALIP=YES ;;
|
||||
--with-stream_geoip_module) STREAM_GEOIP=YES ;;
|
||||
--with-stream_geoip_module=dynamic)
|
||||
|
|
@ -339,13 +321,10 @@ use the \"--with-mail_ssl_module\" option instead"
|
|||
--without-stream_split_clients_module)
|
||||
STREAM_SPLIT_CLIENTS=NO ;;
|
||||
--without-stream_return_module) STREAM_RETURN=NO ;;
|
||||
--without-stream_set_module) STREAM_SET=NO ;;
|
||||
--without-stream_upstream_hash_module)
|
||||
STREAM_UPSTREAM_HASH=NO ;;
|
||||
--without-stream_upstream_least_conn_module)
|
||||
STREAM_UPSTREAM_LEAST_CONN=NO ;;
|
||||
--without-stream_upstream_random_module)
|
||||
STREAM_UPSTREAM_RANDOM=NO ;;
|
||||
--without-stream_upstream_zone_module)
|
||||
STREAM_UPSTREAM_ZONE=NO ;;
|
||||
|
||||
|
|
@ -369,7 +348,6 @@ use the \"--with-mail_ssl_module\" option instead"
|
|||
--with-pcre=*) PCRE="$value" ;;
|
||||
--with-pcre-opt=*) PCRE_OPT="$value" ;;
|
||||
--with-pcre-jit) PCRE_JIT=YES ;;
|
||||
--without-pcre2) PCRE2=DISABLED ;;
|
||||
|
||||
--with-openssl=*) OPENSSL="$value" ;;
|
||||
--with-openssl-opt=*) OPENSSL_OPT="$value" ;;
|
||||
|
|
@ -454,11 +432,8 @@ cat << END
|
|||
|
||||
--with-file-aio enable file AIO support
|
||||
|
||||
--without-quic_bpf_module disable ngx_quic_bpf_module
|
||||
|
||||
--with-http_ssl_module enable ngx_http_ssl_module
|
||||
--with-http_v2_module enable ngx_http_v2_module
|
||||
--with-http_v3_module enable ngx_http_v3_module
|
||||
--with-http_realip_module enable ngx_http_realip_module
|
||||
--with-http_addition_module enable ngx_http_addition_module
|
||||
--with-http_xslt_module enable ngx_http_xslt_module
|
||||
|
|
@ -510,8 +485,6 @@ cat << END
|
|||
disable ngx_http_upstream_ip_hash_module
|
||||
--without-http_upstream_least_conn_module
|
||||
disable ngx_http_upstream_least_conn_module
|
||||
--without-http_upstream_random_module
|
||||
disable ngx_http_upstream_random_module
|
||||
--without-http_upstream_keepalive_module
|
||||
disable ngx_http_upstream_keepalive_module
|
||||
--without-http_upstream_zone_module
|
||||
|
|
@ -547,7 +520,6 @@ cat << END
|
|||
--with-stream enable TCP/UDP proxy module
|
||||
--with-stream=dynamic enable dynamic TCP/UDP proxy module
|
||||
--with-stream_ssl_module enable ngx_stream_ssl_module
|
||||
--with-stream_quic_module enable ngx_stream_quic_module
|
||||
--with-stream_realip_module enable ngx_stream_realip_module
|
||||
--with-stream_geoip_module enable ngx_stream_geoip_module
|
||||
--with-stream_geoip_module=dynamic enable dynamic ngx_stream_geoip_module
|
||||
|
|
@ -559,13 +531,10 @@ cat << END
|
|||
--without-stream_split_clients_module
|
||||
disable ngx_stream_split_clients_module
|
||||
--without-stream_return_module disable ngx_stream_return_module
|
||||
--without-stream_set_module disable ngx_stream_set_module
|
||||
--without-stream_upstream_hash_module
|
||||
disable ngx_stream_upstream_hash_module
|
||||
--without-stream_upstream_least_conn_module
|
||||
disable ngx_stream_upstream_least_conn_module
|
||||
--without-stream_upstream_random_module
|
||||
disable ngx_stream_upstream_random_module
|
||||
--without-stream_upstream_zone_module
|
||||
disable ngx_stream_upstream_zone_module
|
||||
|
||||
|
|
@ -590,7 +559,6 @@ cat << END
|
|||
--with-pcre=DIR set path to PCRE library sources
|
||||
--with-pcre-opt=OPTIONS set additional build options for PCRE
|
||||
--with-pcre-jit build PCRE with JIT compilation support
|
||||
--without-pcre2 do not use PCRE2 library
|
||||
|
||||
--with-zlib=DIR set path to zlib library sources
|
||||
--with-zlib-opt=OPTIONS set additional build options for zlib
|
||||
|
|
|
|||
|
|
@ -110,7 +110,7 @@ case "$NGX_MACHINE" in
|
|||
NGX_MACH_CACHE_LINE=64
|
||||
;;
|
||||
|
||||
aarch64 | arm64)
|
||||
aarch64 )
|
||||
have=NGX_ALIGNMENT value=16 . auto/define
|
||||
NGX_MACH_CACHE_LINE=64
|
||||
;;
|
||||
|
|
|
|||
|
|
@ -44,10 +44,12 @@ if [ $osreldate -gt 300007 ]; then
|
|||
CORE_SRCS="$CORE_SRCS $FREEBSD_SENDFILE_SRCS"
|
||||
fi
|
||||
|
||||
if [ $osreldate -gt 1100093 ]; then
|
||||
echo " + sendfile()'s SF_NODISKIO found"
|
||||
if [ $NGX_FILE_AIO = YES ]; then
|
||||
if [ $osreldate -gt 502103 ]; then
|
||||
echo " + sendfile()'s SF_NODISKIO found"
|
||||
|
||||
have=NGX_HAVE_SENDFILE_NODISKIO . auto/have
|
||||
have=NGX_HAVE_AIO_SENDFILE . auto/have
|
||||
fi
|
||||
fi
|
||||
|
||||
# POSIX semaphores
|
||||
|
|
|
|||
|
|
@ -86,31 +86,6 @@ if [ $ngx_found = yes ]; then
|
|||
ee.data.ptr = NULL;
|
||||
epoll_ctl(efd, EPOLL_CTL_ADD, fd, &ee)"
|
||||
. auto/feature
|
||||
|
||||
|
||||
# eventfd()
|
||||
|
||||
ngx_feature="eventfd()"
|
||||
ngx_feature_name="NGX_HAVE_EVENTFD"
|
||||
ngx_feature_run=no
|
||||
ngx_feature_incs="#include <sys/eventfd.h>"
|
||||
ngx_feature_path=
|
||||
ngx_feature_libs=
|
||||
ngx_feature_test="(void) eventfd(0, 0)"
|
||||
. auto/feature
|
||||
|
||||
if [ $ngx_found = yes ]; then
|
||||
have=NGX_HAVE_SYS_EVENTFD_H . auto/have
|
||||
fi
|
||||
|
||||
|
||||
if [ $ngx_found = no ]; then
|
||||
|
||||
ngx_feature="eventfd() (SYS_eventfd)"
|
||||
ngx_feature_incs="#include <sys/syscall.h>"
|
||||
ngx_feature_test="(void) SYS_eventfd"
|
||||
. auto/feature
|
||||
fi
|
||||
fi
|
||||
|
||||
|
||||
|
|
@ -210,8 +185,6 @@ ngx_feature_test="struct __user_cap_data_struct data;
|
|||
data.effective = CAP_TO_MASK(CAP_NET_RAW);
|
||||
data.permitted = 0;
|
||||
|
||||
(void) header;
|
||||
(void) data;
|
||||
(void) SYS_capset"
|
||||
. auto/feature
|
||||
|
||||
|
|
@ -232,63 +205,4 @@ ngx_feature_test="struct crypt_data cd;
|
|||
ngx_include="sys/vfs.h"; . auto/include
|
||||
|
||||
|
||||
# BPF sockhash
|
||||
|
||||
ngx_feature="BPF sockhash"
|
||||
ngx_feature_name="NGX_HAVE_BPF"
|
||||
ngx_feature_run=no
|
||||
ngx_feature_incs="#include <linux/bpf.h>
|
||||
#include <sys/syscall.h>"
|
||||
ngx_feature_path=
|
||||
ngx_feature_libs=
|
||||
ngx_feature_test="union bpf_attr attr = { 0 };
|
||||
|
||||
attr.map_flags = 0;
|
||||
attr.map_type = BPF_MAP_TYPE_SOCKHASH;
|
||||
|
||||
syscall(__NR_bpf, 0, &attr, 0);"
|
||||
. auto/feature
|
||||
|
||||
if [ $ngx_found = yes ]; then
|
||||
CORE_SRCS="$CORE_SRCS src/core/ngx_bpf.c"
|
||||
CORE_DEPS="$CORE_DEPS src/core/ngx_bpf.h"
|
||||
|
||||
if [ $QUIC_BPF != NONE ]; then
|
||||
QUIC_BPF=YES
|
||||
fi
|
||||
fi
|
||||
|
||||
|
||||
ngx_feature="SO_COOKIE"
|
||||
ngx_feature_name="NGX_HAVE_SO_COOKIE"
|
||||
ngx_feature_run=no
|
||||
ngx_feature_incs="#include <sys/socket.h>
|
||||
$NGX_INCLUDE_INTTYPES_H"
|
||||
ngx_feature_path=
|
||||
ngx_feature_libs=
|
||||
ngx_feature_test="socklen_t optlen = sizeof(uint64_t);
|
||||
uint64_t cookie;
|
||||
getsockopt(0, SOL_SOCKET, SO_COOKIE, &cookie, &optlen)"
|
||||
. auto/feature
|
||||
|
||||
if [ $ngx_found = yes ]; then
|
||||
SO_COOKIE_FOUND=YES
|
||||
fi
|
||||
|
||||
|
||||
# UDP segmentation offloading
|
||||
|
||||
ngx_feature="UDP_SEGMENT"
|
||||
ngx_feature_name="NGX_HAVE_UDP_SEGMENT"
|
||||
ngx_feature_run=no
|
||||
ngx_feature_incs="#include <sys/socket.h>
|
||||
#include <netinet/udp.h>"
|
||||
ngx_feature_path=
|
||||
ngx_feature_libs=
|
||||
ngx_feature_test="socklen_t optlen = sizeof(int);
|
||||
int val;
|
||||
getsockopt(0, SOL_UDP, UDP_SEGMENT, &val, &optlen)"
|
||||
. auto/feature
|
||||
|
||||
|
||||
CC_AUX_FLAGS="$cc_aux_flags -D_GNU_SOURCE -D_FILE_OFFSET_BITS=64"
|
||||
|
|
|
|||
|
|
@ -11,7 +11,6 @@ CORE_SRCS="$WIN32_SRCS $IOCP_SRCS"
|
|||
OS_CONFIG="$WIN32_CONFIG"
|
||||
NGX_ICONS="$NGX_WIN32_ICONS"
|
||||
SELECT_SRCS=$WIN32_SELECT_SRCS
|
||||
POLL_SRCS=$WIN32_POLL_SRCS
|
||||
|
||||
ngx_pic_opt=
|
||||
ngx_binext=".exe"
|
||||
|
|
@ -32,7 +31,12 @@ case "$NGX_CC_NAME" in
|
|||
esac
|
||||
|
||||
EVENT_MODULES="$EVENT_MODULES $IOCP_MODULE"
|
||||
#EVENT_FOUND=YES
|
||||
EVENT_FOUND=YES
|
||||
|
||||
if [ $EVENT_SELECT = NO ]; then
|
||||
CORE_SRCS="$CORE_SRCS $SELECT_SRCS"
|
||||
EVENT_MODULES="$EVENT_MODULES $SELECT_MODULE"
|
||||
fi
|
||||
|
||||
have=NGX_HAVE_INET6 . auto/have
|
||||
|
||||
|
|
|
|||
10
auto/sources
10
auto/sources
|
|
@ -83,20 +83,18 @@ CORE_SRCS="src/core/nginx.c \
|
|||
|
||||
EVENT_MODULES="ngx_events_module ngx_event_core_module"
|
||||
|
||||
EVENT_INCS="src/event src/event/modules src/event/quic"
|
||||
EVENT_INCS="src/event src/event/modules"
|
||||
|
||||
EVENT_DEPS="src/event/ngx_event.h \
|
||||
src/event/ngx_event_timer.h \
|
||||
src/event/ngx_event_posted.h \
|
||||
src/event/ngx_event_connect.h \
|
||||
src/event/ngx_event_pipe.h \
|
||||
src/event/ngx_event_udp.h"
|
||||
src/event/ngx_event_pipe.h"
|
||||
|
||||
EVENT_SRCS="src/event/ngx_event.c \
|
||||
src/event/ngx_event_timer.c \
|
||||
src/event/ngx_event_posted.c \
|
||||
src/event/ngx_event_accept.c \
|
||||
src/event/ngx_event_udp.c \
|
||||
src/event/ngx_event_connect.c \
|
||||
src/event/ngx_event_pipe.c"
|
||||
|
||||
|
|
@ -107,7 +105,6 @@ WIN32_SELECT_SRCS=src/event/modules/ngx_win32_select_module.c
|
|||
|
||||
POLL_MODULE=ngx_poll_module
|
||||
POLL_SRCS=src/event/modules/ngx_poll_module.c
|
||||
WIN32_POLL_SRCS=src/event/modules/ngx_win32_poll_module.c
|
||||
|
||||
KQUEUE_MODULE=ngx_kqueue_module
|
||||
KQUEUE_SRCS=src/event/modules/ngx_kqueue_module.c
|
||||
|
|
@ -256,6 +253,3 @@ NGX_WIN32_RC="src/os/win32/nginx.rc"
|
|||
|
||||
|
||||
HTTP_FILE_CACHE_SRCS=src/http/ngx_http_file_cache.c
|
||||
|
||||
HTTP_HUFF_SRCS="src/http/ngx_http_huff_decode.c
|
||||
src/http/ngx_http_huff_encode.c"
|
||||
|
|
|
|||
|
|
@ -16,9 +16,9 @@ if [ $USE_PCRE = DISABLED ]; then
|
|||
|
||||
else
|
||||
case $PCRE in
|
||||
YES) echo " + using system $PCRE_LIBRARY library" ;;
|
||||
YES) echo " + using system PCRE library" ;;
|
||||
NONE) echo " + PCRE library is not used" ;;
|
||||
*) echo " + using $PCRE_LIBRARY library: $PCRE" ;;
|
||||
*) echo " + using PCRE library: $PCRE" ;;
|
||||
esac
|
||||
fi
|
||||
|
||||
|
|
|
|||
91
auto/unix
91
auto/unix
|
|
@ -582,6 +582,29 @@ Currently file AIO is supported on FreeBSD 4.3+ and Linux 2.6.22+ only
|
|||
END
|
||||
exit 1
|
||||
fi
|
||||
|
||||
else
|
||||
|
||||
ngx_feature="eventfd()"
|
||||
ngx_feature_name="NGX_HAVE_EVENTFD"
|
||||
ngx_feature_run=no
|
||||
ngx_feature_incs="#include <sys/eventfd.h>"
|
||||
ngx_feature_path=
|
||||
ngx_feature_libs=
|
||||
ngx_feature_test="(void) eventfd(0, 0)"
|
||||
. auto/feature
|
||||
|
||||
if [ $ngx_found = yes ]; then
|
||||
have=NGX_HAVE_SYS_EVENTFD_H . auto/have
|
||||
fi
|
||||
|
||||
if [ $ngx_found = no ]; then
|
||||
|
||||
ngx_feature="eventfd() (SYS_eventfd)"
|
||||
ngx_feature_incs="#include <sys/syscall.h>"
|
||||
ngx_feature_test="(void) SYS_eventfd"
|
||||
. auto/feature
|
||||
fi
|
||||
fi
|
||||
|
||||
|
||||
|
|
@ -704,33 +727,17 @@ ngx_feature_test="char buf[1]; struct iovec vec[1]; ssize_t n;
|
|||
. auto/feature
|
||||
|
||||
|
||||
# strerrordesc_np(), introduced in glibc 2.32
|
||||
|
||||
ngx_feature="strerrordesc_np()"
|
||||
ngx_feature_name="NGX_HAVE_STRERRORDESC_NP"
|
||||
ngx_feature_run=no
|
||||
ngx_feature_incs='#include <string.h>'
|
||||
ngx_feature="sys_nerr"
|
||||
ngx_feature_name="NGX_SYS_NERR"
|
||||
ngx_feature_run=value
|
||||
ngx_feature_incs='#include <errno.h>
|
||||
#include <stdio.h>'
|
||||
ngx_feature_path=
|
||||
ngx_feature_libs=
|
||||
ngx_feature_test="char *p; p = strerrordesc_np(0);
|
||||
if (p == NULL) return 1"
|
||||
ngx_feature_test='printf("%d", sys_nerr);'
|
||||
. auto/feature
|
||||
|
||||
|
||||
if [ $ngx_found = no ]; then
|
||||
|
||||
ngx_feature="sys_nerr"
|
||||
ngx_feature_name="NGX_SYS_NERR"
|
||||
ngx_feature_run=value
|
||||
ngx_feature_incs='#include <errno.h>
|
||||
#include <stdio.h>'
|
||||
ngx_feature_path=
|
||||
ngx_feature_libs=
|
||||
ngx_feature_test='printf("%d", sys_nerr);'
|
||||
. auto/feature
|
||||
fi
|
||||
|
||||
|
||||
if [ $ngx_found = no ]; then
|
||||
|
||||
# Cygiwn defines _sys_nerr
|
||||
|
|
@ -746,6 +753,34 @@ if [ $ngx_found = no ]; then
|
|||
fi
|
||||
|
||||
|
||||
if [ $ngx_found = no ]; then
|
||||
|
||||
# Solaris has no sys_nerr
|
||||
ngx_feature='maximum errno'
|
||||
ngx_feature_name=NGX_SYS_NERR
|
||||
ngx_feature_run=value
|
||||
ngx_feature_incs='#include <errno.h>
|
||||
#include <string.h>
|
||||
#include <stdio.h>'
|
||||
ngx_feature_path=
|
||||
ngx_feature_libs=
|
||||
ngx_feature_test='int n;
|
||||
char *p;
|
||||
for (n = 1; n < 1000; n++) {
|
||||
errno = 0;
|
||||
p = strerror(n);
|
||||
if (errno == EINVAL
|
||||
|| p == NULL
|
||||
|| strncmp(p, "Unknown error", 13) == 0)
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
printf("%d", n);'
|
||||
. auto/feature
|
||||
fi
|
||||
|
||||
|
||||
ngx_feature="localtime_r()"
|
||||
ngx_feature_name="NGX_HAVE_LOCALTIME_R"
|
||||
ngx_feature_run=no
|
||||
|
|
@ -908,18 +943,6 @@ ngx_feature_test="int i = FIONBIO; printf(\"%d\", i)"
|
|||
. auto/feature
|
||||
|
||||
|
||||
ngx_feature="ioctl(FIONREAD)"
|
||||
ngx_feature_name="NGX_HAVE_FIONREAD"
|
||||
ngx_feature_run=no
|
||||
ngx_feature_incs="#include <sys/ioctl.h>
|
||||
#include <stdio.h>
|
||||
$NGX_INCLUDE_SYS_FILIO_H"
|
||||
ngx_feature_path=
|
||||
ngx_feature_libs=
|
||||
ngx_feature_test="int i = FIONREAD; printf(\"%d\", i)"
|
||||
. auto/feature
|
||||
|
||||
|
||||
ngx_feature="struct tm.tm_gmtoff"
|
||||
ngx_feature_name="NGX_HAVE_GMTOFF"
|
||||
ngx_feature_run=no
|
||||
|
|
|
|||
|
|
@ -15,7 +15,6 @@ types {
|
|||
text/vnd.wap.wml wml;
|
||||
text/x-component htc;
|
||||
|
||||
image/avif avif;
|
||||
image/png png;
|
||||
image/svg+xml svg svgz;
|
||||
image/tiff tif tiff;
|
||||
|
|
@ -25,9 +24,7 @@ types {
|
|||
image/x-jng jng;
|
||||
image/x-ms-bmp bmp;
|
||||
|
||||
font/woff woff;
|
||||
font/woff2 woff2;
|
||||
|
||||
application/font-woff woff;
|
||||
application/java-archive jar war ear;
|
||||
application/json json;
|
||||
application/mac-binhex40 hqx;
|
||||
|
|
@ -52,7 +49,6 @@ types {
|
|||
application/vnd.openxmlformats-officedocument.wordprocessingml.document
|
||||
docx;
|
||||
application/vnd.wap.wmlc wmlc;
|
||||
application/wasm wasm;
|
||||
application/x-7z-compressed 7z;
|
||||
application/x-cocoa cco;
|
||||
application/x-java-archive-diff jardiff;
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -3,9 +3,11 @@
|
|||
<head>
|
||||
<title>Error</title>
|
||||
<style>
|
||||
html { color-scheme: light dark; }
|
||||
body { width: 35em; margin: 0 auto;
|
||||
font-family: Tahoma, Verdana, Arial, sans-serif; }
|
||||
body {
|
||||
width: 35em;
|
||||
margin: 0 auto;
|
||||
font-family: Tahoma, Verdana, Arial, sans-serif;
|
||||
}
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
|
|
@ -13,7 +15,7 @@ font-family: Tahoma, Verdana, Arial, sans-serif; }
|
|||
<p>Sorry, the page you are looking for is currently unavailable.<br/>
|
||||
Please try again later.</p>
|
||||
<p>If you are the system administrator of this resource then you should check
|
||||
the error log for details.</p>
|
||||
the <a href="http://nginx.org/r/error_log">error log</a> for details.</p>
|
||||
<p><em>Faithfully yours, nginx.</em></p>
|
||||
</body>
|
||||
</html>
|
||||
|
|
|
|||
|
|
@ -3,9 +3,11 @@
|
|||
<head>
|
||||
<title>Welcome to nginx!</title>
|
||||
<style>
|
||||
html { color-scheme: light dark; }
|
||||
body { width: 35em; margin: 0 auto;
|
||||
font-family: Tahoma, Verdana, Arial, sans-serif; }
|
||||
body {
|
||||
width: 35em;
|
||||
margin: 0 auto;
|
||||
font-family: Tahoma, Verdana, Arial, sans-serif;
|
||||
}
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
.\"
|
||||
.\" Copyright (C) 2010, 2019 Sergey A. Osokin
|
||||
.\" Copyright (C) 2010 Sergey A. Osokin
|
||||
.\" Copyright (C) Nginx, Inc.
|
||||
.\" All rights reserved.
|
||||
.\"
|
||||
|
|
@ -25,7 +25,7 @@
|
|||
.\" SUCH DAMAGE.
|
||||
.\"
|
||||
.\"
|
||||
.Dd November 5, 2020
|
||||
.Dd June 16, 2015
|
||||
.Dt NGINX 8
|
||||
.Os
|
||||
.Sh NAME
|
||||
|
|
@ -35,7 +35,6 @@
|
|||
.Nm
|
||||
.Op Fl ?hqTtVv
|
||||
.Op Fl c Ar file
|
||||
.Op Fl e Ar file
|
||||
.Op Fl g Ar directives
|
||||
.Op Fl p Ar prefix
|
||||
.Op Fl s Ar signal
|
||||
|
|
@ -43,8 +42,7 @@
|
|||
.Nm
|
||||
(pronounced
|
||||
.Dq engine x )
|
||||
is an HTTP and reverse proxy server, a mail proxy server, and a generic
|
||||
TCP/UDP proxy server.
|
||||
is an HTTP and reverse proxy server, as well as a mail proxy server.
|
||||
It is known for its high performance, stability, rich feature set, simple
|
||||
configuration, and low resource consumption.
|
||||
.Pp
|
||||
|
|
@ -55,12 +53,6 @@ Print help.
|
|||
.It Fl c Ar file
|
||||
Use an alternative configuration
|
||||
.Ar file .
|
||||
.It Fl e Ar file
|
||||
Use an alternative error log
|
||||
.Ar file .
|
||||
Special value
|
||||
.Cm stderr
|
||||
indicates that the standard error output should be used.
|
||||
.It Fl g Ar directives
|
||||
Set global configuration directives.
|
||||
See
|
||||
|
|
@ -90,15 +82,15 @@ The following table shows the corresponding system signals:
|
|||
.It Cm reload
|
||||
.Dv SIGHUP
|
||||
.El
|
||||
.It Fl T
|
||||
Same as
|
||||
.Fl t ,
|
||||
but additionally dump configuration files to standard output.
|
||||
.It Fl t
|
||||
Do not run, just test the configuration file.
|
||||
.Nm
|
||||
checks the configuration file syntax and then tries to open files
|
||||
referenced in the configuration file.
|
||||
.It Fl T
|
||||
Same as
|
||||
.Fl t ,
|
||||
but additionally dump configuration files to standard output.
|
||||
.It Fl V
|
||||
Print the
|
||||
.Nm
|
||||
|
|
@ -205,10 +197,10 @@ Development of
|
|||
started in 2002, with the first public release on October 4, 2004.
|
||||
.Sh AUTHORS
|
||||
.An -nosplit
|
||||
.An Igor Sysoev Aq Mt igor@sysoev.ru .
|
||||
.An Igor Sysoev Aq igor@sysoev.ru .
|
||||
.Pp
|
||||
This manual page was originally written by
|
||||
.An Sergey A. Osokin Aq Mt osa@FreeBSD.org.ru
|
||||
.An Sergey A. Osokin Aq osa@FreeBSD.org.ru
|
||||
as a result of compiling many
|
||||
.Nm
|
||||
documents from all over the world.
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
/*
|
||||
* Copyright (C) 2002-2021 Igor Sysoev
|
||||
* Copyright (C) 2011-2022 Nginx, Inc.
|
||||
* Copyright (C) 2002-2018 Igor Sysoev
|
||||
* Copyright (C) 2011-2018 Nginx, Inc.
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -6,15 +6,21 @@ TEMP = tmp
|
|||
|
||||
CC = cl
|
||||
OBJS = objs.msvc8
|
||||
OPENSSL = openssl-1.1.1t
|
||||
ZLIB = zlib-1.2.13
|
||||
PCRE = pcre2-10.39
|
||||
OPENSSL = openssl-1.0.2q
|
||||
ZLIB = zlib-1.2.11
|
||||
PCRE = pcre-8.42
|
||||
|
||||
|
||||
release: export
|
||||
|
||||
mv $(TEMP)/$(NGINX)/auto/configure $(TEMP)/$(NGINX)
|
||||
|
||||
# delete incomplete sources
|
||||
rm $(TEMP)/$(NGINX)/src/event/ngx_event_acceptex.c
|
||||
rm $(TEMP)/$(NGINX)/src/event/ngx_event_connectex.c
|
||||
rm $(TEMP)/$(NGINX)/src/event/modules/ngx_iocp_module.*
|
||||
rm -r $(TEMP)/$(NGINX)/src/os/win32
|
||||
|
||||
mv $(TEMP)/$(NGINX)/docs/text/LICENSE $(TEMP)/$(NGINX)
|
||||
mv $(TEMP)/$(NGINX)/docs/text/README $(TEMP)/$(NGINX)
|
||||
mv $(TEMP)/$(NGINX)/docs/html $(TEMP)/$(NGINX)
|
||||
|
|
@ -59,6 +65,7 @@ win32:
|
|||
--with-cc-opt=-DFD_SETSIZE=1024 \
|
||||
--with-pcre=$(OBJS)/lib/$(PCRE) \
|
||||
--with-zlib=$(OBJS)/lib/$(ZLIB) \
|
||||
--with-select_module \
|
||||
--with-http_v2_module \
|
||||
--with-http_realip_module \
|
||||
--with-http_addition_module \
|
||||
|
|
@ -76,7 +83,7 @@ win32:
|
|||
--with-mail \
|
||||
--with-stream \
|
||||
--with-openssl=$(OBJS)/lib/$(OPENSSL) \
|
||||
--with-openssl-opt="no-asm no-tests -D_WIN32_WINNT=0x0501" \
|
||||
--with-openssl-opt=no-asm \
|
||||
--with-http_ssl_module \
|
||||
--with-mail_ssl_module \
|
||||
--with-stream_ssl_module
|
||||
|
|
|
|||
|
|
@ -183,7 +183,6 @@ static ngx_uint_t ngx_show_help;
|
|||
static ngx_uint_t ngx_show_version;
|
||||
static ngx_uint_t ngx_show_configure;
|
||||
static u_char *ngx_prefix;
|
||||
static u_char *ngx_error_log;
|
||||
static u_char *ngx_conf_file;
|
||||
static u_char *ngx_conf_params;
|
||||
static char *ngx_signal;
|
||||
|
|
@ -231,7 +230,7 @@ main(int argc, char *const *argv)
|
|||
ngx_pid = ngx_getpid();
|
||||
ngx_parent = ngx_getppid();
|
||||
|
||||
log = ngx_log_init(ngx_prefix, ngx_error_log);
|
||||
log = ngx_log_init(ngx_prefix);
|
||||
if (log == NULL) {
|
||||
return 1;
|
||||
}
|
||||
|
|
@ -394,9 +393,9 @@ ngx_show_version_info(void)
|
|||
|
||||
if (ngx_show_help) {
|
||||
ngx_write_stderr(
|
||||
"Usage: nginx [-?hvVtTq] [-s signal] [-p prefix]" NGX_LINEFEED
|
||||
" [-e filename] [-c filename] [-g directives]"
|
||||
NGX_LINEFEED NGX_LINEFEED
|
||||
"Usage: nginx [-?hvVtTq] [-s signal] [-c filename] "
|
||||
"[-p prefix] [-g directives]" NGX_LINEFEED
|
||||
NGX_LINEFEED
|
||||
"Options:" NGX_LINEFEED
|
||||
" -?,-h : this help" NGX_LINEFEED
|
||||
" -v : show version and exit" NGX_LINEFEED
|
||||
|
|
@ -414,12 +413,6 @@ ngx_show_version_info(void)
|
|||
NGX_LINEFEED
|
||||
#else
|
||||
" -p prefix : set prefix path (default: NONE)" NGX_LINEFEED
|
||||
#endif
|
||||
" -e filename : set error log file (default: "
|
||||
#ifdef NGX_ERROR_LOG_STDERR
|
||||
"stderr)" NGX_LINEFEED
|
||||
#else
|
||||
NGX_ERROR_LOG_PATH ")" NGX_LINEFEED
|
||||
#endif
|
||||
" -c filename : set configuration file (default: " NGX_CONF_PATH
|
||||
")" NGX_LINEFEED
|
||||
|
|
@ -499,7 +492,6 @@ ngx_add_inherited_sockets(ngx_cycle_t *cycle)
|
|||
ngx_memzero(ls, sizeof(ngx_listening_t));
|
||||
|
||||
ls->fd = (ngx_socket_t) s;
|
||||
ls->inherited = 1;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -680,9 +672,6 @@ ngx_exec_new_binary(ngx_cycle_t *cycle, char *const *argv)
|
|||
|
||||
ls = cycle->listening.elts;
|
||||
for (i = 0; i < cycle->listening.nelts; i++) {
|
||||
if (ls[i].ignore) {
|
||||
continue;
|
||||
}
|
||||
p = ngx_sprintf(p, "%ud;", ls[i].fd);
|
||||
}
|
||||
|
||||
|
|
@ -810,24 +799,6 @@ ngx_get_options(int argc, char *const *argv)
|
|||
ngx_log_stderr(0, "option \"-p\" requires directory name");
|
||||
return NGX_ERROR;
|
||||
|
||||
case 'e':
|
||||
if (*p) {
|
||||
ngx_error_log = p;
|
||||
|
||||
} else if (argv[++i]) {
|
||||
ngx_error_log = (u_char *) argv[i];
|
||||
|
||||
} else {
|
||||
ngx_log_stderr(0, "option \"-e\" requires file name");
|
||||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
if (ngx_strcmp(ngx_error_log, "stderr") == 0) {
|
||||
ngx_error_log = (u_char *) "";
|
||||
}
|
||||
|
||||
goto next;
|
||||
|
||||
case 'c':
|
||||
if (*p) {
|
||||
ngx_conf_file = p;
|
||||
|
|
@ -1020,14 +991,6 @@ ngx_process_options(ngx_cycle_t *cycle)
|
|||
}
|
||||
}
|
||||
|
||||
if (ngx_error_log) {
|
||||
cycle->error_log.len = ngx_strlen(ngx_error_log);
|
||||
cycle->error_log.data = ngx_error_log;
|
||||
|
||||
} else {
|
||||
ngx_str_set(&cycle->error_log, NGX_ERROR_LOG_PATH);
|
||||
}
|
||||
|
||||
if (ngx_conf_params) {
|
||||
cycle->conf_param.len = ngx_strlen(ngx_conf_params);
|
||||
cycle->conf_param.data = ngx_conf_params;
|
||||
|
|
|
|||
|
|
@ -9,8 +9,8 @@
|
|||
#define _NGINX_H_INCLUDED_
|
||||
|
||||
|
||||
#define nginx_version 1023004
|
||||
#define NGINX_VERSION "1.23.4"
|
||||
#define nginx_version 1014002
|
||||
#define NGINX_VERSION "1.14.2"
|
||||
#define NGINX_VER "nginx/" NGINX_VERSION
|
||||
|
||||
#ifdef NGX_BUILD
|
||||
|
|
|
|||
|
|
@ -1,143 +0,0 @@
|
|||
|
||||
/*
|
||||
* Copyright (C) Nginx, Inc.
|
||||
*/
|
||||
|
||||
|
||||
#include <ngx_config.h>
|
||||
#include <ngx_core.h>
|
||||
|
||||
#define NGX_BPF_LOGBUF_SIZE (16 * 1024)
|
||||
|
||||
|
||||
static ngx_inline int
|
||||
ngx_bpf(enum bpf_cmd cmd, union bpf_attr *attr, unsigned int size)
|
||||
{
|
||||
return syscall(__NR_bpf, cmd, attr, size);
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
ngx_bpf_program_link(ngx_bpf_program_t *program, const char *symbol, int fd)
|
||||
{
|
||||
ngx_uint_t i;
|
||||
ngx_bpf_reloc_t *rl;
|
||||
|
||||
rl = program->relocs;
|
||||
|
||||
for (i = 0; i < program->nrelocs; i++) {
|
||||
if (ngx_strcmp(rl[i].name, symbol) == 0) {
|
||||
program->ins[rl[i].offset].src_reg = 1;
|
||||
program->ins[rl[i].offset].imm = fd;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
int
|
||||
ngx_bpf_load_program(ngx_log_t *log, ngx_bpf_program_t *program)
|
||||
{
|
||||
int fd;
|
||||
union bpf_attr attr;
|
||||
#if (NGX_DEBUG)
|
||||
char buf[NGX_BPF_LOGBUF_SIZE];
|
||||
#endif
|
||||
|
||||
ngx_memzero(&attr, sizeof(union bpf_attr));
|
||||
|
||||
attr.license = (uintptr_t) program->license;
|
||||
attr.prog_type = program->type;
|
||||
attr.insns = (uintptr_t) program->ins;
|
||||
attr.insn_cnt = program->nins;
|
||||
|
||||
#if (NGX_DEBUG)
|
||||
/* for verifier errors */
|
||||
attr.log_buf = (uintptr_t) buf;
|
||||
attr.log_size = NGX_BPF_LOGBUF_SIZE;
|
||||
attr.log_level = 1;
|
||||
#endif
|
||||
|
||||
fd = ngx_bpf(BPF_PROG_LOAD, &attr, sizeof(attr));
|
||||
if (fd < 0) {
|
||||
ngx_log_error(NGX_LOG_ALERT, log, ngx_errno,
|
||||
"failed to load BPF program");
|
||||
|
||||
ngx_log_debug1(NGX_LOG_DEBUG_CORE, log, 0,
|
||||
"bpf verifier: %s", buf);
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
return fd;
|
||||
}
|
||||
|
||||
|
||||
int
|
||||
ngx_bpf_map_create(ngx_log_t *log, enum bpf_map_type type, int key_size,
|
||||
int value_size, int max_entries, uint32_t map_flags)
|
||||
{
|
||||
int fd;
|
||||
union bpf_attr attr;
|
||||
|
||||
ngx_memzero(&attr, sizeof(union bpf_attr));
|
||||
|
||||
attr.map_type = type;
|
||||
attr.key_size = key_size;
|
||||
attr.value_size = value_size;
|
||||
attr.max_entries = max_entries;
|
||||
attr.map_flags = map_flags;
|
||||
|
||||
fd = ngx_bpf(BPF_MAP_CREATE, &attr, sizeof(attr));
|
||||
if (fd < 0) {
|
||||
ngx_log_error(NGX_LOG_ALERT, log, ngx_errno,
|
||||
"failed to create BPF map");
|
||||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
return fd;
|
||||
}
|
||||
|
||||
|
||||
int
|
||||
ngx_bpf_map_update(int fd, const void *key, const void *value, uint64_t flags)
|
||||
{
|
||||
union bpf_attr attr;
|
||||
|
||||
ngx_memzero(&attr, sizeof(union bpf_attr));
|
||||
|
||||
attr.map_fd = fd;
|
||||
attr.key = (uintptr_t) key;
|
||||
attr.value = (uintptr_t) value;
|
||||
attr.flags = flags;
|
||||
|
||||
return ngx_bpf(BPF_MAP_UPDATE_ELEM, &attr, sizeof(attr));
|
||||
}
|
||||
|
||||
|
||||
int
|
||||
ngx_bpf_map_delete(int fd, const void *key)
|
||||
{
|
||||
union bpf_attr attr;
|
||||
|
||||
ngx_memzero(&attr, sizeof(union bpf_attr));
|
||||
|
||||
attr.map_fd = fd;
|
||||
attr.key = (uintptr_t) key;
|
||||
|
||||
return ngx_bpf(BPF_MAP_DELETE_ELEM, &attr, sizeof(attr));
|
||||
}
|
||||
|
||||
|
||||
int
|
||||
ngx_bpf_map_lookup(int fd, const void *key, void *value)
|
||||
{
|
||||
union bpf_attr attr;
|
||||
|
||||
ngx_memzero(&attr, sizeof(union bpf_attr));
|
||||
|
||||
attr.map_fd = fd;
|
||||
attr.key = (uintptr_t) key;
|
||||
attr.value = (uintptr_t) value;
|
||||
|
||||
return ngx_bpf(BPF_MAP_LOOKUP_ELEM, &attr, sizeof(attr));
|
||||
}
|
||||
|
|
@ -1,43 +0,0 @@
|
|||
|
||||
/*
|
||||
* Copyright (C) Nginx, Inc.
|
||||
*/
|
||||
|
||||
|
||||
#ifndef _NGX_BPF_H_INCLUDED_
|
||||
#define _NGX_BPF_H_INCLUDED_
|
||||
|
||||
|
||||
#include <ngx_config.h>
|
||||
#include <ngx_core.h>
|
||||
|
||||
#include <linux/bpf.h>
|
||||
|
||||
|
||||
typedef struct {
|
||||
char *name;
|
||||
int offset;
|
||||
} ngx_bpf_reloc_t;
|
||||
|
||||
typedef struct {
|
||||
char *license;
|
||||
enum bpf_prog_type type;
|
||||
struct bpf_insn *ins;
|
||||
size_t nins;
|
||||
ngx_bpf_reloc_t *relocs;
|
||||
size_t nrelocs;
|
||||
} ngx_bpf_program_t;
|
||||
|
||||
|
||||
void ngx_bpf_program_link(ngx_bpf_program_t *program, const char *symbol,
|
||||
int fd);
|
||||
int ngx_bpf_load_program(ngx_log_t *log, ngx_bpf_program_t *program);
|
||||
|
||||
int ngx_bpf_map_create(ngx_log_t *log, enum bpf_map_type type, int key_size,
|
||||
int value_size, int max_entries, uint32_t map_flags);
|
||||
int ngx_bpf_map_update(int fd, const void *key, const void *value,
|
||||
uint64_t flags);
|
||||
int ngx_bpf_map_delete(int fd, const void *key);
|
||||
int ngx_bpf_map_lookup(int fd, const void *key, void *value);
|
||||
|
||||
#endif /* _NGX_BPF_H_INCLUDED_ */
|
||||
|
|
@ -137,7 +137,6 @@ ngx_chain_add_copy(ngx_pool_t *pool, ngx_chain_t **chain, ngx_chain_t *in)
|
|||
while (in) {
|
||||
cl = ngx_alloc_chain_link(pool);
|
||||
if (cl == NULL) {
|
||||
*ll = NULL;
|
||||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
|
|
@ -203,16 +202,16 @@ ngx_chain_update_chains(ngx_pool_t *p, ngx_chain_t **free, ngx_chain_t **busy,
|
|||
while (*busy) {
|
||||
cl = *busy;
|
||||
|
||||
if (ngx_buf_size(cl->buf) != 0) {
|
||||
break;
|
||||
}
|
||||
|
||||
if (cl->buf->tag != tag) {
|
||||
*busy = cl->next;
|
||||
ngx_free_chain(p, cl);
|
||||
continue;
|
||||
}
|
||||
|
||||
if (ngx_buf_size(cl->buf) != 0) {
|
||||
break;
|
||||
}
|
||||
|
||||
cl->buf->pos = cl->buf->start;
|
||||
cl->buf->last = cl->buf->start;
|
||||
|
||||
|
|
|
|||
|
|
@ -90,6 +90,9 @@ struct ngx_output_chain_ctx_s {
|
|||
|
||||
#if (NGX_HAVE_FILE_AIO || NGX_COMPAT)
|
||||
ngx_output_chain_aio_pt aio_handler;
|
||||
#if (NGX_HAVE_AIO_SENDFILE || NGX_COMPAT)
|
||||
ssize_t (*aio_preload)(ngx_buf_t *file);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if (NGX_THREADS || NGX_COMPAT)
|
||||
|
|
@ -122,20 +125,20 @@ typedef struct {
|
|||
#define NGX_CHAIN_ERROR (ngx_chain_t *) NGX_ERROR
|
||||
|
||||
|
||||
#define ngx_buf_in_memory(b) ((b)->temporary || (b)->memory || (b)->mmap)
|
||||
#define ngx_buf_in_memory_only(b) (ngx_buf_in_memory(b) && !(b)->in_file)
|
||||
#define ngx_buf_in_memory(b) (b->temporary || b->memory || b->mmap)
|
||||
#define ngx_buf_in_memory_only(b) (ngx_buf_in_memory(b) && !b->in_file)
|
||||
|
||||
#define ngx_buf_special(b) \
|
||||
(((b)->flush || (b)->last_buf || (b)->sync) \
|
||||
&& !ngx_buf_in_memory(b) && !(b)->in_file)
|
||||
((b->flush || b->last_buf || b->sync) \
|
||||
&& !ngx_buf_in_memory(b) && !b->in_file)
|
||||
|
||||
#define ngx_buf_sync_only(b) \
|
||||
((b)->sync && !ngx_buf_in_memory(b) \
|
||||
&& !(b)->in_file && !(b)->flush && !(b)->last_buf)
|
||||
(b->sync \
|
||||
&& !ngx_buf_in_memory(b) && !b->in_file && !b->flush && !b->last_buf)
|
||||
|
||||
#define ngx_buf_size(b) \
|
||||
(ngx_buf_in_memory(b) ? (off_t) ((b)->last - (b)->pos): \
|
||||
((b)->file_last - (b)->file_pos))
|
||||
(ngx_buf_in_memory(b) ? (off_t) (b->last - b->pos): \
|
||||
(b->file_last - b->file_pos))
|
||||
|
||||
ngx_buf_t *ngx_create_temp_buf(ngx_pool_t *pool, size_t size);
|
||||
ngx_chain_t *ngx_create_chain_of_bufs(ngx_pool_t *pool, ngx_bufs_t *bufs);
|
||||
|
|
@ -146,8 +149,8 @@ ngx_chain_t *ngx_create_chain_of_bufs(ngx_pool_t *pool, ngx_bufs_t *bufs);
|
|||
|
||||
ngx_chain_t *ngx_alloc_chain_link(ngx_pool_t *pool);
|
||||
#define ngx_free_chain(pool, cl) \
|
||||
(cl)->next = (pool)->chain; \
|
||||
(pool)->chain = (cl)
|
||||
cl->next = pool->chain; \
|
||||
pool->chain = cl
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -310,7 +310,7 @@ ngx_conf_parse(ngx_conf_t *cf, ngx_str_t *filename)
|
|||
goto failed;
|
||||
}
|
||||
|
||||
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "%s", rv);
|
||||
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, rv);
|
||||
|
||||
goto failed;
|
||||
}
|
||||
|
|
@ -544,8 +544,8 @@ ngx_conf_read_token(ngx_conf_t *cf)
|
|||
}
|
||||
|
||||
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
|
||||
"unexpected end of file, "
|
||||
"expecting \";\" or \"}\"");
|
||||
"unexpected end of file, "
|
||||
"expecting \";\" or \"}\"");
|
||||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
|
|
@ -656,14 +656,13 @@ ngx_conf_read_token(ngx_conf_t *cf)
|
|||
}
|
||||
|
||||
if (last_space) {
|
||||
|
||||
start = b->pos - 1;
|
||||
start_line = cf->conf_file->line;
|
||||
|
||||
if (ch == ' ' || ch == '\t' || ch == CR || ch == LF) {
|
||||
continue;
|
||||
}
|
||||
|
||||
start = b->pos - 1;
|
||||
start_line = cf->conf_file->line;
|
||||
|
||||
switch (ch) {
|
||||
|
||||
case ';':
|
||||
|
|
@ -1137,7 +1136,7 @@ ngx_conf_set_keyval_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
|
|||
|
||||
a = (ngx_array_t **) (p + cmd->offset);
|
||||
|
||||
if (*a == NGX_CONF_UNSET_PTR || *a == NULL) {
|
||||
if (*a == NULL) {
|
||||
*a = ngx_array_create(cf->pool, 4, sizeof(ngx_keyval_t));
|
||||
if (*a == NULL) {
|
||||
return NGX_CONF_ERROR;
|
||||
|
|
|
|||
|
|
@ -49,7 +49,7 @@
|
|||
#define NGX_DIRECT_CONF 0x00010000
|
||||
|
||||
#define NGX_MAIN_CONF 0x01000000
|
||||
#define NGX_ANY_CONF 0xFF000000
|
||||
#define NGX_ANY_CONF 0x1F000000
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -92,7 +92,7 @@ ngx_create_listening(ngx_conf_t *cf, struct sockaddr *sockaddr,
|
|||
|
||||
|
||||
ngx_int_t
|
||||
ngx_clone_listening(ngx_cycle_t *cycle, ngx_listening_t *ls)
|
||||
ngx_clone_listening(ngx_conf_t *cf, ngx_listening_t *ls)
|
||||
{
|
||||
#if (NGX_HAVE_REUSEPORT)
|
||||
|
||||
|
|
@ -100,19 +100,20 @@ ngx_clone_listening(ngx_cycle_t *cycle, ngx_listening_t *ls)
|
|||
ngx_core_conf_t *ccf;
|
||||
ngx_listening_t ols;
|
||||
|
||||
if (!ls->reuseport || ls->worker != 0) {
|
||||
if (!ls->reuseport) {
|
||||
return NGX_OK;
|
||||
}
|
||||
|
||||
ols = *ls;
|
||||
|
||||
ccf = (ngx_core_conf_t *) ngx_get_conf(cycle->conf_ctx, ngx_core_module);
|
||||
ccf = (ngx_core_conf_t *) ngx_get_conf(cf->cycle->conf_ctx,
|
||||
ngx_core_module);
|
||||
|
||||
for (n = 1; n < ccf->worker_processes; n++) {
|
||||
|
||||
/* create a socket for each worker process */
|
||||
|
||||
ls = ngx_array_push(&cycle->listening);
|
||||
ls = ngx_array_push(&cf->cycle->listening);
|
||||
if (ls == NULL) {
|
||||
return NGX_ERROR;
|
||||
}
|
||||
|
|
@ -276,22 +277,6 @@ ngx_set_inherited_sockets(ngx_cycle_t *cycle)
|
|||
reuseport = 0;
|
||||
olen = sizeof(int);
|
||||
|
||||
#ifdef SO_REUSEPORT_LB
|
||||
|
||||
if (getsockopt(ls[i].fd, SOL_SOCKET, SO_REUSEPORT_LB,
|
||||
(void *) &reuseport, &olen)
|
||||
== -1)
|
||||
{
|
||||
ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
|
||||
"getsockopt(SO_REUSEPORT_LB) %V failed, ignored",
|
||||
&ls[i].addr_text);
|
||||
|
||||
} else {
|
||||
ls[i].reuseport = reuseport ? 1 : 0;
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
if (getsockopt(ls[i].fd, SOL_SOCKET, SO_REUSEPORT,
|
||||
(void *) &reuseport, &olen)
|
||||
== -1)
|
||||
|
|
@ -303,7 +288,6 @@ ngx_set_inherited_sockets(ngx_cycle_t *cycle)
|
|||
} else {
|
||||
ls[i].reuseport = reuseport ? 1 : 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
|
|
@ -321,9 +305,7 @@ ngx_set_inherited_sockets(ngx_cycle_t *cycle)
|
|||
{
|
||||
err = ngx_socket_errno;
|
||||
|
||||
if (err != NGX_EOPNOTSUPP && err != NGX_ENOPROTOOPT
|
||||
&& err != NGX_EINVAL)
|
||||
{
|
||||
if (err != NGX_EOPNOTSUPP && err != NGX_ENOPROTOOPT) {
|
||||
ngx_log_error(NGX_LOG_NOTICE, cycle->log, err,
|
||||
"getsockopt(TCP_FASTOPEN) %V failed, ignored",
|
||||
&ls[i].addr_text);
|
||||
|
|
@ -442,20 +424,6 @@ ngx_open_listening_sockets(ngx_cycle_t *cycle)
|
|||
|
||||
int reuseport = 1;
|
||||
|
||||
#ifdef SO_REUSEPORT_LB
|
||||
|
||||
if (setsockopt(ls[i].fd, SOL_SOCKET, SO_REUSEPORT_LB,
|
||||
(const void *) &reuseport, sizeof(int))
|
||||
== -1)
|
||||
{
|
||||
ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
|
||||
"setsockopt(SO_REUSEPORT_LB) %V failed, "
|
||||
"ignored",
|
||||
&ls[i].addr_text);
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
if (setsockopt(ls[i].fd, SOL_SOCKET, SO_REUSEPORT,
|
||||
(const void *) &reuseport, sizeof(int))
|
||||
== -1)
|
||||
|
|
@ -464,7 +432,6 @@ ngx_open_listening_sockets(ngx_cycle_t *cycle)
|
|||
"setsockopt(SO_REUSEPORT) %V failed, ignored",
|
||||
&ls[i].addr_text);
|
||||
}
|
||||
#endif
|
||||
|
||||
ls[i].add_reuseport = 0;
|
||||
}
|
||||
|
|
@ -491,24 +458,21 @@ ngx_open_listening_sockets(ngx_cycle_t *cycle)
|
|||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
if (ls[i].type != SOCK_DGRAM || !ngx_test_config) {
|
||||
if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR,
|
||||
(const void *) &reuseaddr, sizeof(int))
|
||||
== -1)
|
||||
{
|
||||
ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
|
||||
"setsockopt(SO_REUSEADDR) %V failed",
|
||||
&ls[i].addr_text);
|
||||
|
||||
if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR,
|
||||
(const void *) &reuseaddr, sizeof(int))
|
||||
== -1)
|
||||
{
|
||||
if (ngx_close_socket(s) == -1) {
|
||||
ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
|
||||
"setsockopt(SO_REUSEADDR) %V failed",
|
||||
ngx_close_socket_n " %V failed",
|
||||
&ls[i].addr_text);
|
||||
|
||||
if (ngx_close_socket(s) == -1) {
|
||||
ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
|
||||
ngx_close_socket_n " %V failed",
|
||||
&ls[i].addr_text);
|
||||
}
|
||||
|
||||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
#if (NGX_HAVE_REUSEPORT)
|
||||
|
|
@ -518,27 +482,6 @@ ngx_open_listening_sockets(ngx_cycle_t *cycle)
|
|||
|
||||
reuseport = 1;
|
||||
|
||||
#ifdef SO_REUSEPORT_LB
|
||||
|
||||
if (setsockopt(s, SOL_SOCKET, SO_REUSEPORT_LB,
|
||||
(const void *) &reuseport, sizeof(int))
|
||||
== -1)
|
||||
{
|
||||
ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
|
||||
"setsockopt(SO_REUSEPORT_LB) %V failed",
|
||||
&ls[i].addr_text);
|
||||
|
||||
if (ngx_close_socket(s) == -1) {
|
||||
ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
|
||||
ngx_close_socket_n " %V failed",
|
||||
&ls[i].addr_text);
|
||||
}
|
||||
|
||||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
if (setsockopt(s, SOL_SOCKET, SO_REUSEPORT,
|
||||
(const void *) &reuseport, sizeof(int))
|
||||
== -1)
|
||||
|
|
@ -555,7 +498,6 @@ ngx_open_listening_sockets(ngx_cycle_t *cycle)
|
|||
|
||||
return NGX_ERROR;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
|
||||
|
|
@ -656,7 +598,7 @@ ngx_open_listening_sockets(ngx_cycle_t *cycle)
|
|||
/*
|
||||
* on OpenVZ after suspend/resume EADDRINUSE
|
||||
* may be returned by listen() instead of bind(), see
|
||||
* https://bugs.openvz.org/browse/OVZ-5587
|
||||
* https://bugzilla.openvz.org/show_bug.cgi?id=2470
|
||||
*/
|
||||
|
||||
if (err != NGX_EADDRINUSE || !ngx_test_config) {
|
||||
|
|
@ -1033,12 +975,6 @@ ngx_close_listening_sockets(ngx_cycle_t *cycle)
|
|||
ls = cycle->listening.elts;
|
||||
for (i = 0; i < cycle->listening.nelts; i++) {
|
||||
|
||||
#if (NGX_QUIC)
|
||||
if (ls[i].quic) {
|
||||
continue;
|
||||
}
|
||||
#endif
|
||||
|
||||
c = ls[i].connection;
|
||||
|
||||
if (c) {
|
||||
|
|
@ -1075,8 +1011,7 @@ ngx_close_listening_sockets(ngx_cycle_t *cycle)
|
|||
|
||||
if (ls[i].sockaddr->sa_family == AF_UNIX
|
||||
&& ngx_process <= NGX_PROCESS_MASTER
|
||||
&& ngx_new_binary == 0
|
||||
&& (!ls[i].inherited || ngx_getppid() != ngx_parent))
|
||||
&& ngx_new_binary == 0)
|
||||
{
|
||||
u_char *name = ls[i].addr_text.data + sizeof("unix:") - 1;
|
||||
|
||||
|
|
@ -1112,10 +1047,13 @@ ngx_get_connection(ngx_socket_t s, ngx_log_t *log)
|
|||
return NULL;
|
||||
}
|
||||
|
||||
ngx_drain_connections((ngx_cycle_t *) ngx_cycle);
|
||||
|
||||
c = ngx_cycle->free_connections;
|
||||
|
||||
if (c == NULL) {
|
||||
ngx_drain_connections((ngx_cycle_t *) ngx_cycle);
|
||||
c = ngx_cycle->free_connections;
|
||||
}
|
||||
|
||||
if (c == NULL) {
|
||||
ngx_log_error(NGX_LOG_ALERT, log, 0,
|
||||
"%ui worker_connections are not enough",
|
||||
|
|
@ -1300,22 +1238,6 @@ ngx_drain_connections(ngx_cycle_t *cycle)
|
|||
ngx_queue_t *q;
|
||||
ngx_connection_t *c;
|
||||
|
||||
if (cycle->free_connection_n > cycle->connection_n / 16
|
||||
|| cycle->reusable_connections_n == 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
if (cycle->connections_reuse_time != ngx_time()) {
|
||||
cycle->connections_reuse_time = ngx_time();
|
||||
|
||||
ngx_log_error(NGX_LOG_WARN, cycle->log, 0,
|
||||
"%ui worker_connections are not enough, "
|
||||
"reusing connections",
|
||||
cycle->connection_n);
|
||||
}
|
||||
|
||||
c = NULL;
|
||||
n = ngx_max(ngx_min(32, cycle->reusable_connections_n / 8), 1);
|
||||
|
||||
for (i = 0; i < n; i++) {
|
||||
|
|
@ -1332,21 +1254,6 @@ ngx_drain_connections(ngx_cycle_t *cycle)
|
|||
c->close = 1;
|
||||
c->read->handler(c->read);
|
||||
}
|
||||
|
||||
if (cycle->free_connection_n == 0 && c && c->reusable) {
|
||||
|
||||
/*
|
||||
* if no connections were freed, try to reuse the last
|
||||
* connection again: this should free it as long as
|
||||
* previous reuse moved it to lingering close
|
||||
*/
|
||||
|
||||
ngx_log_debug0(NGX_LOG_DEBUG_CORE, c->log, 0,
|
||||
"reusing connection again");
|
||||
|
||||
c->close = 1;
|
||||
c->read->handler(c->read);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -45,13 +45,12 @@ struct ngx_listening_s {
|
|||
size_t pool_size;
|
||||
/* should be here because of the AcceptEx() preread */
|
||||
size_t post_accept_buffer_size;
|
||||
/* should be here because of the deferred accept */
|
||||
ngx_msec_t post_accept_timeout;
|
||||
|
||||
ngx_listening_t *previous;
|
||||
ngx_connection_t *connection;
|
||||
|
||||
ngx_rbtree_t rbtree;
|
||||
ngx_rbtree_node_t sentinel;
|
||||
|
||||
ngx_uint_t worker;
|
||||
|
||||
unsigned open:1;
|
||||
|
|
@ -73,7 +72,6 @@ struct ngx_listening_s {
|
|||
unsigned reuseport:1;
|
||||
unsigned add_reuseport:1;
|
||||
unsigned keepalive:2;
|
||||
unsigned quic:1;
|
||||
|
||||
unsigned deferred_accept:1;
|
||||
unsigned delete_deferred:1;
|
||||
|
|
@ -146,18 +144,13 @@ struct ngx_connection_s {
|
|||
socklen_t socklen;
|
||||
ngx_str_t addr_text;
|
||||
|
||||
ngx_proxy_protocol_t *proxy_protocol;
|
||||
|
||||
#if (NGX_QUIC || NGX_COMPAT)
|
||||
ngx_quic_stream_t *quic;
|
||||
#endif
|
||||
ngx_str_t proxy_protocol_addr;
|
||||
in_port_t proxy_protocol_port;
|
||||
|
||||
#if (NGX_SSL || NGX_COMPAT)
|
||||
ngx_ssl_connection_t *ssl;
|
||||
#endif
|
||||
|
||||
ngx_udp_connection_t *udp;
|
||||
|
||||
struct sockaddr *local_sockaddr;
|
||||
socklen_t local_socklen;
|
||||
|
||||
|
|
@ -167,7 +160,6 @@ struct ngx_connection_s {
|
|||
|
||||
ngx_atomic_uint_t number;
|
||||
|
||||
ngx_msec_t start_time;
|
||||
ngx_uint_t requests;
|
||||
|
||||
unsigned buffered:8;
|
||||
|
|
@ -177,7 +169,6 @@ struct ngx_connection_s {
|
|||
unsigned timedout:1;
|
||||
unsigned error:1;
|
||||
unsigned destroyed:1;
|
||||
unsigned pipeline:1;
|
||||
|
||||
unsigned idle:1;
|
||||
unsigned reusable:1;
|
||||
|
|
@ -190,9 +181,8 @@ struct ngx_connection_s {
|
|||
unsigned tcp_nopush:2; /* ngx_connection_tcp_nopush_e */
|
||||
|
||||
unsigned need_last_buf:1;
|
||||
unsigned need_flush_buf:1;
|
||||
|
||||
#if (NGX_HAVE_SENDFILE_NODISKIO || NGX_COMPAT)
|
||||
#if (NGX_HAVE_AIO_SENDFILE || NGX_COMPAT)
|
||||
unsigned busy_count:2;
|
||||
#endif
|
||||
|
||||
|
|
@ -215,7 +205,7 @@ struct ngx_connection_s {
|
|||
|
||||
ngx_listening_t *ngx_create_listening(ngx_conf_t *cf, struct sockaddr *sockaddr,
|
||||
socklen_t socklen);
|
||||
ngx_int_t ngx_clone_listening(ngx_cycle_t *cycle, ngx_listening_t *ls);
|
||||
ngx_int_t ngx_clone_listening(ngx_conf_t *cf, ngx_listening_t *ls);
|
||||
ngx_int_t ngx_set_inherited_sockets(ngx_cycle_t *cycle);
|
||||
ngx_int_t ngx_open_listening_sockets(ngx_cycle_t *cycle);
|
||||
void ngx_configure_listening_sockets(ngx_cycle_t *cycle);
|
||||
|
|
|
|||
|
|
@ -26,10 +26,7 @@ typedef struct ngx_event_aio_s ngx_event_aio_t;
|
|||
typedef struct ngx_connection_s ngx_connection_t;
|
||||
typedef struct ngx_thread_task_s ngx_thread_task_t;
|
||||
typedef struct ngx_ssl_s ngx_ssl_t;
|
||||
typedef struct ngx_proxy_protocol_s ngx_proxy_protocol_t;
|
||||
typedef struct ngx_quic_stream_s ngx_quic_stream_t;
|
||||
typedef struct ngx_ssl_connection_s ngx_ssl_connection_t;
|
||||
typedef struct ngx_udp_connection_s ngx_udp_connection_t;
|
||||
|
||||
typedef void (*ngx_event_handler_pt)(ngx_event_t *ev);
|
||||
typedef void (*ngx_connection_handler_pt)(ngx_connection_t *c);
|
||||
|
|
@ -83,9 +80,6 @@ typedef void (*ngx_connection_handler_pt)(ngx_connection_t *c);
|
|||
#include <ngx_resolver.h>
|
||||
#if (NGX_OPENSSL)
|
||||
#include <ngx_event_openssl.h>
|
||||
#if (NGX_QUIC)
|
||||
#include <ngx_event_quic.h>
|
||||
#endif
|
||||
#endif
|
||||
#include <ngx_process_cycle.h>
|
||||
#include <ngx_conf_file.h>
|
||||
|
|
@ -95,9 +89,6 @@ typedef void (*ngx_connection_handler_pt)(ngx_connection_t *c);
|
|||
#include <ngx_connection.h>
|
||||
#include <ngx_syslog.h>
|
||||
#include <ngx_proxy_protocol.h>
|
||||
#if (NGX_HAVE_BPF)
|
||||
#include <ngx_bpf.h>
|
||||
#endif
|
||||
|
||||
|
||||
#define LF (u_char) '\n'
|
||||
|
|
|
|||
|
|
@ -96,15 +96,6 @@ ngx_init_cycle(ngx_cycle_t *old_cycle)
|
|||
return NULL;
|
||||
}
|
||||
|
||||
cycle->error_log.len = old_cycle->error_log.len;
|
||||
cycle->error_log.data = ngx_pnalloc(pool, old_cycle->error_log.len + 1);
|
||||
if (cycle->error_log.data == NULL) {
|
||||
ngx_destroy_pool(pool);
|
||||
return NULL;
|
||||
}
|
||||
ngx_cpystrn(cycle->error_log.data, old_cycle->error_log.data,
|
||||
old_cycle->error_log.len + 1);
|
||||
|
||||
cycle->conf_file.len = old_cycle->conf_file.len;
|
||||
cycle->conf_file.data = ngx_pnalloc(pool, old_cycle->conf_file.len + 1);
|
||||
if (cycle->conf_file.data == NULL) {
|
||||
|
|
@ -529,7 +520,6 @@ ngx_init_cycle(ngx_cycle_t *old_cycle)
|
|||
== NGX_OK)
|
||||
{
|
||||
nls[n].fd = ls[i].fd;
|
||||
nls[n].inherited = ls[i].inherited;
|
||||
nls[n].previous = &ls[i];
|
||||
ls[i].remain = 1;
|
||||
|
||||
|
|
@ -853,69 +843,6 @@ failed:
|
|||
}
|
||||
}
|
||||
|
||||
/* free the newly created shared memory */
|
||||
|
||||
part = &cycle->shared_memory.part;
|
||||
shm_zone = part->elts;
|
||||
|
||||
for (i = 0; /* void */ ; i++) {
|
||||
|
||||
if (i >= part->nelts) {
|
||||
if (part->next == NULL) {
|
||||
break;
|
||||
}
|
||||
part = part->next;
|
||||
shm_zone = part->elts;
|
||||
i = 0;
|
||||
}
|
||||
|
||||
if (shm_zone[i].shm.addr == NULL) {
|
||||
continue;
|
||||
}
|
||||
|
||||
opart = &old_cycle->shared_memory.part;
|
||||
oshm_zone = opart->elts;
|
||||
|
||||
for (n = 0; /* void */ ; n++) {
|
||||
|
||||
if (n >= opart->nelts) {
|
||||
if (opart->next == NULL) {
|
||||
break;
|
||||
}
|
||||
opart = opart->next;
|
||||
oshm_zone = opart->elts;
|
||||
n = 0;
|
||||
}
|
||||
|
||||
if (shm_zone[i].shm.name.len != oshm_zone[n].shm.name.len) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (ngx_strncmp(shm_zone[i].shm.name.data,
|
||||
oshm_zone[n].shm.name.data,
|
||||
shm_zone[i].shm.name.len)
|
||||
!= 0)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
if (shm_zone[i].tag == oshm_zone[n].tag
|
||||
&& shm_zone[i].shm.size == oshm_zone[n].shm.size
|
||||
&& !shm_zone[i].noreuse)
|
||||
{
|
||||
goto old_shm_zone_found;
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
ngx_shm_free(&shm_zone[i].shm);
|
||||
|
||||
old_shm_zone_found:
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
if (ngx_test_config) {
|
||||
ngx_destroy_cycle_pools(&conf);
|
||||
return NULL;
|
||||
|
|
@ -994,8 +921,7 @@ ngx_init_zone_pool(ngx_cycle_t *cycle, ngx_shm_zone_t *zn)
|
|||
|
||||
#else
|
||||
|
||||
file = ngx_pnalloc(cycle->pool,
|
||||
cycle->lock_file.len + zn->shm.name.len + 1);
|
||||
file = ngx_pnalloc(cycle->pool, cycle->lock_file.len + zn->shm.name.len);
|
||||
if (file == NULL) {
|
||||
return NGX_ERROR;
|
||||
}
|
||||
|
|
@ -1018,7 +944,6 @@ ngx_int_t
|
|||
ngx_create_pidfile(ngx_str_t *name, ngx_log_t *log)
|
||||
{
|
||||
size_t len;
|
||||
ngx_int_t rc;
|
||||
ngx_uint_t create;
|
||||
ngx_file_t file;
|
||||
u_char pid[NGX_INT64_LEN + 2];
|
||||
|
|
@ -1043,13 +968,11 @@ ngx_create_pidfile(ngx_str_t *name, ngx_log_t *log)
|
|||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
rc = NGX_OK;
|
||||
|
||||
if (!ngx_test_config) {
|
||||
len = ngx_snprintf(pid, NGX_INT64_LEN + 2, "%P%N", ngx_pid) - pid;
|
||||
|
||||
if (ngx_write_file(&file, pid, len, 0) == NGX_ERROR) {
|
||||
rc = NGX_ERROR;
|
||||
return NGX_ERROR;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1058,7 +981,7 @@ ngx_create_pidfile(ngx_str_t *name, ngx_log_t *log)
|
|||
ngx_close_file_n " \"%s\" failed", file.name.data);
|
||||
}
|
||||
|
||||
return rc;
|
||||
return NGX_OK;
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -1350,7 +1273,6 @@ ngx_shared_memory_add(ngx_conf_t *cf, ngx_str_t *name, size_t size, void *tag)
|
|||
|
||||
shm_zone->data = NULL;
|
||||
shm_zone->shm.log = cf->cycle->log;
|
||||
shm_zone->shm.addr = NULL;
|
||||
shm_zone->shm.size = size;
|
||||
shm_zone->shm.name = *name;
|
||||
shm_zone->shm.exists = 0;
|
||||
|
|
|
|||
|
|
@ -55,7 +55,6 @@ struct ngx_cycle_s {
|
|||
|
||||
ngx_queue_t reusable_connections_queue;
|
||||
ngx_uint_t reusable_connections_n;
|
||||
time_t connections_reuse_time;
|
||||
|
||||
ngx_array_t listening;
|
||||
ngx_array_t paths;
|
||||
|
|
@ -80,7 +79,6 @@ struct ngx_cycle_s {
|
|||
ngx_str_t conf_param;
|
||||
ngx_str_t conf_prefix;
|
||||
ngx_str_t prefix;
|
||||
ngx_str_t error_log;
|
||||
ngx_str_t lock_file;
|
||||
ngx_str_t hostname;
|
||||
};
|
||||
|
|
|
|||
|
|
@ -796,12 +796,10 @@ ngx_copy_file(u_char *from, u_char *to, ngx_copy_file_t *cf)
|
|||
{
|
||||
char *buf;
|
||||
off_t size;
|
||||
time_t time;
|
||||
size_t len;
|
||||
ssize_t n;
|
||||
ngx_fd_t fd, nfd;
|
||||
ngx_int_t rc;
|
||||
ngx_uint_t access;
|
||||
ngx_file_info_t fi;
|
||||
|
||||
rc = NGX_ERROR;
|
||||
|
|
@ -816,10 +814,8 @@ ngx_copy_file(u_char *from, u_char *to, ngx_copy_file_t *cf)
|
|||
goto failed;
|
||||
}
|
||||
|
||||
if (cf->size != -1 && cf->access != 0 && cf->time != -1) {
|
||||
if (cf->size != -1) {
|
||||
size = cf->size;
|
||||
access = cf->access;
|
||||
time = cf->time;
|
||||
|
||||
} else {
|
||||
if (ngx_fd_info(fd, &fi) == NGX_FILE_ERROR) {
|
||||
|
|
@ -829,9 +825,7 @@ ngx_copy_file(u_char *from, u_char *to, ngx_copy_file_t *cf)
|
|||
goto failed;
|
||||
}
|
||||
|
||||
size = (cf->size != -1) ? cf->size : ngx_file_size(&fi);
|
||||
access = cf->access ? cf->access : ngx_file_access(&fi);
|
||||
time = (cf->time != -1) ? cf->time : ngx_file_mtime(&fi);
|
||||
size = ngx_file_size(&fi);
|
||||
}
|
||||
|
||||
len = cf->buf_size ? cf->buf_size : 65536;
|
||||
|
|
@ -845,7 +839,8 @@ ngx_copy_file(u_char *from, u_char *to, ngx_copy_file_t *cf)
|
|||
goto failed;
|
||||
}
|
||||
|
||||
nfd = ngx_open_file(to, NGX_FILE_WRONLY, NGX_FILE_TRUNCATE, access);
|
||||
nfd = ngx_open_file(to, NGX_FILE_WRONLY, NGX_FILE_CREATE_OR_OPEN,
|
||||
cf->access);
|
||||
|
||||
if (nfd == NGX_INVALID_FILE) {
|
||||
ngx_log_error(NGX_LOG_CRIT, cf->log, ngx_errno,
|
||||
|
|
@ -892,10 +887,12 @@ ngx_copy_file(u_char *from, u_char *to, ngx_copy_file_t *cf)
|
|||
size -= n;
|
||||
}
|
||||
|
||||
if (ngx_set_file_time(to, nfd, time) != NGX_OK) {
|
||||
ngx_log_error(NGX_LOG_ALERT, cf->log, ngx_errno,
|
||||
ngx_set_file_time_n " \"%s\" failed", to);
|
||||
goto failed;
|
||||
if (cf->time != -1) {
|
||||
if (ngx_set_file_time(to, nfd, cf->time) != NGX_OK) {
|
||||
ngx_log_error(NGX_LOG_ALERT, cf->log, ngx_errno,
|
||||
ngx_set_file_time_n " \"%s\" failed", to);
|
||||
goto failed;
|
||||
}
|
||||
}
|
||||
|
||||
rc = NGX_OK;
|
||||
|
|
@ -1017,13 +1014,13 @@ ngx_walk_tree(ngx_tree_ctx_t *ctx, ngx_str_t *tree)
|
|||
|
||||
file.len = tree->len + 1 + len;
|
||||
|
||||
if (file.len > buf.len) {
|
||||
if (file.len + NGX_DIR_MASK_LEN > buf.len) {
|
||||
|
||||
if (buf.len) {
|
||||
ngx_free(buf.data);
|
||||
}
|
||||
|
||||
buf.len = tree->len + 1 + len;
|
||||
buf.len = tree->len + 1 + len + NGX_DIR_MASK_LEN;
|
||||
|
||||
buf.data = ngx_alloc(buf.len + 1, ctx->log);
|
||||
if (buf.data == NULL) {
|
||||
|
|
|
|||
|
|
@ -265,19 +265,7 @@ ngx_hash_init(ngx_hash_init_t *hinit, ngx_hash_key_t *names, ngx_uint_t nelts)
|
|||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
if (hinit->bucket_size > 65536 - ngx_cacheline_size) {
|
||||
ngx_log_error(NGX_LOG_EMERG, hinit->pool->log, 0,
|
||||
"could not build %s, too large "
|
||||
"%s_bucket_size: %i",
|
||||
hinit->name, hinit->name, hinit->bucket_size);
|
||||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
for (n = 0; n < nelts; n++) {
|
||||
if (names[n].key.data == NULL) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (hinit->bucket_size < NGX_HASH_ELT_SIZE(&names[n]) + sizeof(void *))
|
||||
{
|
||||
ngx_log_error(NGX_LOG_EMERG, hinit->pool->log, 0,
|
||||
|
|
@ -312,19 +300,17 @@ ngx_hash_init(ngx_hash_init_t *hinit, ngx_hash_key_t *names, ngx_uint_t nelts)
|
|||
}
|
||||
|
||||
key = names[n].key_hash % size;
|
||||
len = test[key] + NGX_HASH_ELT_SIZE(&names[n]);
|
||||
test[key] = (u_short) (test[key] + NGX_HASH_ELT_SIZE(&names[n]));
|
||||
|
||||
#if 0
|
||||
ngx_log_error(NGX_LOG_ALERT, hinit->pool->log, 0,
|
||||
"%ui: %ui %uz \"%V\"",
|
||||
size, key, len, &names[n].key);
|
||||
"%ui: %ui %ui \"%V\"",
|
||||
size, key, test[key], &names[n].key);
|
||||
#endif
|
||||
|
||||
if (len > bucket_size) {
|
||||
if (test[key] > (u_short) bucket_size) {
|
||||
goto next;
|
||||
}
|
||||
|
||||
test[key] = (u_short) len;
|
||||
}
|
||||
|
||||
goto found;
|
||||
|
|
@ -355,18 +341,7 @@ found:
|
|||
}
|
||||
|
||||
key = names[n].key_hash % size;
|
||||
len = test[key] + NGX_HASH_ELT_SIZE(&names[n]);
|
||||
|
||||
if (len > 65536 - ngx_cacheline_size) {
|
||||
ngx_log_error(NGX_LOG_EMERG, hinit->pool->log, 0,
|
||||
"could not build %s, you should "
|
||||
"increase %s_max_size: %i",
|
||||
hinit->name, hinit->name, hinit->max_size);
|
||||
ngx_free(test);
|
||||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
test[key] = (u_short) len;
|
||||
test[key] = (u_short) (test[key] + NGX_HASH_ELT_SIZE(&names[n]));
|
||||
}
|
||||
|
||||
len = 0;
|
||||
|
|
|
|||
|
|
@ -89,15 +89,12 @@ typedef struct {
|
|||
} ngx_hash_keys_arrays_t;
|
||||
|
||||
|
||||
typedef struct ngx_table_elt_s ngx_table_elt_t;
|
||||
|
||||
struct ngx_table_elt_s {
|
||||
typedef struct {
|
||||
ngx_uint_t hash;
|
||||
ngx_str_t key;
|
||||
ngx_str_t value;
|
||||
u_char *lowcase_key;
|
||||
ngx_table_elt_t *next;
|
||||
};
|
||||
} ngx_table_elt_t;
|
||||
|
||||
|
||||
void *ngx_hash_find(ngx_hash_t *hash, ngx_uint_t key, u_char *name, size_t len);
|
||||
|
|
|
|||
|
|
@ -12,8 +12,6 @@
|
|||
static ngx_int_t ngx_parse_unix_domain_url(ngx_pool_t *pool, ngx_url_t *u);
|
||||
static ngx_int_t ngx_parse_inet_url(ngx_pool_t *pool, ngx_url_t *u);
|
||||
static ngx_int_t ngx_parse_inet6_url(ngx_pool_t *pool, ngx_url_t *u);
|
||||
static ngx_int_t ngx_inet_add_addr(ngx_pool_t *pool, ngx_url_t *u,
|
||||
struct sockaddr *sockaddr, socklen_t socklen, ngx_uint_t total);
|
||||
|
||||
|
||||
in_addr_t
|
||||
|
|
@ -782,10 +780,13 @@ ngx_parse_unix_domain_url(ngx_pool_t *pool, ngx_url_t *u)
|
|||
static ngx_int_t
|
||||
ngx_parse_inet_url(ngx_pool_t *pool, ngx_url_t *u)
|
||||
{
|
||||
u_char *host, *port, *last, *uri, *args, *dash;
|
||||
size_t len;
|
||||
ngx_int_t n;
|
||||
struct sockaddr_in *sin;
|
||||
u_char *p, *host, *port, *last, *uri, *args;
|
||||
size_t len;
|
||||
ngx_int_t n;
|
||||
struct sockaddr_in *sin;
|
||||
#if (NGX_HAVE_INET6)
|
||||
struct sockaddr_in6 *sin6;
|
||||
#endif
|
||||
|
||||
u->socklen = sizeof(struct sockaddr_in);
|
||||
sin = (struct sockaddr_in *) &u->sockaddr;
|
||||
|
|
@ -830,25 +831,6 @@ ngx_parse_inet_url(ngx_pool_t *pool, ngx_url_t *u)
|
|||
|
||||
len = last - port;
|
||||
|
||||
if (u->listen) {
|
||||
dash = ngx_strlchr(port, last, '-');
|
||||
|
||||
if (dash) {
|
||||
dash++;
|
||||
|
||||
n = ngx_atoi(dash, last - dash);
|
||||
|
||||
if (n < 1 || n > 65535) {
|
||||
u->err = "invalid port";
|
||||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
u->last_port = (in_port_t) n;
|
||||
|
||||
len = dash - port - 1;
|
||||
}
|
||||
}
|
||||
|
||||
n = ngx_atoi(port, len);
|
||||
|
||||
if (n < 1 || n > 65535) {
|
||||
|
|
@ -856,15 +838,10 @@ ngx_parse_inet_url(ngx_pool_t *pool, ngx_url_t *u)
|
|||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
if (u->last_port && n > u->last_port) {
|
||||
u->err = "invalid port range";
|
||||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
u->port = (in_port_t) n;
|
||||
sin->sin_port = htons((in_port_t) n);
|
||||
|
||||
u->port_text.len = last - port;
|
||||
u->port_text.len = len;
|
||||
u->port_text.data = port;
|
||||
|
||||
last = port - 1;
|
||||
|
|
@ -876,69 +853,31 @@ ngx_parse_inet_url(ngx_pool_t *pool, ngx_url_t *u)
|
|||
|
||||
/* test value as port only */
|
||||
|
||||
len = last - host;
|
||||
|
||||
dash = ngx_strlchr(host, last, '-');
|
||||
|
||||
if (dash) {
|
||||
dash++;
|
||||
|
||||
n = ngx_atoi(dash, last - dash);
|
||||
|
||||
if (n == NGX_ERROR) {
|
||||
goto no_port;
|
||||
}
|
||||
|
||||
if (n < 1 || n > 65535) {
|
||||
u->err = "invalid port";
|
||||
|
||||
} else {
|
||||
u->last_port = (in_port_t) n;
|
||||
}
|
||||
|
||||
len = dash - host - 1;
|
||||
}
|
||||
|
||||
n = ngx_atoi(host, len);
|
||||
n = ngx_atoi(host, last - host);
|
||||
|
||||
if (n != NGX_ERROR) {
|
||||
|
||||
if (u->err) {
|
||||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
if (n < 1 || n > 65535) {
|
||||
u->err = "invalid port";
|
||||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
if (u->last_port && n > u->last_port) {
|
||||
u->err = "invalid port range";
|
||||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
u->port = (in_port_t) n;
|
||||
sin->sin_port = htons((in_port_t) n);
|
||||
sin->sin_addr.s_addr = INADDR_ANY;
|
||||
|
||||
u->port_text.len = last - host;
|
||||
u->port_text.data = host;
|
||||
|
||||
u->wildcard = 1;
|
||||
|
||||
return ngx_inet_add_addr(pool, u, &u->sockaddr.sockaddr,
|
||||
u->socklen, 1);
|
||||
return NGX_OK;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
no_port:
|
||||
|
||||
u->err = NULL;
|
||||
u->no_port = 1;
|
||||
u->port = u->default_port;
|
||||
sin->sin_port = htons(u->default_port);
|
||||
u->last_port = 0;
|
||||
}
|
||||
|
||||
len = last - host;
|
||||
|
|
@ -954,7 +893,7 @@ no_port:
|
|||
if (u->listen && len == 1 && *host == '*') {
|
||||
sin->sin_addr.s_addr = INADDR_ANY;
|
||||
u->wildcard = 1;
|
||||
return ngx_inet_add_addr(pool, u, &u->sockaddr.sockaddr, u->socklen, 1);
|
||||
return NGX_OK;
|
||||
}
|
||||
|
||||
sin->sin_addr.s_addr = ngx_inet_addr(host, len);
|
||||
|
|
@ -965,7 +904,33 @@ no_port:
|
|||
u->wildcard = 1;
|
||||
}
|
||||
|
||||
return ngx_inet_add_addr(pool, u, &u->sockaddr.sockaddr, u->socklen, 1);
|
||||
u->naddrs = 1;
|
||||
|
||||
u->addrs = ngx_pcalloc(pool, sizeof(ngx_addr_t));
|
||||
if (u->addrs == NULL) {
|
||||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
sin = ngx_pcalloc(pool, sizeof(struct sockaddr_in));
|
||||
if (sin == NULL) {
|
||||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
ngx_memcpy(sin, &u->sockaddr, sizeof(struct sockaddr_in));
|
||||
|
||||
u->addrs[0].sockaddr = (struct sockaddr *) sin;
|
||||
u->addrs[0].socklen = sizeof(struct sockaddr_in);
|
||||
|
||||
p = ngx_pnalloc(pool, u->host.len + sizeof(":65535") - 1);
|
||||
if (p == NULL) {
|
||||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
u->addrs[0].name.len = ngx_sprintf(p, "%V:%d",
|
||||
&u->host, u->port) - p;
|
||||
u->addrs[0].name.data = p;
|
||||
|
||||
return NGX_OK;
|
||||
}
|
||||
|
||||
if (u->no_resolve) {
|
||||
|
|
@ -979,7 +944,29 @@ no_port:
|
|||
u->family = u->addrs[0].sockaddr->sa_family;
|
||||
u->socklen = u->addrs[0].socklen;
|
||||
ngx_memcpy(&u->sockaddr, u->addrs[0].sockaddr, u->addrs[0].socklen);
|
||||
u->wildcard = ngx_inet_wildcard(&u->sockaddr.sockaddr);
|
||||
|
||||
switch (u->family) {
|
||||
|
||||
#if (NGX_HAVE_INET6)
|
||||
case AF_INET6:
|
||||
sin6 = (struct sockaddr_in6 *) &u->sockaddr;
|
||||
|
||||
if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) {
|
||||
u->wildcard = 1;
|
||||
}
|
||||
|
||||
break;
|
||||
#endif
|
||||
|
||||
default: /* AF_INET */
|
||||
sin = (struct sockaddr_in *) &u->sockaddr;
|
||||
|
||||
if (sin->sin_addr.s_addr == INADDR_ANY) {
|
||||
u->wildcard = 1;
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
return NGX_OK;
|
||||
}
|
||||
|
|
@ -989,7 +976,7 @@ static ngx_int_t
|
|||
ngx_parse_inet6_url(ngx_pool_t *pool, ngx_url_t *u)
|
||||
{
|
||||
#if (NGX_HAVE_INET6)
|
||||
u_char *p, *host, *port, *last, *uri, *dash;
|
||||
u_char *p, *host, *port, *last, *uri;
|
||||
size_t len;
|
||||
ngx_int_t n;
|
||||
struct sockaddr_in6 *sin6;
|
||||
|
|
@ -1035,25 +1022,6 @@ ngx_parse_inet6_url(ngx_pool_t *pool, ngx_url_t *u)
|
|||
|
||||
len = last - port;
|
||||
|
||||
if (u->listen) {
|
||||
dash = ngx_strlchr(port, last, '-');
|
||||
|
||||
if (dash) {
|
||||
dash++;
|
||||
|
||||
n = ngx_atoi(dash, last - dash);
|
||||
|
||||
if (n < 1 || n > 65535) {
|
||||
u->err = "invalid port";
|
||||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
u->last_port = (in_port_t) n;
|
||||
|
||||
len = dash - port - 1;
|
||||
}
|
||||
}
|
||||
|
||||
n = ngx_atoi(port, len);
|
||||
|
||||
if (n < 1 || n > 65535) {
|
||||
|
|
@ -1061,15 +1029,10 @@ ngx_parse_inet6_url(ngx_pool_t *pool, ngx_url_t *u)
|
|||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
if (u->last_port && n > u->last_port) {
|
||||
u->err = "invalid port range";
|
||||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
u->port = (in_port_t) n;
|
||||
sin6->sin6_port = htons((in_port_t) n);
|
||||
|
||||
u->port_text.len = last - port;
|
||||
u->port_text.len = len;
|
||||
u->port_text.data = port;
|
||||
|
||||
} else {
|
||||
|
|
@ -1098,8 +1061,33 @@ ngx_parse_inet6_url(ngx_pool_t *pool, ngx_url_t *u)
|
|||
}
|
||||
|
||||
u->family = AF_INET6;
|
||||
u->naddrs = 1;
|
||||
|
||||
return ngx_inet_add_addr(pool, u, &u->sockaddr.sockaddr, u->socklen, 1);
|
||||
u->addrs = ngx_pcalloc(pool, sizeof(ngx_addr_t));
|
||||
if (u->addrs == NULL) {
|
||||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
sin6 = ngx_pcalloc(pool, sizeof(struct sockaddr_in6));
|
||||
if (sin6 == NULL) {
|
||||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
ngx_memcpy(sin6, &u->sockaddr, sizeof(struct sockaddr_in6));
|
||||
|
||||
u->addrs[0].sockaddr = (struct sockaddr *) sin6;
|
||||
u->addrs[0].socklen = sizeof(struct sockaddr_in6);
|
||||
|
||||
p = ngx_pnalloc(pool, u->host.len + sizeof(":65535") - 1);
|
||||
if (p == NULL) {
|
||||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
u->addrs[0].name.len = ngx_sprintf(p, "%V:%d",
|
||||
&u->host, u->port) - p;
|
||||
u->addrs[0].name.data = p;
|
||||
|
||||
return NGX_OK;
|
||||
|
||||
#else
|
||||
|
||||
|
|
@ -1116,9 +1104,15 @@ ngx_parse_inet6_url(ngx_pool_t *pool, ngx_url_t *u)
|
|||
ngx_int_t
|
||||
ngx_inet_resolve_host(ngx_pool_t *pool, ngx_url_t *u)
|
||||
{
|
||||
u_char *host;
|
||||
ngx_uint_t n;
|
||||
struct addrinfo hints, *res, *rp;
|
||||
u_char *p, *host;
|
||||
size_t len;
|
||||
in_port_t port;
|
||||
ngx_uint_t i;
|
||||
struct addrinfo hints, *res, *rp;
|
||||
struct sockaddr_in *sin;
|
||||
struct sockaddr_in6 *sin6;
|
||||
|
||||
port = htons(u->port);
|
||||
|
||||
host = ngx_alloc(u->host.len + 1, pool->log);
|
||||
if (host == NULL) {
|
||||
|
|
@ -1142,7 +1136,7 @@ ngx_inet_resolve_host(ngx_pool_t *pool, ngx_url_t *u)
|
|||
|
||||
ngx_free(host);
|
||||
|
||||
for (n = 0, rp = res; rp != NULL; rp = rp->ai_next) {
|
||||
for (i = 0, rp = res; rp != NULL; rp = rp->ai_next) {
|
||||
|
||||
switch (rp->ai_family) {
|
||||
|
||||
|
|
@ -1154,33 +1148,92 @@ ngx_inet_resolve_host(ngx_pool_t *pool, ngx_url_t *u)
|
|||
continue;
|
||||
}
|
||||
|
||||
n++;
|
||||
i++;
|
||||
}
|
||||
|
||||
if (n == 0) {
|
||||
if (i == 0) {
|
||||
u->err = "host not found";
|
||||
goto failed;
|
||||
}
|
||||
|
||||
/* MP: ngx_shared_palloc() */
|
||||
|
||||
u->addrs = ngx_pcalloc(pool, i * sizeof(ngx_addr_t));
|
||||
if (u->addrs == NULL) {
|
||||
goto failed;
|
||||
}
|
||||
|
||||
u->naddrs = i;
|
||||
|
||||
i = 0;
|
||||
|
||||
/* AF_INET addresses first */
|
||||
|
||||
for (rp = res; rp != NULL; rp = rp->ai_next) {
|
||||
|
||||
switch (rp->ai_family) {
|
||||
|
||||
case AF_INET:
|
||||
case AF_INET6:
|
||||
break;
|
||||
|
||||
default:
|
||||
if (rp->ai_family != AF_INET) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (ngx_inet_add_addr(pool, u, rp->ai_addr, rp->ai_addrlen, n)
|
||||
!= NGX_OK)
|
||||
{
|
||||
sin = ngx_pcalloc(pool, rp->ai_addrlen);
|
||||
if (sin == NULL) {
|
||||
goto failed;
|
||||
}
|
||||
|
||||
ngx_memcpy(sin, rp->ai_addr, rp->ai_addrlen);
|
||||
|
||||
sin->sin_port = port;
|
||||
|
||||
u->addrs[i].sockaddr = (struct sockaddr *) sin;
|
||||
u->addrs[i].socklen = rp->ai_addrlen;
|
||||
|
||||
len = NGX_INET_ADDRSTRLEN + sizeof(":65535") - 1;
|
||||
|
||||
p = ngx_pnalloc(pool, len);
|
||||
if (p == NULL) {
|
||||
goto failed;
|
||||
}
|
||||
|
||||
len = ngx_sock_ntop((struct sockaddr *) sin, rp->ai_addrlen, p, len, 1);
|
||||
|
||||
u->addrs[i].name.len = len;
|
||||
u->addrs[i].name.data = p;
|
||||
|
||||
i++;
|
||||
}
|
||||
|
||||
for (rp = res; rp != NULL; rp = rp->ai_next) {
|
||||
|
||||
if (rp->ai_family != AF_INET6) {
|
||||
continue;
|
||||
}
|
||||
|
||||
sin6 = ngx_pcalloc(pool, rp->ai_addrlen);
|
||||
if (sin6 == NULL) {
|
||||
goto failed;
|
||||
}
|
||||
|
||||
ngx_memcpy(sin6, rp->ai_addr, rp->ai_addrlen);
|
||||
|
||||
sin6->sin6_port = port;
|
||||
|
||||
u->addrs[i].sockaddr = (struct sockaddr *) sin6;
|
||||
u->addrs[i].socklen = rp->ai_addrlen;
|
||||
|
||||
len = NGX_INET6_ADDRSTRLEN + sizeof("[]:65535") - 1;
|
||||
|
||||
p = ngx_pnalloc(pool, len);
|
||||
if (p == NULL) {
|
||||
goto failed;
|
||||
}
|
||||
|
||||
len = ngx_sock_ntop((struct sockaddr *) sin6, rp->ai_addrlen, p,
|
||||
len, 1);
|
||||
|
||||
u->addrs[i].name.len = len;
|
||||
u->addrs[i].name.data = p;
|
||||
|
||||
i++;
|
||||
}
|
||||
|
||||
freeaddrinfo(res);
|
||||
|
|
@ -1197,19 +1250,21 @@ failed:
|
|||
ngx_int_t
|
||||
ngx_inet_resolve_host(ngx_pool_t *pool, ngx_url_t *u)
|
||||
{
|
||||
u_char *host;
|
||||
ngx_uint_t i, n;
|
||||
u_char *p, *host;
|
||||
size_t len;
|
||||
in_port_t port;
|
||||
in_addr_t in_addr;
|
||||
ngx_uint_t i;
|
||||
struct hostent *h;
|
||||
struct sockaddr_in sin;
|
||||
struct sockaddr_in *sin;
|
||||
|
||||
/* AF_INET only */
|
||||
|
||||
ngx_memzero(&sin, sizeof(struct sockaddr_in));
|
||||
port = htons(u->port);
|
||||
|
||||
sin.sin_family = AF_INET;
|
||||
sin.sin_addr.s_addr = ngx_inet_addr(u->host.data, u->host.len);
|
||||
in_addr = ngx_inet_addr(u->host.data, u->host.len);
|
||||
|
||||
if (sin.sin_addr.s_addr == INADDR_NONE) {
|
||||
if (in_addr == INADDR_NONE) {
|
||||
host = ngx_alloc(u->host.len + 1, pool->log);
|
||||
if (host == NULL) {
|
||||
return NGX_ERROR;
|
||||
|
|
@ -1226,31 +1281,76 @@ ngx_inet_resolve_host(ngx_pool_t *pool, ngx_url_t *u)
|
|||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
for (n = 0; h->h_addr_list[n] != NULL; n++) { /* void */ }
|
||||
for (i = 0; h->h_addr_list[i] != NULL; i++) { /* void */ }
|
||||
|
||||
/* MP: ngx_shared_palloc() */
|
||||
|
||||
for (i = 0; i < n; i++) {
|
||||
sin.sin_addr.s_addr = *(in_addr_t *) (h->h_addr_list[i]);
|
||||
u->addrs = ngx_pcalloc(pool, i * sizeof(ngx_addr_t));
|
||||
if (u->addrs == NULL) {
|
||||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
if (ngx_inet_add_addr(pool, u, (struct sockaddr *) &sin,
|
||||
sizeof(struct sockaddr_in), n)
|
||||
!= NGX_OK)
|
||||
{
|
||||
u->naddrs = i;
|
||||
|
||||
for (i = 0; i < u->naddrs; i++) {
|
||||
|
||||
sin = ngx_pcalloc(pool, sizeof(struct sockaddr_in));
|
||||
if (sin == NULL) {
|
||||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
sin->sin_family = AF_INET;
|
||||
sin->sin_port = port;
|
||||
sin->sin_addr.s_addr = *(in_addr_t *) (h->h_addr_list[i]);
|
||||
|
||||
u->addrs[i].sockaddr = (struct sockaddr *) sin;
|
||||
u->addrs[i].socklen = sizeof(struct sockaddr_in);
|
||||
|
||||
len = NGX_INET_ADDRSTRLEN + sizeof(":65535") - 1;
|
||||
|
||||
p = ngx_pnalloc(pool, len);
|
||||
if (p == NULL) {
|
||||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
len = ngx_sock_ntop((struct sockaddr *) sin,
|
||||
sizeof(struct sockaddr_in), p, len, 1);
|
||||
|
||||
u->addrs[i].name.len = len;
|
||||
u->addrs[i].name.data = p;
|
||||
}
|
||||
|
||||
} else {
|
||||
|
||||
/* MP: ngx_shared_palloc() */
|
||||
|
||||
if (ngx_inet_add_addr(pool, u, (struct sockaddr *) &sin,
|
||||
sizeof(struct sockaddr_in), 1)
|
||||
!= NGX_OK)
|
||||
{
|
||||
u->addrs = ngx_pcalloc(pool, sizeof(ngx_addr_t));
|
||||
if (u->addrs == NULL) {
|
||||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
sin = ngx_pcalloc(pool, sizeof(struct sockaddr_in));
|
||||
if (sin == NULL) {
|
||||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
u->naddrs = 1;
|
||||
|
||||
sin->sin_family = AF_INET;
|
||||
sin->sin_port = port;
|
||||
sin->sin_addr.s_addr = in_addr;
|
||||
|
||||
u->addrs[0].sockaddr = (struct sockaddr *) sin;
|
||||
u->addrs[0].socklen = sizeof(struct sockaddr_in);
|
||||
|
||||
p = ngx_pnalloc(pool, u->host.len + sizeof(":65535") - 1);
|
||||
if (p == NULL) {
|
||||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
u->addrs[0].name.len = ngx_sprintf(p, "%V:%d",
|
||||
&u->host, ntohs(port)) - p;
|
||||
u->addrs[0].name.data = p;
|
||||
}
|
||||
|
||||
return NGX_OK;
|
||||
|
|
@ -1259,67 +1359,6 @@ ngx_inet_resolve_host(ngx_pool_t *pool, ngx_url_t *u)
|
|||
#endif /* NGX_HAVE_GETADDRINFO && NGX_HAVE_INET6 */
|
||||
|
||||
|
||||
static ngx_int_t
|
||||
ngx_inet_add_addr(ngx_pool_t *pool, ngx_url_t *u, struct sockaddr *sockaddr,
|
||||
socklen_t socklen, ngx_uint_t total)
|
||||
{
|
||||
u_char *p;
|
||||
size_t len;
|
||||
ngx_uint_t i, nports;
|
||||
ngx_addr_t *addr;
|
||||
struct sockaddr *sa;
|
||||
|
||||
nports = u->last_port ? u->last_port - u->port + 1 : 1;
|
||||
|
||||
if (u->addrs == NULL) {
|
||||
u->addrs = ngx_palloc(pool, total * nports * sizeof(ngx_addr_t));
|
||||
if (u->addrs == NULL) {
|
||||
return NGX_ERROR;
|
||||
}
|
||||
}
|
||||
|
||||
for (i = 0; i < nports; i++) {
|
||||
sa = ngx_pcalloc(pool, socklen);
|
||||
if (sa == NULL) {
|
||||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
ngx_memcpy(sa, sockaddr, socklen);
|
||||
|
||||
ngx_inet_set_port(sa, u->port + i);
|
||||
|
||||
switch (sa->sa_family) {
|
||||
|
||||
#if (NGX_HAVE_INET6)
|
||||
case AF_INET6:
|
||||
len = NGX_INET6_ADDRSTRLEN + sizeof("[]:65536") - 1;
|
||||
break;
|
||||
#endif
|
||||
|
||||
default: /* AF_INET */
|
||||
len = NGX_INET_ADDRSTRLEN + sizeof(":65535") - 1;
|
||||
}
|
||||
|
||||
p = ngx_pnalloc(pool, len);
|
||||
if (p == NULL) {
|
||||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
len = ngx_sock_ntop(sa, socklen, p, len, 1);
|
||||
|
||||
addr = &u->addrs[u->naddrs++];
|
||||
|
||||
addr->sockaddr = sa;
|
||||
addr->socklen = socklen;
|
||||
|
||||
addr->name.len = len;
|
||||
addr->name.data = p;
|
||||
}
|
||||
|
||||
return NGX_OK;
|
||||
}
|
||||
|
||||
|
||||
ngx_int_t
|
||||
ngx_cmp_sockaddr(struct sockaddr *sa1, socklen_t slen1,
|
||||
struct sockaddr *sa2, socklen_t slen2, ngx_uint_t cmp_port)
|
||||
|
|
@ -1456,40 +1495,3 @@ ngx_inet_set_port(struct sockaddr *sa, in_port_t port)
|
|||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
ngx_uint_t
|
||||
ngx_inet_wildcard(struct sockaddr *sa)
|
||||
{
|
||||
struct sockaddr_in *sin;
|
||||
#if (NGX_HAVE_INET6)
|
||||
struct sockaddr_in6 *sin6;
|
||||
#endif
|
||||
|
||||
switch (sa->sa_family) {
|
||||
|
||||
case AF_INET:
|
||||
sin = (struct sockaddr_in *) sa;
|
||||
|
||||
if (sin->sin_addr.s_addr == INADDR_ANY) {
|
||||
return 1;
|
||||
}
|
||||
|
||||
break;
|
||||
|
||||
#if (NGX_HAVE_INET6)
|
||||
|
||||
case AF_INET6:
|
||||
sin6 = (struct sockaddr_in6 *) sa;
|
||||
|
||||
if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) {
|
||||
return 1;
|
||||
}
|
||||
|
||||
break;
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -86,7 +86,6 @@ typedef struct {
|
|||
|
||||
in_port_t port;
|
||||
in_port_t default_port;
|
||||
in_port_t last_port;
|
||||
int family;
|
||||
|
||||
unsigned listen:1;
|
||||
|
|
@ -126,7 +125,6 @@ ngx_int_t ngx_cmp_sockaddr(struct sockaddr *sa1, socklen_t slen1,
|
|||
struct sockaddr *sa2, socklen_t slen2, ngx_uint_t cmp_port);
|
||||
in_port_t ngx_inet_get_port(struct sockaddr *sa);
|
||||
void ngx_inet_set_port(struct sockaddr *sa, in_port_t port);
|
||||
ngx_uint_t ngx_inet_wildcard(struct sockaddr *sa);
|
||||
|
||||
|
||||
#endif /* _NGX_INET_H_INCLUDED_ */
|
||||
|
|
|
|||
|
|
@ -315,7 +315,7 @@ ngx_log_errno(u_char *buf, u_char *last, ngx_err_t err)
|
|||
|
||||
|
||||
ngx_log_t *
|
||||
ngx_log_init(u_char *prefix, u_char *error_log)
|
||||
ngx_log_init(u_char *prefix)
|
||||
{
|
||||
u_char *p, *name;
|
||||
size_t nlen, plen;
|
||||
|
|
@ -323,11 +323,13 @@ ngx_log_init(u_char *prefix, u_char *error_log)
|
|||
ngx_log.file = &ngx_log_file;
|
||||
ngx_log.log_level = NGX_LOG_NOTICE;
|
||||
|
||||
if (error_log == NULL) {
|
||||
error_log = (u_char *) NGX_ERROR_LOG_PATH;
|
||||
}
|
||||
name = (u_char *) NGX_ERROR_LOG_PATH;
|
||||
|
||||
/*
|
||||
* we use ngx_strlen() here since BCC warns about
|
||||
* condition is always false and unreachable code
|
||||
*/
|
||||
|
||||
name = error_log;
|
||||
nlen = ngx_strlen(name);
|
||||
|
||||
if (nlen == 0) {
|
||||
|
|
@ -367,7 +369,7 @@ ngx_log_init(u_char *prefix, u_char *error_log)
|
|||
*p++ = '/';
|
||||
}
|
||||
|
||||
ngx_cpystrn(p, error_log, nlen + 1);
|
||||
ngx_cpystrn(p, (u_char *) NGX_ERROR_LOG_PATH, nlen + 1);
|
||||
|
||||
p = name;
|
||||
}
|
||||
|
|
@ -401,7 +403,8 @@ ngx_log_init(u_char *prefix, u_char *error_log)
|
|||
ngx_int_t
|
||||
ngx_log_open_default(ngx_cycle_t *cycle)
|
||||
{
|
||||
ngx_log_t *log;
|
||||
ngx_log_t *log;
|
||||
static ngx_str_t error_log = ngx_string(NGX_ERROR_LOG_PATH);
|
||||
|
||||
if (ngx_log_get_file_log(&cycle->new_log) != NULL) {
|
||||
return NGX_OK;
|
||||
|
|
@ -422,7 +425,7 @@ ngx_log_open_default(ngx_cycle_t *cycle)
|
|||
|
||||
log->log_level = NGX_LOG_ERR;
|
||||
|
||||
log->file = ngx_conf_open_file(cycle, &cycle->error_log);
|
||||
log->file = ngx_conf_open_file(cycle, &error_log);
|
||||
if (log->file == NULL) {
|
||||
return NGX_ERROR;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -228,7 +228,7 @@ void ngx_cdecl ngx_log_debug_core(ngx_log_t *log, ngx_err_t err,
|
|||
|
||||
/*********************************/
|
||||
|
||||
ngx_log_t *ngx_log_init(u_char *prefix, u_char *error_log);
|
||||
ngx_log_t *ngx_log_init(u_char *prefix);
|
||||
void ngx_cdecl ngx_log_abort(ngx_err_t err, const char *fmt, ...);
|
||||
void ngx_cdecl ngx_log_stderr(ngx_err_t err, const char *fmt, ...);
|
||||
u_char *ngx_log_errno(u_char *buf, u_char *last, ngx_err_t err);
|
||||
|
|
|
|||
|
|
@ -41,7 +41,7 @@
|
|||
#define NGX_MODULE_SIGNATURE_3 "0"
|
||||
#endif
|
||||
|
||||
#if (NGX_HAVE_SENDFILE_NODISKIO || NGX_COMPAT)
|
||||
#if (NGX_HAVE_AIO_SENDFILE || NGX_COMPAT)
|
||||
#define NGX_MODULE_SIGNATURE_4 "1"
|
||||
#else
|
||||
#define NGX_MODULE_SIGNATURE_4 "0"
|
||||
|
|
|
|||
|
|
@ -29,6 +29,10 @@
|
|||
|
||||
static ngx_inline ngx_int_t
|
||||
ngx_output_chain_as_is(ngx_output_chain_ctx_t *ctx, ngx_buf_t *buf);
|
||||
#if (NGX_HAVE_AIO_SENDFILE)
|
||||
static ngx_int_t ngx_output_chain_aio_setup(ngx_output_chain_ctx_t *ctx,
|
||||
ngx_file_t *file);
|
||||
#endif
|
||||
static ngx_int_t ngx_output_chain_add_copy(ngx_pool_t *pool,
|
||||
ngx_chain_t **chain, ngx_chain_t *in);
|
||||
static ngx_int_t ngx_output_chain_align_file_buf(ngx_output_chain_ctx_t *ctx,
|
||||
|
|
@ -122,26 +126,6 @@ ngx_output_chain(ngx_output_chain_ctx_t *ctx, ngx_chain_t *in)
|
|||
continue;
|
||||
}
|
||||
|
||||
if (bsize < 0) {
|
||||
|
||||
ngx_log_error(NGX_LOG_ALERT, ctx->pool->log, 0,
|
||||
"negative size buf in output "
|
||||
"t:%d r:%d f:%d %p %p-%p %p %O-%O",
|
||||
ctx->in->buf->temporary,
|
||||
ctx->in->buf->recycled,
|
||||
ctx->in->buf->in_file,
|
||||
ctx->in->buf->start,
|
||||
ctx->in->buf->pos,
|
||||
ctx->in->buf->last,
|
||||
ctx->in->buf->file,
|
||||
ctx->in->buf->file_pos,
|
||||
ctx->in->buf->file_last);
|
||||
|
||||
ngx_debug_point();
|
||||
|
||||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
if (ngx_output_chain_as_is(ctx, ctx->in->buf)) {
|
||||
|
||||
/* move the chain link to the output chain */
|
||||
|
|
@ -256,6 +240,10 @@ ngx_output_chain_as_is(ngx_output_chain_ctx_t *ctx, ngx_buf_t *buf)
|
|||
}
|
||||
#endif
|
||||
|
||||
if (buf->in_file && buf->file->directio) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
sendfile = ctx->sendfile;
|
||||
|
||||
#if (NGX_SENDFILE_LIMIT)
|
||||
|
|
@ -264,19 +252,6 @@ ngx_output_chain_as_is(ngx_output_chain_ctx_t *ctx, ngx_buf_t *buf)
|
|||
sendfile = 0;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
#if !(NGX_HAVE_SENDFILE_NODISKIO)
|
||||
|
||||
/*
|
||||
* With DIRECTIO, disable sendfile() unless sendfile(SF_NOCACHE)
|
||||
* is available.
|
||||
*/
|
||||
|
||||
if (buf->in_file && buf->file->directio) {
|
||||
sendfile = 0;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
if (!sendfile) {
|
||||
|
|
@ -288,6 +263,12 @@ ngx_output_chain_as_is(ngx_output_chain_ctx_t *ctx, ngx_buf_t *buf)
|
|||
buf->in_file = 0;
|
||||
}
|
||||
|
||||
#if (NGX_HAVE_AIO_SENDFILE)
|
||||
if (ctx->aio_preload && buf->in_file) {
|
||||
(void) ngx_output_chain_aio_setup(ctx, buf->file);
|
||||
}
|
||||
#endif
|
||||
|
||||
if (ctx->need_in_memory && !ngx_buf_in_memory(buf)) {
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -300,6 +281,28 @@ ngx_output_chain_as_is(ngx_output_chain_ctx_t *ctx, ngx_buf_t *buf)
|
|||
}
|
||||
|
||||
|
||||
#if (NGX_HAVE_AIO_SENDFILE)
|
||||
|
||||
static ngx_int_t
|
||||
ngx_output_chain_aio_setup(ngx_output_chain_ctx_t *ctx, ngx_file_t *file)
|
||||
{
|
||||
ngx_event_aio_t *aio;
|
||||
|
||||
if (file->aio == NULL && ngx_file_aio_init(file, ctx->pool) != NGX_OK) {
|
||||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
aio = file->aio;
|
||||
|
||||
aio->data = ctx->filter_ctx;
|
||||
aio->preload_handler = ctx->aio_preload;
|
||||
|
||||
return NGX_OK;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
static ngx_int_t
|
||||
ngx_output_chain_add_copy(ngx_pool_t *pool, ngx_chain_t **chain,
|
||||
ngx_chain_t *in)
|
||||
|
|
@ -662,6 +665,7 @@ ngx_chain_writer(void *data, ngx_chain_t *in)
|
|||
|
||||
for (size = 0; in; in = in->next) {
|
||||
|
||||
#if 1
|
||||
if (ngx_buf_size(in->buf) == 0 && !ngx_buf_special(in->buf)) {
|
||||
|
||||
ngx_log_error(NGX_LOG_ALERT, ctx->pool->log, 0,
|
||||
|
|
@ -681,26 +685,7 @@ ngx_chain_writer(void *data, ngx_chain_t *in)
|
|||
|
||||
continue;
|
||||
}
|
||||
|
||||
if (ngx_buf_size(in->buf) < 0) {
|
||||
|
||||
ngx_log_error(NGX_LOG_ALERT, ctx->pool->log, 0,
|
||||
"negative size buf in chain writer "
|
||||
"t:%d r:%d f:%d %p %p-%p %p %O-%O",
|
||||
in->buf->temporary,
|
||||
in->buf->recycled,
|
||||
in->buf->in_file,
|
||||
in->buf->start,
|
||||
in->buf->pos,
|
||||
in->buf->last,
|
||||
in->buf->file,
|
||||
in->buf->file_pos,
|
||||
in->buf->file_last);
|
||||
|
||||
ngx_debug_point();
|
||||
|
||||
return NGX_ERROR;
|
||||
}
|
||||
#endif
|
||||
|
||||
size += ngx_buf_size(in->buf);
|
||||
|
||||
|
|
@ -724,6 +709,7 @@ ngx_chain_writer(void *data, ngx_chain_t *in)
|
|||
|
||||
for (cl = ctx->out; cl; cl = cl->next) {
|
||||
|
||||
#if 1
|
||||
if (ngx_buf_size(cl->buf) == 0 && !ngx_buf_special(cl->buf)) {
|
||||
|
||||
ngx_log_error(NGX_LOG_ALERT, ctx->pool->log, 0,
|
||||
|
|
@ -743,26 +729,7 @@ ngx_chain_writer(void *data, ngx_chain_t *in)
|
|||
|
||||
continue;
|
||||
}
|
||||
|
||||
if (ngx_buf_size(cl->buf) < 0) {
|
||||
|
||||
ngx_log_error(NGX_LOG_ALERT, ctx->pool->log, 0,
|
||||
"negative size buf in chain writer "
|
||||
"t:%d r:%d f:%d %p %p-%p %p %O-%O",
|
||||
cl->buf->temporary,
|
||||
cl->buf->recycled,
|
||||
cl->buf->in_file,
|
||||
cl->buf->start,
|
||||
cl->buf->pos,
|
||||
cl->buf->last,
|
||||
cl->buf->file,
|
||||
cl->buf->file_pos,
|
||||
cl->buf->file_last);
|
||||
|
||||
ngx_debug_point();
|
||||
|
||||
return NGX_ERROR;
|
||||
}
|
||||
#endif
|
||||
|
||||
size += ngx_buf_size(cl->buf);
|
||||
}
|
||||
|
|
@ -780,10 +747,6 @@ ngx_chain_writer(void *data, ngx_chain_t *in)
|
|||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
if (chain && c->write->ready) {
|
||||
ngx_post_event(c->write, &ngx_posted_next_events);
|
||||
}
|
||||
|
||||
for (cl = ctx->out; cl && cl != chain; /* void */) {
|
||||
ln = cl;
|
||||
cl = cl->next;
|
||||
|
|
|
|||
|
|
@ -13,15 +13,7 @@
|
|||
#define NGX_PROXY_PROTOCOL_AF_INET6 2
|
||||
|
||||
|
||||
#define ngx_proxy_protocol_parse_uint16(p) \
|
||||
( ((uint16_t) (p)[0] << 8) \
|
||||
+ ( (p)[1]) )
|
||||
|
||||
#define ngx_proxy_protocol_parse_uint32(p) \
|
||||
( ((uint32_t) (p)[0] << 24) \
|
||||
+ ( (p)[1] << 16) \
|
||||
+ ( (p)[2] << 8) \
|
||||
+ ( (p)[3]) )
|
||||
#define ngx_proxy_protocol_parse_uint16(p) ((p)[0] << 8 | (p)[1])
|
||||
|
||||
|
||||
typedef struct {
|
||||
|
|
@ -48,60 +40,16 @@ typedef struct {
|
|||
} ngx_proxy_protocol_inet6_addrs_t;
|
||||
|
||||
|
||||
typedef struct {
|
||||
u_char type;
|
||||
u_char len[2];
|
||||
} ngx_proxy_protocol_tlv_t;
|
||||
|
||||
|
||||
typedef struct {
|
||||
u_char client;
|
||||
u_char verify[4];
|
||||
} ngx_proxy_protocol_tlv_ssl_t;
|
||||
|
||||
|
||||
typedef struct {
|
||||
ngx_str_t name;
|
||||
ngx_uint_t type;
|
||||
} ngx_proxy_protocol_tlv_entry_t;
|
||||
|
||||
|
||||
static u_char *ngx_proxy_protocol_read_addr(ngx_connection_t *c, u_char *p,
|
||||
u_char *last, ngx_str_t *addr);
|
||||
static u_char *ngx_proxy_protocol_read_port(u_char *p, u_char *last,
|
||||
in_port_t *port, u_char sep);
|
||||
static u_char *ngx_proxy_protocol_v2_read(ngx_connection_t *c, u_char *buf,
|
||||
u_char *last);
|
||||
static ngx_int_t ngx_proxy_protocol_lookup_tlv(ngx_connection_t *c,
|
||||
ngx_str_t *tlvs, ngx_uint_t type, ngx_str_t *value);
|
||||
|
||||
|
||||
static ngx_proxy_protocol_tlv_entry_t ngx_proxy_protocol_tlv_entries[] = {
|
||||
{ ngx_string("alpn"), 0x01 },
|
||||
{ ngx_string("authority"), 0x02 },
|
||||
{ ngx_string("unique_id"), 0x05 },
|
||||
{ ngx_string("ssl"), 0x20 },
|
||||
{ ngx_string("netns"), 0x30 },
|
||||
{ ngx_null_string, 0x00 }
|
||||
};
|
||||
|
||||
|
||||
static ngx_proxy_protocol_tlv_entry_t ngx_proxy_protocol_tlv_ssl_entries[] = {
|
||||
{ ngx_string("version"), 0x21 },
|
||||
{ ngx_string("cn"), 0x22 },
|
||||
{ ngx_string("cipher"), 0x23 },
|
||||
{ ngx_string("sig_alg"), 0x24 },
|
||||
{ ngx_string("key_alg"), 0x25 },
|
||||
{ ngx_null_string, 0x00 }
|
||||
};
|
||||
|
||||
|
||||
u_char *
|
||||
ngx_proxy_protocol_read(ngx_connection_t *c, u_char *buf, u_char *last)
|
||||
{
|
||||
size_t len;
|
||||
u_char *p;
|
||||
ngx_proxy_protocol_t *pp;
|
||||
size_t len;
|
||||
u_char ch, *p, *addr, *port;
|
||||
ngx_int_t n;
|
||||
|
||||
static const u_char signature[] = "\r\n\r\n\0\r\nQUIT\n";
|
||||
|
||||
|
|
@ -109,7 +57,7 @@ ngx_proxy_protocol_read(ngx_connection_t *c, u_char *buf, u_char *last)
|
|||
len = last - buf;
|
||||
|
||||
if (len >= sizeof(ngx_proxy_protocol_header_t)
|
||||
&& ngx_memcmp(p, signature, sizeof(signature) - 1) == 0)
|
||||
&& memcmp(p, signature, sizeof(signature) - 1) == 0)
|
||||
{
|
||||
return ngx_proxy_protocol_v2_read(c, buf, last);
|
||||
}
|
||||
|
|
@ -135,83 +83,11 @@ ngx_proxy_protocol_read(ngx_connection_t *c, u_char *buf, u_char *last)
|
|||
}
|
||||
|
||||
p += 5;
|
||||
|
||||
pp = ngx_pcalloc(c->pool, sizeof(ngx_proxy_protocol_t));
|
||||
if (pp == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
p = ngx_proxy_protocol_read_addr(c, p, last, &pp->src_addr);
|
||||
if (p == NULL) {
|
||||
goto invalid;
|
||||
}
|
||||
|
||||
p = ngx_proxy_protocol_read_addr(c, p, last, &pp->dst_addr);
|
||||
if (p == NULL) {
|
||||
goto invalid;
|
||||
}
|
||||
|
||||
p = ngx_proxy_protocol_read_port(p, last, &pp->src_port, ' ');
|
||||
if (p == NULL) {
|
||||
goto invalid;
|
||||
}
|
||||
|
||||
p = ngx_proxy_protocol_read_port(p, last, &pp->dst_port, CR);
|
||||
if (p == NULL) {
|
||||
goto invalid;
|
||||
}
|
||||
|
||||
if (p == last) {
|
||||
goto invalid;
|
||||
}
|
||||
|
||||
if (*p++ != LF) {
|
||||
goto invalid;
|
||||
}
|
||||
|
||||
ngx_log_debug4(NGX_LOG_DEBUG_CORE, c->log, 0,
|
||||
"PROXY protocol src: %V %d, dst: %V %d",
|
||||
&pp->src_addr, pp->src_port, &pp->dst_addr, pp->dst_port);
|
||||
|
||||
c->proxy_protocol = pp;
|
||||
|
||||
return p;
|
||||
|
||||
skip:
|
||||
|
||||
for ( /* void */ ; p < last - 1; p++) {
|
||||
if (p[0] == CR && p[1] == LF) {
|
||||
return p + 2;
|
||||
}
|
||||
}
|
||||
|
||||
invalid:
|
||||
|
||||
for (p = buf; p < last; p++) {
|
||||
if (*p == CR || *p == LF) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
ngx_log_error(NGX_LOG_ERR, c->log, 0,
|
||||
"broken header: \"%*s\"", (size_t) (p - buf), buf);
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
static u_char *
|
||||
ngx_proxy_protocol_read_addr(ngx_connection_t *c, u_char *p, u_char *last,
|
||||
ngx_str_t *addr)
|
||||
{
|
||||
size_t len;
|
||||
u_char ch, *pos;
|
||||
|
||||
pos = p;
|
||||
addr = p;
|
||||
|
||||
for ( ;; ) {
|
||||
if (p == last) {
|
||||
return NULL;
|
||||
goto invalid;
|
||||
}
|
||||
|
||||
ch = *p++;
|
||||
|
|
@ -225,54 +101,70 @@ ngx_proxy_protocol_read_addr(ngx_connection_t *c, u_char *p, u_char *last,
|
|||
&& (ch < 'A' || ch > 'F')
|
||||
&& (ch < '0' || ch > '9'))
|
||||
{
|
||||
return NULL;
|
||||
goto invalid;
|
||||
}
|
||||
}
|
||||
|
||||
len = p - pos - 1;
|
||||
len = p - addr - 1;
|
||||
c->proxy_protocol_addr.data = ngx_pnalloc(c->pool, len);
|
||||
|
||||
addr->data = ngx_pnalloc(c->pool, len);
|
||||
if (addr->data == NULL) {
|
||||
if (c->proxy_protocol_addr.data == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
ngx_memcpy(addr->data, pos, len);
|
||||
addr->len = len;
|
||||
|
||||
return p;
|
||||
}
|
||||
|
||||
|
||||
static u_char *
|
||||
ngx_proxy_protocol_read_port(u_char *p, u_char *last, in_port_t *port,
|
||||
u_char sep)
|
||||
{
|
||||
size_t len;
|
||||
u_char *pos;
|
||||
ngx_int_t n;
|
||||
|
||||
pos = p;
|
||||
ngx_memcpy(c->proxy_protocol_addr.data, addr, len);
|
||||
c->proxy_protocol_addr.len = len;
|
||||
|
||||
for ( ;; ) {
|
||||
if (p == last) {
|
||||
return NULL;
|
||||
goto invalid;
|
||||
}
|
||||
|
||||
if (*p++ == sep) {
|
||||
if (*p++ == ' ') {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
len = p - pos - 1;
|
||||
port = p;
|
||||
|
||||
n = ngx_atoi(pos, len);
|
||||
if (n < 0 || n > 65535) {
|
||||
return NULL;
|
||||
for ( ;; ) {
|
||||
if (p == last) {
|
||||
goto invalid;
|
||||
}
|
||||
|
||||
if (*p++ == ' ') {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
*port = (in_port_t) n;
|
||||
len = p - port - 1;
|
||||
|
||||
return p;
|
||||
n = ngx_atoi(port, len);
|
||||
|
||||
if (n < 0 || n > 65535) {
|
||||
goto invalid;
|
||||
}
|
||||
|
||||
c->proxy_protocol_port = (in_port_t) n;
|
||||
|
||||
ngx_log_debug2(NGX_LOG_DEBUG_CORE, c->log, 0,
|
||||
"PROXY protocol address: %V %d", &c->proxy_protocol_addr,
|
||||
c->proxy_protocol_port);
|
||||
|
||||
skip:
|
||||
|
||||
for ( /* void */ ; p < last - 1; p++) {
|
||||
if (p[0] == CR && p[1] == LF) {
|
||||
return p + 2;
|
||||
}
|
||||
}
|
||||
|
||||
invalid:
|
||||
|
||||
ngx_log_error(NGX_LOG_ERR, c->log, 0,
|
||||
"broken header: \"%*s\"", (size_t) (last - buf), buf);
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -281,9 +173,7 @@ ngx_proxy_protocol_write(ngx_connection_t *c, u_char *buf, u_char *last)
|
|||
{
|
||||
ngx_uint_t port, lport;
|
||||
|
||||
if (last - buf < NGX_PROXY_PROTOCOL_V1_MAX_HEADER) {
|
||||
ngx_log_error(NGX_LOG_ALERT, c->log, 0,
|
||||
"too small buffer for PROXY protocol");
|
||||
if (last - buf < NGX_PROXY_PROTOCOL_MAX_HEADER) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
|
@ -329,8 +219,7 @@ ngx_proxy_protocol_v2_read(ngx_connection_t *c, u_char *buf, u_char *last)
|
|||
size_t len;
|
||||
socklen_t socklen;
|
||||
ngx_uint_t version, command, family, transport;
|
||||
ngx_sockaddr_t src_sockaddr, dst_sockaddr;
|
||||
ngx_proxy_protocol_t *pp;
|
||||
ngx_sockaddr_t sockaddr;
|
||||
ngx_proxy_protocol_header_t *header;
|
||||
ngx_proxy_protocol_inet_addrs_t *in;
|
||||
#if (NGX_HAVE_INET6)
|
||||
|
|
@ -377,11 +266,6 @@ ngx_proxy_protocol_v2_read(ngx_connection_t *c, u_char *buf, u_char *last)
|
|||
return end;
|
||||
}
|
||||
|
||||
pp = ngx_pcalloc(c->pool, sizeof(ngx_proxy_protocol_t));
|
||||
if (pp == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
family = header->family_transport >> 4;
|
||||
|
||||
switch (family) {
|
||||
|
|
@ -394,16 +278,11 @@ ngx_proxy_protocol_v2_read(ngx_connection_t *c, u_char *buf, u_char *last)
|
|||
|
||||
in = (ngx_proxy_protocol_inet_addrs_t *) buf;
|
||||
|
||||
src_sockaddr.sockaddr_in.sin_family = AF_INET;
|
||||
src_sockaddr.sockaddr_in.sin_port = 0;
|
||||
ngx_memcpy(&src_sockaddr.sockaddr_in.sin_addr, in->src_addr, 4);
|
||||
sockaddr.sockaddr_in.sin_family = AF_INET;
|
||||
sockaddr.sockaddr_in.sin_port = 0;
|
||||
memcpy(&sockaddr.sockaddr_in.sin_addr, in->src_addr, 4);
|
||||
|
||||
dst_sockaddr.sockaddr_in.sin_family = AF_INET;
|
||||
dst_sockaddr.sockaddr_in.sin_port = 0;
|
||||
ngx_memcpy(&dst_sockaddr.sockaddr_in.sin_addr, in->dst_addr, 4);
|
||||
|
||||
pp->src_port = ngx_proxy_protocol_parse_uint16(in->src_port);
|
||||
pp->dst_port = ngx_proxy_protocol_parse_uint16(in->dst_port);
|
||||
c->proxy_protocol_port = ngx_proxy_protocol_parse_uint16(in->src_port);
|
||||
|
||||
socklen = sizeof(struct sockaddr_in);
|
||||
|
||||
|
|
@ -421,16 +300,11 @@ ngx_proxy_protocol_v2_read(ngx_connection_t *c, u_char *buf, u_char *last)
|
|||
|
||||
in6 = (ngx_proxy_protocol_inet6_addrs_t *) buf;
|
||||
|
||||
src_sockaddr.sockaddr_in6.sin6_family = AF_INET6;
|
||||
src_sockaddr.sockaddr_in6.sin6_port = 0;
|
||||
ngx_memcpy(&src_sockaddr.sockaddr_in6.sin6_addr, in6->src_addr, 16);
|
||||
sockaddr.sockaddr_in6.sin6_family = AF_INET6;
|
||||
sockaddr.sockaddr_in6.sin6_port = 0;
|
||||
memcpy(&sockaddr.sockaddr_in6.sin6_addr, in6->src_addr, 16);
|
||||
|
||||
dst_sockaddr.sockaddr_in6.sin6_family = AF_INET6;
|
||||
dst_sockaddr.sockaddr_in6.sin6_port = 0;
|
||||
ngx_memcpy(&dst_sockaddr.sockaddr_in6.sin6_addr, in6->dst_addr, 16);
|
||||
|
||||
pp->src_port = ngx_proxy_protocol_parse_uint16(in6->src_port);
|
||||
pp->dst_port = ngx_proxy_protocol_parse_uint16(in6->dst_port);
|
||||
c->proxy_protocol_port = ngx_proxy_protocol_parse_uint16(in6->src_port);
|
||||
|
||||
socklen = sizeof(struct sockaddr_in6);
|
||||
|
||||
|
|
@ -447,168 +321,23 @@ ngx_proxy_protocol_v2_read(ngx_connection_t *c, u_char *buf, u_char *last)
|
|||
return end;
|
||||
}
|
||||
|
||||
pp->src_addr.data = ngx_pnalloc(c->pool, NGX_SOCKADDR_STRLEN);
|
||||
if (pp->src_addr.data == NULL) {
|
||||
c->proxy_protocol_addr.data = ngx_pnalloc(c->pool, NGX_SOCKADDR_STRLEN);
|
||||
if (c->proxy_protocol_addr.data == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
pp->src_addr.len = ngx_sock_ntop(&src_sockaddr.sockaddr, socklen,
|
||||
pp->src_addr.data, NGX_SOCKADDR_STRLEN, 0);
|
||||
c->proxy_protocol_addr.len = ngx_sock_ntop(&sockaddr.sockaddr, socklen,
|
||||
c->proxy_protocol_addr.data,
|
||||
NGX_SOCKADDR_STRLEN, 0);
|
||||
|
||||
pp->dst_addr.data = ngx_pnalloc(c->pool, NGX_SOCKADDR_STRLEN);
|
||||
if (pp->dst_addr.data == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
pp->dst_addr.len = ngx_sock_ntop(&dst_sockaddr.sockaddr, socklen,
|
||||
pp->dst_addr.data, NGX_SOCKADDR_STRLEN, 0);
|
||||
|
||||
ngx_log_debug4(NGX_LOG_DEBUG_CORE, c->log, 0,
|
||||
"PROXY protocol v2 src: %V %d, dst: %V %d",
|
||||
&pp->src_addr, pp->src_port, &pp->dst_addr, pp->dst_port);
|
||||
ngx_log_debug2(NGX_LOG_DEBUG_CORE, c->log, 0,
|
||||
"PROXY protocol v2 address: %V %d", &c->proxy_protocol_addr,
|
||||
c->proxy_protocol_port);
|
||||
|
||||
if (buf < end) {
|
||||
pp->tlvs.data = ngx_pnalloc(c->pool, end - buf);
|
||||
if (pp->tlvs.data == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
ngx_memcpy(pp->tlvs.data, buf, end - buf);
|
||||
pp->tlvs.len = end - buf;
|
||||
ngx_log_debug1(NGX_LOG_DEBUG_CORE, c->log, 0,
|
||||
"PROXY protocol v2 %z bytes of tlv ignored", end - buf);
|
||||
}
|
||||
|
||||
c->proxy_protocol = pp;
|
||||
|
||||
return end;
|
||||
}
|
||||
|
||||
|
||||
ngx_int_t
|
||||
ngx_proxy_protocol_get_tlv(ngx_connection_t *c, ngx_str_t *name,
|
||||
ngx_str_t *value)
|
||||
{
|
||||
u_char *p;
|
||||
size_t n;
|
||||
uint32_t verify;
|
||||
ngx_str_t ssl, *tlvs;
|
||||
ngx_int_t rc, type;
|
||||
ngx_proxy_protocol_tlv_ssl_t *tlv_ssl;
|
||||
ngx_proxy_protocol_tlv_entry_t *te;
|
||||
|
||||
if (c->proxy_protocol == NULL) {
|
||||
return NGX_DECLINED;
|
||||
}
|
||||
|
||||
ngx_log_debug1(NGX_LOG_DEBUG_CORE, c->log, 0,
|
||||
"PROXY protocol v2 get tlv \"%V\"", name);
|
||||
|
||||
te = ngx_proxy_protocol_tlv_entries;
|
||||
tlvs = &c->proxy_protocol->tlvs;
|
||||
|
||||
p = name->data;
|
||||
n = name->len;
|
||||
|
||||
if (n >= 4 && p[0] == 's' && p[1] == 's' && p[2] == 'l' && p[3] == '_') {
|
||||
|
||||
rc = ngx_proxy_protocol_lookup_tlv(c, tlvs, 0x20, &ssl);
|
||||
if (rc != NGX_OK) {
|
||||
return rc;
|
||||
}
|
||||
|
||||
if (ssl.len < sizeof(ngx_proxy_protocol_tlv_ssl_t)) {
|
||||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
p += 4;
|
||||
n -= 4;
|
||||
|
||||
if (n == 6 && ngx_strncmp(p, "verify", 6) == 0) {
|
||||
|
||||
tlv_ssl = (ngx_proxy_protocol_tlv_ssl_t *) ssl.data;
|
||||
verify = ngx_proxy_protocol_parse_uint32(tlv_ssl->verify);
|
||||
|
||||
value->data = ngx_pnalloc(c->pool, NGX_INT32_LEN);
|
||||
if (value->data == NULL) {
|
||||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
value->len = ngx_sprintf(value->data, "%uD", verify)
|
||||
- value->data;
|
||||
return NGX_OK;
|
||||
}
|
||||
|
||||
ssl.data += sizeof(ngx_proxy_protocol_tlv_ssl_t);
|
||||
ssl.len -= sizeof(ngx_proxy_protocol_tlv_ssl_t);
|
||||
|
||||
te = ngx_proxy_protocol_tlv_ssl_entries;
|
||||
tlvs = &ssl;
|
||||
}
|
||||
|
||||
if (n >= 2 && p[0] == '0' && p[1] == 'x') {
|
||||
|
||||
type = ngx_hextoi(p + 2, n - 2);
|
||||
if (type == NGX_ERROR) {
|
||||
ngx_log_error(NGX_LOG_ERR, c->log, 0,
|
||||
"invalid PROXY protocol TLV \"%V\"", name);
|
||||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
return ngx_proxy_protocol_lookup_tlv(c, tlvs, type, value);
|
||||
}
|
||||
|
||||
for ( /* void */ ; te->type; te++) {
|
||||
if (te->name.len == n && ngx_strncmp(te->name.data, p, n) == 0) {
|
||||
return ngx_proxy_protocol_lookup_tlv(c, tlvs, te->type, value);
|
||||
}
|
||||
}
|
||||
|
||||
ngx_log_error(NGX_LOG_ERR, c->log, 0,
|
||||
"unknown PROXY protocol TLV \"%V\"", name);
|
||||
|
||||
return NGX_DECLINED;
|
||||
}
|
||||
|
||||
|
||||
static ngx_int_t
|
||||
ngx_proxy_protocol_lookup_tlv(ngx_connection_t *c, ngx_str_t *tlvs,
|
||||
ngx_uint_t type, ngx_str_t *value)
|
||||
{
|
||||
u_char *p;
|
||||
size_t n, len;
|
||||
ngx_proxy_protocol_tlv_t *tlv;
|
||||
|
||||
ngx_log_debug1(NGX_LOG_DEBUG_CORE, c->log, 0,
|
||||
"PROXY protocol v2 lookup tlv:%02xi", type);
|
||||
|
||||
p = tlvs->data;
|
||||
n = tlvs->len;
|
||||
|
||||
while (n) {
|
||||
if (n < sizeof(ngx_proxy_protocol_tlv_t)) {
|
||||
ngx_log_error(NGX_LOG_ERR, c->log, 0, "broken PROXY protocol TLV");
|
||||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
tlv = (ngx_proxy_protocol_tlv_t *) p;
|
||||
len = ngx_proxy_protocol_parse_uint16(tlv->len);
|
||||
|
||||
p += sizeof(ngx_proxy_protocol_tlv_t);
|
||||
n -= sizeof(ngx_proxy_protocol_tlv_t);
|
||||
|
||||
if (n < len) {
|
||||
ngx_log_error(NGX_LOG_ERR, c->log, 0, "broken PROXY protocol TLV");
|
||||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
if (tlv->type == type) {
|
||||
value->data = p;
|
||||
value->len = len;
|
||||
return NGX_OK;
|
||||
}
|
||||
|
||||
p += len;
|
||||
n -= len;
|
||||
}
|
||||
|
||||
return NGX_DECLINED;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -13,25 +13,13 @@
|
|||
#include <ngx_core.h>
|
||||
|
||||
|
||||
#define NGX_PROXY_PROTOCOL_V1_MAX_HEADER 107
|
||||
#define NGX_PROXY_PROTOCOL_MAX_HEADER 4096
|
||||
|
||||
|
||||
struct ngx_proxy_protocol_s {
|
||||
ngx_str_t src_addr;
|
||||
ngx_str_t dst_addr;
|
||||
in_port_t src_port;
|
||||
in_port_t dst_port;
|
||||
ngx_str_t tlvs;
|
||||
};
|
||||
#define NGX_PROXY_PROTOCOL_MAX_HEADER 107
|
||||
|
||||
|
||||
u_char *ngx_proxy_protocol_read(ngx_connection_t *c, u_char *buf,
|
||||
u_char *last);
|
||||
u_char *ngx_proxy_protocol_write(ngx_connection_t *c, u_char *buf,
|
||||
u_char *last);
|
||||
ngx_int_t ngx_proxy_protocol_get_tlv(ngx_connection_t *c, ngx_str_t *name,
|
||||
ngx_str_t *value);
|
||||
|
||||
|
||||
#endif /* _NGX_PROXY_PROTOCOL_H_INCLUDED_ */
|
||||
|
|
|
|||
|
|
@ -174,7 +174,12 @@ ngx_rbtree_delete(ngx_rbtree_t *tree, ngx_rbtree_node_t *node)
|
|||
|
||||
} else {
|
||||
subst = ngx_rbtree_min(node->right, sentinel);
|
||||
temp = subst->right;
|
||||
|
||||
if (subst->left != sentinel) {
|
||||
temp = subst->left;
|
||||
} else {
|
||||
temp = subst->right;
|
||||
}
|
||||
}
|
||||
|
||||
if (subst == *root) {
|
||||
|
|
|
|||
|
|
@ -47,9 +47,6 @@ struct ngx_rbtree_s {
|
|||
(tree)->sentinel = s; \
|
||||
(tree)->insert = i
|
||||
|
||||
#define ngx_rbtree_data(node, type, link) \
|
||||
(type *) ((u_char *) (node) - offsetof(type, link))
|
||||
|
||||
|
||||
void ngx_rbtree_insert(ngx_rbtree_t *tree, ngx_rbtree_node_t *node);
|
||||
void ngx_rbtree_delete(ngx_rbtree_t *tree, ngx_rbtree_node_t *node);
|
||||
|
|
|
|||
|
|
@ -10,22 +10,15 @@
|
|||
|
||||
|
||||
typedef struct {
|
||||
ngx_flag_t pcre_jit;
|
||||
ngx_list_t *studies;
|
||||
ngx_flag_t pcre_jit;
|
||||
} ngx_regex_conf_t;
|
||||
|
||||
|
||||
static ngx_inline void ngx_regex_malloc_init(ngx_pool_t *pool);
|
||||
static ngx_inline void ngx_regex_malloc_done(void);
|
||||
|
||||
#if (NGX_PCRE2)
|
||||
static void * ngx_libc_cdecl ngx_regex_malloc(size_t size, void *data);
|
||||
static void ngx_libc_cdecl ngx_regex_free(void *p, void *data);
|
||||
#else
|
||||
static void * ngx_libc_cdecl ngx_regex_malloc(size_t size);
|
||||
static void ngx_libc_cdecl ngx_regex_free(void *p);
|
||||
#if (NGX_HAVE_PCRE_JIT)
|
||||
static void ngx_pcre_free_studies(void *data);
|
||||
#endif
|
||||
static void ngx_regex_cleanup(void *data);
|
||||
|
||||
static ngx_int_t ngx_regex_module_init(ngx_cycle_t *cycle);
|
||||
|
||||
|
|
@ -72,197 +65,32 @@ ngx_module_t ngx_regex_module = {
|
|||
};
|
||||
|
||||
|
||||
static ngx_pool_t *ngx_regex_pool;
|
||||
static ngx_list_t *ngx_regex_studies;
|
||||
static ngx_uint_t ngx_regex_direct_alloc;
|
||||
|
||||
#if (NGX_PCRE2)
|
||||
static pcre2_compile_context *ngx_regex_compile_context;
|
||||
static pcre2_match_data *ngx_regex_match_data;
|
||||
static ngx_uint_t ngx_regex_match_data_size;
|
||||
#endif
|
||||
static ngx_pool_t *ngx_pcre_pool;
|
||||
static ngx_list_t *ngx_pcre_studies;
|
||||
|
||||
|
||||
void
|
||||
ngx_regex_init(void)
|
||||
{
|
||||
#if !(NGX_PCRE2)
|
||||
pcre_malloc = ngx_regex_malloc;
|
||||
pcre_free = ngx_regex_free;
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
static ngx_inline void
|
||||
ngx_regex_malloc_init(ngx_pool_t *pool)
|
||||
{
|
||||
ngx_regex_pool = pool;
|
||||
ngx_regex_direct_alloc = (pool == NULL) ? 1 : 0;
|
||||
ngx_pcre_pool = pool;
|
||||
}
|
||||
|
||||
|
||||
static ngx_inline void
|
||||
ngx_regex_malloc_done(void)
|
||||
{
|
||||
ngx_regex_pool = NULL;
|
||||
ngx_regex_direct_alloc = 0;
|
||||
ngx_pcre_pool = NULL;
|
||||
}
|
||||
|
||||
|
||||
#if (NGX_PCRE2)
|
||||
|
||||
ngx_int_t
|
||||
ngx_regex_compile(ngx_regex_compile_t *rc)
|
||||
{
|
||||
int n, errcode;
|
||||
char *p;
|
||||
u_char errstr[128];
|
||||
size_t erroff;
|
||||
uint32_t options;
|
||||
pcre2_code *re;
|
||||
ngx_regex_elt_t *elt;
|
||||
pcre2_general_context *gctx;
|
||||
pcre2_compile_context *cctx;
|
||||
|
||||
if (ngx_regex_compile_context == NULL) {
|
||||
/*
|
||||
* Allocate a compile context if not yet allocated. This uses
|
||||
* direct allocations from heap, so the result can be cached
|
||||
* even at runtime.
|
||||
*/
|
||||
|
||||
ngx_regex_malloc_init(NULL);
|
||||
|
||||
gctx = pcre2_general_context_create(ngx_regex_malloc, ngx_regex_free,
|
||||
NULL);
|
||||
if (gctx == NULL) {
|
||||
ngx_regex_malloc_done();
|
||||
goto nomem;
|
||||
}
|
||||
|
||||
cctx = pcre2_compile_context_create(gctx);
|
||||
if (cctx == NULL) {
|
||||
pcre2_general_context_free(gctx);
|
||||
ngx_regex_malloc_done();
|
||||
goto nomem;
|
||||
}
|
||||
|
||||
ngx_regex_compile_context = cctx;
|
||||
|
||||
pcre2_general_context_free(gctx);
|
||||
ngx_regex_malloc_done();
|
||||
}
|
||||
|
||||
options = 0;
|
||||
|
||||
if (rc->options & NGX_REGEX_CASELESS) {
|
||||
options |= PCRE2_CASELESS;
|
||||
}
|
||||
|
||||
if (rc->options & NGX_REGEX_MULTILINE) {
|
||||
options |= PCRE2_MULTILINE;
|
||||
}
|
||||
|
||||
if (rc->options & ~(NGX_REGEX_CASELESS|NGX_REGEX_MULTILINE)) {
|
||||
rc->err.len = ngx_snprintf(rc->err.data, rc->err.len,
|
||||
"regex \"%V\" compilation failed: invalid options",
|
||||
&rc->pattern)
|
||||
- rc->err.data;
|
||||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
ngx_regex_malloc_init(rc->pool);
|
||||
|
||||
re = pcre2_compile(rc->pattern.data, rc->pattern.len, options,
|
||||
&errcode, &erroff, ngx_regex_compile_context);
|
||||
|
||||
/* ensure that there is no current pool */
|
||||
ngx_regex_malloc_done();
|
||||
|
||||
if (re == NULL) {
|
||||
pcre2_get_error_message(errcode, errstr, 128);
|
||||
|
||||
if ((size_t) erroff == rc->pattern.len) {
|
||||
rc->err.len = ngx_snprintf(rc->err.data, rc->err.len,
|
||||
"pcre2_compile() failed: %s in \"%V\"",
|
||||
errstr, &rc->pattern)
|
||||
- rc->err.data;
|
||||
|
||||
} else {
|
||||
rc->err.len = ngx_snprintf(rc->err.data, rc->err.len,
|
||||
"pcre2_compile() failed: %s in \"%V\" at \"%s\"",
|
||||
errstr, &rc->pattern, rc->pattern.data + erroff)
|
||||
- rc->err.data;
|
||||
}
|
||||
|
||||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
rc->regex = re;
|
||||
|
||||
/* do not study at runtime */
|
||||
|
||||
if (ngx_regex_studies != NULL) {
|
||||
elt = ngx_list_push(ngx_regex_studies);
|
||||
if (elt == NULL) {
|
||||
goto nomem;
|
||||
}
|
||||
|
||||
elt->regex = rc->regex;
|
||||
elt->name = rc->pattern.data;
|
||||
}
|
||||
|
||||
n = pcre2_pattern_info(re, PCRE2_INFO_CAPTURECOUNT, &rc->captures);
|
||||
if (n < 0) {
|
||||
p = "pcre2_pattern_info(\"%V\", PCRE2_INFO_CAPTURECOUNT) failed: %d";
|
||||
goto failed;
|
||||
}
|
||||
|
||||
if (rc->captures == 0) {
|
||||
return NGX_OK;
|
||||
}
|
||||
|
||||
n = pcre2_pattern_info(re, PCRE2_INFO_NAMECOUNT, &rc->named_captures);
|
||||
if (n < 0) {
|
||||
p = "pcre2_pattern_info(\"%V\", PCRE2_INFO_NAMECOUNT) failed: %d";
|
||||
goto failed;
|
||||
}
|
||||
|
||||
if (rc->named_captures == 0) {
|
||||
return NGX_OK;
|
||||
}
|
||||
|
||||
n = pcre2_pattern_info(re, PCRE2_INFO_NAMEENTRYSIZE, &rc->name_size);
|
||||
if (n < 0) {
|
||||
p = "pcre2_pattern_info(\"%V\", PCRE2_INFO_NAMEENTRYSIZE) failed: %d";
|
||||
goto failed;
|
||||
}
|
||||
|
||||
n = pcre2_pattern_info(re, PCRE2_INFO_NAMETABLE, &rc->names);
|
||||
if (n < 0) {
|
||||
p = "pcre2_pattern_info(\"%V\", PCRE2_INFO_NAMETABLE) failed: %d";
|
||||
goto failed;
|
||||
}
|
||||
|
||||
return NGX_OK;
|
||||
|
||||
failed:
|
||||
|
||||
rc->err.len = ngx_snprintf(rc->err.data, rc->err.len, p, &rc->pattern, n)
|
||||
- rc->err.data;
|
||||
return NGX_ERROR;
|
||||
|
||||
nomem:
|
||||
|
||||
rc->err.len = ngx_snprintf(rc->err.data, rc->err.len,
|
||||
"regex \"%V\" compilation failed: no memory",
|
||||
&rc->pattern)
|
||||
- rc->err.data;
|
||||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
ngx_int_t
|
||||
ngx_regex_compile(ngx_regex_compile_t *rc)
|
||||
{
|
||||
|
|
@ -270,30 +98,11 @@ ngx_regex_compile(ngx_regex_compile_t *rc)
|
|||
char *p;
|
||||
pcre *re;
|
||||
const char *errstr;
|
||||
ngx_uint_t options;
|
||||
ngx_regex_elt_t *elt;
|
||||
|
||||
options = 0;
|
||||
|
||||
if (rc->options & NGX_REGEX_CASELESS) {
|
||||
options |= PCRE_CASELESS;
|
||||
}
|
||||
|
||||
if (rc->options & NGX_REGEX_MULTILINE) {
|
||||
options |= PCRE_MULTILINE;
|
||||
}
|
||||
|
||||
if (rc->options & ~(NGX_REGEX_CASELESS|NGX_REGEX_MULTILINE)) {
|
||||
rc->err.len = ngx_snprintf(rc->err.data, rc->err.len,
|
||||
"regex \"%V\" compilation failed: invalid options",
|
||||
&rc->pattern)
|
||||
- rc->err.data;
|
||||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
ngx_regex_malloc_init(rc->pool);
|
||||
|
||||
re = pcre_compile((const char *) rc->pattern.data, (int) options,
|
||||
re = pcre_compile((const char *) rc->pattern.data, (int) rc->options,
|
||||
&errstr, &erroff, NULL);
|
||||
|
||||
/* ensure that there is no current pool */
|
||||
|
|
@ -304,13 +113,13 @@ ngx_regex_compile(ngx_regex_compile_t *rc)
|
|||
rc->err.len = ngx_snprintf(rc->err.data, rc->err.len,
|
||||
"pcre_compile() failed: %s in \"%V\"",
|
||||
errstr, &rc->pattern)
|
||||
- rc->err.data;
|
||||
- rc->err.data;
|
||||
|
||||
} else {
|
||||
rc->err.len = ngx_snprintf(rc->err.data, rc->err.len,
|
||||
"pcre_compile() failed: %s in \"%V\" at \"%s\"",
|
||||
errstr, &rc->pattern, rc->pattern.data + erroff)
|
||||
- rc->err.data;
|
||||
- rc->err.data;
|
||||
}
|
||||
|
||||
return NGX_ERROR;
|
||||
|
|
@ -325,8 +134,8 @@ ngx_regex_compile(ngx_regex_compile_t *rc)
|
|||
|
||||
/* do not study at runtime */
|
||||
|
||||
if (ngx_regex_studies != NULL) {
|
||||
elt = ngx_list_push(ngx_regex_studies);
|
||||
if (ngx_pcre_studies != NULL) {
|
||||
elt = ngx_list_push(ngx_pcre_studies);
|
||||
if (elt == NULL) {
|
||||
goto nomem;
|
||||
}
|
||||
|
|
@ -384,83 +193,6 @@ nomem:
|
|||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
#if (NGX_PCRE2)
|
||||
|
||||
ngx_int_t
|
||||
ngx_regex_exec(ngx_regex_t *re, ngx_str_t *s, int *captures, ngx_uint_t size)
|
||||
{
|
||||
size_t *ov;
|
||||
ngx_int_t rc;
|
||||
ngx_uint_t n, i;
|
||||
|
||||
/*
|
||||
* The pcre2_match() function might allocate memory for backtracking
|
||||
* frames, typical allocations are from 40k and above. So the allocator
|
||||
* is configured to do direct allocations from heap during matching.
|
||||
*/
|
||||
|
||||
ngx_regex_malloc_init(NULL);
|
||||
|
||||
if (ngx_regex_match_data == NULL
|
||||
|| size > ngx_regex_match_data_size)
|
||||
{
|
||||
/*
|
||||
* Allocate a match data if not yet allocated or smaller than
|
||||
* needed.
|
||||
*/
|
||||
|
||||
if (ngx_regex_match_data) {
|
||||
pcre2_match_data_free(ngx_regex_match_data);
|
||||
}
|
||||
|
||||
ngx_regex_match_data_size = size;
|
||||
ngx_regex_match_data = pcre2_match_data_create(size / 3, NULL);
|
||||
|
||||
if (ngx_regex_match_data == NULL) {
|
||||
rc = PCRE2_ERROR_NOMEMORY;
|
||||
goto failed;
|
||||
}
|
||||
}
|
||||
|
||||
rc = pcre2_match(re, s->data, s->len, 0, 0, ngx_regex_match_data, NULL);
|
||||
|
||||
if (rc < 0) {
|
||||
goto failed;
|
||||
}
|
||||
|
||||
n = pcre2_get_ovector_count(ngx_regex_match_data);
|
||||
ov = pcre2_get_ovector_pointer(ngx_regex_match_data);
|
||||
|
||||
if (n > size / 3) {
|
||||
n = size / 3;
|
||||
}
|
||||
|
||||
for (i = 0; i < n; i++) {
|
||||
captures[i * 2] = ov[i * 2];
|
||||
captures[i * 2 + 1] = ov[i * 2 + 1];
|
||||
}
|
||||
|
||||
failed:
|
||||
|
||||
ngx_regex_malloc_done();
|
||||
|
||||
return rc;
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
ngx_int_t
|
||||
ngx_regex_exec(ngx_regex_t *re, ngx_str_t *s, int *captures, ngx_uint_t size)
|
||||
{
|
||||
return pcre_exec(re->code, re->extra, (const char *) s->data, s->len,
|
||||
0, 0, captures, size);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
ngx_int_t
|
||||
ngx_regex_exec_array(ngx_array_t *a, ngx_str_t *s, ngx_log_t *log)
|
||||
|
|
@ -495,40 +227,14 @@ ngx_regex_exec_array(ngx_array_t *a, ngx_str_t *s, ngx_log_t *log)
|
|||
}
|
||||
|
||||
|
||||
#if (NGX_PCRE2)
|
||||
|
||||
static void * ngx_libc_cdecl
|
||||
ngx_regex_malloc(size_t size, void *data)
|
||||
{
|
||||
if (ngx_regex_pool) {
|
||||
return ngx_palloc(ngx_regex_pool, size);
|
||||
}
|
||||
|
||||
if (ngx_regex_direct_alloc) {
|
||||
return ngx_alloc(size, ngx_cycle->log);
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
static void ngx_libc_cdecl
|
||||
ngx_regex_free(void *p, void *data)
|
||||
{
|
||||
if (ngx_regex_direct_alloc) {
|
||||
ngx_free(p);
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
static void * ngx_libc_cdecl
|
||||
ngx_regex_malloc(size_t size)
|
||||
{
|
||||
if (ngx_regex_pool) {
|
||||
return ngx_palloc(ngx_regex_pool, size);
|
||||
ngx_pool_t *pool;
|
||||
pool = ngx_pcre_pool;
|
||||
|
||||
if (pool) {
|
||||
return ngx_palloc(pool, size);
|
||||
}
|
||||
|
||||
return NULL;
|
||||
|
|
@ -541,20 +247,19 @@ ngx_regex_free(void *p)
|
|||
return;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
#if (NGX_HAVE_PCRE_JIT)
|
||||
|
||||
static void
|
||||
ngx_regex_cleanup(void *data)
|
||||
ngx_pcre_free_studies(void *data)
|
||||
{
|
||||
#if (NGX_PCRE2 || NGX_HAVE_PCRE_JIT)
|
||||
ngx_regex_conf_t *rcf = data;
|
||||
ngx_list_t *studies = data;
|
||||
|
||||
ngx_uint_t i;
|
||||
ngx_list_part_t *part;
|
||||
ngx_regex_elt_t *elts;
|
||||
|
||||
part = &rcf->studies->part;
|
||||
part = &studies->part;
|
||||
elts = part->elts;
|
||||
|
||||
for (i = 0; /* void */ ; i++) {
|
||||
|
|
@ -569,83 +274,56 @@ ngx_regex_cleanup(void *data)
|
|||
i = 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* The PCRE JIT compiler uses mmap for its executable codes, so we
|
||||
* have to explicitly call the pcre_free_study() function to free
|
||||
* this memory. In PCRE2, we call the pcre2_code_free() function
|
||||
* for the same reason.
|
||||
*/
|
||||
|
||||
#if (NGX_PCRE2)
|
||||
pcre2_code_free(elts[i].regex);
|
||||
#else
|
||||
if (elts[i].regex->extra != NULL) {
|
||||
pcre_free_study(elts[i].regex->extra);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
|
||||
/*
|
||||
* On configuration parsing errors ngx_regex_module_init() will not
|
||||
* be called. Make sure ngx_regex_studies is properly cleared anyway.
|
||||
*/
|
||||
|
||||
ngx_regex_studies = NULL;
|
||||
|
||||
#if (NGX_PCRE2)
|
||||
|
||||
/*
|
||||
* Free compile context and match data. If needed at runtime by
|
||||
* the new cycle, these will be re-allocated.
|
||||
*/
|
||||
|
||||
if (ngx_regex_compile_context) {
|
||||
pcre2_compile_context_free(ngx_regex_compile_context);
|
||||
ngx_regex_compile_context = NULL;
|
||||
}
|
||||
|
||||
if (ngx_regex_match_data) {
|
||||
pcre2_match_data_free(ngx_regex_match_data);
|
||||
ngx_regex_match_data = NULL;
|
||||
ngx_regex_match_data_size = 0;
|
||||
}
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
static ngx_int_t
|
||||
ngx_regex_module_init(ngx_cycle_t *cycle)
|
||||
{
|
||||
int opt;
|
||||
#if !(NGX_PCRE2)
|
||||
const char *errstr;
|
||||
#endif
|
||||
ngx_uint_t i;
|
||||
ngx_list_part_t *part;
|
||||
ngx_regex_elt_t *elts;
|
||||
ngx_regex_conf_t *rcf;
|
||||
int opt;
|
||||
const char *errstr;
|
||||
ngx_uint_t i;
|
||||
ngx_list_part_t *part;
|
||||
ngx_regex_elt_t *elts;
|
||||
|
||||
opt = 0;
|
||||
|
||||
#if (NGX_HAVE_PCRE_JIT)
|
||||
{
|
||||
ngx_regex_conf_t *rcf;
|
||||
ngx_pool_cleanup_t *cln;
|
||||
|
||||
rcf = (ngx_regex_conf_t *) ngx_get_conf(cycle->conf_ctx, ngx_regex_module);
|
||||
|
||||
#if (NGX_PCRE2 || NGX_HAVE_PCRE_JIT)
|
||||
|
||||
if (rcf->pcre_jit) {
|
||||
#if (NGX_PCRE2)
|
||||
opt = 1;
|
||||
#else
|
||||
opt = PCRE_STUDY_JIT_COMPILE;
|
||||
#endif
|
||||
}
|
||||
|
||||
/*
|
||||
* The PCRE JIT compiler uses mmap for its executable codes, so we
|
||||
* have to explicitly call the pcre_free_study() function to free
|
||||
* this memory.
|
||||
*/
|
||||
|
||||
cln = ngx_pool_cleanup_add(cycle->pool, 0);
|
||||
if (cln == NULL) {
|
||||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
cln->handler = ngx_pcre_free_studies;
|
||||
cln->data = ngx_pcre_studies;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
ngx_regex_malloc_init(cycle->pool);
|
||||
|
||||
part = &rcf->studies->part;
|
||||
part = &ngx_pcre_studies->part;
|
||||
elts = part->elts;
|
||||
|
||||
for (i = 0; /* void */ ; i++) {
|
||||
|
|
@ -660,23 +338,6 @@ ngx_regex_module_init(ngx_cycle_t *cycle)
|
|||
i = 0;
|
||||
}
|
||||
|
||||
#if (NGX_PCRE2)
|
||||
|
||||
if (opt) {
|
||||
int n;
|
||||
|
||||
n = pcre2_jit_compile(elts[i].regex, PCRE2_JIT_COMPLETE);
|
||||
|
||||
if (n != 0) {
|
||||
ngx_log_error(NGX_LOG_INFO, cycle->log, 0,
|
||||
"pcre2_jit_compile() failed: %d in \"%s\", "
|
||||
"ignored",
|
||||
n, elts[i].name);
|
||||
}
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
elts[i].regex->extra = pcre_study(elts[i].regex->code, opt, &errstr);
|
||||
|
||||
if (errstr != NULL) {
|
||||
|
|
@ -699,16 +360,12 @@ ngx_regex_module_init(ngx_cycle_t *cycle)
|
|||
elts[i].name);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
|
||||
ngx_regex_malloc_done();
|
||||
|
||||
ngx_regex_studies = NULL;
|
||||
#if (NGX_PCRE2)
|
||||
ngx_regex_compile_context = NULL;
|
||||
#endif
|
||||
ngx_pcre_studies = NULL;
|
||||
|
||||
return NGX_OK;
|
||||
}
|
||||
|
|
@ -717,8 +374,7 @@ ngx_regex_module_init(ngx_cycle_t *cycle)
|
|||
static void *
|
||||
ngx_regex_create_conf(ngx_cycle_t *cycle)
|
||||
{
|
||||
ngx_regex_conf_t *rcf;
|
||||
ngx_pool_cleanup_t *cln;
|
||||
ngx_regex_conf_t *rcf;
|
||||
|
||||
rcf = ngx_pcalloc(cycle->pool, sizeof(ngx_regex_conf_t));
|
||||
if (rcf == NULL) {
|
||||
|
|
@ -727,21 +383,11 @@ ngx_regex_create_conf(ngx_cycle_t *cycle)
|
|||
|
||||
rcf->pcre_jit = NGX_CONF_UNSET;
|
||||
|
||||
cln = ngx_pool_cleanup_add(cycle->pool, 0);
|
||||
if (cln == NULL) {
|
||||
ngx_pcre_studies = ngx_list_create(cycle->pool, 8, sizeof(ngx_regex_elt_t));
|
||||
if (ngx_pcre_studies == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
cln->handler = ngx_regex_cleanup;
|
||||
cln->data = rcf;
|
||||
|
||||
rcf->studies = ngx_list_create(cycle->pool, 8, sizeof(ngx_regex_elt_t));
|
||||
if (rcf->studies == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
ngx_regex_studies = rcf->studies;
|
||||
|
||||
return rcf;
|
||||
}
|
||||
|
||||
|
|
@ -766,21 +412,7 @@ ngx_regex_pcre_jit(ngx_conf_t *cf, void *post, void *data)
|
|||
return NGX_CONF_OK;
|
||||
}
|
||||
|
||||
#if (NGX_PCRE2)
|
||||
{
|
||||
int r;
|
||||
uint32_t jit;
|
||||
|
||||
jit = 0;
|
||||
r = pcre2_config(PCRE2_CONFIG_JIT, &jit);
|
||||
|
||||
if (r != 0 || jit != 1) {
|
||||
ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
|
||||
"PCRE2 library does not support JIT");
|
||||
*fp = 0;
|
||||
}
|
||||
}
|
||||
#elif (NGX_HAVE_PCRE_JIT)
|
||||
#if (NGX_HAVE_PCRE_JIT)
|
||||
{
|
||||
int jit, r;
|
||||
|
||||
|
|
|
|||
|
|
@ -12,38 +12,24 @@
|
|||
#include <ngx_config.h>
|
||||
#include <ngx_core.h>
|
||||
|
||||
|
||||
#if (NGX_PCRE2)
|
||||
|
||||
#define PCRE2_CODE_UNIT_WIDTH 8
|
||||
#include <pcre2.h>
|
||||
|
||||
#define NGX_REGEX_NO_MATCHED PCRE2_ERROR_NOMATCH /* -1 */
|
||||
|
||||
typedef pcre2_code ngx_regex_t;
|
||||
|
||||
#else
|
||||
|
||||
#include <pcre.h>
|
||||
|
||||
#define NGX_REGEX_NO_MATCHED PCRE_ERROR_NOMATCH /* -1 */
|
||||
|
||||
#define NGX_REGEX_NO_MATCHED PCRE_ERROR_NOMATCH /* -1 */
|
||||
|
||||
#define NGX_REGEX_CASELESS PCRE_CASELESS
|
||||
|
||||
|
||||
typedef struct {
|
||||
pcre *code;
|
||||
pcre_extra *extra;
|
||||
} ngx_regex_t;
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
#define NGX_REGEX_CASELESS 0x00000001
|
||||
#define NGX_REGEX_MULTILINE 0x00000002
|
||||
|
||||
|
||||
typedef struct {
|
||||
ngx_str_t pattern;
|
||||
ngx_pool_t *pool;
|
||||
ngx_uint_t options;
|
||||
ngx_int_t options;
|
||||
|
||||
ngx_regex_t *regex;
|
||||
int captures;
|
||||
|
|
@ -63,14 +49,10 @@ typedef struct {
|
|||
void ngx_regex_init(void);
|
||||
ngx_int_t ngx_regex_compile(ngx_regex_compile_t *rc);
|
||||
|
||||
ngx_int_t ngx_regex_exec(ngx_regex_t *re, ngx_str_t *s, int *captures,
|
||||
ngx_uint_t size);
|
||||
|
||||
#if (NGX_PCRE2)
|
||||
#define ngx_regex_exec_n "pcre2_match()"
|
||||
#else
|
||||
#define ngx_regex_exec_n "pcre_exec()"
|
||||
#endif
|
||||
#define ngx_regex_exec(re, s, captures, size) \
|
||||
pcre_exec(re->code, re->extra, (const char *) (s)->data, (s)->len, 0, 0, \
|
||||
captures, size)
|
||||
#define ngx_regex_exec_n "pcre_exec()"
|
||||
|
||||
ngx_int_t ngx_regex_exec_array(ngx_array_t *a, ngx_str_t *s, ngx_log_t *log);
|
||||
|
||||
|
|
|
|||
|
|
@ -51,7 +51,9 @@ typedef struct {
|
|||
} ngx_resolver_an_t;
|
||||
|
||||
|
||||
#define ngx_resolver_node(n) ngx_rbtree_data(n, ngx_resolver_node_t, node)
|
||||
#define ngx_resolver_node(n) \
|
||||
(ngx_resolver_node_t *) \
|
||||
((u_char *) (n) - offsetof(ngx_resolver_node_t, node))
|
||||
|
||||
|
||||
static ngx_int_t ngx_udp_connect(ngx_resolver_connection_t *rec);
|
||||
|
|
@ -139,25 +141,24 @@ ngx_resolver_create(ngx_conf_t *cf, ngx_str_t *names, ngx_uint_t n)
|
|||
ngx_pool_cleanup_t *cln;
|
||||
ngx_resolver_connection_t *rec;
|
||||
|
||||
r = ngx_pcalloc(cf->pool, sizeof(ngx_resolver_t));
|
||||
if (r == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
r->event = ngx_pcalloc(cf->pool, sizeof(ngx_event_t));
|
||||
if (r->event == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
cln = ngx_pool_cleanup_add(cf->pool, 0);
|
||||
if (cln == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
cln->handler = ngx_resolver_cleanup;
|
||||
|
||||
r = ngx_calloc(sizeof(ngx_resolver_t), cf->log);
|
||||
if (r == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
cln->data = r;
|
||||
|
||||
r->ipv4 = 1;
|
||||
r->event = ngx_calloc(sizeof(ngx_event_t), cf->log);
|
||||
if (r->event == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
ngx_rbtree_init(&r->name_rbtree, &r->name_sentinel,
|
||||
ngx_resolver_rbtree_insert_value);
|
||||
|
|
@ -227,23 +228,6 @@ ngx_resolver_create(ngx_conf_t *cf, ngx_str_t *names, ngx_uint_t n)
|
|||
}
|
||||
|
||||
#if (NGX_HAVE_INET6)
|
||||
if (ngx_strncmp(names[i].data, "ipv4=", 5) == 0) {
|
||||
|
||||
if (ngx_strcmp(&names[i].data[5], "on") == 0) {
|
||||
r->ipv4 = 1;
|
||||
|
||||
} else if (ngx_strcmp(&names[i].data[5], "off") == 0) {
|
||||
r->ipv4 = 0;
|
||||
|
||||
} else {
|
||||
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
|
||||
"invalid parameter: %V", &names[i]);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
if (ngx_strncmp(names[i].data, "ipv6=", 5) == 0) {
|
||||
|
||||
if (ngx_strcmp(&names[i].data[5], "on") == 0) {
|
||||
|
|
@ -292,19 +276,6 @@ ngx_resolver_create(ngx_conf_t *cf, ngx_str_t *names, ngx_uint_t n)
|
|||
}
|
||||
}
|
||||
|
||||
#if (NGX_HAVE_INET6)
|
||||
if (r->ipv4 + r->ipv6 == 0) {
|
||||
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
|
||||
"\"ipv4\" and \"ipv6\" cannot both be \"off\"");
|
||||
return NULL;
|
||||
}
|
||||
#endif
|
||||
|
||||
if (n && r->connections.nelts == 0) {
|
||||
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "no name servers defined");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return r;
|
||||
}
|
||||
|
||||
|
|
@ -317,42 +288,52 @@ ngx_resolver_cleanup(void *data)
|
|||
ngx_uint_t i;
|
||||
ngx_resolver_connection_t *rec;
|
||||
|
||||
ngx_log_debug0(NGX_LOG_DEBUG_CORE, ngx_cycle->log, 0, "cleanup resolver");
|
||||
if (r) {
|
||||
ngx_log_debug0(NGX_LOG_DEBUG_CORE, ngx_cycle->log, 0,
|
||||
"cleanup resolver");
|
||||
|
||||
ngx_resolver_cleanup_tree(r, &r->name_rbtree);
|
||||
ngx_resolver_cleanup_tree(r, &r->name_rbtree);
|
||||
|
||||
ngx_resolver_cleanup_tree(r, &r->srv_rbtree);
|
||||
ngx_resolver_cleanup_tree(r, &r->srv_rbtree);
|
||||
|
||||
ngx_resolver_cleanup_tree(r, &r->addr_rbtree);
|
||||
ngx_resolver_cleanup_tree(r, &r->addr_rbtree);
|
||||
|
||||
#if (NGX_HAVE_INET6)
|
||||
ngx_resolver_cleanup_tree(r, &r->addr6_rbtree);
|
||||
ngx_resolver_cleanup_tree(r, &r->addr6_rbtree);
|
||||
#endif
|
||||
|
||||
if (r->event->timer_set) {
|
||||
ngx_del_timer(r->event);
|
||||
}
|
||||
if (r->event) {
|
||||
if (r->event->timer_set) {
|
||||
ngx_del_timer(r->event);
|
||||
}
|
||||
|
||||
rec = r->connections.elts;
|
||||
|
||||
for (i = 0; i < r->connections.nelts; i++) {
|
||||
if (rec[i].udp) {
|
||||
ngx_close_connection(rec[i].udp);
|
||||
ngx_free(r->event);
|
||||
}
|
||||
|
||||
if (rec[i].tcp) {
|
||||
ngx_close_connection(rec[i].tcp);
|
||||
|
||||
rec = r->connections.elts;
|
||||
|
||||
for (i = 0; i < r->connections.nelts; i++) {
|
||||
if (rec[i].udp) {
|
||||
ngx_close_connection(rec[i].udp);
|
||||
}
|
||||
|
||||
if (rec[i].tcp) {
|
||||
ngx_close_connection(rec[i].tcp);
|
||||
}
|
||||
|
||||
if (rec[i].read_buf) {
|
||||
ngx_resolver_free(r, rec[i].read_buf->start);
|
||||
ngx_resolver_free(r, rec[i].read_buf);
|
||||
}
|
||||
|
||||
if (rec[i].write_buf) {
|
||||
ngx_resolver_free(r, rec[i].write_buf->start);
|
||||
ngx_resolver_free(r, rec[i].write_buf);
|
||||
}
|
||||
}
|
||||
|
||||
if (rec[i].read_buf) {
|
||||
ngx_resolver_free(r, rec[i].read_buf->start);
|
||||
ngx_resolver_free(r, rec[i].read_buf);
|
||||
}
|
||||
|
||||
if (rec[i].write_buf) {
|
||||
ngx_resolver_free(r, rec[i].write_buf->start);
|
||||
ngx_resolver_free(r, rec[i].write_buf);
|
||||
}
|
||||
ngx_free(r);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -863,7 +844,7 @@ ngx_resolve_name_locked(ngx_resolver_t *r, ngx_resolver_ctx_t *ctx,
|
|||
r->last_connection = 0;
|
||||
}
|
||||
|
||||
rn->naddrs = r->ipv4 ? (u_short) -1 : 0;
|
||||
rn->naddrs = (u_short) -1;
|
||||
rn->tcp = 0;
|
||||
#if (NGX_HAVE_INET6)
|
||||
rn->naddrs6 = r->ipv6 ? (u_short) -1 : 0;
|
||||
|
|
@ -872,15 +853,7 @@ ngx_resolve_name_locked(ngx_resolver_t *r, ngx_resolver_ctx_t *ctx,
|
|||
rn->nsrvs = 0;
|
||||
|
||||
if (ngx_resolver_send_query(r, rn) != NGX_OK) {
|
||||
|
||||
/* immediately retry once on failure */
|
||||
|
||||
rn->last_connection++;
|
||||
if (rn->last_connection == r->connections.nelts) {
|
||||
rn->last_connection = 0;
|
||||
}
|
||||
|
||||
(void) ngx_resolver_send_query(r, rn);
|
||||
goto failed;
|
||||
}
|
||||
|
||||
if (ngx_resolver_set_timeout(r, ctx) != NGX_OK) {
|
||||
|
|
@ -997,8 +970,7 @@ ngx_resolve_addr(ngx_resolver_ctx_t *ctx)
|
|||
|
||||
name = ngx_resolver_dup(r, rn->name, rn->nlen);
|
||||
if (name == NULL) {
|
||||
ngx_resolver_free(r, ctx);
|
||||
return NGX_ERROR;
|
||||
goto failed;
|
||||
}
|
||||
|
||||
ctx->name.len = rn->nlen;
|
||||
|
|
@ -1085,15 +1057,7 @@ ngx_resolve_addr(ngx_resolver_ctx_t *ctx)
|
|||
rn->nsrvs = 0;
|
||||
|
||||
if (ngx_resolver_send_query(r, rn) != NGX_OK) {
|
||||
|
||||
/* immediately retry once on failure */
|
||||
|
||||
rn->last_connection++;
|
||||
if (rn->last_connection == r->connections.nelts) {
|
||||
rn->last_connection = 0;
|
||||
}
|
||||
|
||||
(void) ngx_resolver_send_query(r, rn);
|
||||
goto failed;
|
||||
}
|
||||
|
||||
if (ngx_resolver_set_timeout(r, ctx) != NGX_OK) {
|
||||
|
|
@ -1290,7 +1254,7 @@ ngx_resolver_send_query(ngx_resolver_t *r, ngx_resolver_node_t *rn)
|
|||
rec->log.action = "resolving";
|
||||
}
|
||||
|
||||
if (rn->query && rn->naddrs == (u_short) -1) {
|
||||
if (rn->naddrs == (u_short) -1) {
|
||||
rc = rn->tcp ? ngx_resolver_send_tcp_query(r, rec, rn->query, rn->qlen)
|
||||
: ngx_resolver_send_udp_query(r, rec, rn->query, rn->qlen);
|
||||
|
||||
|
|
@ -1335,23 +1299,16 @@ ngx_resolver_send_udp_query(ngx_resolver_t *r, ngx_resolver_connection_t *rec,
|
|||
|
||||
n = ngx_send(rec->udp, query, qlen);
|
||||
|
||||
if (n == NGX_ERROR) {
|
||||
goto failed;
|
||||
if (n == -1) {
|
||||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
if ((size_t) n != (size_t) qlen) {
|
||||
ngx_log_error(NGX_LOG_CRIT, &rec->log, 0, "send() incomplete");
|
||||
goto failed;
|
||||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
return NGX_OK;
|
||||
|
||||
failed:
|
||||
|
||||
ngx_close_connection(rec->udp);
|
||||
rec->udp = NULL;
|
||||
|
||||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -1416,7 +1373,6 @@ ngx_resolver_send_tcp_query(ngx_resolver_t *r, ngx_resolver_connection_t *rec,
|
|||
|
||||
rec->tcp->data = rec;
|
||||
rec->tcp->write->handler = ngx_resolver_tcp_write;
|
||||
rec->tcp->write->cancelable = 1;
|
||||
rec->tcp->read->handler = ngx_resolver_tcp_read;
|
||||
rec->tcp->read->resolver = 1;
|
||||
|
||||
|
|
@ -1589,28 +1545,13 @@ ngx_resolver_udp_read(ngx_event_t *rev)
|
|||
do {
|
||||
n = ngx_udp_recv(c, buf, NGX_RESOLVER_UDP_SIZE);
|
||||
|
||||
if (n == NGX_AGAIN) {
|
||||
break;
|
||||
}
|
||||
|
||||
if (n == NGX_ERROR) {
|
||||
goto failed;
|
||||
if (n < 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
ngx_resolver_process_response(rec->resolver, buf, n, 0);
|
||||
|
||||
} while (rev->ready);
|
||||
|
||||
if (ngx_handle_read_event(rev, 0) != NGX_OK) {
|
||||
goto failed;
|
||||
}
|
||||
|
||||
return;
|
||||
|
||||
failed:
|
||||
|
||||
ngx_close_connection(rec->udp);
|
||||
rec->udp = NULL;
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -1792,13 +1733,10 @@ ngx_resolver_process_response(ngx_resolver_t *r, u_char *buf, size_t n,
|
|||
q = ngx_queue_next(q))
|
||||
{
|
||||
rn = ngx_queue_data(q, ngx_resolver_node_t, queue);
|
||||
qident = (rn->query[0] << 8) + rn->query[1];
|
||||
|
||||
if (rn->query) {
|
||||
qident = (rn->query[0] << 8) + rn->query[1];
|
||||
|
||||
if (qident == ident) {
|
||||
goto dns_error_name;
|
||||
}
|
||||
if (qident == ident) {
|
||||
goto dns_error_name;
|
||||
}
|
||||
|
||||
#if (NGX_HAVE_INET6)
|
||||
|
|
@ -1827,12 +1765,6 @@ ngx_resolver_process_response(ngx_resolver_t *r, u_char *buf, size_t n,
|
|||
i = sizeof(ngx_resolver_hdr_t);
|
||||
|
||||
while (i < (ngx_uint_t) n) {
|
||||
|
||||
if (buf[i] & 0xc0) {
|
||||
err = "unexpected compression pointer in DNS response";
|
||||
goto done;
|
||||
}
|
||||
|
||||
if (buf[i] == '\0') {
|
||||
goto found;
|
||||
}
|
||||
|
|
@ -1968,7 +1900,7 @@ ngx_resolver_process_a(ngx_resolver_t *r, u_char *buf, size_t n,
|
|||
|
||||
if (rn == NULL) {
|
||||
ngx_log_error(r->log_level, r->log, 0,
|
||||
"unexpected DNS response for %V", &name);
|
||||
"unexpected response for %V", &name);
|
||||
ngx_resolver_free(r, name.data);
|
||||
goto failed;
|
||||
}
|
||||
|
|
@ -1980,7 +1912,7 @@ ngx_resolver_process_a(ngx_resolver_t *r, u_char *buf, size_t n,
|
|||
|
||||
if (rn->query6 == NULL || rn->naddrs6 != (u_short) -1) {
|
||||
ngx_log_error(r->log_level, r->log, 0,
|
||||
"unexpected DNS response for %V", &name);
|
||||
"unexpected response for %V", &name);
|
||||
ngx_resolver_free(r, name.data);
|
||||
goto failed;
|
||||
}
|
||||
|
|
@ -1999,7 +1931,7 @@ ngx_resolver_process_a(ngx_resolver_t *r, u_char *buf, size_t n,
|
|||
|
||||
if (rn->query == NULL || rn->naddrs != (u_short) -1) {
|
||||
ngx_log_error(r->log_level, r->log, 0,
|
||||
"unexpected DNS response for %V", &name);
|
||||
"unexpected response for %V", &name);
|
||||
ngx_resolver_free(r, name.data);
|
||||
goto failed;
|
||||
}
|
||||
|
|
@ -2014,7 +1946,7 @@ ngx_resolver_process_a(ngx_resolver_t *r, u_char *buf, size_t n,
|
|||
|
||||
if (ident != qident) {
|
||||
ngx_log_error(r->log_level, r->log, 0,
|
||||
"wrong ident %ui in DNS response for %V, expect %ui",
|
||||
"wrong ident %ui response for %V, expect %ui",
|
||||
ident, &name, qident);
|
||||
ngx_resolver_free(r, name.data);
|
||||
goto failed;
|
||||
|
|
@ -2199,7 +2131,7 @@ ngx_resolver_process_a(ngx_resolver_t *r, u_char *buf, size_t n,
|
|||
|
||||
if (class != 1) {
|
||||
ngx_log_error(r->log_level, r->log, 0,
|
||||
"unexpected RR class %ui in DNS response", class);
|
||||
"unexpected RR class %ui", class);
|
||||
goto failed;
|
||||
}
|
||||
|
||||
|
|
@ -2268,7 +2200,7 @@ ngx_resolver_process_a(ngx_resolver_t *r, u_char *buf, size_t n,
|
|||
default:
|
||||
|
||||
ngx_log_error(r->log_level, r->log, 0,
|
||||
"unexpected RR type %ui in DNS response", type);
|
||||
"unexpected RR type %ui", type);
|
||||
}
|
||||
|
||||
i += len;
|
||||
|
|
@ -2617,7 +2549,7 @@ ngx_resolver_process_srv(ngx_resolver_t *r, u_char *buf, size_t n,
|
|||
|
||||
if (rn == NULL || rn->query == NULL) {
|
||||
ngx_log_error(r->log_level, r->log, 0,
|
||||
"unexpected DNS response for %V", &name);
|
||||
"unexpected response for %V", &name);
|
||||
ngx_resolver_free(r, name.data);
|
||||
goto failed;
|
||||
}
|
||||
|
|
@ -2631,7 +2563,7 @@ ngx_resolver_process_srv(ngx_resolver_t *r, u_char *buf, size_t n,
|
|||
|
||||
if (ident != qident) {
|
||||
ngx_log_error(r->log_level, r->log, 0,
|
||||
"wrong ident %ui in DNS response for %V, expect %ui",
|
||||
"wrong ident %ui response for %V, expect %ui",
|
||||
ident, &name, qident);
|
||||
ngx_resolver_free(r, name.data);
|
||||
goto failed;
|
||||
|
|
@ -2741,7 +2673,7 @@ ngx_resolver_process_srv(ngx_resolver_t *r, u_char *buf, size_t n,
|
|||
|
||||
if (class != 1) {
|
||||
ngx_log_error(r->log_level, r->log, 0,
|
||||
"unexpected RR class %ui in DNS response", class);
|
||||
"unexpected RR class %ui", class);
|
||||
goto failed;
|
||||
}
|
||||
|
||||
|
|
@ -2784,7 +2716,7 @@ ngx_resolver_process_srv(ngx_resolver_t *r, u_char *buf, size_t n,
|
|||
default:
|
||||
|
||||
ngx_log_error(r->log_level, r->log, 0,
|
||||
"unexpected RR type %ui in DNS response", type);
|
||||
"unexpected RR type %ui", type);
|
||||
}
|
||||
|
||||
i += len;
|
||||
|
|
@ -3215,7 +3147,7 @@ valid:
|
|||
|
||||
if (rn == NULL || rn->query == NULL) {
|
||||
ngx_log_error(r->log_level, r->log, 0,
|
||||
"unexpected DNS response for %V", &name);
|
||||
"unexpected response for %V", &name);
|
||||
ngx_resolver_free(r, name.data);
|
||||
goto failed;
|
||||
}
|
||||
|
|
@ -3224,7 +3156,7 @@ valid:
|
|||
|
||||
if (ident != qident) {
|
||||
ngx_log_error(r->log_level, r->log, 0,
|
||||
"wrong ident %ui in DNS response for %V, expect %ui",
|
||||
"wrong ident %ui response for %V, expect %ui",
|
||||
ident, &name, qident);
|
||||
ngx_resolver_free(r, name.data);
|
||||
goto failed;
|
||||
|
|
@ -3306,7 +3238,7 @@ valid:
|
|||
|
||||
if (class != 1) {
|
||||
ngx_log_error(r->log_level, r->log, 0,
|
||||
"unexpected RR class %ui in DNS response", class);
|
||||
"unexpected RR class %ui", class);
|
||||
goto failed;
|
||||
}
|
||||
|
||||
|
|
@ -3333,7 +3265,7 @@ valid:
|
|||
default:
|
||||
|
||||
ngx_log_error(r->log_level, r->log, 0,
|
||||
"unexpected RR type %ui in DNS response", type);
|
||||
"unexpected RR type %ui", type);
|
||||
}
|
||||
|
||||
i += len;
|
||||
|
|
@ -3675,7 +3607,7 @@ ngx_resolver_create_name_query(ngx_resolver_t *r, ngx_resolver_node_t *rn,
|
|||
len = sizeof(ngx_resolver_hdr_t) + nlen + sizeof(ngx_resolver_qs_t);
|
||||
|
||||
#if (NGX_HAVE_INET6)
|
||||
p = ngx_resolver_alloc(r, len * (r->ipv4 + r->ipv6));
|
||||
p = ngx_resolver_alloc(r, r->ipv6 ? len * 2 : len);
|
||||
#else
|
||||
p = ngx_resolver_alloc(r, len);
|
||||
#endif
|
||||
|
|
@ -3688,21 +3620,19 @@ ngx_resolver_create_name_query(ngx_resolver_t *r, ngx_resolver_node_t *rn,
|
|||
|
||||
#if (NGX_HAVE_INET6)
|
||||
if (r->ipv6) {
|
||||
rn->query6 = r->ipv4 ? (p + len) : p;
|
||||
rn->query6 = p + len;
|
||||
}
|
||||
#endif
|
||||
|
||||
query = (ngx_resolver_hdr_t *) p;
|
||||
|
||||
if (r->ipv4) {
|
||||
ident = ngx_random();
|
||||
ident = ngx_random();
|
||||
|
||||
ngx_log_debug2(NGX_LOG_DEBUG_CORE, r->log, 0,
|
||||
"resolve: \"%V\" A %i", name, ident & 0xffff);
|
||||
ngx_log_debug2(NGX_LOG_DEBUG_CORE, r->log, 0,
|
||||
"resolve: \"%V\" A %i", name, ident & 0xffff);
|
||||
|
||||
query->ident_hi = (u_char) ((ident >> 8) & 0xff);
|
||||
query->ident_lo = (u_char) (ident & 0xff);
|
||||
}
|
||||
query->ident_hi = (u_char) ((ident >> 8) & 0xff);
|
||||
query->ident_lo = (u_char) (ident & 0xff);
|
||||
|
||||
/* recursion query */
|
||||
query->flags_hi = 1; query->flags_lo = 0;
|
||||
|
|
@ -3763,9 +3693,7 @@ ngx_resolver_create_name_query(ngx_resolver_t *r, ngx_resolver_node_t *rn,
|
|||
|
||||
p = rn->query6;
|
||||
|
||||
if (r->ipv4) {
|
||||
ngx_memcpy(p, rn->query, rn->qlen);
|
||||
}
|
||||
ngx_memcpy(p, rn->query, rn->qlen);
|
||||
|
||||
query = (ngx_resolver_hdr_t *) p;
|
||||
|
||||
|
|
@ -3978,11 +3906,11 @@ ngx_resolver_copy(ngx_resolver_t *r, ngx_str_t *name, u_char *buf, u_char *src,
|
|||
{
|
||||
char *err;
|
||||
u_char *p, *dst;
|
||||
size_t len;
|
||||
ssize_t len;
|
||||
ngx_uint_t i, n;
|
||||
|
||||
p = src;
|
||||
len = 0;
|
||||
len = -1;
|
||||
|
||||
/*
|
||||
* compression pointers allow to create endless loop, so we set limit;
|
||||
|
|
@ -3997,16 +3925,6 @@ ngx_resolver_copy(ngx_resolver_t *r, ngx_str_t *name, u_char *buf, u_char *src,
|
|||
}
|
||||
|
||||
if (n & 0xc0) {
|
||||
if ((n & 0xc0) != 0xc0) {
|
||||
err = "invalid label type in DNS response";
|
||||
goto invalid;
|
||||
}
|
||||
|
||||
if (p >= last) {
|
||||
err = "name is out of DNS response";
|
||||
goto invalid;
|
||||
}
|
||||
|
||||
n = ((n & 0x3f) << 8) + *p;
|
||||
p = &buf[n];
|
||||
|
||||
|
|
@ -4016,12 +3934,12 @@ ngx_resolver_copy(ngx_resolver_t *r, ngx_str_t *name, u_char *buf, u_char *src,
|
|||
}
|
||||
|
||||
if (p >= last) {
|
||||
err = "name is out of DNS response";
|
||||
err = "name is out of response";
|
||||
goto invalid;
|
||||
}
|
||||
}
|
||||
|
||||
err = "compression pointers loop in DNS response";
|
||||
err = "compression pointers loop";
|
||||
|
||||
invalid:
|
||||
|
||||
|
|
@ -4035,7 +3953,7 @@ done:
|
|||
return NGX_OK;
|
||||
}
|
||||
|
||||
if (len == 0) {
|
||||
if (len == -1) {
|
||||
ngx_str_null(name);
|
||||
return NGX_OK;
|
||||
}
|
||||
|
|
@ -4047,23 +3965,30 @@ done:
|
|||
|
||||
name->data = dst;
|
||||
|
||||
n = *src++;
|
||||
|
||||
for ( ;; ) {
|
||||
n = *src++;
|
||||
|
||||
if (n == 0) {
|
||||
name->len = dst - name->data - 1;
|
||||
return NGX_OK;
|
||||
}
|
||||
|
||||
if (n & 0xc0) {
|
||||
n = ((n & 0x3f) << 8) + *src;
|
||||
src = &buf[n];
|
||||
|
||||
n = *src++;
|
||||
|
||||
} else {
|
||||
ngx_strlow(dst, src, n);
|
||||
dst += n;
|
||||
src += n;
|
||||
*dst++ = '.';
|
||||
|
||||
n = *src++;
|
||||
|
||||
if (n != 0) {
|
||||
*dst++ = '.';
|
||||
}
|
||||
}
|
||||
|
||||
if (n == 0) {
|
||||
name->len = dst - name->data;
|
||||
return NGX_OK;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -4324,15 +4249,7 @@ ngx_resolver_report_srv(ngx_resolver_t *r, ngx_resolver_ctx_t *ctx)
|
|||
}
|
||||
|
||||
if (naddrs == 0) {
|
||||
ctx->state = srvs[0].state;
|
||||
|
||||
for (i = 0; i < nsrvs; i++) {
|
||||
if (srvs[i].state == NGX_RESOLVE_NXDOMAIN) {
|
||||
ctx->state = NGX_RESOLVE_NXDOMAIN;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
ctx->state = NGX_RESOLVE_NXDOMAIN;
|
||||
ctx->valid = ngx_time() + (r->valid ? r->valid : 10);
|
||||
|
||||
ctx->handler(ctx);
|
||||
|
|
@ -4478,7 +4395,7 @@ ngx_udp_connect(ngx_resolver_connection_t *rec)
|
|||
if (c == NULL) {
|
||||
if (ngx_close_socket(s) == -1) {
|
||||
ngx_log_error(NGX_LOG_ALERT, &rec->log, ngx_socket_errno,
|
||||
ngx_close_socket_n " failed");
|
||||
ngx_close_socket_n "failed");
|
||||
}
|
||||
|
||||
return NGX_ERROR;
|
||||
|
|
@ -4501,8 +4418,6 @@ ngx_udp_connect(ngx_resolver_connection_t *rec)
|
|||
|
||||
c->number = ngx_atomic_fetch_add(ngx_connection_counter, 1);
|
||||
|
||||
c->start_time = ngx_current_msec;
|
||||
|
||||
ngx_log_debug3(NGX_LOG_DEBUG_EVENT, &rec->log, 0,
|
||||
"connect to %V, fd:%d #%uA", &rec->server, s, c->number);
|
||||
|
||||
|
|
@ -4566,7 +4481,7 @@ ngx_tcp_connect(ngx_resolver_connection_t *rec)
|
|||
if (c == NULL) {
|
||||
if (ngx_close_socket(s) == -1) {
|
||||
ngx_log_error(NGX_LOG_ALERT, &rec->log, ngx_socket_errno,
|
||||
ngx_close_socket_n " failed");
|
||||
ngx_close_socket_n "failed");
|
||||
}
|
||||
|
||||
return NGX_ERROR;
|
||||
|
|
@ -4589,8 +4504,6 @@ ngx_tcp_connect(ngx_resolver_connection_t *rec)
|
|||
|
||||
c->number = ngx_atomic_fetch_add(ngx_connection_counter, 1);
|
||||
|
||||
c->start_time = ngx_current_msec;
|
||||
|
||||
if (ngx_add_conn) {
|
||||
if (ngx_add_conn(c) == NGX_ERROR) {
|
||||
goto failed;
|
||||
|
|
@ -4633,7 +4546,7 @@ ngx_tcp_connect(ngx_resolver_connection_t *rec)
|
|||
level = NGX_LOG_CRIT;
|
||||
}
|
||||
|
||||
ngx_log_error(level, &rec->log, err, "connect() to %V failed",
|
||||
ngx_log_error(level, c->log, err, "connect() to %V failed",
|
||||
&rec->server);
|
||||
|
||||
ngx_close_connection(c);
|
||||
|
|
|
|||
|
|
@ -175,10 +175,8 @@ struct ngx_resolver_s {
|
|||
ngx_queue_t srv_expire_queue;
|
||||
ngx_queue_t addr_expire_queue;
|
||||
|
||||
unsigned ipv4:1;
|
||||
|
||||
#if (NGX_HAVE_INET6)
|
||||
unsigned ipv6:1;
|
||||
ngx_uint_t ipv6; /* unsigned ipv6:1; */
|
||||
ngx_rbtree_t addr6_rbtree;
|
||||
ngx_rbtree_node_t addr6_sentinel;
|
||||
ngx_queue_t addr6_resend_queue;
|
||||
|
|
|
|||
|
|
@ -89,10 +89,22 @@ ngx_rwlock_rlock(ngx_atomic_t *lock)
|
|||
void
|
||||
ngx_rwlock_unlock(ngx_atomic_t *lock)
|
||||
{
|
||||
if (*lock == NGX_RWLOCK_WLOCK) {
|
||||
ngx_atomic_uint_t readers;
|
||||
|
||||
readers = *lock;
|
||||
|
||||
if (readers == NGX_RWLOCK_WLOCK) {
|
||||
(void) ngx_atomic_cmp_set(lock, NGX_RWLOCK_WLOCK, 0);
|
||||
} else {
|
||||
(void) ngx_atomic_fetch_add(lock, -1);
|
||||
return;
|
||||
}
|
||||
|
||||
for ( ;; ) {
|
||||
|
||||
if (ngx_atomic_cmp_set(lock, readers, readers - 1)) {
|
||||
return;
|
||||
}
|
||||
|
||||
readers = *lock;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -635,9 +635,10 @@ ngx_slab_free_locked(ngx_slab_pool_t *pool, void *p)
|
|||
goto fail;
|
||||
}
|
||||
|
||||
n = ((u_char *) p - pool->start) >> ngx_pagesize_shift;
|
||||
size = slab & ~NGX_SLAB_PAGE_START;
|
||||
|
||||
ngx_slab_free_pages(pool, page, size);
|
||||
ngx_slab_free_pages(pool, &pool->pages[n], size);
|
||||
|
||||
ngx_slab_junk(p, size << ngx_pagesize_shift);
|
||||
|
||||
|
|
|
|||
|
|
@ -11,8 +11,6 @@
|
|||
|
||||
static u_char *ngx_sprintf_num(u_char *buf, u_char *last, uint64_t ui64,
|
||||
u_char zero, ngx_uint_t hexadecimal, ngx_uint_t width);
|
||||
static u_char *ngx_sprintf_str(u_char *buf, u_char *last, u_char *src,
|
||||
size_t len, ngx_uint_t hexadecimal);
|
||||
static void ngx_encode_base64_internal(ngx_str_t *dst, ngx_str_t *src,
|
||||
const u_char *basis, ngx_uint_t padding);
|
||||
static ngx_int_t ngx_decode_base64_internal(ngx_str_t *dst, ngx_str_t *src,
|
||||
|
|
@ -103,10 +101,10 @@ ngx_pstrdup(ngx_pool_t *pool, ngx_str_t *src)
|
|||
* %M ngx_msec_t
|
||||
* %r rlim_t
|
||||
* %p void *
|
||||
* %[x|X]V ngx_str_t *
|
||||
* %[x|X]v ngx_variable_value_t *
|
||||
* %[x|X]s null-terminated string
|
||||
* %*[x|X]s length and string
|
||||
* %V ngx_str_t *
|
||||
* %v ngx_variable_value_t *
|
||||
* %s null-terminated string
|
||||
* %*s length and string
|
||||
* %Z '\0'
|
||||
* %N '\n'
|
||||
* %c char
|
||||
|
|
@ -167,7 +165,7 @@ ngx_vslprintf(u_char *buf, u_char *last, const char *fmt, va_list args)
|
|||
u_char *p, zero;
|
||||
int d;
|
||||
double f;
|
||||
size_t slen;
|
||||
size_t len, slen;
|
||||
int64_t i64;
|
||||
uint64_t ui64, frac;
|
||||
ngx_msec_t ms;
|
||||
|
|
@ -252,7 +250,8 @@ ngx_vslprintf(u_char *buf, u_char *last, const char *fmt, va_list args)
|
|||
case 'V':
|
||||
v = va_arg(args, ngx_str_t *);
|
||||
|
||||
buf = ngx_sprintf_str(buf, last, v->data, v->len, hex);
|
||||
len = ngx_min(((size_t) (last - buf)), v->len);
|
||||
buf = ngx_cpymem(buf, v->data, len);
|
||||
fmt++;
|
||||
|
||||
continue;
|
||||
|
|
@ -260,7 +259,8 @@ ngx_vslprintf(u_char *buf, u_char *last, const char *fmt, va_list args)
|
|||
case 'v':
|
||||
vv = va_arg(args, ngx_variable_value_t *);
|
||||
|
||||
buf = ngx_sprintf_str(buf, last, vv->data, vv->len, hex);
|
||||
len = ngx_min(((size_t) (last - buf)), vv->len);
|
||||
buf = ngx_cpymem(buf, vv->data, len);
|
||||
fmt++;
|
||||
|
||||
continue;
|
||||
|
|
@ -268,7 +268,16 @@ ngx_vslprintf(u_char *buf, u_char *last, const char *fmt, va_list args)
|
|||
case 's':
|
||||
p = va_arg(args, u_char *);
|
||||
|
||||
buf = ngx_sprintf_str(buf, last, p, slen, hex);
|
||||
if (slen == (size_t) -1) {
|
||||
while (*p && buf < last) {
|
||||
*buf++ = *p++;
|
||||
}
|
||||
|
||||
} else {
|
||||
len = ngx_min(((size_t) (last - buf)), slen);
|
||||
buf = ngx_cpymem(buf, p, len);
|
||||
}
|
||||
|
||||
fmt++;
|
||||
|
||||
continue;
|
||||
|
|
@ -567,64 +576,6 @@ ngx_sprintf_num(u_char *buf, u_char *last, uint64_t ui64, u_char zero,
|
|||
}
|
||||
|
||||
|
||||
static u_char *
|
||||
ngx_sprintf_str(u_char *buf, u_char *last, u_char *src, size_t len,
|
||||
ngx_uint_t hexadecimal)
|
||||
{
|
||||
static u_char hex[] = "0123456789abcdef";
|
||||
static u_char HEX[] = "0123456789ABCDEF";
|
||||
|
||||
if (hexadecimal == 0) {
|
||||
|
||||
if (len == (size_t) -1) {
|
||||
while (*src && buf < last) {
|
||||
*buf++ = *src++;
|
||||
}
|
||||
|
||||
} else {
|
||||
len = ngx_min((size_t) (last - buf), len);
|
||||
buf = ngx_cpymem(buf, src, len);
|
||||
}
|
||||
|
||||
} else if (hexadecimal == 1) {
|
||||
|
||||
if (len == (size_t) -1) {
|
||||
|
||||
while (*src && buf < last - 1) {
|
||||
*buf++ = hex[*src >> 4];
|
||||
*buf++ = hex[*src++ & 0xf];
|
||||
}
|
||||
|
||||
} else {
|
||||
|
||||
while (len-- && buf < last - 1) {
|
||||
*buf++ = hex[*src >> 4];
|
||||
*buf++ = hex[*src++ & 0xf];
|
||||
}
|
||||
}
|
||||
|
||||
} else { /* hexadecimal == 2 */
|
||||
|
||||
if (len == (size_t) -1) {
|
||||
|
||||
while (*src && buf < last - 1) {
|
||||
*buf++ = HEX[*src >> 4];
|
||||
*buf++ = HEX[*src++ & 0xf];
|
||||
}
|
||||
|
||||
} else {
|
||||
|
||||
while (len-- && buf < last - 1) {
|
||||
*buf++ = HEX[*src >> 4];
|
||||
*buf++ = HEX[*src++ & 0xf];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return buf;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* We use ngx_strcasecmp()/ngx_strncasecmp() for 7-bit ASCII strings only,
|
||||
* and implement our own ngx_strcasecmp()/ngx_strncasecmp()
|
||||
|
|
@ -1364,12 +1315,7 @@ ngx_utf8_decode(u_char **p, size_t n)
|
|||
|
||||
u = **p;
|
||||
|
||||
if (u >= 0xf8) {
|
||||
|
||||
(*p)++;
|
||||
return 0xffffffff;
|
||||
|
||||
} else if (u >= 0xf0) {
|
||||
if (u >= 0xf0) {
|
||||
|
||||
u &= 0x07;
|
||||
valid = 0xffff;
|
||||
|
|
@ -1435,7 +1381,7 @@ ngx_utf8_length(u_char *p, size_t n)
|
|||
continue;
|
||||
}
|
||||
|
||||
if (ngx_utf8_decode(&p, last - p) > 0x10ffff) {
|
||||
if (ngx_utf8_decode(&p, n) > 0x10ffff) {
|
||||
/* invalid UTF-8 */
|
||||
return n;
|
||||
}
|
||||
|
|
@ -1498,32 +1444,19 @@ ngx_escape_uri(u_char *dst, u_char *src, size_t size, ngx_uint_t type)
|
|||
uint32_t *escape;
|
||||
static u_char hex[] = "0123456789ABCDEF";
|
||||
|
||||
/*
|
||||
* Per RFC 3986 only the following chars are allowed in URIs unescaped:
|
||||
*
|
||||
* unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~"
|
||||
* gen-delims = ":" / "/" / "?" / "#" / "[" / "]" / "@"
|
||||
* sub-delims = "!" / "$" / "&" / "'" / "(" / ")"
|
||||
* / "*" / "+" / "," / ";" / "="
|
||||
*
|
||||
* And "%" can appear as a part of escaping itself. The following
|
||||
* characters are not allowed and need to be escaped: %00-%1F, %7F-%FF,
|
||||
* " ", """, "<", ">", "\", "^", "`", "{", "|", "}".
|
||||
*/
|
||||
|
||||
/* " ", "#", "%", "?", not allowed */
|
||||
/* " ", "#", "%", "?", %00-%1F, %7F-%FF */
|
||||
|
||||
static uint32_t uri[] = {
|
||||
0xffffffff, /* 1111 1111 1111 1111 1111 1111 1111 1111 */
|
||||
|
||||
/* ?>=< ;:98 7654 3210 /.-, +*)( '&%$ #"! */
|
||||
0xd000002d, /* 1101 0000 0000 0000 0000 0000 0010 1101 */
|
||||
0x80000029, /* 1000 0000 0000 0000 0000 0000 0010 1001 */
|
||||
|
||||
/* _^]\ [ZYX WVUT SRQP ONML KJIH GFED CBA@ */
|
||||
0x50000000, /* 0101 0000 0000 0000 0000 0000 0000 0000 */
|
||||
0x00000000, /* 0000 0000 0000 0000 0000 0000 0000 0000 */
|
||||
|
||||
/* ~}| {zyx wvut srqp onml kjih gfed cba` */
|
||||
0xb8000001, /* 1011 1000 0000 0000 0000 0000 0000 0001 */
|
||||
0x80000000, /* 1000 0000 0000 0000 0000 0000 0000 0000 */
|
||||
|
||||
0xffffffff, /* 1111 1111 1111 1111 1111 1111 1111 1111 */
|
||||
0xffffffff, /* 1111 1111 1111 1111 1111 1111 1111 1111 */
|
||||
|
|
@ -1531,19 +1464,19 @@ ngx_escape_uri(u_char *dst, u_char *src, size_t size, ngx_uint_t type)
|
|||
0xffffffff /* 1111 1111 1111 1111 1111 1111 1111 1111 */
|
||||
};
|
||||
|
||||
/* " ", "#", "%", "&", "+", ";", "?", not allowed */
|
||||
/* " ", "#", "%", "&", "+", "?", %00-%1F, %7F-%FF */
|
||||
|
||||
static uint32_t args[] = {
|
||||
0xffffffff, /* 1111 1111 1111 1111 1111 1111 1111 1111 */
|
||||
|
||||
/* ?>=< ;:98 7654 3210 /.-, +*)( '&%$ #"! */
|
||||
0xd800086d, /* 1101 1000 0000 0000 0000 1000 0110 1101 */
|
||||
0x88000869, /* 1000 1000 0000 0000 0000 1000 0110 1001 */
|
||||
|
||||
/* _^]\ [ZYX WVUT SRQP ONML KJIH GFED CBA@ */
|
||||
0x50000000, /* 0101 0000 0000 0000 0000 0000 0000 0000 */
|
||||
0x00000000, /* 0000 0000 0000 0000 0000 0000 0000 0000 */
|
||||
|
||||
/* ~}| {zyx wvut srqp onml kjih gfed cba` */
|
||||
0xb8000001, /* 1011 1000 0000 0000 0000 0000 0000 0001 */
|
||||
0x80000000, /* 1000 0000 0000 0000 0000 0000 0000 0000 */
|
||||
|
||||
0xffffffff, /* 1111 1111 1111 1111 1111 1111 1111 1111 */
|
||||
0xffffffff, /* 1111 1111 1111 1111 1111 1111 1111 1111 */
|
||||
|
|
@ -1571,19 +1504,19 @@ ngx_escape_uri(u_char *dst, u_char *src, size_t size, ngx_uint_t type)
|
|||
0xffffffff /* 1111 1111 1111 1111 1111 1111 1111 1111 */
|
||||
};
|
||||
|
||||
/* " ", "#", """, "%", "'", not allowed */
|
||||
/* " ", "#", """, "%", "'", %00-%1F, %7F-%FF */
|
||||
|
||||
static uint32_t html[] = {
|
||||
0xffffffff, /* 1111 1111 1111 1111 1111 1111 1111 1111 */
|
||||
|
||||
/* ?>=< ;:98 7654 3210 /.-, +*)( '&%$ #"! */
|
||||
0x500000ad, /* 0101 0000 0000 0000 0000 0000 1010 1101 */
|
||||
0x000000ad, /* 0000 0000 0000 0000 0000 0000 1010 1101 */
|
||||
|
||||
/* _^]\ [ZYX WVUT SRQP ONML KJIH GFED CBA@ */
|
||||
0x50000000, /* 0101 0000 0000 0000 0000 0000 0000 0000 */
|
||||
0x00000000, /* 0000 0000 0000 0000 0000 0000 0000 0000 */
|
||||
|
||||
/* ~}| {zyx wvut srqp onml kjih gfed cba` */
|
||||
0xb8000001, /* 1011 1000 0000 0000 0000 0000 0000 0001 */
|
||||
0x80000000, /* 1000 0000 0000 0000 0000 0000 0000 0000 */
|
||||
|
||||
0xffffffff, /* 1111 1111 1111 1111 1111 1111 1111 1111 */
|
||||
0xffffffff, /* 1111 1111 1111 1111 1111 1111 1111 1111 */
|
||||
|
|
@ -1591,19 +1524,19 @@ ngx_escape_uri(u_char *dst, u_char *src, size_t size, ngx_uint_t type)
|
|||
0xffffffff /* 1111 1111 1111 1111 1111 1111 1111 1111 */
|
||||
};
|
||||
|
||||
/* " ", """, "'", not allowed */
|
||||
/* " ", """, "%", "'", %00-%1F, %7F-%FF */
|
||||
|
||||
static uint32_t refresh[] = {
|
||||
0xffffffff, /* 1111 1111 1111 1111 1111 1111 1111 1111 */
|
||||
|
||||
/* ?>=< ;:98 7654 3210 /.-, +*)( '&%$ #"! */
|
||||
0x50000085, /* 0101 0000 0000 0000 0000 0000 1000 0101 */
|
||||
0x00000085, /* 0000 0000 0000 0000 0000 0000 1000 0101 */
|
||||
|
||||
/* _^]\ [ZYX WVUT SRQP ONML KJIH GFED CBA@ */
|
||||
0x50000000, /* 0101 0000 0000 0000 0000 0000 0000 0000 */
|
||||
0x00000000, /* 0000 0000 0000 0000 0000 0000 0000 0000 */
|
||||
|
||||
/* ~}| {zyx wvut srqp onml kjih gfed cba` */
|
||||
0xd8000001, /* 1011 1000 0000 0000 0000 0000 0000 0001 */
|
||||
0x80000000, /* 1000 0000 0000 0000 0000 0000 0000 0000 */
|
||||
|
||||
0xffffffff, /* 1111 1111 1111 1111 1111 1111 1111 1111 */
|
||||
0xffffffff, /* 1111 1111 1111 1111 1111 1111 1111 1111 */
|
||||
|
|
@ -2080,14 +2013,6 @@ ngx_sort(void *base, size_t n, size_t size,
|
|||
}
|
||||
|
||||
|
||||
void
|
||||
ngx_explicit_memzero(void *buf, size_t n)
|
||||
{
|
||||
ngx_memzero(buf, n);
|
||||
ngx_memory_barrier();
|
||||
}
|
||||
|
||||
|
||||
#if (NGX_MEMCPY_LIMIT)
|
||||
|
||||
void *
|
||||
|
|
|
|||
|
|
@ -88,8 +88,6 @@ ngx_strlchr(u_char *p, u_char *last, u_char c)
|
|||
#define ngx_memzero(buf, n) (void) memset(buf, 0, n)
|
||||
#define ngx_memset(buf, c, n) (void) memset(buf, c, n)
|
||||
|
||||
void ngx_explicit_memzero(void *buf, size_t n);
|
||||
|
||||
|
||||
#if (NGX_MEMCPY_LIMIT)
|
||||
|
||||
|
|
@ -140,12 +138,12 @@ ngx_copy(u_char *dst, u_char *src, size_t len)
|
|||
#endif
|
||||
|
||||
|
||||
#define ngx_memmove(dst, src, n) (void) memmove(dst, src, n)
|
||||
#define ngx_movemem(dst, src, n) (((u_char *) memmove(dst, src, n)) + (n))
|
||||
#define ngx_memmove(dst, src, n) (void) memmove(dst, src, n)
|
||||
#define ngx_movemem(dst, src, n) (((u_char *) memmove(dst, src, n)) + (n))
|
||||
|
||||
|
||||
/* msvc and icc7 compile memcmp() to the inline loop */
|
||||
#define ngx_memcmp(s1, s2, n) memcmp(s1, s2, n)
|
||||
#define ngx_memcmp(s1, s2, n) memcmp((const char *) s1, (const char *) s2, n)
|
||||
|
||||
|
||||
u_char *ngx_cpystrn(u_char *dst, u_char *src, size_t n);
|
||||
|
|
|
|||
|
|
@ -18,7 +18,6 @@
|
|||
static char *ngx_syslog_parse_args(ngx_conf_t *cf, ngx_syslog_peer_t *peer);
|
||||
static ngx_int_t ngx_syslog_init_peer(ngx_syslog_peer_t *peer);
|
||||
static void ngx_syslog_cleanup(void *data);
|
||||
static u_char *ngx_syslog_log_error(ngx_log_t *log, u_char *buf, size_t len);
|
||||
|
||||
|
||||
static char *facilities[] = {
|
||||
|
|
@ -40,8 +39,7 @@ static ngx_event_t ngx_syslog_dummy_event;
|
|||
char *
|
||||
ngx_syslog_process_conf(ngx_conf_t *cf, ngx_syslog_peer_t *peer)
|
||||
{
|
||||
ngx_pool_cleanup_t *cln;
|
||||
|
||||
peer->pool = cf->pool;
|
||||
peer->facility = NGX_CONF_UNSET_UINT;
|
||||
peer->severity = NGX_CONF_UNSET_UINT;
|
||||
|
||||
|
|
@ -67,24 +65,8 @@ ngx_syslog_process_conf(ngx_conf_t *cf, ngx_syslog_peer_t *peer)
|
|||
ngx_str_set(&peer->tag, "nginx");
|
||||
}
|
||||
|
||||
peer->hostname = &cf->cycle->hostname;
|
||||
peer->logp = &cf->cycle->new_log;
|
||||
|
||||
peer->conn.fd = (ngx_socket_t) -1;
|
||||
|
||||
peer->conn.read = &ngx_syslog_dummy_event;
|
||||
peer->conn.write = &ngx_syslog_dummy_event;
|
||||
|
||||
ngx_syslog_dummy_event.log = &ngx_syslog_dummy_log;
|
||||
|
||||
cln = ngx_pool_cleanup_add(cf->pool, 0);
|
||||
if (cln == NULL) {
|
||||
return NGX_CONF_ERROR;
|
||||
}
|
||||
|
||||
cln->data = peer;
|
||||
cln->handler = ngx_syslog_cleanup;
|
||||
|
||||
return NGX_CONF_OK;
|
||||
}
|
||||
|
||||
|
|
@ -247,7 +229,7 @@ ngx_syslog_add_header(ngx_syslog_peer_t *peer, u_char *buf)
|
|||
}
|
||||
|
||||
return ngx_sprintf(buf, "<%ui>%V %V %V: ", pri, &ngx_cached_syslog_time,
|
||||
peer->hostname, &peer->tag);
|
||||
&ngx_cycle->hostname, &peer->tag);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -290,19 +272,15 @@ ngx_syslog_send(ngx_syslog_peer_t *peer, u_char *buf, size_t len)
|
|||
{
|
||||
ssize_t n;
|
||||
|
||||
if (peer->log.handler == NULL) {
|
||||
peer->log = *peer->logp;
|
||||
peer->log.handler = ngx_syslog_log_error;
|
||||
peer->log.data = peer;
|
||||
peer->log.action = "logging to syslog";
|
||||
}
|
||||
|
||||
if (peer->conn.fd == (ngx_socket_t) -1) {
|
||||
if (ngx_syslog_init_peer(peer) != NGX_OK) {
|
||||
return NGX_ERROR;
|
||||
}
|
||||
}
|
||||
|
||||
/* log syslog socket events with valid log */
|
||||
peer->conn.log = ngx_cycle->log;
|
||||
|
||||
if (ngx_send) {
|
||||
n = ngx_send(&peer->conn, buf, len);
|
||||
|
||||
|
|
@ -311,16 +289,20 @@ ngx_syslog_send(ngx_syslog_peer_t *peer, u_char *buf, size_t len)
|
|||
n = ngx_os_io.send(&peer->conn, buf, len);
|
||||
}
|
||||
|
||||
if (n == NGX_ERROR) {
|
||||
#if (NGX_HAVE_UNIX_DOMAIN)
|
||||
|
||||
if (n == NGX_ERROR && peer->server.sockaddr->sa_family == AF_UNIX) {
|
||||
|
||||
if (ngx_close_socket(peer->conn.fd) == -1) {
|
||||
ngx_log_error(NGX_LOG_ALERT, &peer->log, ngx_socket_errno,
|
||||
ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, ngx_socket_errno,
|
||||
ngx_close_socket_n " failed");
|
||||
}
|
||||
|
||||
peer->conn.fd = (ngx_socket_t) -1;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
return n;
|
||||
}
|
||||
|
||||
|
|
@ -328,29 +310,42 @@ ngx_syslog_send(ngx_syslog_peer_t *peer, u_char *buf, size_t len)
|
|||
static ngx_int_t
|
||||
ngx_syslog_init_peer(ngx_syslog_peer_t *peer)
|
||||
{
|
||||
ngx_socket_t fd;
|
||||
ngx_socket_t fd;
|
||||
ngx_pool_cleanup_t *cln;
|
||||
|
||||
peer->conn.read = &ngx_syslog_dummy_event;
|
||||
peer->conn.write = &ngx_syslog_dummy_event;
|
||||
|
||||
ngx_syslog_dummy_event.log = &ngx_syslog_dummy_log;
|
||||
|
||||
fd = ngx_socket(peer->server.sockaddr->sa_family, SOCK_DGRAM, 0);
|
||||
if (fd == (ngx_socket_t) -1) {
|
||||
ngx_log_error(NGX_LOG_ALERT, &peer->log, ngx_socket_errno,
|
||||
ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, ngx_socket_errno,
|
||||
ngx_socket_n " failed");
|
||||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
if (ngx_nonblocking(fd) == -1) {
|
||||
ngx_log_error(NGX_LOG_ALERT, &peer->log, ngx_socket_errno,
|
||||
ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, ngx_socket_errno,
|
||||
ngx_nonblocking_n " failed");
|
||||
goto failed;
|
||||
}
|
||||
|
||||
if (connect(fd, peer->server.sockaddr, peer->server.socklen) == -1) {
|
||||
ngx_log_error(NGX_LOG_ALERT, &peer->log, ngx_socket_errno,
|
||||
ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, ngx_socket_errno,
|
||||
"connect() failed");
|
||||
goto failed;
|
||||
}
|
||||
|
||||
cln = ngx_pool_cleanup_add(peer->pool, 0);
|
||||
if (cln == NULL) {
|
||||
goto failed;
|
||||
}
|
||||
|
||||
cln->data = peer;
|
||||
cln->handler = ngx_syslog_cleanup;
|
||||
|
||||
peer->conn.fd = fd;
|
||||
peer->conn.log = &peer->log;
|
||||
|
||||
/* UDP sockets are always ready to write */
|
||||
peer->conn.write->ready = 1;
|
||||
|
|
@ -360,7 +355,7 @@ ngx_syslog_init_peer(ngx_syslog_peer_t *peer)
|
|||
failed:
|
||||
|
||||
if (ngx_close_socket(fd) == -1) {
|
||||
ngx_log_error(NGX_LOG_ALERT, &peer->log, ngx_socket_errno,
|
||||
ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, ngx_socket_errno,
|
||||
ngx_close_socket_n " failed");
|
||||
}
|
||||
|
||||
|
|
@ -381,30 +376,7 @@ ngx_syslog_cleanup(void *data)
|
|||
}
|
||||
|
||||
if (ngx_close_socket(peer->conn.fd) == -1) {
|
||||
ngx_log_error(NGX_LOG_ALERT, &peer->log, ngx_socket_errno,
|
||||
ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, ngx_socket_errno,
|
||||
ngx_close_socket_n " failed");
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static u_char *
|
||||
ngx_syslog_log_error(ngx_log_t *log, u_char *buf, size_t len)
|
||||
{
|
||||
u_char *p;
|
||||
ngx_syslog_peer_t *peer;
|
||||
|
||||
p = buf;
|
||||
|
||||
if (log->action) {
|
||||
p = ngx_snprintf(buf, len, " while %s", log->action);
|
||||
len -= p - buf;
|
||||
}
|
||||
|
||||
peer = log->data;
|
||||
|
||||
if (peer) {
|
||||
p = ngx_snprintf(p, len, ", server: %V", &peer->server.name);
|
||||
}
|
||||
|
||||
return p;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -9,20 +9,15 @@
|
|||
|
||||
|
||||
typedef struct {
|
||||
ngx_uint_t facility;
|
||||
ngx_uint_t severity;
|
||||
ngx_str_t tag;
|
||||
ngx_pool_t *pool;
|
||||
ngx_uint_t facility;
|
||||
ngx_uint_t severity;
|
||||
ngx_str_t tag;
|
||||
|
||||
ngx_str_t *hostname;
|
||||
|
||||
ngx_addr_t server;
|
||||
ngx_connection_t conn;
|
||||
|
||||
ngx_log_t log;
|
||||
ngx_log_t *logp;
|
||||
|
||||
unsigned busy:1;
|
||||
unsigned nohostname:1;
|
||||
ngx_addr_t server;
|
||||
ngx_connection_t conn;
|
||||
unsigned busy:1;
|
||||
unsigned nohostname:1;
|
||||
} ngx_syslog_peer_t;
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -200,6 +200,10 @@ ngx_monotonic_time(time_t sec, ngx_uint_t msec)
|
|||
|
||||
#if defined(CLOCK_MONOTONIC_FAST)
|
||||
clock_gettime(CLOCK_MONOTONIC_FAST, &ts);
|
||||
|
||||
#elif defined(CLOCK_MONOTONIC_COARSE)
|
||||
clock_gettime(CLOCK_MONOTONIC_COARSE, &ts);
|
||||
|
||||
#else
|
||||
clock_gettime(CLOCK_MONOTONIC, &ts);
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -43,8 +43,8 @@ extern volatile ngx_str_t ngx_cached_http_log_iso8601;
|
|||
extern volatile ngx_str_t ngx_cached_syslog_time;
|
||||
|
||||
/*
|
||||
* milliseconds elapsed since some unspecified point in the past
|
||||
* and truncated to ngx_msec_t, used in event timers
|
||||
* milliseconds elapsed since epoch and truncated to ngx_msec_t,
|
||||
* used in event timers
|
||||
*/
|
||||
extern volatile ngx_msec_t ngx_current_msec;
|
||||
|
||||
|
|
|
|||
|
|
@ -495,7 +495,6 @@ ngx_devpoll_process_events(ngx_cycle_t *cycle, ngx_msec_t timer,
|
|||
|
||||
if ((revents & POLLIN) && rev->active) {
|
||||
rev->ready = 1;
|
||||
rev->available = -1;
|
||||
|
||||
if (flags & NGX_POST_EVENTS) {
|
||||
queue = rev->accept ? &ngx_posted_accept_events
|
||||
|
|
|
|||
|
|
@ -886,10 +886,11 @@ ngx_epoll_process_events(ngx_cycle_t *cycle, ngx_msec_t timer, ngx_uint_t flags)
|
|||
if (revents & EPOLLRDHUP) {
|
||||
rev->pending_eof = 1;
|
||||
}
|
||||
|
||||
rev->available = 1;
|
||||
#endif
|
||||
|
||||
rev->ready = 1;
|
||||
rev->available = -1;
|
||||
|
||||
if (flags & NGX_POST_EVENTS) {
|
||||
queue = rev->accept ? &ngx_posted_accept_events
|
||||
|
|
|
|||
|
|
@ -250,7 +250,9 @@ ngx_eventport_init(ngx_cycle_t *cycle, ngx_msec_t timer)
|
|||
|
||||
ngx_memzero(&sev, sizeof(struct sigevent));
|
||||
sev.sigev_notify = SIGEV_PORT;
|
||||
#if !(NGX_TEST_BUILD_EVENTPORT)
|
||||
sev.sigev_value.sival_ptr = &pn;
|
||||
#endif
|
||||
|
||||
if (timer_create(CLOCK_REALTIME, &sev, &event_timer) == -1) {
|
||||
ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
|
||||
|
|
@ -399,7 +401,7 @@ ngx_eventport_del_event(ngx_event_t *ev, ngx_int_t event, ngx_uint_t flags)
|
|||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
} else if (ev->active) {
|
||||
} else {
|
||||
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, ev->log, 0,
|
||||
"eventport del event: fd:%d", c->fd);
|
||||
|
||||
|
|
@ -559,7 +561,6 @@ ngx_eventport_process_events(ngx_cycle_t *cycle, ngx_msec_t timer,
|
|||
|
||||
if (revents & POLLIN) {
|
||||
rev->ready = 1;
|
||||
rev->available = -1;
|
||||
|
||||
if (flags & NGX_POST_EVENTS) {
|
||||
queue = rev->accept ? &ngx_posted_accept_events
|
||||
|
|
|
|||
|
|
@ -231,8 +231,9 @@ ngx_iocp_del_connection(ngx_connection_t *c, ngx_uint_t flags)
|
|||
}
|
||||
|
||||
|
||||
static ngx_int_t
|
||||
ngx_iocp_process_events(ngx_cycle_t *cycle, ngx_msec_t timer, ngx_uint_t flags)
|
||||
static
|
||||
ngx_int_t ngx_iocp_process_events(ngx_cycle_t *cycle, ngx_msec_t timer,
|
||||
ngx_uint_t flags)
|
||||
{
|
||||
int rc;
|
||||
u_int key;
|
||||
|
|
@ -355,7 +356,7 @@ ngx_iocp_create_conf(ngx_cycle_t *cycle)
|
|||
|
||||
cf = ngx_palloc(cycle->pool, sizeof(ngx_iocp_conf_t));
|
||||
if (cf == NULL) {
|
||||
return NULL;
|
||||
return NGX_CONF_ERROR;
|
||||
}
|
||||
|
||||
cf->threads = NGX_CONF_UNSET;
|
||||
|
|
|
|||
|
|
@ -84,7 +84,7 @@ ngx_poll_init(ngx_cycle_t *cycle, ngx_msec_t timer)
|
|||
}
|
||||
|
||||
if (event_list) {
|
||||
ngx_memcpy(list, event_list, sizeof(struct pollfd) * nevents);
|
||||
ngx_memcpy(list, event_list, sizeof(ngx_event_t *) * nevents);
|
||||
ngx_free(event_list);
|
||||
}
|
||||
|
||||
|
|
@ -370,7 +370,6 @@ ngx_poll_process_events(ngx_cycle_t *cycle, ngx_msec_t timer, ngx_uint_t flags)
|
|||
|
||||
ev = c->read;
|
||||
ev->ready = 1;
|
||||
ev->available = -1;
|
||||
|
||||
queue = ev->accept ? &ngx_posted_accept_events
|
||||
: &ngx_posted_events;
|
||||
|
|
|
|||
|
|
@ -330,7 +330,6 @@ ngx_select_process_events(ngx_cycle_t *cycle, ngx_msec_t timer,
|
|||
|
||||
if (found) {
|
||||
ev->ready = 1;
|
||||
ev->available = -1;
|
||||
|
||||
queue = ev->accept ? &ngx_posted_accept_events
|
||||
: &ngx_posted_events;
|
||||
|
|
|
|||
|
|
@ -1,436 +0,0 @@
|
|||
|
||||
/*
|
||||
* Copyright (C) Igor Sysoev
|
||||
* Copyright (C) Maxim Dounin
|
||||
* Copyright (C) Nginx, Inc.
|
||||
*/
|
||||
|
||||
|
||||
#include <ngx_config.h>
|
||||
#include <ngx_core.h>
|
||||
#include <ngx_event.h>
|
||||
|
||||
|
||||
static ngx_int_t ngx_poll_init(ngx_cycle_t *cycle, ngx_msec_t timer);
|
||||
static void ngx_poll_done(ngx_cycle_t *cycle);
|
||||
static ngx_int_t ngx_poll_add_event(ngx_event_t *ev, ngx_int_t event,
|
||||
ngx_uint_t flags);
|
||||
static ngx_int_t ngx_poll_del_event(ngx_event_t *ev, ngx_int_t event,
|
||||
ngx_uint_t flags);
|
||||
static ngx_int_t ngx_poll_process_events(ngx_cycle_t *cycle, ngx_msec_t timer,
|
||||
ngx_uint_t flags);
|
||||
static char *ngx_poll_init_conf(ngx_cycle_t *cycle, void *conf);
|
||||
|
||||
|
||||
static struct pollfd *event_list;
|
||||
static ngx_connection_t **event_index;
|
||||
static ngx_uint_t nevents;
|
||||
|
||||
|
||||
static ngx_str_t poll_name = ngx_string("poll");
|
||||
|
||||
static ngx_event_module_t ngx_poll_module_ctx = {
|
||||
&poll_name,
|
||||
NULL, /* create configuration */
|
||||
ngx_poll_init_conf, /* init configuration */
|
||||
|
||||
{
|
||||
ngx_poll_add_event, /* add an event */
|
||||
ngx_poll_del_event, /* delete an event */
|
||||
ngx_poll_add_event, /* enable an event */
|
||||
ngx_poll_del_event, /* disable an event */
|
||||
NULL, /* add an connection */
|
||||
NULL, /* delete an connection */
|
||||
NULL, /* trigger a notify */
|
||||
ngx_poll_process_events, /* process the events */
|
||||
ngx_poll_init, /* init the events */
|
||||
ngx_poll_done /* done the events */
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
ngx_module_t ngx_poll_module = {
|
||||
NGX_MODULE_V1,
|
||||
&ngx_poll_module_ctx, /* module context */
|
||||
NULL, /* module directives */
|
||||
NGX_EVENT_MODULE, /* module type */
|
||||
NULL, /* init master */
|
||||
NULL, /* init module */
|
||||
NULL, /* init process */
|
||||
NULL, /* init thread */
|
||||
NULL, /* exit thread */
|
||||
NULL, /* exit process */
|
||||
NULL, /* exit master */
|
||||
NGX_MODULE_V1_PADDING
|
||||
};
|
||||
|
||||
|
||||
|
||||
static ngx_int_t
|
||||
ngx_poll_init(ngx_cycle_t *cycle, ngx_msec_t timer)
|
||||
{
|
||||
struct pollfd *list;
|
||||
ngx_connection_t **index;
|
||||
|
||||
if (event_list == NULL) {
|
||||
nevents = 0;
|
||||
}
|
||||
|
||||
if (ngx_process >= NGX_PROCESS_WORKER
|
||||
|| cycle->old_cycle == NULL
|
||||
|| cycle->old_cycle->connection_n < cycle->connection_n)
|
||||
{
|
||||
list = ngx_alloc(sizeof(struct pollfd) * cycle->connection_n,
|
||||
cycle->log);
|
||||
if (list == NULL) {
|
||||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
if (event_list) {
|
||||
ngx_memcpy(list, event_list, sizeof(struct pollfd) * nevents);
|
||||
ngx_free(event_list);
|
||||
}
|
||||
|
||||
event_list = list;
|
||||
|
||||
index = ngx_alloc(sizeof(ngx_connection_t *) * cycle->connection_n,
|
||||
cycle->log);
|
||||
if (index == NULL) {
|
||||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
if (event_index) {
|
||||
ngx_memcpy(index, event_index,
|
||||
sizeof(ngx_connection_t *) * nevents);
|
||||
ngx_free(event_index);
|
||||
}
|
||||
|
||||
event_index = index;
|
||||
}
|
||||
|
||||
ngx_io = ngx_os_io;
|
||||
|
||||
ngx_event_actions = ngx_poll_module_ctx.actions;
|
||||
|
||||
ngx_event_flags = NGX_USE_LEVEL_EVENT;
|
||||
|
||||
return NGX_OK;
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
ngx_poll_done(ngx_cycle_t *cycle)
|
||||
{
|
||||
ngx_free(event_list);
|
||||
ngx_free(event_index);
|
||||
|
||||
event_list = NULL;
|
||||
event_index = NULL;
|
||||
}
|
||||
|
||||
|
||||
static ngx_int_t
|
||||
ngx_poll_add_event(ngx_event_t *ev, ngx_int_t event, ngx_uint_t flags)
|
||||
{
|
||||
ngx_event_t *e;
|
||||
ngx_connection_t *c;
|
||||
|
||||
c = ev->data;
|
||||
|
||||
ev->active = 1;
|
||||
|
||||
if (ev->index != NGX_INVALID_INDEX) {
|
||||
ngx_log_error(NGX_LOG_ALERT, ev->log, 0,
|
||||
"poll event fd:%d ev:%i is already set", c->fd, event);
|
||||
return NGX_OK;
|
||||
}
|
||||
|
||||
if (event == NGX_READ_EVENT) {
|
||||
e = c->write;
|
||||
#if (NGX_READ_EVENT != POLLIN)
|
||||
event = POLLIN;
|
||||
#endif
|
||||
|
||||
} else {
|
||||
e = c->read;
|
||||
#if (NGX_WRITE_EVENT != POLLOUT)
|
||||
event = POLLOUT;
|
||||
#endif
|
||||
}
|
||||
|
||||
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ev->log, 0,
|
||||
"poll add event: fd:%d ev:%i", c->fd, event);
|
||||
|
||||
if (e == NULL || e->index == NGX_INVALID_INDEX) {
|
||||
|
||||
event_list[nevents].fd = c->fd;
|
||||
event_list[nevents].events = (short) event;
|
||||
event_list[nevents].revents = 0;
|
||||
|
||||
event_index[nevents] = c;
|
||||
|
||||
ev->index = nevents;
|
||||
nevents++;
|
||||
|
||||
} else {
|
||||
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, ev->log, 0,
|
||||
"poll add index: %i", e->index);
|
||||
|
||||
event_list[e->index].events |= (short) event;
|
||||
ev->index = e->index;
|
||||
}
|
||||
|
||||
return NGX_OK;
|
||||
}
|
||||
|
||||
|
||||
static ngx_int_t
|
||||
ngx_poll_del_event(ngx_event_t *ev, ngx_int_t event, ngx_uint_t flags)
|
||||
{
|
||||
ngx_event_t *e;
|
||||
ngx_connection_t *c;
|
||||
|
||||
c = ev->data;
|
||||
|
||||
ev->active = 0;
|
||||
|
||||
if (ev->index == NGX_INVALID_INDEX) {
|
||||
ngx_log_error(NGX_LOG_ALERT, ev->log, 0,
|
||||
"poll event fd:%d ev:%i is already deleted",
|
||||
c->fd, event);
|
||||
return NGX_OK;
|
||||
}
|
||||
|
||||
if (event == NGX_READ_EVENT) {
|
||||
e = c->write;
|
||||
#if (NGX_READ_EVENT != POLLIN)
|
||||
event = POLLIN;
|
||||
#endif
|
||||
|
||||
} else {
|
||||
e = c->read;
|
||||
#if (NGX_WRITE_EVENT != POLLOUT)
|
||||
event = POLLOUT;
|
||||
#endif
|
||||
}
|
||||
|
||||
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ev->log, 0,
|
||||
"poll del event: fd:%d ev:%i", c->fd, event);
|
||||
|
||||
if (e == NULL || e->index == NGX_INVALID_INDEX) {
|
||||
nevents--;
|
||||
|
||||
if (ev->index < nevents) {
|
||||
|
||||
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ev->log, 0,
|
||||
"index: copy event %ui to %i", nevents, ev->index);
|
||||
|
||||
event_list[ev->index] = event_list[nevents];
|
||||
event_index[ev->index] = event_index[nevents];
|
||||
|
||||
c = event_index[ev->index];
|
||||
|
||||
if (c->fd == (ngx_socket_t) -1) {
|
||||
ngx_log_error(NGX_LOG_ALERT, ev->log, 0,
|
||||
"unexpected last event");
|
||||
|
||||
} else {
|
||||
if (c->read->index == nevents) {
|
||||
c->read->index = ev->index;
|
||||
}
|
||||
|
||||
if (c->write->index == nevents) {
|
||||
c->write->index = ev->index;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
} else {
|
||||
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, ev->log, 0,
|
||||
"poll del index: %i", e->index);
|
||||
|
||||
event_list[e->index].events &= (short) ~event;
|
||||
}
|
||||
|
||||
ev->index = NGX_INVALID_INDEX;
|
||||
|
||||
return NGX_OK;
|
||||
}
|
||||
|
||||
|
||||
static ngx_int_t
|
||||
ngx_poll_process_events(ngx_cycle_t *cycle, ngx_msec_t timer, ngx_uint_t flags)
|
||||
{
|
||||
int ready, revents;
|
||||
ngx_err_t err;
|
||||
ngx_uint_t i, found;
|
||||
ngx_event_t *ev;
|
||||
ngx_queue_t *queue;
|
||||
ngx_connection_t *c;
|
||||
|
||||
/* NGX_TIMER_INFINITE == INFTIM */
|
||||
|
||||
#if (NGX_DEBUG0)
|
||||
if (cycle->log->log_level & NGX_LOG_DEBUG_ALL) {
|
||||
for (i = 0; i < nevents; i++) {
|
||||
ngx_log_debug3(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
|
||||
"poll: %ui: fd:%d ev:%04Xd",
|
||||
i, event_list[i].fd, event_list[i].events);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0, "poll timer: %M", timer);
|
||||
|
||||
ready = WSAPoll(event_list, (u_int) nevents, (int) timer);
|
||||
|
||||
err = (ready == -1) ? ngx_errno : 0;
|
||||
|
||||
if (flags & NGX_UPDATE_TIME || ngx_event_timer_alarm) {
|
||||
ngx_time_update();
|
||||
}
|
||||
|
||||
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
|
||||
"poll ready %d of %ui", ready, nevents);
|
||||
|
||||
if (err) {
|
||||
ngx_log_error(NGX_LOG_ALERT, cycle->log, err, "WSAPoll() failed");
|
||||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
if (ready == 0) {
|
||||
if (timer != NGX_TIMER_INFINITE) {
|
||||
return NGX_OK;
|
||||
}
|
||||
|
||||
ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
|
||||
"WSAPoll() returned no events without timeout");
|
||||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
for (i = 0; i < nevents && ready; i++) {
|
||||
|
||||
revents = event_list[i].revents;
|
||||
|
||||
#if 1
|
||||
ngx_log_debug4(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
|
||||
"poll: %ui: fd:%d ev:%04Xd rev:%04Xd",
|
||||
i, event_list[i].fd, event_list[i].events, revents);
|
||||
#else
|
||||
if (revents) {
|
||||
ngx_log_debug4(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
|
||||
"poll: %ui: fd:%d ev:%04Xd rev:%04Xd",
|
||||
i, event_list[i].fd, event_list[i].events, revents);
|
||||
}
|
||||
#endif
|
||||
|
||||
if (revents & POLLNVAL) {
|
||||
ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
|
||||
"poll() error fd:%d ev:%04Xd rev:%04Xd",
|
||||
event_list[i].fd, event_list[i].events, revents);
|
||||
}
|
||||
|
||||
if (revents & ~(POLLIN|POLLOUT|POLLERR|POLLHUP|POLLNVAL)) {
|
||||
ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
|
||||
"strange poll() events fd:%d ev:%04Xd rev:%04Xd",
|
||||
event_list[i].fd, event_list[i].events, revents);
|
||||
}
|
||||
|
||||
if (event_list[i].fd == (ngx_socket_t) -1) {
|
||||
/*
|
||||
* the disabled event, a workaround for our possible bug,
|
||||
* see the comment below
|
||||
*/
|
||||
continue;
|
||||
}
|
||||
|
||||
c = event_index[i];
|
||||
|
||||
if (c->fd == (ngx_socket_t) -1) {
|
||||
ngx_log_error(NGX_LOG_ALERT, cycle->log, 0, "unexpected event");
|
||||
|
||||
/*
|
||||
* it is certainly our fault and it should be investigated,
|
||||
* in the meantime we disable this event to avoid a CPU spinning
|
||||
*/
|
||||
|
||||
if (i == nevents - 1) {
|
||||
nevents--;
|
||||
} else {
|
||||
event_list[i].fd = (ngx_socket_t) -1;
|
||||
}
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
if (revents & (POLLERR|POLLHUP|POLLNVAL)) {
|
||||
|
||||
/*
|
||||
* if the error events were returned, add POLLIN and POLLOUT
|
||||
* to handle the events at least in one active handler
|
||||
*/
|
||||
|
||||
revents |= POLLIN|POLLOUT;
|
||||
}
|
||||
|
||||
found = 0;
|
||||
|
||||
if ((revents & POLLIN) && c->read->active) {
|
||||
found = 1;
|
||||
|
||||
ev = c->read;
|
||||
ev->ready = 1;
|
||||
ev->available = -1;
|
||||
|
||||
queue = ev->accept ? &ngx_posted_accept_events
|
||||
: &ngx_posted_events;
|
||||
|
||||
ngx_post_event(ev, queue);
|
||||
}
|
||||
|
||||
if ((revents & POLLOUT) && c->write->active) {
|
||||
found = 1;
|
||||
|
||||
ev = c->write;
|
||||
ev->ready = 1;
|
||||
|
||||
ngx_post_event(ev, &ngx_posted_events);
|
||||
}
|
||||
|
||||
if (found) {
|
||||
ready--;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
if (ready != 0) {
|
||||
ngx_log_error(NGX_LOG_ALERT, cycle->log, 0, "poll ready != events");
|
||||
}
|
||||
|
||||
return NGX_OK;
|
||||
}
|
||||
|
||||
|
||||
static char *
|
||||
ngx_poll_init_conf(ngx_cycle_t *cycle, void *conf)
|
||||
{
|
||||
ngx_event_conf_t *ecf;
|
||||
|
||||
ecf = ngx_event_get_conf(cycle->conf_ctx, ngx_event_core_module);
|
||||
|
||||
if (ecf->use != ngx_poll_module.ctx_index) {
|
||||
return NGX_CONF_OK;
|
||||
}
|
||||
|
||||
#if (NGX_LOAD_WSAPOLL)
|
||||
|
||||
if (!ngx_have_wsapoll) {
|
||||
ngx_log_error(NGX_LOG_EMERG, cycle->log, 0,
|
||||
"poll is not available on this platform");
|
||||
return NGX_CONF_ERROR;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
return NGX_CONF_OK;
|
||||
}
|
||||
|
|
@ -26,7 +26,6 @@ static fd_set master_read_fd_set;
|
|||
static fd_set master_write_fd_set;
|
||||
static fd_set work_read_fd_set;
|
||||
static fd_set work_write_fd_set;
|
||||
static fd_set work_except_fd_set;
|
||||
|
||||
static ngx_uint_t max_read;
|
||||
static ngx_uint_t max_write;
|
||||
|
|
@ -252,11 +251,9 @@ ngx_select_process_events(ngx_cycle_t *cycle, ngx_msec_t timer,
|
|||
|
||||
work_read_fd_set = master_read_fd_set;
|
||||
work_write_fd_set = master_write_fd_set;
|
||||
work_except_fd_set = master_write_fd_set;
|
||||
|
||||
if (max_read || max_write) {
|
||||
ready = select(0, &work_read_fd_set, &work_write_fd_set,
|
||||
&work_except_fd_set, tp);
|
||||
ready = select(0, &work_read_fd_set, &work_write_fd_set, NULL, tp);
|
||||
|
||||
} else {
|
||||
|
||||
|
|
@ -309,20 +306,14 @@ ngx_select_process_events(ngx_cycle_t *cycle, ngx_msec_t timer,
|
|||
|
||||
if (ev->write) {
|
||||
if (FD_ISSET(c->fd, &work_write_fd_set)) {
|
||||
found++;
|
||||
found = 1;
|
||||
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
|
||||
"select write %d", c->fd);
|
||||
}
|
||||
|
||||
if (FD_ISSET(c->fd, &work_except_fd_set)) {
|
||||
found++;
|
||||
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
|
||||
"select except %d", c->fd);
|
||||
}
|
||||
|
||||
} else {
|
||||
if (FD_ISSET(c->fd, &work_read_fd_set)) {
|
||||
found++;
|
||||
found = 1;
|
||||
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
|
||||
"select read %d", c->fd);
|
||||
}
|
||||
|
|
@ -330,14 +321,13 @@ ngx_select_process_events(ngx_cycle_t *cycle, ngx_msec_t timer,
|
|||
|
||||
if (found) {
|
||||
ev->ready = 1;
|
||||
ev->available = -1;
|
||||
|
||||
queue = ev->accept ? &ngx_posted_accept_events
|
||||
: &ngx_posted_events;
|
||||
|
||||
ngx_post_event(ev, queue);
|
||||
|
||||
nready += found;
|
||||
nready++;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -55,7 +55,6 @@ ngx_uint_t ngx_accept_events;
|
|||
ngx_uint_t ngx_accept_mutex_held;
|
||||
ngx_msec_t ngx_accept_mutex_delay;
|
||||
ngx_int_t ngx_accept_disabled;
|
||||
ngx_uint_t ngx_use_exclusive_accept;
|
||||
|
||||
|
||||
#if (NGX_STAT_STUB)
|
||||
|
|
@ -238,11 +237,6 @@ ngx_process_events_and_timers(ngx_cycle_t *cycle)
|
|||
}
|
||||
}
|
||||
|
||||
if (!ngx_queue_empty(&ngx_posted_next_events)) {
|
||||
ngx_event_move_posted_next(cycle);
|
||||
timer = 0;
|
||||
}
|
||||
|
||||
delta = ngx_current_msec;
|
||||
|
||||
(void) ngx_process_events(cycle, timer, flags);
|
||||
|
|
@ -258,7 +252,9 @@ ngx_process_events_and_timers(ngx_cycle_t *cycle)
|
|||
ngx_shmtx_unlock(&ngx_accept_mutex);
|
||||
}
|
||||
|
||||
ngx_event_expire_timers();
|
||||
if (delta) {
|
||||
ngx_event_expire_timers();
|
||||
}
|
||||
|
||||
ngx_event_process_posted(cycle, &ngx_posted_events);
|
||||
}
|
||||
|
|
@ -267,18 +263,6 @@ ngx_process_events_and_timers(ngx_cycle_t *cycle)
|
|||
ngx_int_t
|
||||
ngx_handle_read_event(ngx_event_t *rev, ngx_uint_t flags)
|
||||
{
|
||||
#if (NGX_QUIC)
|
||||
|
||||
ngx_connection_t *c;
|
||||
|
||||
c = rev->data;
|
||||
|
||||
if (c->quic) {
|
||||
return NGX_OK;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
if (ngx_event_flags & NGX_USE_CLEAR_EVENT) {
|
||||
|
||||
/* kqueue, epoll */
|
||||
|
|
@ -329,7 +313,7 @@ ngx_handle_read_event(ngx_event_t *rev, ngx_uint_t flags)
|
|||
return NGX_OK;
|
||||
}
|
||||
|
||||
if (rev->oneshot && rev->ready) {
|
||||
if (rev->oneshot && !rev->ready) {
|
||||
if (ngx_del_event(rev, NGX_READ_EVENT, 0) == NGX_ERROR) {
|
||||
return NGX_ERROR;
|
||||
}
|
||||
|
|
@ -349,15 +333,9 @@ ngx_handle_write_event(ngx_event_t *wev, size_t lowat)
|
|||
{
|
||||
ngx_connection_t *c;
|
||||
|
||||
c = wev->data;
|
||||
|
||||
#if (NGX_QUIC)
|
||||
if (c->quic) {
|
||||
return NGX_OK;
|
||||
}
|
||||
#endif
|
||||
|
||||
if (lowat) {
|
||||
c = wev->data;
|
||||
|
||||
if (ngx_send_lowat(c, lowat) == NGX_ERROR) {
|
||||
return NGX_ERROR;
|
||||
}
|
||||
|
|
@ -432,58 +410,12 @@ ngx_handle_write_event(ngx_event_t *wev, size_t lowat)
|
|||
static char *
|
||||
ngx_event_init_conf(ngx_cycle_t *cycle, void *conf)
|
||||
{
|
||||
#if (NGX_HAVE_REUSEPORT)
|
||||
ngx_uint_t i;
|
||||
ngx_core_conf_t *ccf;
|
||||
ngx_listening_t *ls;
|
||||
#endif
|
||||
|
||||
if (ngx_get_conf(cycle->conf_ctx, ngx_events_module) == NULL) {
|
||||
ngx_log_error(NGX_LOG_EMERG, cycle->log, 0,
|
||||
"no \"events\" section in configuration");
|
||||
return NGX_CONF_ERROR;
|
||||
}
|
||||
|
||||
if (cycle->connection_n < cycle->listening.nelts + 1) {
|
||||
|
||||
/*
|
||||
* there should be at least one connection for each listening
|
||||
* socket, plus an additional connection for channel
|
||||
*/
|
||||
|
||||
ngx_log_error(NGX_LOG_EMERG, cycle->log, 0,
|
||||
"%ui worker_connections are not enough "
|
||||
"for %ui listening sockets",
|
||||
cycle->connection_n, cycle->listening.nelts);
|
||||
|
||||
return NGX_CONF_ERROR;
|
||||
}
|
||||
|
||||
#if (NGX_HAVE_REUSEPORT)
|
||||
|
||||
ccf = (ngx_core_conf_t *) ngx_get_conf(cycle->conf_ctx, ngx_core_module);
|
||||
|
||||
if (!ngx_test_config && ccf->master) {
|
||||
|
||||
ls = cycle->listening.elts;
|
||||
for (i = 0; i < cycle->listening.nelts; i++) {
|
||||
|
||||
if (!ls[i].reuseport || ls[i].worker != 0) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (ngx_clone_listening(cycle, &ls[i]) != NGX_OK) {
|
||||
return NGX_CONF_ERROR;
|
||||
}
|
||||
|
||||
/* cloning may change cycle->listening.elts */
|
||||
|
||||
ls = cycle->listening.elts;
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
return NGX_CONF_OK;
|
||||
}
|
||||
|
||||
|
|
@ -666,10 +598,7 @@ ngx_event_process_init(ngx_cycle_t *cycle)
|
|||
|
||||
#endif
|
||||
|
||||
ngx_use_exclusive_accept = 0;
|
||||
|
||||
ngx_queue_init(&ngx_posted_accept_events);
|
||||
ngx_queue_init(&ngx_posted_next_events);
|
||||
ngx_queue_init(&ngx_posted_events);
|
||||
|
||||
if (ngx_event_timer_init(cycle->log) == NGX_ERROR) {
|
||||
|
|
@ -831,9 +760,7 @@ ngx_event_process_init(ngx_cycle_t *cycle)
|
|||
rev->deferred_accept = ls[i].deferred_accept;
|
||||
#endif
|
||||
|
||||
if (!(ngx_event_flags & NGX_USE_IOCP_EVENT)
|
||||
&& cycle->old_cycle)
|
||||
{
|
||||
if (!(ngx_event_flags & NGX_USE_IOCP_EVENT)) {
|
||||
if (ls[i].previous) {
|
||||
|
||||
/*
|
||||
|
|
@ -891,16 +818,8 @@ ngx_event_process_init(ngx_cycle_t *cycle)
|
|||
|
||||
#else
|
||||
|
||||
if (c->type == SOCK_STREAM) {
|
||||
rev->handler = ngx_event_accept;
|
||||
|
||||
#if (NGX_QUIC)
|
||||
} else if (ls[i].quic) {
|
||||
rev->handler = ngx_quic_recvmsg;
|
||||
#endif
|
||||
} else {
|
||||
rev->handler = ngx_event_recvmsg;
|
||||
}
|
||||
rev->handler = (c->type == SOCK_STREAM) ? ngx_event_accept
|
||||
: ngx_event_recvmsg;
|
||||
|
||||
#if (NGX_HAVE_REUSEPORT)
|
||||
|
||||
|
|
@ -923,8 +842,6 @@ ngx_event_process_init(ngx_cycle_t *cycle)
|
|||
if ((ngx_event_flags & NGX_USE_EPOLL_EVENT)
|
||||
&& ccf->worker_processes > 1)
|
||||
{
|
||||
ngx_use_exclusive_accept = 1;
|
||||
|
||||
if (ngx_add_event(rev, NGX_READ_EVENT, NGX_EXCLUSIVE_EVENT)
|
||||
== NGX_ERROR)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -91,14 +91,21 @@ struct ngx_event_s {
|
|||
* write: available space in buffer when event is ready
|
||||
* or lowat when event is set with NGX_LOWAT_EVENT flag
|
||||
*
|
||||
* epoll with EPOLLRDHUP:
|
||||
* accept: 1 if accept many, 0 otherwise
|
||||
* read: 1 if there can be data to read, 0 otherwise
|
||||
*
|
||||
* iocp: TODO
|
||||
*
|
||||
* otherwise:
|
||||
* accept: 1 if accept many, 0 otherwise
|
||||
* read: bytes to read when event is ready, -1 if not known
|
||||
*/
|
||||
|
||||
#if (NGX_HAVE_KQUEUE) || (NGX_HAVE_IOCP)
|
||||
int available;
|
||||
#else
|
||||
unsigned available:1;
|
||||
#endif
|
||||
|
||||
ngx_event_handler_pt handler;
|
||||
|
||||
|
|
@ -147,6 +154,10 @@ struct ngx_event_aio_s {
|
|||
|
||||
ngx_fd_t fd;
|
||||
|
||||
#if (NGX_HAVE_AIO_SENDFILE || NGX_COMPAT)
|
||||
ssize_t (*preload_handler)(ngx_buf_t *file);
|
||||
#endif
|
||||
|
||||
#if (NGX_HAVE_EVENTFD)
|
||||
int64_t res;
|
||||
#endif
|
||||
|
|
@ -462,7 +473,6 @@ extern ngx_uint_t ngx_accept_events;
|
|||
extern ngx_uint_t ngx_accept_mutex_held;
|
||||
extern ngx_msec_t ngx_accept_mutex_delay;
|
||||
extern ngx_int_t ngx_accept_disabled;
|
||||
extern ngx_uint_t ngx_use_exclusive_accept;
|
||||
|
||||
|
||||
#if (NGX_STAT_STUB)
|
||||
|
|
@ -489,17 +499,16 @@ extern ngx_module_t ngx_event_core_module;
|
|||
|
||||
|
||||
#define ngx_event_get_conf(conf_ctx, module) \
|
||||
(*(ngx_get_conf(conf_ctx, ngx_events_module))) [module.ctx_index]
|
||||
(*(ngx_get_conf(conf_ctx, ngx_events_module))) [module.ctx_index];
|
||||
|
||||
|
||||
|
||||
void ngx_event_accept(ngx_event_t *ev);
|
||||
ngx_int_t ngx_trylock_accept_mutex(ngx_cycle_t *cycle);
|
||||
ngx_int_t ngx_enable_accept_events(ngx_cycle_t *cycle);
|
||||
u_char *ngx_accept_log_error(ngx_log_t *log, u_char *buf, size_t len);
|
||||
#if (NGX_DEBUG)
|
||||
void ngx_debug_accepted_connection(ngx_event_conf_t *ecf, ngx_connection_t *c);
|
||||
#if !(NGX_WIN32)
|
||||
void ngx_event_recvmsg(ngx_event_t *ev);
|
||||
#endif
|
||||
ngx_int_t ngx_trylock_accept_mutex(ngx_cycle_t *cycle);
|
||||
u_char *ngx_accept_log_error(ngx_log_t *log, u_char *buf, size_t len);
|
||||
|
||||
|
||||
void ngx_process_events_and_timers(ngx_cycle_t *cycle);
|
||||
|
|
@ -523,7 +532,6 @@ ngx_int_t ngx_send_lowat(ngx_connection_t *c, size_t lowat);
|
|||
|
||||
#include <ngx_event_timer.h>
|
||||
#include <ngx_event_posted.h>
|
||||
#include <ngx_event_udp.h>
|
||||
|
||||
#if (NGX_WIN32)
|
||||
#include <ngx_iocp_module.h>
|
||||
|
|
|
|||
|
|
@ -10,11 +10,13 @@
|
|||
#include <ngx_event.h>
|
||||
|
||||
|
||||
static ngx_int_t ngx_enable_accept_events(ngx_cycle_t *cycle);
|
||||
static ngx_int_t ngx_disable_accept_events(ngx_cycle_t *cycle, ngx_uint_t all);
|
||||
#if (NGX_HAVE_EPOLLEXCLUSIVE)
|
||||
static void ngx_reorder_accept_events(ngx_listening_t *ls);
|
||||
#endif
|
||||
static void ngx_close_accepted_connection(ngx_connection_t *c);
|
||||
#if (NGX_DEBUG)
|
||||
static void ngx_debug_accepted_connection(ngx_event_conf_t *ecf,
|
||||
ngx_connection_t *c);
|
||||
#endif
|
||||
|
||||
|
||||
void
|
||||
|
|
@ -259,8 +261,6 @@ ngx_event_accept(ngx_event_t *ev)
|
|||
|
||||
c->number = ngx_atomic_fetch_add(ngx_connection_counter, 1);
|
||||
|
||||
c->start_time = ngx_current_msec;
|
||||
|
||||
#if (NGX_STAT_STUB)
|
||||
(void) ngx_atomic_fetch_add(ngx_stat_handled, 1);
|
||||
#endif
|
||||
|
|
@ -317,13 +317,344 @@ ngx_event_accept(ngx_event_t *ev)
|
|||
}
|
||||
|
||||
} while (ev->available);
|
||||
|
||||
#if (NGX_HAVE_EPOLLEXCLUSIVE)
|
||||
ngx_reorder_accept_events(ls);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
#if !(NGX_WIN32)
|
||||
|
||||
void
|
||||
ngx_event_recvmsg(ngx_event_t *ev)
|
||||
{
|
||||
ssize_t n;
|
||||
ngx_log_t *log;
|
||||
ngx_err_t err;
|
||||
ngx_event_t *rev, *wev;
|
||||
struct iovec iov[1];
|
||||
struct msghdr msg;
|
||||
ngx_sockaddr_t sa;
|
||||
ngx_listening_t *ls;
|
||||
ngx_event_conf_t *ecf;
|
||||
ngx_connection_t *c, *lc;
|
||||
static u_char buffer[65535];
|
||||
|
||||
#if (NGX_HAVE_MSGHDR_MSG_CONTROL)
|
||||
|
||||
#if (NGX_HAVE_IP_RECVDSTADDR)
|
||||
u_char msg_control[CMSG_SPACE(sizeof(struct in_addr))];
|
||||
#elif (NGX_HAVE_IP_PKTINFO)
|
||||
u_char msg_control[CMSG_SPACE(sizeof(struct in_pktinfo))];
|
||||
#endif
|
||||
|
||||
#if (NGX_HAVE_INET6 && NGX_HAVE_IPV6_RECVPKTINFO)
|
||||
u_char msg_control6[CMSG_SPACE(sizeof(struct in6_pktinfo))];
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
if (ev->timedout) {
|
||||
if (ngx_enable_accept_events((ngx_cycle_t *) ngx_cycle) != NGX_OK) {
|
||||
return;
|
||||
}
|
||||
|
||||
ev->timedout = 0;
|
||||
}
|
||||
|
||||
ecf = ngx_event_get_conf(ngx_cycle->conf_ctx, ngx_event_core_module);
|
||||
|
||||
if (!(ngx_event_flags & NGX_USE_KQUEUE_EVENT)) {
|
||||
ev->available = ecf->multi_accept;
|
||||
}
|
||||
|
||||
lc = ev->data;
|
||||
ls = lc->listening;
|
||||
ev->ready = 0;
|
||||
|
||||
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ev->log, 0,
|
||||
"recvmsg on %V, ready: %d", &ls->addr_text, ev->available);
|
||||
|
||||
do {
|
||||
ngx_memzero(&msg, sizeof(struct msghdr));
|
||||
|
||||
iov[0].iov_base = (void *) buffer;
|
||||
iov[0].iov_len = sizeof(buffer);
|
||||
|
||||
msg.msg_name = &sa;
|
||||
msg.msg_namelen = sizeof(ngx_sockaddr_t);
|
||||
msg.msg_iov = iov;
|
||||
msg.msg_iovlen = 1;
|
||||
|
||||
#if (NGX_HAVE_MSGHDR_MSG_CONTROL)
|
||||
|
||||
if (ls->wildcard) {
|
||||
|
||||
#if (NGX_HAVE_IP_RECVDSTADDR || NGX_HAVE_IP_PKTINFO)
|
||||
if (ls->sockaddr->sa_family == AF_INET) {
|
||||
msg.msg_control = &msg_control;
|
||||
msg.msg_controllen = sizeof(msg_control);
|
||||
}
|
||||
#endif
|
||||
|
||||
#if (NGX_HAVE_INET6 && NGX_HAVE_IPV6_RECVPKTINFO)
|
||||
if (ls->sockaddr->sa_family == AF_INET6) {
|
||||
msg.msg_control = &msg_control6;
|
||||
msg.msg_controllen = sizeof(msg_control6);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
n = recvmsg(lc->fd, &msg, 0);
|
||||
|
||||
if (n == -1) {
|
||||
err = ngx_socket_errno;
|
||||
|
||||
if (err == NGX_EAGAIN) {
|
||||
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, ev->log, err,
|
||||
"recvmsg() not ready");
|
||||
return;
|
||||
}
|
||||
|
||||
ngx_log_error(NGX_LOG_ALERT, ev->log, err, "recvmsg() failed");
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
#if (NGX_STAT_STUB)
|
||||
(void) ngx_atomic_fetch_add(ngx_stat_accepted, 1);
|
||||
#endif
|
||||
|
||||
#if (NGX_HAVE_MSGHDR_MSG_CONTROL)
|
||||
if (msg.msg_flags & (MSG_TRUNC|MSG_CTRUNC)) {
|
||||
ngx_log_error(NGX_LOG_ALERT, ev->log, 0,
|
||||
"recvmsg() truncated data");
|
||||
continue;
|
||||
}
|
||||
#endif
|
||||
|
||||
ngx_accept_disabled = ngx_cycle->connection_n / 8
|
||||
- ngx_cycle->free_connection_n;
|
||||
|
||||
c = ngx_get_connection(lc->fd, ev->log);
|
||||
if (c == NULL) {
|
||||
return;
|
||||
}
|
||||
|
||||
c->shared = 1;
|
||||
c->type = SOCK_DGRAM;
|
||||
c->socklen = msg.msg_namelen;
|
||||
|
||||
if (c->socklen > (socklen_t) sizeof(ngx_sockaddr_t)) {
|
||||
c->socklen = sizeof(ngx_sockaddr_t);
|
||||
}
|
||||
|
||||
if (c->socklen == 0) {
|
||||
|
||||
/*
|
||||
* on Linux recvmsg() returns zero msg_namelen
|
||||
* when receiving packets from unbound AF_UNIX sockets
|
||||
*/
|
||||
|
||||
c->socklen = sizeof(struct sockaddr);
|
||||
ngx_memzero(&sa, sizeof(struct sockaddr));
|
||||
sa.sockaddr.sa_family = ls->sockaddr->sa_family;
|
||||
}
|
||||
|
||||
#if (NGX_STAT_STUB)
|
||||
(void) ngx_atomic_fetch_add(ngx_stat_active, 1);
|
||||
#endif
|
||||
|
||||
c->pool = ngx_create_pool(ls->pool_size, ev->log);
|
||||
if (c->pool == NULL) {
|
||||
ngx_close_accepted_connection(c);
|
||||
return;
|
||||
}
|
||||
|
||||
c->sockaddr = ngx_palloc(c->pool, c->socklen);
|
||||
if (c->sockaddr == NULL) {
|
||||
ngx_close_accepted_connection(c);
|
||||
return;
|
||||
}
|
||||
|
||||
ngx_memcpy(c->sockaddr, msg.msg_name, c->socklen);
|
||||
|
||||
log = ngx_palloc(c->pool, sizeof(ngx_log_t));
|
||||
if (log == NULL) {
|
||||
ngx_close_accepted_connection(c);
|
||||
return;
|
||||
}
|
||||
|
||||
*log = ls->log;
|
||||
|
||||
c->send = ngx_udp_send;
|
||||
c->send_chain = ngx_udp_send_chain;
|
||||
|
||||
c->log = log;
|
||||
c->pool->log = log;
|
||||
|
||||
c->listening = ls;
|
||||
c->local_sockaddr = ls->sockaddr;
|
||||
c->local_socklen = ls->socklen;
|
||||
|
||||
#if (NGX_HAVE_MSGHDR_MSG_CONTROL)
|
||||
|
||||
if (ls->wildcard) {
|
||||
struct cmsghdr *cmsg;
|
||||
struct sockaddr *sockaddr;
|
||||
|
||||
sockaddr = ngx_palloc(c->pool, c->local_socklen);
|
||||
if (sockaddr == NULL) {
|
||||
ngx_close_accepted_connection(c);
|
||||
return;
|
||||
}
|
||||
|
||||
ngx_memcpy(sockaddr, c->local_sockaddr, c->local_socklen);
|
||||
c->local_sockaddr = sockaddr;
|
||||
|
||||
for (cmsg = CMSG_FIRSTHDR(&msg);
|
||||
cmsg != NULL;
|
||||
cmsg = CMSG_NXTHDR(&msg, cmsg))
|
||||
{
|
||||
|
||||
#if (NGX_HAVE_IP_RECVDSTADDR)
|
||||
|
||||
if (cmsg->cmsg_level == IPPROTO_IP
|
||||
&& cmsg->cmsg_type == IP_RECVDSTADDR
|
||||
&& sockaddr->sa_family == AF_INET)
|
||||
{
|
||||
struct in_addr *addr;
|
||||
struct sockaddr_in *sin;
|
||||
|
||||
addr = (struct in_addr *) CMSG_DATA(cmsg);
|
||||
sin = (struct sockaddr_in *) sockaddr;
|
||||
sin->sin_addr = *addr;
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
#elif (NGX_HAVE_IP_PKTINFO)
|
||||
|
||||
if (cmsg->cmsg_level == IPPROTO_IP
|
||||
&& cmsg->cmsg_type == IP_PKTINFO
|
||||
&& sockaddr->sa_family == AF_INET)
|
||||
{
|
||||
struct in_pktinfo *pkt;
|
||||
struct sockaddr_in *sin;
|
||||
|
||||
pkt = (struct in_pktinfo *) CMSG_DATA(cmsg);
|
||||
sin = (struct sockaddr_in *) sockaddr;
|
||||
sin->sin_addr = pkt->ipi_addr;
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
#if (NGX_HAVE_INET6 && NGX_HAVE_IPV6_RECVPKTINFO)
|
||||
|
||||
if (cmsg->cmsg_level == IPPROTO_IPV6
|
||||
&& cmsg->cmsg_type == IPV6_PKTINFO
|
||||
&& sockaddr->sa_family == AF_INET6)
|
||||
{
|
||||
struct in6_pktinfo *pkt6;
|
||||
struct sockaddr_in6 *sin6;
|
||||
|
||||
pkt6 = (struct in6_pktinfo *) CMSG_DATA(cmsg);
|
||||
sin6 = (struct sockaddr_in6 *) sockaddr;
|
||||
sin6->sin6_addr = pkt6->ipi6_addr;
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
c->buffer = ngx_create_temp_buf(c->pool, n);
|
||||
if (c->buffer == NULL) {
|
||||
ngx_close_accepted_connection(c);
|
||||
return;
|
||||
}
|
||||
|
||||
c->buffer->last = ngx_cpymem(c->buffer->last, buffer, n);
|
||||
|
||||
rev = c->read;
|
||||
wev = c->write;
|
||||
|
||||
wev->ready = 1;
|
||||
|
||||
rev->log = log;
|
||||
wev->log = log;
|
||||
|
||||
/*
|
||||
* TODO: MT: - ngx_atomic_fetch_add()
|
||||
* or protection by critical section or light mutex
|
||||
*
|
||||
* TODO: MP: - allocated in a shared memory
|
||||
* - ngx_atomic_fetch_add()
|
||||
* or protection by critical section or light mutex
|
||||
*/
|
||||
|
||||
c->number = ngx_atomic_fetch_add(ngx_connection_counter, 1);
|
||||
|
||||
#if (NGX_STAT_STUB)
|
||||
(void) ngx_atomic_fetch_add(ngx_stat_handled, 1);
|
||||
#endif
|
||||
|
||||
if (ls->addr_ntop) {
|
||||
c->addr_text.data = ngx_pnalloc(c->pool, ls->addr_text_max_len);
|
||||
if (c->addr_text.data == NULL) {
|
||||
ngx_close_accepted_connection(c);
|
||||
return;
|
||||
}
|
||||
|
||||
c->addr_text.len = ngx_sock_ntop(c->sockaddr, c->socklen,
|
||||
c->addr_text.data,
|
||||
ls->addr_text_max_len, 0);
|
||||
if (c->addr_text.len == 0) {
|
||||
ngx_close_accepted_connection(c);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
#if (NGX_DEBUG)
|
||||
{
|
||||
ngx_str_t addr;
|
||||
u_char text[NGX_SOCKADDR_STRLEN];
|
||||
|
||||
ngx_debug_accepted_connection(ecf, c);
|
||||
|
||||
if (log->log_level & NGX_LOG_DEBUG_EVENT) {
|
||||
addr.data = text;
|
||||
addr.len = ngx_sock_ntop(c->sockaddr, c->socklen, text,
|
||||
NGX_SOCKADDR_STRLEN, 1);
|
||||
|
||||
ngx_log_debug4(NGX_LOG_DEBUG_EVENT, log, 0,
|
||||
"*%uA recvmsg: %V fd:%d n:%z",
|
||||
c->number, &addr, c->fd, n);
|
||||
}
|
||||
|
||||
}
|
||||
#endif
|
||||
|
||||
log->data = NULL;
|
||||
log->handler = NULL;
|
||||
|
||||
ls->handler(c);
|
||||
|
||||
if (ngx_event_flags & NGX_USE_KQUEUE_EVENT) {
|
||||
ev->available -= n;
|
||||
}
|
||||
|
||||
} while (ev->available);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
ngx_int_t
|
||||
ngx_trylock_accept_mutex(ngx_cycle_t *cycle)
|
||||
{
|
||||
|
|
@ -362,7 +693,7 @@ ngx_trylock_accept_mutex(ngx_cycle_t *cycle)
|
|||
}
|
||||
|
||||
|
||||
ngx_int_t
|
||||
static ngx_int_t
|
||||
ngx_enable_accept_events(ngx_cycle_t *cycle)
|
||||
{
|
||||
ngx_uint_t i;
|
||||
|
|
@ -427,57 +758,6 @@ ngx_disable_accept_events(ngx_cycle_t *cycle, ngx_uint_t all)
|
|||
}
|
||||
|
||||
|
||||
#if (NGX_HAVE_EPOLLEXCLUSIVE)
|
||||
|
||||
static void
|
||||
ngx_reorder_accept_events(ngx_listening_t *ls)
|
||||
{
|
||||
ngx_connection_t *c;
|
||||
|
||||
/*
|
||||
* Linux with EPOLLEXCLUSIVE usually notifies only the process which
|
||||
* was first to add the listening socket to the epoll instance. As
|
||||
* a result most of the connections are handled by the first worker
|
||||
* process. To fix this, we re-add the socket periodically, so other
|
||||
* workers will get a chance to accept connections.
|
||||
*/
|
||||
|
||||
if (!ngx_use_exclusive_accept) {
|
||||
return;
|
||||
}
|
||||
|
||||
#if (NGX_HAVE_REUSEPORT)
|
||||
|
||||
if (ls->reuseport) {
|
||||
return;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
c = ls->connection;
|
||||
|
||||
if (c->requests++ % 16 != 0
|
||||
&& ngx_accept_disabled <= 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
if (ngx_del_event(c->read, NGX_READ_EVENT, NGX_DISABLE_EVENT)
|
||||
== NGX_ERROR)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
if (ngx_add_event(c->read, NGX_READ_EVENT, NGX_EXCLUSIVE_EVENT)
|
||||
== NGX_ERROR)
|
||||
{
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
static void
|
||||
ngx_close_accepted_connection(ngx_connection_t *c)
|
||||
{
|
||||
|
|
@ -488,7 +768,7 @@ ngx_close_accepted_connection(ngx_connection_t *c)
|
|||
fd = c->fd;
|
||||
c->fd = (ngx_socket_t) -1;
|
||||
|
||||
if (ngx_close_socket(fd) == -1) {
|
||||
if (!c->shared && ngx_close_socket(fd) == -1) {
|
||||
ngx_log_error(NGX_LOG_ALERT, c->log, ngx_socket_errno,
|
||||
ngx_close_socket_n " failed");
|
||||
}
|
||||
|
|
@ -513,7 +793,7 @@ ngx_accept_log_error(ngx_log_t *log, u_char *buf, size_t len)
|
|||
|
||||
#if (NGX_DEBUG)
|
||||
|
||||
void
|
||||
static void
|
||||
ngx_debug_accepted_connection(ngx_event_conf_t *ecf, ngx_connection_t *c)
|
||||
{
|
||||
struct sockaddr_in *sin;
|
||||
|
|
|
|||
|
|
@ -80,8 +80,6 @@ ngx_event_acceptex(ngx_event_t *rev)
|
|||
|
||||
c->number = ngx_atomic_fetch_add(ngx_connection_counter, 1);
|
||||
|
||||
c->start_time = ngx_current_msec;
|
||||
|
||||
ls->handler(c);
|
||||
|
||||
return;
|
||||
|
|
|
|||
|
|
@ -20,7 +20,7 @@ static ngx_int_t ngx_event_connect_set_transparent(ngx_peer_connection_t *pc,
|
|||
ngx_int_t
|
||||
ngx_event_connect_peer(ngx_peer_connection_t *pc)
|
||||
{
|
||||
int rc, type, value;
|
||||
int rc, type;
|
||||
#if (NGX_HAVE_IP_BIND_ADDRESS_NO_PORT || NGX_LINUX)
|
||||
in_port_t port;
|
||||
#endif
|
||||
|
|
@ -55,7 +55,7 @@ ngx_event_connect_peer(ngx_peer_connection_t *pc)
|
|||
if (c == NULL) {
|
||||
if (ngx_close_socket(s) == -1) {
|
||||
ngx_log_error(NGX_LOG_ALERT, pc->log, ngx_socket_errno,
|
||||
ngx_close_socket_n " failed");
|
||||
ngx_close_socket_n "failed");
|
||||
}
|
||||
|
||||
return NGX_ERROR;
|
||||
|
|
@ -73,18 +73,6 @@ ngx_event_connect_peer(ngx_peer_connection_t *pc)
|
|||
}
|
||||
}
|
||||
|
||||
if (pc->so_keepalive) {
|
||||
value = 1;
|
||||
|
||||
if (setsockopt(s, SOL_SOCKET, SO_KEEPALIVE,
|
||||
(const void *) &value, sizeof(int))
|
||||
== -1)
|
||||
{
|
||||
ngx_log_error(NGX_LOG_ALERT, pc->log, ngx_socket_errno,
|
||||
"setsockopt(SO_KEEPALIVE) failed, ignored");
|
||||
}
|
||||
}
|
||||
|
||||
if (ngx_nonblocking(s) == -1) {
|
||||
ngx_log_error(NGX_LOG_ALERT, pc->log, ngx_socket_errno,
|
||||
ngx_nonblocking_n " failed");
|
||||
|
|
@ -179,8 +167,6 @@ ngx_event_connect_peer(ngx_peer_connection_t *pc)
|
|||
c->recv = ngx_udp_recv;
|
||||
c->send = ngx_send;
|
||||
c->send_chain = ngx_udp_send_chain;
|
||||
|
||||
c->need_flush_buf = 1;
|
||||
}
|
||||
|
||||
c->log_error = pc->log_error;
|
||||
|
|
@ -195,8 +181,6 @@ ngx_event_connect_peer(ngx_peer_connection_t *pc)
|
|||
|
||||
c->number = ngx_atomic_fetch_add(ngx_connection_counter, 1);
|
||||
|
||||
c->start_time = ngx_current_msec;
|
||||
|
||||
if (ngx_add_conn) {
|
||||
if (ngx_add_conn(c) == NGX_ERROR) {
|
||||
goto failed;
|
||||
|
|
|
|||
|
|
@ -62,8 +62,6 @@ struct ngx_peer_connection_s {
|
|||
|
||||
unsigned cached:1;
|
||||
unsigned transparent:1;
|
||||
unsigned so_keepalive:1;
|
||||
unsigned down:1;
|
||||
|
||||
/* ngx_connection_log_error_e */
|
||||
unsigned log_error:2;
|
||||
|
|
|
|||
|
|
@ -127,8 +127,8 @@ void ngx_iocp_wait_events(int main)
|
|||
conn[0] = NULL;
|
||||
|
||||
for ( ;; ) {
|
||||
offset = (nevents == WSA_MAXIMUM_WAIT_EVENTS + 1) ? 1 : 0;
|
||||
timeout = (nevents == 1 && !first) ? 60000 : INFINITE;
|
||||
offset = (nevents == WSA_MAXIMUM_WAIT_EVENTS + 1) ? 1: 0;
|
||||
timeout = (nevents == 1 && !first) ? 60000: INFINITE;
|
||||
|
||||
n = WSAWaitForMultipleEvents(nevents - offset, events[offset],
|
||||
0, timeout, 0);
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -12,8 +12,6 @@
|
|||
#include <ngx_config.h>
|
||||
#include <ngx_core.h>
|
||||
|
||||
#define OPENSSL_SUPPRESS_DEPRECATED
|
||||
|
||||
#include <openssl/ssl.h>
|
||||
#include <openssl/err.h>
|
||||
#include <openssl/bn.h>
|
||||
|
|
@ -24,19 +22,12 @@
|
|||
#include <openssl/engine.h>
|
||||
#endif
|
||||
#include <openssl/evp.h>
|
||||
#if (NGX_QUIC)
|
||||
#ifdef OPENSSL_IS_BORINGSSL
|
||||
#include <openssl/hkdf.h>
|
||||
#include <openssl/chacha.h>
|
||||
#else
|
||||
#include <openssl/kdf.h>
|
||||
#endif
|
||||
#endif
|
||||
#include <openssl/hmac.h>
|
||||
#ifndef OPENSSL_NO_OCSP
|
||||
#include <openssl/ocsp.h>
|
||||
#endif
|
||||
#include <openssl/rand.h>
|
||||
#include <openssl/rsa.h>
|
||||
#include <openssl/x509.h>
|
||||
#include <openssl/x509v3.h>
|
||||
|
||||
|
|
@ -73,19 +64,6 @@
|
|||
#endif
|
||||
|
||||
|
||||
#if (OPENSSL_VERSION_NUMBER >= 0x30000000L && !defined SSL_get_peer_certificate)
|
||||
#define SSL_get_peer_certificate(s) SSL_get1_peer_certificate(s)
|
||||
#endif
|
||||
|
||||
|
||||
#if (OPENSSL_VERSION_NUMBER < 0x30000000L && !defined ERR_peek_error_data)
|
||||
#define ERR_peek_error_data(d, f) ERR_peek_error_line_data(NULL, NULL, d, f)
|
||||
#endif
|
||||
|
||||
|
||||
typedef struct ngx_ssl_ocsp_s ngx_ssl_ocsp_t;
|
||||
|
||||
|
||||
struct ngx_ssl_s {
|
||||
SSL_CTX *ctx;
|
||||
ngx_log_t *log;
|
||||
|
|
@ -103,31 +81,15 @@ struct ngx_ssl_connection_s {
|
|||
|
||||
ngx_connection_handler_pt handler;
|
||||
|
||||
ngx_ssl_session_t *session;
|
||||
ngx_connection_handler_pt save_session;
|
||||
|
||||
ngx_event_handler_pt saved_read_handler;
|
||||
ngx_event_handler_pt saved_write_handler;
|
||||
|
||||
ngx_ssl_ocsp_t *ocsp;
|
||||
|
||||
u_char early_buf;
|
||||
|
||||
unsigned handshaked:1;
|
||||
unsigned handshake_rejected:1;
|
||||
unsigned renegotiation:1;
|
||||
unsigned buffer:1;
|
||||
unsigned sendfile:1;
|
||||
unsigned no_wait_shutdown:1;
|
||||
unsigned no_send_shutdown:1;
|
||||
unsigned shutdown_without_free:1;
|
||||
unsigned handshake_buffer_set:1;
|
||||
unsigned session_timeout_set:1;
|
||||
unsigned try_early_data:1;
|
||||
unsigned in_early:1;
|
||||
unsigned in_ocsp:1;
|
||||
unsigned early_preread:1;
|
||||
unsigned write_blocked:1;
|
||||
};
|
||||
|
||||
|
||||
|
|
@ -143,37 +105,37 @@ typedef struct ngx_ssl_sess_id_s ngx_ssl_sess_id_t;
|
|||
|
||||
struct ngx_ssl_sess_id_s {
|
||||
ngx_rbtree_node_t node;
|
||||
u_char *id;
|
||||
size_t len;
|
||||
u_char *session;
|
||||
ngx_queue_t queue;
|
||||
time_t expire;
|
||||
u_char id[32];
|
||||
#if (NGX_PTR_SIZE == 8)
|
||||
u_char *session;
|
||||
#else
|
||||
u_char session[1];
|
||||
void *stub;
|
||||
u_char sess_id[32];
|
||||
#endif
|
||||
};
|
||||
|
||||
|
||||
typedef struct {
|
||||
u_char name[16];
|
||||
u_char hmac_key[32];
|
||||
u_char aes_key[32];
|
||||
time_t expire;
|
||||
unsigned size:8;
|
||||
unsigned shared:1;
|
||||
} ngx_ssl_ticket_key_t;
|
||||
|
||||
|
||||
typedef struct {
|
||||
ngx_rbtree_t session_rbtree;
|
||||
ngx_rbtree_node_t sentinel;
|
||||
ngx_queue_t expire_queue;
|
||||
ngx_ssl_ticket_key_t ticket_keys[3];
|
||||
time_t fail_time;
|
||||
} ngx_ssl_session_cache_t;
|
||||
|
||||
|
||||
#ifdef SSL_CTRL_SET_TLSEXT_TICKET_KEY_CB
|
||||
|
||||
typedef struct {
|
||||
size_t size;
|
||||
u_char name[16];
|
||||
u_char hmac_key[32];
|
||||
u_char aes_key[32];
|
||||
} ngx_ssl_session_ticket_key_t;
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
#define NGX_SSL_SSLv2 0x0002
|
||||
#define NGX_SSL_SSLv3 0x0004
|
||||
#define NGX_SSL_TLSv1 0x0008
|
||||
|
|
@ -190,14 +152,10 @@ typedef struct {
|
|||
|
||||
ngx_int_t ngx_ssl_init(ngx_log_t *log);
|
||||
ngx_int_t ngx_ssl_create(ngx_ssl_t *ssl, ngx_uint_t protocols, void *data);
|
||||
|
||||
ngx_int_t ngx_ssl_certificates(ngx_conf_t *cf, ngx_ssl_t *ssl,
|
||||
ngx_array_t *certs, ngx_array_t *keys, ngx_array_t *passwords);
|
||||
ngx_int_t ngx_ssl_certificate(ngx_conf_t *cf, ngx_ssl_t *ssl,
|
||||
ngx_str_t *cert, ngx_str_t *key, ngx_array_t *passwords);
|
||||
ngx_int_t ngx_ssl_connection_certificate(ngx_connection_t *c, ngx_pool_t *pool,
|
||||
ngx_str_t *cert, ngx_str_t *key, ngx_array_t *passwords);
|
||||
|
||||
ngx_int_t ngx_ssl_ciphers(ngx_conf_t *cf, ngx_ssl_t *ssl, ngx_str_t *ciphers,
|
||||
ngx_uint_t prefer_server_ciphers);
|
||||
ngx_int_t ngx_ssl_client_certificate(ngx_conf_t *cf, ngx_ssl_t *ssl,
|
||||
|
|
@ -209,42 +167,22 @@ ngx_int_t ngx_ssl_stapling(ngx_conf_t *cf, ngx_ssl_t *ssl,
|
|||
ngx_str_t *file, ngx_str_t *responder, ngx_uint_t verify);
|
||||
ngx_int_t ngx_ssl_stapling_resolver(ngx_conf_t *cf, ngx_ssl_t *ssl,
|
||||
ngx_resolver_t *resolver, ngx_msec_t resolver_timeout);
|
||||
ngx_int_t ngx_ssl_ocsp(ngx_conf_t *cf, ngx_ssl_t *ssl, ngx_str_t *responder,
|
||||
ngx_uint_t depth, ngx_shm_zone_t *shm_zone);
|
||||
ngx_int_t ngx_ssl_ocsp_resolver(ngx_conf_t *cf, ngx_ssl_t *ssl,
|
||||
ngx_resolver_t *resolver, ngx_msec_t resolver_timeout);
|
||||
|
||||
ngx_int_t ngx_ssl_ocsp_validate(ngx_connection_t *c);
|
||||
ngx_int_t ngx_ssl_ocsp_get_status(ngx_connection_t *c, const char **s);
|
||||
void ngx_ssl_ocsp_cleanup(ngx_connection_t *c);
|
||||
ngx_int_t ngx_ssl_ocsp_cache_init(ngx_shm_zone_t *shm_zone, void *data);
|
||||
|
||||
RSA *ngx_ssl_rsa512_key_callback(ngx_ssl_conn_t *ssl_conn, int is_export,
|
||||
int key_length);
|
||||
ngx_array_t *ngx_ssl_read_password_file(ngx_conf_t *cf, ngx_str_t *file);
|
||||
ngx_array_t *ngx_ssl_preserve_passwords(ngx_conf_t *cf,
|
||||
ngx_array_t *passwords);
|
||||
ngx_int_t ngx_ssl_dhparam(ngx_conf_t *cf, ngx_ssl_t *ssl, ngx_str_t *file);
|
||||
ngx_int_t ngx_ssl_ecdh_curve(ngx_conf_t *cf, ngx_ssl_t *ssl, ngx_str_t *name);
|
||||
ngx_int_t ngx_ssl_early_data(ngx_conf_t *cf, ngx_ssl_t *ssl,
|
||||
ngx_uint_t enable);
|
||||
ngx_int_t ngx_ssl_conf_commands(ngx_conf_t *cf, ngx_ssl_t *ssl,
|
||||
ngx_array_t *commands);
|
||||
|
||||
ngx_int_t ngx_ssl_client_session_cache(ngx_conf_t *cf, ngx_ssl_t *ssl,
|
||||
ngx_uint_t enable);
|
||||
ngx_int_t ngx_ssl_session_cache(ngx_ssl_t *ssl, ngx_str_t *sess_ctx,
|
||||
ngx_array_t *certificates, ssize_t builtin_session_cache,
|
||||
ngx_shm_zone_t *shm_zone, time_t timeout);
|
||||
ssize_t builtin_session_cache, ngx_shm_zone_t *shm_zone, time_t timeout);
|
||||
ngx_int_t ngx_ssl_session_ticket_keys(ngx_conf_t *cf, ngx_ssl_t *ssl,
|
||||
ngx_array_t *paths);
|
||||
ngx_int_t ngx_ssl_session_cache_init(ngx_shm_zone_t *shm_zone, void *data);
|
||||
|
||||
ngx_int_t ngx_ssl_create_connection(ngx_ssl_t *ssl, ngx_connection_t *c,
|
||||
ngx_uint_t flags);
|
||||
|
||||
void ngx_ssl_remove_cached_session(SSL_CTX *ssl, ngx_ssl_session_t *sess);
|
||||
ngx_int_t ngx_ssl_set_session(ngx_connection_t *c, ngx_ssl_session_t *session);
|
||||
ngx_ssl_session_t *ngx_ssl_get_session(ngx_connection_t *c);
|
||||
ngx_ssl_session_t *ngx_ssl_get0_session(ngx_connection_t *c);
|
||||
#define ngx_ssl_get_session(c) SSL_get1_session(c->ssl->connection)
|
||||
#define ngx_ssl_free_session SSL_SESSION_free
|
||||
#define ngx_ssl_get_connection(ssl_conn) \
|
||||
SSL_get_ex_data(ssl_conn, ngx_ssl_connection_index)
|
||||
|
|
@ -267,20 +205,14 @@ ngx_int_t ngx_ssl_get_cipher_name(ngx_connection_t *c, ngx_pool_t *pool,
|
|||
ngx_str_t *s);
|
||||
ngx_int_t ngx_ssl_get_ciphers(ngx_connection_t *c, ngx_pool_t *pool,
|
||||
ngx_str_t *s);
|
||||
ngx_int_t ngx_ssl_get_curve(ngx_connection_t *c, ngx_pool_t *pool,
|
||||
ngx_str_t *s);
|
||||
ngx_int_t ngx_ssl_get_curves(ngx_connection_t *c, ngx_pool_t *pool,
|
||||
ngx_str_t *s);
|
||||
ngx_int_t ngx_ssl_get_session_id(ngx_connection_t *c, ngx_pool_t *pool,
|
||||
ngx_str_t *s);
|
||||
ngx_int_t ngx_ssl_get_session_reused(ngx_connection_t *c, ngx_pool_t *pool,
|
||||
ngx_str_t *s);
|
||||
ngx_int_t ngx_ssl_get_early_data(ngx_connection_t *c, ngx_pool_t *pool,
|
||||
ngx_str_t *s);
|
||||
ngx_int_t ngx_ssl_get_server_name(ngx_connection_t *c, ngx_pool_t *pool,
|
||||
ngx_str_t *s);
|
||||
ngx_int_t ngx_ssl_get_alpn_protocol(ngx_connection_t *c, ngx_pool_t *pool,
|
||||
ngx_str_t *s);
|
||||
ngx_int_t ngx_ssl_get_raw_certificate(ngx_connection_t *c, ngx_pool_t *pool,
|
||||
ngx_str_t *s);
|
||||
ngx_int_t ngx_ssl_get_certificate(ngx_connection_t *c, ngx_pool_t *pool,
|
||||
|
|
@ -310,9 +242,6 @@ ngx_int_t ngx_ssl_get_client_v_remain(ngx_connection_t *c, ngx_pool_t *pool,
|
|||
|
||||
|
||||
ngx_int_t ngx_ssl_handshake(ngx_connection_t *c);
|
||||
#if (NGX_DEBUG)
|
||||
void ngx_ssl_handshake_log(ngx_connection_t *c);
|
||||
#endif
|
||||
ssize_t ngx_ssl_recv(ngx_connection_t *c, u_char *buf, size_t size);
|
||||
ssize_t ngx_ssl_write(ngx_connection_t *c, u_char *data, size_t size);
|
||||
ssize_t ngx_ssl_recv_chain(ngx_connection_t *c, ngx_chain_t *cl, off_t limit);
|
||||
|
|
@ -328,8 +257,7 @@ void ngx_ssl_cleanup_ctx(void *data);
|
|||
extern int ngx_ssl_connection_index;
|
||||
extern int ngx_ssl_server_conf_index;
|
||||
extern int ngx_ssl_session_cache_index;
|
||||
extern int ngx_ssl_ticket_keys_index;
|
||||
extern int ngx_ssl_ocsp_index;
|
||||
extern int ngx_ssl_session_ticket_keys_index;
|
||||
extern int ngx_ssl_certificate_index;
|
||||
extern int ngx_ssl_next_certificate_index;
|
||||
extern int ngx_ssl_certificate_name_index;
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -172,11 +172,7 @@ ngx_event_pipe_read_upstream(ngx_event_pipe_t *p)
|
|||
*/
|
||||
|
||||
if (p->upstream->read->available == 0
|
||||
&& p->upstream->read->pending_eof
|
||||
#if (NGX_SSL)
|
||||
&& !p->upstream->ssl
|
||||
#endif
|
||||
)
|
||||
&& p->upstream->read->pending_eof)
|
||||
{
|
||||
p->upstream->read->ready = 0;
|
||||
p->upstream->read->eof = 1;
|
||||
|
|
@ -960,22 +956,6 @@ ngx_event_pipe_copy_input_filter(ngx_event_pipe_t *p, ngx_buf_t *buf)
|
|||
return NGX_OK;
|
||||
}
|
||||
|
||||
if (p->upstream_done) {
|
||||
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, p->log, 0,
|
||||
"input data after close");
|
||||
return NGX_OK;
|
||||
}
|
||||
|
||||
if (p->length == 0) {
|
||||
p->upstream_done = 1;
|
||||
|
||||
ngx_log_error(NGX_LOG_WARN, p->log, 0,
|
||||
"upstream sent more data than specified in "
|
||||
"\"Content-Length\" header");
|
||||
|
||||
return NGX_OK;
|
||||
}
|
||||
|
||||
cl = ngx_chain_get_free_buf(p->pool, &p->free);
|
||||
if (cl == NULL) {
|
||||
return NGX_ERROR;
|
||||
|
|
@ -1003,18 +983,6 @@ ngx_event_pipe_copy_input_filter(ngx_event_pipe_t *p, ngx_buf_t *buf)
|
|||
return NGX_OK;
|
||||
}
|
||||
|
||||
if (b->last - b->pos > p->length) {
|
||||
|
||||
ngx_log_error(NGX_LOG_WARN, p->log, 0,
|
||||
"upstream sent more data than specified in "
|
||||
"\"Content-Length\" header");
|
||||
|
||||
b->last = b->pos + p->length;
|
||||
p->upstream_done = 1;
|
||||
|
||||
return NGX_OK;
|
||||
}
|
||||
|
||||
p->length -= b->last - b->pos;
|
||||
|
||||
return NGX_OK;
|
||||
|
|
|
|||
|
|
@ -11,7 +11,6 @@
|
|||
|
||||
|
||||
ngx_queue_t ngx_posted_accept_events;
|
||||
ngx_queue_t ngx_posted_next_events;
|
||||
ngx_queue_t ngx_posted_events;
|
||||
|
||||
|
||||
|
|
@ -34,27 +33,3 @@ ngx_event_process_posted(ngx_cycle_t *cycle, ngx_queue_t *posted)
|
|||
ev->handler(ev);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
ngx_event_move_posted_next(ngx_cycle_t *cycle)
|
||||
{
|
||||
ngx_queue_t *q;
|
||||
ngx_event_t *ev;
|
||||
|
||||
for (q = ngx_queue_head(&ngx_posted_next_events);
|
||||
q != ngx_queue_sentinel(&ngx_posted_next_events);
|
||||
q = ngx_queue_next(q))
|
||||
{
|
||||
ev = ngx_queue_data(q, ngx_event_t, queue);
|
||||
|
||||
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
|
||||
"posted next event %p", ev);
|
||||
|
||||
ev->ready = 1;
|
||||
ev->available = -1;
|
||||
}
|
||||
|
||||
ngx_queue_add(&ngx_posted_events, &ngx_posted_next_events);
|
||||
ngx_queue_init(&ngx_posted_next_events);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -39,11 +39,9 @@
|
|||
|
||||
|
||||
void ngx_event_process_posted(ngx_cycle_t *cycle, ngx_queue_t *posted);
|
||||
void ngx_event_move_posted_next(ngx_cycle_t *cycle);
|
||||
|
||||
|
||||
extern ngx_queue_t ngx_posted_accept_events;
|
||||
extern ngx_queue_t ngx_posted_next_events;
|
||||
extern ngx_queue_t ngx_posted_events;
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -73,7 +73,7 @@ ngx_event_expire_timers(void)
|
|||
return;
|
||||
}
|
||||
|
||||
ev = ngx_rbtree_data(node, ngx_event_t, timer);
|
||||
ev = (ngx_event_t *) ((char *) node - offsetof(ngx_event_t, timer));
|
||||
|
||||
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ev->log, 0,
|
||||
"event timer del: %d: %M",
|
||||
|
|
@ -113,7 +113,7 @@ ngx_event_no_timers_left(void)
|
|||
node;
|
||||
node = ngx_rbtree_next(&ngx_event_timer_rbtree, node))
|
||||
{
|
||||
ev = ngx_rbtree_data(node, ngx_event_t, timer);
|
||||
ev = (ngx_event_t *) ((char *) node - offsetof(ngx_event_t, timer));
|
||||
|
||||
if (!ev->cancelable) {
|
||||
return NGX_AGAIN;
|
||||
|
|
|
|||
|
|
@ -1,588 +0,0 @@
|
|||
|
||||
/*
|
||||
* Copyright (C) Roman Arutyunyan
|
||||
* Copyright (C) Nginx, Inc.
|
||||
*/
|
||||
|
||||
|
||||
#include <ngx_config.h>
|
||||
#include <ngx_core.h>
|
||||
#include <ngx_event.h>
|
||||
|
||||
|
||||
#if !(NGX_WIN32)
|
||||
|
||||
static void ngx_close_accepted_udp_connection(ngx_connection_t *c);
|
||||
static ssize_t ngx_udp_shared_recv(ngx_connection_t *c, u_char *buf,
|
||||
size_t size);
|
||||
static ngx_int_t ngx_insert_udp_connection(ngx_connection_t *c);
|
||||
static ngx_connection_t *ngx_lookup_udp_connection(ngx_listening_t *ls,
|
||||
struct sockaddr *sockaddr, socklen_t socklen,
|
||||
struct sockaddr *local_sockaddr, socklen_t local_socklen);
|
||||
|
||||
|
||||
void
|
||||
ngx_event_recvmsg(ngx_event_t *ev)
|
||||
{
|
||||
ssize_t n;
|
||||
ngx_buf_t buf;
|
||||
ngx_log_t *log;
|
||||
ngx_err_t err;
|
||||
socklen_t socklen, local_socklen;
|
||||
ngx_event_t *rev, *wev;
|
||||
struct iovec iov[1];
|
||||
struct msghdr msg;
|
||||
ngx_sockaddr_t sa, lsa;
|
||||
struct sockaddr *sockaddr, *local_sockaddr;
|
||||
ngx_listening_t *ls;
|
||||
ngx_event_conf_t *ecf;
|
||||
ngx_connection_t *c, *lc;
|
||||
static u_char buffer[65535];
|
||||
|
||||
#if (NGX_HAVE_ADDRINFO_CMSG)
|
||||
u_char msg_control[CMSG_SPACE(sizeof(ngx_addrinfo_t))];
|
||||
#endif
|
||||
|
||||
if (ev->timedout) {
|
||||
if (ngx_enable_accept_events((ngx_cycle_t *) ngx_cycle) != NGX_OK) {
|
||||
return;
|
||||
}
|
||||
|
||||
ev->timedout = 0;
|
||||
}
|
||||
|
||||
ecf = ngx_event_get_conf(ngx_cycle->conf_ctx, ngx_event_core_module);
|
||||
|
||||
if (!(ngx_event_flags & NGX_USE_KQUEUE_EVENT)) {
|
||||
ev->available = ecf->multi_accept;
|
||||
}
|
||||
|
||||
lc = ev->data;
|
||||
ls = lc->listening;
|
||||
ev->ready = 0;
|
||||
|
||||
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ev->log, 0,
|
||||
"recvmsg on %V, ready: %d", &ls->addr_text, ev->available);
|
||||
|
||||
do {
|
||||
ngx_memzero(&msg, sizeof(struct msghdr));
|
||||
|
||||
iov[0].iov_base = (void *) buffer;
|
||||
iov[0].iov_len = sizeof(buffer);
|
||||
|
||||
msg.msg_name = &sa;
|
||||
msg.msg_namelen = sizeof(ngx_sockaddr_t);
|
||||
msg.msg_iov = iov;
|
||||
msg.msg_iovlen = 1;
|
||||
|
||||
#if (NGX_HAVE_ADDRINFO_CMSG)
|
||||
if (ls->wildcard) {
|
||||
msg.msg_control = &msg_control;
|
||||
msg.msg_controllen = sizeof(msg_control);
|
||||
|
||||
ngx_memzero(&msg_control, sizeof(msg_control));
|
||||
}
|
||||
#endif
|
||||
|
||||
n = recvmsg(lc->fd, &msg, 0);
|
||||
|
||||
if (n == -1) {
|
||||
err = ngx_socket_errno;
|
||||
|
||||
if (err == NGX_EAGAIN) {
|
||||
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, ev->log, err,
|
||||
"recvmsg() not ready");
|
||||
return;
|
||||
}
|
||||
|
||||
ngx_log_error(NGX_LOG_ALERT, ev->log, err, "recvmsg() failed");
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
#if (NGX_HAVE_ADDRINFO_CMSG)
|
||||
if (msg.msg_flags & (MSG_TRUNC|MSG_CTRUNC)) {
|
||||
ngx_log_error(NGX_LOG_ALERT, ev->log, 0,
|
||||
"recvmsg() truncated data");
|
||||
continue;
|
||||
}
|
||||
#endif
|
||||
|
||||
sockaddr = msg.msg_name;
|
||||
socklen = msg.msg_namelen;
|
||||
|
||||
if (socklen > (socklen_t) sizeof(ngx_sockaddr_t)) {
|
||||
socklen = sizeof(ngx_sockaddr_t);
|
||||
}
|
||||
|
||||
if (socklen == 0) {
|
||||
|
||||
/*
|
||||
* on Linux recvmsg() returns zero msg_namelen
|
||||
* when receiving packets from unbound AF_UNIX sockets
|
||||
*/
|
||||
|
||||
socklen = sizeof(struct sockaddr);
|
||||
ngx_memzero(&sa, sizeof(struct sockaddr));
|
||||
sa.sockaddr.sa_family = ls->sockaddr->sa_family;
|
||||
}
|
||||
|
||||
local_sockaddr = ls->sockaddr;
|
||||
local_socklen = ls->socklen;
|
||||
|
||||
#if (NGX_HAVE_ADDRINFO_CMSG)
|
||||
|
||||
if (ls->wildcard) {
|
||||
struct cmsghdr *cmsg;
|
||||
|
||||
ngx_memcpy(&lsa, local_sockaddr, local_socklen);
|
||||
local_sockaddr = &lsa.sockaddr;
|
||||
|
||||
for (cmsg = CMSG_FIRSTHDR(&msg);
|
||||
cmsg != NULL;
|
||||
cmsg = CMSG_NXTHDR(&msg, cmsg))
|
||||
{
|
||||
if (ngx_get_srcaddr_cmsg(cmsg, local_sockaddr) == NGX_OK) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
c = ngx_lookup_udp_connection(ls, sockaddr, socklen, local_sockaddr,
|
||||
local_socklen);
|
||||
|
||||
if (c) {
|
||||
|
||||
#if (NGX_DEBUG)
|
||||
if (c->log->log_level & NGX_LOG_DEBUG_EVENT) {
|
||||
ngx_log_handler_pt handler;
|
||||
|
||||
handler = c->log->handler;
|
||||
c->log->handler = NULL;
|
||||
|
||||
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
|
||||
"recvmsg: fd:%d n:%z", c->fd, n);
|
||||
|
||||
c->log->handler = handler;
|
||||
}
|
||||
#endif
|
||||
|
||||
ngx_memzero(&buf, sizeof(ngx_buf_t));
|
||||
|
||||
buf.pos = buffer;
|
||||
buf.last = buffer + n;
|
||||
|
||||
rev = c->read;
|
||||
|
||||
c->udp->buffer = &buf;
|
||||
|
||||
rev->ready = 1;
|
||||
rev->active = 0;
|
||||
|
||||
rev->handler(rev);
|
||||
|
||||
if (c->udp) {
|
||||
c->udp->buffer = NULL;
|
||||
}
|
||||
|
||||
rev->ready = 0;
|
||||
rev->active = 1;
|
||||
|
||||
goto next;
|
||||
}
|
||||
|
||||
#if (NGX_STAT_STUB)
|
||||
(void) ngx_atomic_fetch_add(ngx_stat_accepted, 1);
|
||||
#endif
|
||||
|
||||
ngx_accept_disabled = ngx_cycle->connection_n / 8
|
||||
- ngx_cycle->free_connection_n;
|
||||
|
||||
c = ngx_get_connection(lc->fd, ev->log);
|
||||
if (c == NULL) {
|
||||
return;
|
||||
}
|
||||
|
||||
c->shared = 1;
|
||||
c->type = SOCK_DGRAM;
|
||||
c->socklen = socklen;
|
||||
|
||||
#if (NGX_STAT_STUB)
|
||||
(void) ngx_atomic_fetch_add(ngx_stat_active, 1);
|
||||
#endif
|
||||
|
||||
c->pool = ngx_create_pool(ls->pool_size, ev->log);
|
||||
if (c->pool == NULL) {
|
||||
ngx_close_accepted_udp_connection(c);
|
||||
return;
|
||||
}
|
||||
|
||||
c->sockaddr = ngx_palloc(c->pool, socklen);
|
||||
if (c->sockaddr == NULL) {
|
||||
ngx_close_accepted_udp_connection(c);
|
||||
return;
|
||||
}
|
||||
|
||||
ngx_memcpy(c->sockaddr, sockaddr, socklen);
|
||||
|
||||
log = ngx_palloc(c->pool, sizeof(ngx_log_t));
|
||||
if (log == NULL) {
|
||||
ngx_close_accepted_udp_connection(c);
|
||||
return;
|
||||
}
|
||||
|
||||
*log = ls->log;
|
||||
|
||||
c->recv = ngx_udp_shared_recv;
|
||||
c->send = ngx_udp_send;
|
||||
c->send_chain = ngx_udp_send_chain;
|
||||
|
||||
c->need_flush_buf = 1;
|
||||
|
||||
c->log = log;
|
||||
c->pool->log = log;
|
||||
c->listening = ls;
|
||||
|
||||
if (local_sockaddr == &lsa.sockaddr) {
|
||||
local_sockaddr = ngx_palloc(c->pool, local_socklen);
|
||||
if (local_sockaddr == NULL) {
|
||||
ngx_close_accepted_udp_connection(c);
|
||||
return;
|
||||
}
|
||||
|
||||
ngx_memcpy(local_sockaddr, &lsa, local_socklen);
|
||||
}
|
||||
|
||||
c->local_sockaddr = local_sockaddr;
|
||||
c->local_socklen = local_socklen;
|
||||
|
||||
c->buffer = ngx_create_temp_buf(c->pool, n);
|
||||
if (c->buffer == NULL) {
|
||||
ngx_close_accepted_udp_connection(c);
|
||||
return;
|
||||
}
|
||||
|
||||
c->buffer->last = ngx_cpymem(c->buffer->last, buffer, n);
|
||||
|
||||
rev = c->read;
|
||||
wev = c->write;
|
||||
|
||||
rev->active = 1;
|
||||
wev->ready = 1;
|
||||
|
||||
rev->log = log;
|
||||
wev->log = log;
|
||||
|
||||
/*
|
||||
* TODO: MT: - ngx_atomic_fetch_add()
|
||||
* or protection by critical section or light mutex
|
||||
*
|
||||
* TODO: MP: - allocated in a shared memory
|
||||
* - ngx_atomic_fetch_add()
|
||||
* or protection by critical section or light mutex
|
||||
*/
|
||||
|
||||
c->number = ngx_atomic_fetch_add(ngx_connection_counter, 1);
|
||||
|
||||
c->start_time = ngx_current_msec;
|
||||
|
||||
#if (NGX_STAT_STUB)
|
||||
(void) ngx_atomic_fetch_add(ngx_stat_handled, 1);
|
||||
#endif
|
||||
|
||||
if (ls->addr_ntop) {
|
||||
c->addr_text.data = ngx_pnalloc(c->pool, ls->addr_text_max_len);
|
||||
if (c->addr_text.data == NULL) {
|
||||
ngx_close_accepted_udp_connection(c);
|
||||
return;
|
||||
}
|
||||
|
||||
c->addr_text.len = ngx_sock_ntop(c->sockaddr, c->socklen,
|
||||
c->addr_text.data,
|
||||
ls->addr_text_max_len, 0);
|
||||
if (c->addr_text.len == 0) {
|
||||
ngx_close_accepted_udp_connection(c);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
#if (NGX_DEBUG)
|
||||
{
|
||||
ngx_str_t addr;
|
||||
u_char text[NGX_SOCKADDR_STRLEN];
|
||||
|
||||
ngx_debug_accepted_connection(ecf, c);
|
||||
|
||||
if (log->log_level & NGX_LOG_DEBUG_EVENT) {
|
||||
addr.data = text;
|
||||
addr.len = ngx_sock_ntop(c->sockaddr, c->socklen, text,
|
||||
NGX_SOCKADDR_STRLEN, 1);
|
||||
|
||||
ngx_log_debug4(NGX_LOG_DEBUG_EVENT, log, 0,
|
||||
"*%uA recvmsg: %V fd:%d n:%z",
|
||||
c->number, &addr, c->fd, n);
|
||||
}
|
||||
|
||||
}
|
||||
#endif
|
||||
|
||||
if (ngx_insert_udp_connection(c) != NGX_OK) {
|
||||
ngx_close_accepted_udp_connection(c);
|
||||
return;
|
||||
}
|
||||
|
||||
log->data = NULL;
|
||||
log->handler = NULL;
|
||||
|
||||
ls->handler(c);
|
||||
|
||||
next:
|
||||
|
||||
if (ngx_event_flags & NGX_USE_KQUEUE_EVENT) {
|
||||
ev->available -= n;
|
||||
}
|
||||
|
||||
} while (ev->available);
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
ngx_close_accepted_udp_connection(ngx_connection_t *c)
|
||||
{
|
||||
ngx_free_connection(c);
|
||||
|
||||
c->fd = (ngx_socket_t) -1;
|
||||
|
||||
if (c->pool) {
|
||||
ngx_destroy_pool(c->pool);
|
||||
}
|
||||
|
||||
#if (NGX_STAT_STUB)
|
||||
(void) ngx_atomic_fetch_add(ngx_stat_active, -1);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
static ssize_t
|
||||
ngx_udp_shared_recv(ngx_connection_t *c, u_char *buf, size_t size)
|
||||
{
|
||||
ssize_t n;
|
||||
ngx_buf_t *b;
|
||||
|
||||
if (c->udp == NULL || c->udp->buffer == NULL) {
|
||||
return NGX_AGAIN;
|
||||
}
|
||||
|
||||
b = c->udp->buffer;
|
||||
|
||||
n = ngx_min(b->last - b->pos, (ssize_t) size);
|
||||
|
||||
ngx_memcpy(buf, b->pos, n);
|
||||
|
||||
c->udp->buffer = NULL;
|
||||
|
||||
c->read->ready = 0;
|
||||
c->read->active = 1;
|
||||
|
||||
return n;
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
ngx_udp_rbtree_insert_value(ngx_rbtree_node_t *temp,
|
||||
ngx_rbtree_node_t *node, ngx_rbtree_node_t *sentinel)
|
||||
{
|
||||
ngx_int_t rc;
|
||||
ngx_connection_t *c, *ct;
|
||||
ngx_rbtree_node_t **p;
|
||||
ngx_udp_connection_t *udp, *udpt;
|
||||
|
||||
for ( ;; ) {
|
||||
|
||||
if (node->key < temp->key) {
|
||||
|
||||
p = &temp->left;
|
||||
|
||||
} else if (node->key > temp->key) {
|
||||
|
||||
p = &temp->right;
|
||||
|
||||
} else { /* node->key == temp->key */
|
||||
|
||||
udp = (ngx_udp_connection_t *) node;
|
||||
c = udp->connection;
|
||||
|
||||
udpt = (ngx_udp_connection_t *) temp;
|
||||
ct = udpt->connection;
|
||||
|
||||
rc = ngx_cmp_sockaddr(c->sockaddr, c->socklen,
|
||||
ct->sockaddr, ct->socklen, 1);
|
||||
|
||||
if (rc == 0 && c->listening->wildcard) {
|
||||
rc = ngx_cmp_sockaddr(c->local_sockaddr, c->local_socklen,
|
||||
ct->local_sockaddr, ct->local_socklen, 1);
|
||||
}
|
||||
|
||||
p = (rc < 0) ? &temp->left : &temp->right;
|
||||
}
|
||||
|
||||
if (*p == sentinel) {
|
||||
break;
|
||||
}
|
||||
|
||||
temp = *p;
|
||||
}
|
||||
|
||||
*p = node;
|
||||
node->parent = temp;
|
||||
node->left = sentinel;
|
||||
node->right = sentinel;
|
||||
ngx_rbt_red(node);
|
||||
}
|
||||
|
||||
|
||||
static ngx_int_t
|
||||
ngx_insert_udp_connection(ngx_connection_t *c)
|
||||
{
|
||||
uint32_t hash;
|
||||
ngx_pool_cleanup_t *cln;
|
||||
ngx_udp_connection_t *udp;
|
||||
|
||||
if (c->udp) {
|
||||
return NGX_OK;
|
||||
}
|
||||
|
||||
udp = ngx_pcalloc(c->pool, sizeof(ngx_udp_connection_t));
|
||||
if (udp == NULL) {
|
||||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
udp->connection = c;
|
||||
|
||||
ngx_crc32_init(hash);
|
||||
ngx_crc32_update(&hash, (u_char *) c->sockaddr, c->socklen);
|
||||
|
||||
if (c->listening->wildcard) {
|
||||
ngx_crc32_update(&hash, (u_char *) c->local_sockaddr, c->local_socklen);
|
||||
}
|
||||
|
||||
ngx_crc32_final(hash);
|
||||
|
||||
udp->node.key = hash;
|
||||
|
||||
cln = ngx_pool_cleanup_add(c->pool, 0);
|
||||
if (cln == NULL) {
|
||||
return NGX_ERROR;
|
||||
}
|
||||
|
||||
cln->data = c;
|
||||
cln->handler = ngx_delete_udp_connection;
|
||||
|
||||
ngx_rbtree_insert(&c->listening->rbtree, &udp->node);
|
||||
|
||||
c->udp = udp;
|
||||
|
||||
return NGX_OK;
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
ngx_delete_udp_connection(void *data)
|
||||
{
|
||||
ngx_connection_t *c = data;
|
||||
|
||||
if (c->udp == NULL) {
|
||||
return;
|
||||
}
|
||||
|
||||
ngx_rbtree_delete(&c->listening->rbtree, &c->udp->node);
|
||||
|
||||
c->udp = NULL;
|
||||
}
|
||||
|
||||
|
||||
static ngx_connection_t *
|
||||
ngx_lookup_udp_connection(ngx_listening_t *ls, struct sockaddr *sockaddr,
|
||||
socklen_t socklen, struct sockaddr *local_sockaddr, socklen_t local_socklen)
|
||||
{
|
||||
uint32_t hash;
|
||||
ngx_int_t rc;
|
||||
ngx_connection_t *c;
|
||||
ngx_rbtree_node_t *node, *sentinel;
|
||||
ngx_udp_connection_t *udp;
|
||||
|
||||
#if (NGX_HAVE_UNIX_DOMAIN)
|
||||
|
||||
if (sockaddr->sa_family == AF_UNIX) {
|
||||
struct sockaddr_un *saun = (struct sockaddr_un *) sockaddr;
|
||||
|
||||
if (socklen <= (socklen_t) offsetof(struct sockaddr_un, sun_path)
|
||||
|| saun->sun_path[0] == '\0')
|
||||
{
|
||||
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, ngx_cycle->log, 0,
|
||||
"unbound unix socket");
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
node = ls->rbtree.root;
|
||||
sentinel = ls->rbtree.sentinel;
|
||||
|
||||
ngx_crc32_init(hash);
|
||||
ngx_crc32_update(&hash, (u_char *) sockaddr, socklen);
|
||||
|
||||
if (ls->wildcard) {
|
||||
ngx_crc32_update(&hash, (u_char *) local_sockaddr, local_socklen);
|
||||
}
|
||||
|
||||
ngx_crc32_final(hash);
|
||||
|
||||
while (node != sentinel) {
|
||||
|
||||
if (hash < node->key) {
|
||||
node = node->left;
|
||||
continue;
|
||||
}
|
||||
|
||||
if (hash > node->key) {
|
||||
node = node->right;
|
||||
continue;
|
||||
}
|
||||
|
||||
/* hash == node->key */
|
||||
|
||||
udp = (ngx_udp_connection_t *) node;
|
||||
|
||||
c = udp->connection;
|
||||
|
||||
rc = ngx_cmp_sockaddr(sockaddr, socklen,
|
||||
c->sockaddr, c->socklen, 1);
|
||||
|
||||
if (rc == 0 && ls->wildcard) {
|
||||
rc = ngx_cmp_sockaddr(local_sockaddr, local_socklen,
|
||||
c->local_sockaddr, c->local_socklen, 1);
|
||||
}
|
||||
|
||||
if (rc == 0) {
|
||||
return c;
|
||||
}
|
||||
|
||||
node = (rc < 0) ? node->left : node->right;
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
void
|
||||
ngx_delete_udp_connection(void *data)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
@ -1,65 +0,0 @@
|
|||
|
||||
/*
|
||||
* Copyright (C) Nginx, Inc.
|
||||
*/
|
||||
|
||||
|
||||
#ifndef _NGX_EVENT_UDP_H_INCLUDED_
|
||||
#define _NGX_EVENT_UDP_H_INCLUDED_
|
||||
|
||||
|
||||
#include <ngx_config.h>
|
||||
#include <ngx_core.h>
|
||||
|
||||
|
||||
#if !(NGX_WIN32)
|
||||
|
||||
#if ((NGX_HAVE_MSGHDR_MSG_CONTROL) \
|
||||
&& (NGX_HAVE_IP_SENDSRCADDR || NGX_HAVE_IP_RECVDSTADDR \
|
||||
|| NGX_HAVE_IP_PKTINFO \
|
||||
|| (NGX_HAVE_INET6 && NGX_HAVE_IPV6_RECVPKTINFO)))
|
||||
#define NGX_HAVE_ADDRINFO_CMSG 1
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
struct ngx_udp_connection_s {
|
||||
ngx_rbtree_node_t node;
|
||||
ngx_connection_t *connection;
|
||||
ngx_buf_t *buffer;
|
||||
};
|
||||
|
||||
|
||||
#if (NGX_HAVE_ADDRINFO_CMSG)
|
||||
|
||||
typedef union {
|
||||
#if (NGX_HAVE_IP_SENDSRCADDR || NGX_HAVE_IP_RECVDSTADDR)
|
||||
struct in_addr addr;
|
||||
#endif
|
||||
|
||||
#if (NGX_HAVE_IP_PKTINFO)
|
||||
struct in_pktinfo pkt;
|
||||
#endif
|
||||
|
||||
#if (NGX_HAVE_INET6 && NGX_HAVE_IPV6_RECVPKTINFO)
|
||||
struct in6_pktinfo pkt6;
|
||||
#endif
|
||||
} ngx_addrinfo_t;
|
||||
|
||||
size_t ngx_set_srcaddr_cmsg(struct cmsghdr *cmsg,
|
||||
struct sockaddr *local_sockaddr);
|
||||
ngx_int_t ngx_get_srcaddr_cmsg(struct cmsghdr *cmsg,
|
||||
struct sockaddr *local_sockaddr);
|
||||
|
||||
#endif
|
||||
|
||||
void ngx_event_recvmsg(ngx_event_t *ev);
|
||||
ssize_t ngx_sendmsg(ngx_connection_t *c, struct msghdr *msg, int flags);
|
||||
void ngx_udp_rbtree_insert_value(ngx_rbtree_node_t *temp,
|
||||
ngx_rbtree_node_t *node, ngx_rbtree_node_t *sentinel);
|
||||
#endif
|
||||
|
||||
void ngx_delete_udp_connection(void *data);
|
||||
|
||||
|
||||
#endif /* _NGX_EVENT_UDP_H_INCLUDED_ */
|
||||
|
|
@ -1,113 +0,0 @@
|
|||
#!/bin/bash
|
||||
|
||||
export LANG=C
|
||||
|
||||
set -e
|
||||
|
||||
if [ $# -lt 1 ]; then
|
||||
echo "Usage: PROGNAME=foo LICENSE=bar $0 <bpf object file>"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
|
||||
self=$0
|
||||
filename=$1
|
||||
funcname=$PROGNAME
|
||||
|
||||
generate_head()
|
||||
{
|
||||
cat << END
|
||||
/* AUTO-GENERATED, DO NOT EDIT. */
|
||||
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#include "ngx_bpf.h"
|
||||
|
||||
|
||||
END
|
||||
}
|
||||
|
||||
generate_tail()
|
||||
{
|
||||
cat << END
|
||||
|
||||
ngx_bpf_program_t $PROGNAME = {
|
||||
.relocs = bpf_reloc_prog_$funcname,
|
||||
.nrelocs = sizeof(bpf_reloc_prog_$funcname)
|
||||
/ sizeof(bpf_reloc_prog_$funcname[0]),
|
||||
.ins = bpf_insn_prog_$funcname,
|
||||
.nins = sizeof(bpf_insn_prog_$funcname)
|
||||
/ sizeof(bpf_insn_prog_$funcname[0]),
|
||||
.license = "$LICENSE",
|
||||
.type = BPF_PROG_TYPE_SK_REUSEPORT,
|
||||
};
|
||||
|
||||
END
|
||||
}
|
||||
|
||||
process_relocations()
|
||||
{
|
||||
echo "static ngx_bpf_reloc_t bpf_reloc_prog_$funcname[] = {"
|
||||
|
||||
objdump -r $filename | awk '{
|
||||
|
||||
if (enabled && $NF > 0) {
|
||||
off = strtonum(sprintf("0x%s", $1));
|
||||
name = $3;
|
||||
|
||||
printf(" { \"%s\", %d },\n", name, off/8);
|
||||
}
|
||||
|
||||
if ($1 == "OFFSET") {
|
||||
enabled=1;
|
||||
}
|
||||
}'
|
||||
echo "};"
|
||||
echo
|
||||
}
|
||||
|
||||
process_section()
|
||||
{
|
||||
echo "static struct bpf_insn bpf_insn_prog_$funcname[] = {"
|
||||
echo " /* opcode dst src offset imm */"
|
||||
|
||||
section_info=$(objdump -h $filename --section=$funcname | grep "1 $funcname")
|
||||
|
||||
# dd doesn't know hex
|
||||
length=$(printf "%d" 0x$(echo $section_info | cut -d ' ' -f3))
|
||||
offset=$(printf "%d" 0x$(echo $section_info | cut -d ' ' -f6))
|
||||
|
||||
for ins in $(dd if="$filename" bs=1 count=$length skip=$offset status=none | xxd -p -c 8)
|
||||
do
|
||||
opcode=0x${ins:0:2}
|
||||
srcdst=0x${ins:2:2}
|
||||
|
||||
# bytes are dumped in LE order
|
||||
offset=0x${ins:6:2}${ins:4:2} # short
|
||||
immedi=0x${ins:14:2}${ins:12:2}${ins:10:2}${ins:8:2} # int
|
||||
|
||||
dst="$(($srcdst & 0xF))"
|
||||
src="$(($srcdst & 0xF0))"
|
||||
src="$(($src >> 4))"
|
||||
|
||||
opcode=$(printf "0x%x" $opcode)
|
||||
dst=$(printf "BPF_REG_%d" $dst)
|
||||
src=$(printf "BPF_REG_%d" $src)
|
||||
offset=$(printf "%d" $offset)
|
||||
immedi=$(printf "0x%x" $immedi)
|
||||
|
||||
printf " { %4s, %11s, %11s, (int16_t) %6s, %10s },\n" $opcode $dst $src $offset $immedi
|
||||
done
|
||||
|
||||
cat << END
|
||||
};
|
||||
|
||||
END
|
||||
}
|
||||
|
||||
generate_head
|
||||
process_relocations
|
||||
process_section
|
||||
generate_tail
|
||||
|
||||
|
|
@ -1,30 +0,0 @@
|
|||
CFLAGS=-O2 -Wall
|
||||
|
||||
LICENSE=BSD
|
||||
|
||||
PROGNAME=ngx_quic_reuseport_helper
|
||||
RESULT=ngx_event_quic_bpf_code
|
||||
DEST=../$(RESULT).c
|
||||
|
||||
all: $(RESULT)
|
||||
|
||||
$(RESULT): $(PROGNAME).o
|
||||
LICENSE=$(LICENSE) PROGNAME=$(PROGNAME) bash ./bpfgen.sh $< > $@
|
||||
|
||||
DEFS=-DPROGNAME=\"$(PROGNAME)\" \
|
||||
-DLICENSE_$(LICENSE) \
|
||||
-DLICENSE=\"$(LICENSE)\" \
|
||||
|
||||
$(PROGNAME).o: $(PROGNAME).c
|
||||
clang $(CFLAGS) $(DEFS) -target bpf -c $< -o $@
|
||||
|
||||
install: $(RESULT)
|
||||
cp $(RESULT) $(DEST)
|
||||
|
||||
clean:
|
||||
@rm -f $(RESULT) *.o
|
||||
|
||||
debug: $(PROGNAME).o
|
||||
llvm-objdump -S -no-show-raw-insn $<
|
||||
|
||||
.DELETE_ON_ERROR:
|
||||
|
|
@ -1,140 +0,0 @@
|
|||
#include <errno.h>
|
||||
#include <linux/string.h>
|
||||
#include <linux/udp.h>
|
||||
#include <linux/bpf.h>
|
||||
/*
|
||||
* the bpf_helpers.h is not included into linux-headers, only available
|
||||
* with kernel sources in "tools/lib/bpf/bpf_helpers.h" or in libbpf.
|
||||
*/
|
||||
#include <bpf/bpf_helpers.h>
|
||||
|
||||
|
||||
#if !defined(SEC)
|
||||
#define SEC(NAME) __attribute__((section(NAME), used))
|
||||
#endif
|
||||
|
||||
|
||||
#if defined(LICENSE_GPL)
|
||||
|
||||
/*
|
||||
* To see debug:
|
||||
*
|
||||
* echo 1 > /sys/kernel/debug/tracing/events/bpf_trace/enable
|
||||
* cat /sys/kernel/debug/tracing/trace_pipe
|
||||
* echo 0 > /sys/kernel/debug/tracing/events/bpf_trace/enable
|
||||
*/
|
||||
|
||||
#define debugmsg(fmt, ...) \
|
||||
do { \
|
||||
char __buf[] = fmt; \
|
||||
bpf_trace_printk(__buf, sizeof(__buf), ##__VA_ARGS__); \
|
||||
} while (0)
|
||||
|
||||
#else
|
||||
|
||||
#define debugmsg(fmt, ...)
|
||||
|
||||
#endif
|
||||
|
||||
char _license[] SEC("license") = LICENSE;
|
||||
|
||||
/*****************************************************************************/
|
||||
|
||||
#define NGX_QUIC_PKT_LONG 0x80 /* header form */
|
||||
#define NGX_QUIC_SERVER_CID_LEN 20
|
||||
|
||||
|
||||
#define advance_data(nbytes) \
|
||||
offset += nbytes; \
|
||||
if (start + offset > end) { \
|
||||
debugmsg("cannot read %ld bytes at offset %ld", nbytes, offset); \
|
||||
goto failed; \
|
||||
} \
|
||||
data = start + offset - 1;
|
||||
|
||||
|
||||
#define ngx_quic_parse_uint64(p) \
|
||||
(((__u64)(p)[0] << 56) | \
|
||||
((__u64)(p)[1] << 48) | \
|
||||
((__u64)(p)[2] << 40) | \
|
||||
((__u64)(p)[3] << 32) | \
|
||||
((__u64)(p)[4] << 24) | \
|
||||
((__u64)(p)[5] << 16) | \
|
||||
((__u64)(p)[6] << 8) | \
|
||||
((__u64)(p)[7]))
|
||||
|
||||
/*
|
||||
* actual map object is created by the "bpf" system call,
|
||||
* all pointers to this variable are replaced by the bpf loader
|
||||
*/
|
||||
struct bpf_map_def SEC("maps") ngx_quic_sockmap;
|
||||
|
||||
|
||||
SEC(PROGNAME)
|
||||
int ngx_quic_select_socket_by_dcid(struct sk_reuseport_md *ctx)
|
||||
{
|
||||
int rc;
|
||||
__u64 key;
|
||||
size_t len, offset;
|
||||
unsigned char *start, *end, *data, *dcid;
|
||||
|
||||
start = ctx->data;
|
||||
end = (unsigned char *) ctx->data_end;
|
||||
offset = 0;
|
||||
|
||||
advance_data(sizeof(struct udphdr)); /* data at UDP header */
|
||||
advance_data(1); /* data at QUIC flags */
|
||||
|
||||
if (data[0] & NGX_QUIC_PKT_LONG) {
|
||||
|
||||
advance_data(4); /* data at QUIC version */
|
||||
advance_data(1); /* data at DCID len */
|
||||
|
||||
len = data[0]; /* read DCID length */
|
||||
|
||||
if (len < 8) {
|
||||
/* it's useless to search for key in such short DCID */
|
||||
return SK_PASS;
|
||||
}
|
||||
|
||||
} else {
|
||||
len = NGX_QUIC_SERVER_CID_LEN;
|
||||
}
|
||||
|
||||
dcid = &data[1];
|
||||
advance_data(len); /* we expect the packet to have full DCID */
|
||||
|
||||
/* make verifier happy */
|
||||
if (dcid + sizeof(__u64) > end) {
|
||||
goto failed;
|
||||
}
|
||||
|
||||
key = ngx_quic_parse_uint64(dcid);
|
||||
|
||||
rc = bpf_sk_select_reuseport(ctx, &ngx_quic_sockmap, &key, 0);
|
||||
|
||||
switch (rc) {
|
||||
case 0:
|
||||
debugmsg("nginx quic socket selected by key 0x%llx", key);
|
||||
return SK_PASS;
|
||||
|
||||
/* kernel returns positive error numbers, errno.h defines positive */
|
||||
case -ENOENT:
|
||||
debugmsg("nginx quic default route for key 0x%llx", key);
|
||||
/* let the default reuseport logic decide which socket to choose */
|
||||
return SK_PASS;
|
||||
|
||||
default:
|
||||
debugmsg("nginx quic bpf_sk_select_reuseport err: %d key 0x%llx",
|
||||
rc, key);
|
||||
goto failed;
|
||||
}
|
||||
|
||||
failed:
|
||||
/*
|
||||
* SK_DROP will generate ICMP, but we may want to process "invalid" packet
|
||||
* in userspace quic to investigate further and finally react properly
|
||||
* (maybe ignore, maybe send something in response or close connection)
|
||||
*/
|
||||
return SK_PASS;
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue