nginxtra 1.6.3.9 → 1.8.0.9

data/vendor/nginx/src/event/ngx_event_openssl.h

@@ -14,10 +14,21 @@
 
 #include <openssl/ssl.h>
 #include <openssl/err.h>
+#include <openssl/bn.h>
 #include <openssl/conf.h>
+#include <openssl/crypto.h>
+#include <openssl/dh.h>
+#ifndef OPENSSL_NO_ENGINE
 #include <openssl/engine.h>
+#endif
 #include <openssl/evp.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>
 
 #define NGX_SSL_NAME     "OpenSSL"
 
@@ -112,7 +123,7 @@ 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_certificate(ngx_conf_t *cf, ngx_ssl_t *ssl,
-    ngx_str_t *cert, ngx_str_t *key);
+    ngx_str_t *cert, ngx_str_t *key, ngx_array_t *passwords);
 ngx_int_t ngx_ssl_client_certificate(ngx_conf_t *cf, ngx_ssl_t *ssl,
     ngx_str_t *cert, ngx_int_t depth);
 ngx_int_t ngx_ssl_trusted_certificate(ngx_conf_t *cf, ngx_ssl_t *ssl,
@@ -124,6 +135,7 @@ ngx_int_t ngx_ssl_stapling_resolver(ngx_conf_t *cf, ngx_ssl_t *ssl,
     ngx_resolver_t *resolver, ngx_msec_t resolver_timeout);
 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_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_session_cache(ngx_ssl_t *ssl, ngx_str_t *sess_ctx,
@@ -150,6 +162,8 @@ ngx_int_t ngx_ssl_set_session(ngx_connection_t *c, ngx_ssl_session_t *session);
      || n == X509_V_ERR_CERT_UNTRUSTED                                        \
      || n == X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE)
 
+ngx_int_t ngx_ssl_check_host(ngx_connection_t *c, ngx_str_t *name);
+
 
 ngx_int_t ngx_ssl_get_protocol(ngx_connection_t *c, ngx_pool_t *pool,
     ngx_str_t *s);
@@ -159,6 +173,8 @@ 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_server_name(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,
@@ -169,6 +185,8 @@ ngx_int_t ngx_ssl_get_issuer_dn(ngx_connection_t *c, ngx_pool_t *pool,
     ngx_str_t *s);
 ngx_int_t ngx_ssl_get_serial_number(ngx_connection_t *c, ngx_pool_t *pool,
     ngx_str_t *s);
+ngx_int_t ngx_ssl_get_fingerprint(ngx_connection_t *c, ngx_pool_t *pool,
+    ngx_str_t *s);
 ngx_int_t ngx_ssl_get_client_verify(ngx_connection_t *c, ngx_pool_t *pool,
     ngx_str_t *s);
 
@@ -176,7 +194,7 @@ ngx_int_t ngx_ssl_get_client_verify(ngx_connection_t *c, ngx_pool_t *pool,
 ngx_int_t ngx_ssl_handshake(ngx_connection_t *c);
 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);
+ssize_t ngx_ssl_recv_chain(ngx_connection_t *c, ngx_chain_t *cl, off_t limit);
 ngx_chain_t *ngx_ssl_send_chain(ngx_connection_t *c, ngx_chain_t *in,
     off_t limit);
 void ngx_ssl_free_buffer(ngx_connection_t *c);

data/vendor/nginx/src/event/ngx_event_openssl_stapling.c

@@ -11,7 +11,7 @@
 #include <ngx_event_connect.h>
 
 
-#ifdef SSL_CTRL_SET_TLSEXT_STATUS_REQ_CB
+#if (!defined OPENSSL_NO_OCSP && defined SSL_CTRL_SET_TLSEXT_STATUS_REQ_CB)
 
 
 typedef struct {
@@ -310,6 +310,7 @@ ngx_ssl_stapling_issuer(ngx_conf_t *cf, ngx_ssl_t *ssl)
     if (X509_STORE_CTX_init(store_ctx, store, NULL, NULL) == 0) {
         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
                       "X509_STORE_CTX_init() failed");
+        X509_STORE_CTX_free(store_ctx);
         return NGX_ERROR;
     }
 
@@ -1118,6 +1119,7 @@ ngx_ssl_ocsp_create_request(ngx_ssl_ocsp_ctx_t *ctx)
     if (OCSP_request_add0_id(ocsp, id) == NULL) {
         ngx_ssl_error(NGX_LOG_CRIT, ctx->log, 0,
                       "OCSP_request_add0_id() failed");
+        OCSP_CERTID_free(id);
         goto failed;
     }
 
@@ -1195,6 +1197,8 @@ ngx_ssl_ocsp_create_request(ngx_ssl_ocsp_ctx_t *ctx)
     b->last = p;
     ctx->request = b;
 
+    OCSP_REQUEST_free(ocsp);
+
     return NGX_OK;
 
 failed:

data/vendor/nginx/src/event/ngx_event_pipe.c

@@ -66,11 +66,13 @@ ngx_event_pipe(ngx_event_pipe_t *p, ngx_int_t do_write)
             return NGX_ABORT;
         }
 
-        if (rev->active && !rev->ready) {
-            ngx_add_timer(rev, p->read_timeout);
+        if (!rev->delayed) {
+            if (rev->active && !rev->ready) {
+                ngx_add_timer(rev, p->read_timeout);
 
-        } else if (rev->timer_set) {
-            ngx_del_timer(rev);
+            } else if (rev->timer_set) {
+                ngx_del_timer(rev);
+            }
         }
     }
 
@@ -99,9 +101,11 @@ ngx_event_pipe(ngx_event_pipe_t *p, ngx_int_t do_write)
 static ngx_int_t
 ngx_event_pipe_read_upstream(ngx_event_pipe_t *p)
 {
+    off_t         limit;
     ssize_t       n, size;
     ngx_int_t     rc;
     ngx_buf_t    *b;
+    ngx_msec_t    delay;
     ngx_chain_t  *chain, *cl, *ln;
 
     if (p->upstream_eof || p->upstream_error || p->upstream_done) {
@@ -169,6 +173,25 @@ ngx_event_pipe_read_upstream(ngx_event_pipe_t *p)
             }
 #endif
 
+            if (p->limit_rate) {
+                if (p->upstream->read->delayed) {
+                    break;
+                }
+
+                limit = (off_t) p->limit_rate * (ngx_time() - p->start_sec + 1)
+                        - p->read_length;
+
+                if (limit <= 0) {
+                    p->upstream->read->delayed = 1;
+                    delay = (ngx_msec_t) (- limit * 1000 / p->limit_rate + 1);
+                    ngx_add_timer(p->upstream->read, delay);
+                    break;
+                }
+
+            } else {
+                limit = 0;
+            }
+
             if (p->free_raw_bufs) {
 
                 /* use the free bufs if they exist */
@@ -270,7 +293,7 @@ ngx_event_pipe_read_upstream(ngx_event_pipe_t *p)
                 break;
             }
 
-            n = p->upstream->recv_chain(p->upstream, chain);
+            n = p->upstream->recv_chain(p->upstream, chain, limit);
 
             ngx_log_debug1(NGX_LOG_DEBUG_EVENT, p->log, 0,
                            "pipe recv chain: %z", n);
@@ -301,6 +324,8 @@ ngx_event_pipe_read_upstream(ngx_event_pipe_t *p)
             }
         }
 
+        delay = p->limit_rate ? (ngx_msec_t) n * 1000 / p->limit_rate : 0;
+
         p->read_length += n;
         cl = chain;
         p->free_raw_bufs = NULL;
@@ -337,6 +362,12 @@ ngx_event_pipe_read_upstream(ngx_event_pipe_t *p)
             ln->next = p->free_raw_bufs;
             p->free_raw_bufs = cl;
         }
+
+        if (delay > 0) {
+            p->upstream->read->delayed = 1;
+            ngx_add_timer(p->upstream->read, delay);
+            break;
+        }
     }
 
 #if (NGX_DEBUG)
@@ -345,7 +376,7 @@ ngx_event_pipe_read_upstream(ngx_event_pipe_t *p)
         ngx_log_debug8(NGX_LOG_DEBUG_EVENT, p->log, 0,
                        "pipe buf busy s:%d t:%d f:%d "
                        "%p, pos %p, size: %z "
-                       "file: %O, size: %z",
+                       "file: %O, size: %O",
                        (cl->buf->shadow ? 1 : 0),
                        cl->buf->temporary, cl->buf->in_file,
                        cl->buf->start, cl->buf->pos,
@@ -358,7 +389,7 @@ ngx_event_pipe_read_upstream(ngx_event_pipe_t *p)
         ngx_log_debug8(NGX_LOG_DEBUG_EVENT, p->log, 0,
                        "pipe buf out  s:%d t:%d f:%d "
                        "%p, pos %p, size: %z "
-                       "file: %O, size: %z",
+                       "file: %O, size: %O",
                        (cl->buf->shadow ? 1 : 0),
                        cl->buf->temporary, cl->buf->in_file,
                        cl->buf->start, cl->buf->pos,
@@ -371,7 +402,7 @@ ngx_event_pipe_read_upstream(ngx_event_pipe_t *p)
         ngx_log_debug8(NGX_LOG_DEBUG_EVENT, p->log, 0,
                        "pipe buf in   s:%d t:%d f:%d "
                        "%p, pos %p, size: %z "
-                       "file: %O, size: %z",
+                       "file: %O, size: %O",
                        (cl->buf->shadow ? 1 : 0),
                        cl->buf->temporary, cl->buf->in_file,
                        cl->buf->start, cl->buf->pos,
@@ -384,7 +415,7 @@ ngx_event_pipe_read_upstream(ngx_event_pipe_t *p)
         ngx_log_debug8(NGX_LOG_DEBUG_EVENT, p->log, 0,
                        "pipe buf free s:%d t:%d f:%d "
                        "%p, pos %p, size: %z "
-                       "file: %O, size: %z",
+                       "file: %O, size: %O",
                        (cl->buf->shadow ? 1 : 0),
                        cl->buf->temporary, cl->buf->in_file,
                        cl->buf->start, cl->buf->pos,
@@ -439,7 +470,11 @@ ngx_event_pipe_read_upstream(ngx_event_pipe_t *p)
         }
     }
 
-    if (p->cacheable && p->in) {
+    if (p->cacheable && (p->in || p->buf_to_file)) {
+
+        ngx_log_debug0(NGX_LOG_DEBUG_EVENT, p->log, 0,
+                       "pipe write chain");
+
         if (ngx_event_pipe_write_chain_to_temp_file(p) == NGX_ABORT) {
             return NGX_ABORT;
         }
@@ -515,15 +550,6 @@ ngx_event_pipe_write_to_downstream(ngx_event_pipe_t *p)
                 p->in = NULL;
             }
 
-            if (p->cacheable && p->buf_to_file) {
-                ngx_log_debug0(NGX_LOG_DEBUG_EVENT, p->log, 0,
-                               "pipe write chain");
-
-                if (ngx_event_pipe_write_chain_to_temp_file(p) == NGX_ABORT) {
-                    return NGX_ABORT;
-                }
-            }
-
             ngx_log_debug0(NGX_LOG_DEBUG_EVENT, p->log, 0,
                            "pipe write downstream done");
 

data/vendor/nginx/src/event/ngx_event_pipe.h

@@ -80,6 +80,9 @@ struct ngx_event_pipe_s {
     size_t             preread_size;
     ngx_buf_t         *buf_to_file;
 
+    size_t             limit_rate;
+    time_t             start_sec;
+
     ngx_temp_file_t   *temp_file;
 
     /* STUB */ int     num;

data/vendor/nginx/src/event/ngx_event_posted.c

@@ -10,164 +10,26 @@
 #include <ngx_event.h>
 
 
-ngx_thread_volatile ngx_event_t  *ngx_posted_accept_events;
-ngx_thread_volatile ngx_event_t  *ngx_posted_events;
-
-#if (NGX_THREADS)
-ngx_mutex_t                      *ngx_posted_events_mutex;
-#endif
+ngx_queue_t  ngx_posted_accept_events;
+ngx_queue_t  ngx_posted_events;
 
 
 void
-ngx_event_process_posted(ngx_cycle_t *cycle,
-    ngx_thread_volatile ngx_event_t **posted)
+ngx_event_process_posted(ngx_cycle_t *cycle, ngx_queue_t *posted)
 {
+    ngx_queue_t  *q;
     ngx_event_t  *ev;
 
-    for ( ;; ) {
+    while (!ngx_queue_empty(posted)) {
 
-        ev = (ngx_event_t *) *posted;
+        q = ngx_queue_head(posted);
+        ev = ngx_queue_data(q, ngx_event_t, queue);
 
         ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
                       "posted event %p", ev);
 
-        if (ev == NULL) {
-            return;
-        }
-
         ngx_delete_posted_event(ev);
 
         ev->handler(ev);
     }
 }
-
-
-#if (NGX_THREADS) && !(NGX_WIN32)
-
-void
-ngx_wakeup_worker_thread(ngx_cycle_t *cycle)
-{
-    ngx_int_t     i;
-#if 0
-    ngx_uint_t    busy;
-    ngx_event_t  *ev;
-
-    busy = 1;
-
-    if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
-        return;
-    }
-
-    for (ev = (ngx_event_t *) ngx_posted_events; ev; ev = ev->next) {
-        if (*(ev->lock) == 0) {
-            busy = 0;
-            break;
-        }
-    }
-
-    ngx_mutex_unlock(ngx_posted_events_mutex);
-
-    if (busy) {
-        return;
-    }
-#endif
-
-    for (i = 0; i < ngx_threads_n; i++) {
-        if (ngx_threads[i].state == NGX_THREAD_FREE) {
-            ngx_cond_signal(ngx_threads[i].cv);
-            return;
-        }
-    }
-}
-
-
-ngx_int_t
-ngx_event_thread_process_posted(ngx_cycle_t *cycle)
-{
-    ngx_event_t  *ev;
-
-    for ( ;; ) {
-
-        ev = (ngx_event_t *) ngx_posted_events;
-
-        for ( ;; ) {
-
-            ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
-                          "posted event %p", ev);
-
-            if (ev == NULL) {
-                return NGX_OK;
-            }
-
-            if (ngx_trylock(ev->lock) == 0) {
-
-                ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
-                               "posted event %p is busy", ev);
-
-                ev = ev->next;
-                continue;
-            }
-
-            if (ev->lock != ev->own_lock) {
-                if (*(ev->own_lock)) {
-                    ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
-                             "the own lock of the posted event %p is busy", ev);
-                    ngx_unlock(ev->lock);
-                    ev = ev->next;
-                    continue;
-                }
-                *(ev->own_lock) = 1;
-            }
-
-            ngx_delete_posted_event(ev);
-
-            ev->locked = 1;
-
-            ev->ready |= ev->posted_ready;
-            ev->timedout |= ev->posted_timedout;
-            ev->pending_eof |= ev->posted_eof;
-#if (NGX_HAVE_KQUEUE)
-            ev->kq_errno |= ev->posted_errno;
-#endif
-            if (ev->posted_available) {
-                ev->available = ev->posted_available;
-            }
-
-            ev->posted_ready = 0;
-            ev->posted_timedout = 0;
-            ev->posted_eof = 0;
-#if (NGX_HAVE_KQUEUE)
-            ev->posted_errno = 0;
-#endif
-            ev->posted_available = 0;
-
-            ngx_mutex_unlock(ngx_posted_events_mutex);
-
-            ev->handler(ev);
-
-            ngx_mutex_lock(ngx_posted_events_mutex);
-
-            if (ev->locked) {
-                ngx_unlock(ev->lock);
-
-                if (ev->lock != ev->own_lock) {
-                    ngx_unlock(ev->own_lock);
-                }
-            }
-
-            ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
-                           "posted event %p is done", ev);
-
-            break;
-        }
-    }
-}
-
-#else
-
-void
-ngx_wakeup_worker_thread(ngx_cycle_t *cycle)
-{
-}
-
-#endif

data/vendor/nginx/src/event/ngx_event_posted.h

@@ -14,62 +14,35 @@
 #include <ngx_event.h>
 
 
-#if (NGX_THREADS)
-extern ngx_mutex_t  *ngx_posted_events_mutex;
-#endif
-
-
-#define ngx_locked_post_event(ev, queue)                                      \
+#define ngx_post_event(ev, q)                                                 \
                                                                               \
-    if (ev->prev == NULL) {                                                   \
-        ev->next = (ngx_event_t *) *queue;                                    \
-        ev->prev = (ngx_event_t **) queue;                                    \
-        *queue = ev;                                                          \
+    if (!(ev)->posted) {                                                      \
+        (ev)->posted = 1;                                                     \
+        ngx_queue_insert_tail(q, &(ev)->queue);                               \
                                                                               \
-        if (ev->next) {                                                       \
-            ev->next->prev = &ev->next;                                       \
-        }                                                                     \
-                                                                              \
-        ngx_log_debug1(NGX_LOG_DEBUG_CORE, ev->log, 0, "post event %p", ev);  \
+        ngx_log_debug1(NGX_LOG_DEBUG_CORE, (ev)->log, 0, "post event %p", ev);\
                                                                               \
     } else  {                                                                 \
-        ngx_log_debug1(NGX_LOG_DEBUG_CORE, ev->log, 0,                        \
+        ngx_log_debug1(NGX_LOG_DEBUG_CORE, (ev)->log, 0,                      \
                        "update posted event %p", ev);                         \
     }
 
 
-#define ngx_post_event(ev, queue)                                             \
-                                                                              \
-    ngx_mutex_lock(ngx_posted_events_mutex);                                  \
-    ngx_locked_post_event(ev, queue);                                         \
-    ngx_mutex_unlock(ngx_posted_events_mutex);
-
-
 #define ngx_delete_posted_event(ev)                                           \
                                                                               \
-    *(ev->prev) = ev->next;                                                   \
+    (ev)->posted = 0;                                                         \
+    ngx_queue_remove(&(ev)->queue);                                           \
                                                                               \
-    if (ev->next) {                                                           \
-        ev->next->prev = ev->prev;                                            \
-    }                                                                         \
-                                                                              \
-    ev->prev = NULL;                                                          \
-    ngx_log_debug1(NGX_LOG_DEBUG_CORE, ev->log, 0,                            \
+    ngx_log_debug1(NGX_LOG_DEBUG_CORE, (ev)->log, 0,                          \
                    "delete posted event %p", ev);
 
 
 
-void ngx_event_process_posted(ngx_cycle_t *cycle,
-    ngx_thread_volatile ngx_event_t **posted);
-void ngx_wakeup_worker_thread(ngx_cycle_t *cycle);
-
-#if (NGX_THREADS)
-ngx_int_t ngx_event_thread_process_posted(ngx_cycle_t *cycle);
-#endif
+void ngx_event_process_posted(ngx_cycle_t *cycle, ngx_queue_t *posted);
 
 
-extern ngx_thread_volatile ngx_event_t  *ngx_posted_accept_events;
-extern ngx_thread_volatile ngx_event_t  *ngx_posted_events;
+extern ngx_queue_t  ngx_posted_accept_events;
+extern ngx_queue_t  ngx_posted_events;
 
 
 #endif /* _NGX_EVENT_POSTED_H_INCLUDED_ */