passenger 4.0.59 → 4.0.60

data/packaging/debian/debian_specs/nginx/modules/nginx-development-kit/src/ndk_http.c

@@ -0,0 +1,138 @@
+
+ngx_uint_t
+ndk_http_count_phase_handlers (ngx_http_core_main_conf_t *cmcf)
+{
+    ngx_http_phase_handler_t    *ph;
+    ngx_uint_t                   i;
+    
+    ph = cmcf->phase_engine.handlers;
+    
+    for (i=0; ph[i].checker; i++) /* void */;
+        
+    return  i;        
+}
+
+
+ngx_uint_t
+ndk_http_parse_request_method (ngx_str_t *m)
+{
+    switch (m->len) {
+
+        case 3:
+            
+#if (NGX_HAVE_LITTLE_ENDIAN && NGX_HAVE_NONALIGNED)
+        {
+            u_char    t[4];
+            
+            ngx_memcpy (t, m->data, 3);
+            t[3] = ' ';
+            
+            if (ndk_str3_cmp (t, 'G', 'E', 'T', ' ')) {
+                return  NGX_HTTP_GET;
+            }
+
+            if (ndk_str3_cmp (t, 'P', 'U', 'T', ' ')) {
+                return  NGX_HTTP_PUT;
+            }
+        }
+            
+#else
+
+            if (ndk_str3_cmp (m->data, 'G', 'E', 'T', ' ')) {
+                return  NGX_HTTP_GET;
+            }
+
+            if (ndk_str3_cmp (m->data, 'P', 'U', 'T', ' ')) {
+                return  NGX_HTTP_PUT;
+            }
+
+#endif
+            break;
+
+        case 4:
+            
+            if  (m->data[1] == 'O') {
+
+                if (ndk_str3Ocmp (m->data, 'P', 'O', 'S', 'T')) {
+                    return  NGX_HTTP_POST;
+                }
+
+                if (ndk_str3Ocmp (m->data, 'C', 'O', 'P', 'Y')) {
+                    return  NGX_HTTP_COPY;
+                }
+
+                if (ndk_str3Ocmp (m->data, 'M', 'O', 'V', 'E')) {
+                    return  NGX_HTTP_MOVE;
+                }
+
+                if (ndk_str3Ocmp (m->data, 'L', 'O', 'C', 'K')) {
+                    return  NGX_HTTP_LOCK;
+                }
+
+            } else {
+
+                if (ndk_str4cmp (m->data, 'H', 'E', 'A', 'D')) {
+                    return  NGX_HTTP_HEAD;
+                }
+            }
+
+            break;
+
+        case 5:
+            
+            if (ndk_str5cmp (m->data, 'M', 'K', 'C', 'O', 'L')) {
+                return  NGX_HTTP_MKCOL;
+            }
+
+            if (ndk_str5cmp (m->data, 'P', 'A', 'T', 'C', 'H')) {
+                return  NGX_HTTP_PATCH;
+            }
+
+            if (ndk_str5cmp (m->data, 'T', 'R', 'A', 'C', 'E')) {
+                return  NGX_HTTP_TRACE;
+            }
+
+            break;
+
+        case 6:
+            
+            if (ndk_str6cmp (m->data, 'D', 'E', 'L', 'E', 'T', 'E')) {
+                return  NGX_HTTP_DELETE;
+            }
+
+            if (ndk_str6cmp (m->data, 'U', 'N', 'L', 'O', 'C', 'K')) {
+                return  NGX_HTTP_UNLOCK;
+            }
+
+            break;
+
+        case 7:
+            
+            if (ndk_str7_cmp (m->data, 'O', 'P', 'T', 'I', 'O', 'N', 'S', ' '))
+            {
+                return  NGX_HTTP_OPTIONS;
+            }
+
+            break;
+
+        case 8:
+            
+            if (ndk_str8cmp (m->data, 'P', 'R', 'O', 'P', 'F', 'I', 'N', 'D'))
+            {
+                return  NGX_HTTP_PROPFIND;
+            }
+
+            break;
+
+        case 9:
+            
+            if (ndk_str9cmp (m->data, 'P', 'R', 'O', 'P', 'P', 'A', 'T', 'C', 'H'))
+            {
+                return  NGX_HTTP_PROPPATCH;
+            }
+
+            break;
+    }
+
+    return  0;
+}

data/packaging/debian/debian_specs/nginx/modules/nginx-development-kit/src/ndk_http.h

@@ -0,0 +1,3 @@
+
+ngx_uint_t  ndk_http_count_phase_handlers       (ngx_http_core_main_conf_t *cmcf);
+ngx_uint_t  ndk_http_parse_request_method       (ngx_str_t *m);

data/packaging/debian/debian_specs/nginx/modules/nginx-development-kit/src/ndk_http_headers.h

@@ -0,0 +1,35 @@
+
+
+/* TODO : organize and add */
+/* TODO : check - should it be r->main? */
+
+#define     ndk_http_uri(r)                         (r)->uri
+#define     ndk_http_request_uri(r)                 (r)->unparsed_uri
+
+#define     ndk_http_header_in(r,name)              ((r)->headers_in.name ? &(r)->headers_in.name->value : NULL)
+#define     ndk_http_header_out(r,name)             ((r)->headers_out.name ? &(r)->headers_out.name->value : NULL)
+
+#define     ndk_http_host_header(r)                 ndk_http_header_in (r, host)
+#define     ndk_http_connection_header(r)           ndk_http_header_in (r, connection)
+#define     ndk_http_if_modified_since_header(r)    ndk_http_header_in (r, if_modified_since)
+#define     ndk_http_user_agent_header(r)           ndk_http_header_in (r, user_agent)
+#define     ndk_http_referer_header(r)              ndk_http_header_in (r, referer)
+#define     ndk_http_content_length_header(r)       ndk_http_header_in (r, content_length)
+#define     ndk_http_content_type_header(r)         ndk_http_header_in (r, content_type)
+#define     ndk_http_range_header(r)                ndk_http_header_in (r, range)
+#define     ndk_http_if_range_header(r)             ndk_http_header_in (r, if_range)
+#define     ndk_http_transfer_encoding_header(r)    ndk_http_header_in (r, transfer_encoding)
+#define     ndk_http_expect_header(r)               ndk_http_header_in (r, expect)
+#define     ndk_http_accept_encoding_header(r)      ndk_http_header_in (r, accept_encoding)
+#define     ndk_http_via_header(r)                  ndk_http_header_in (r, via)
+#define     ndk_http_authorization_header(r)        ndk_http_header_in (r, authorization)
+#define     ndk_http_keep_alive_header(r)           ndk_http_header_in (r, keep_alive)
+#define     ndk_http_x_forwarded_for_header(r)      ndk_http_header_in (r, x_forwarded_for)
+#define     ndk_http_x_real_ip_header(r)            ndk_http_header_in (r, x_real_ip)
+#define     ndk_http_accept_header(r)               ndk_http_header_in (r, accept)
+#define     ndk_http_accept_language_header(r)      ndk_http_header_in (r, accept_language)
+#define     ndk_http_depth_header(r)                ndk_http_header_in (r, depth)
+#define     ndk_http_destination_header(r)          ndk_http_header_in (r, destination)
+#define     ndk_http_overwrite_header(r)            ndk_http_header_in (r, overwrite)
+#define     ndk_http_date_header(r)                 ndk_http_header_in (r, date)
+

data/packaging/debian/debian_specs/nginx/modules/nginx-development-kit/src/ndk_log.c

@@ -0,0 +1,3 @@
+
+
+/* TODO : the required functions if the compiler does not have variadic macros */

data/packaging/debian/debian_specs/nginx/modules/nginx-development-kit/src/ndk_log.h

@@ -0,0 +1,165 @@
+
+/* TODO : fix the conf_log macros */
+
+#define NGX_LOG_DEBUG_SCRIPT        NGX_LOG_DEBUG_HTTP      /* TODO : add new section to log/conf directives */
+
+#define ndk_conf_to_log(cf)         ((cf)->log)
+
+#ifndef ndk_request_to_log
+#define ndk_request_to_log(r)       ((r)->connection->log)
+#endif
+
+
+/*********************************/
+
+#if (NGX_HAVE_C99_VARIADIC_MACROS)
+
+#define ndk_log_stderr(log,...)                     ngx_log_error (NGX_LOG_STDERR, log, 0, __VA_ARGS__)
+#define ndk_log_emerg(log,...)                      ngx_log_error (NGX_LOG_EMERG, log, 0, __VA_ARGS__)
+#define ndk_log_alert(log,...)                      ngx_log_error (NGX_LOG_ALERT, log, 0, __VA_ARGS__)
+#define ndk_log_crit(log,...)                       ngx_log_error (NGX_LOG_CRIT, log, 0, __VA_ARGS__)
+#define ndk_log_err(log,...)                        ngx_log_error (NGX_LOG_ERR, log, 0, __VA_ARGS__)
+#define ndk_log_warning(log,...)                    ngx_log_error (NGX_LOG_WARN, log, 0, __VA_ARGS__)
+#define ndk_log_notice(log,...)                     ngx_log_error (NGX_LOG_NOTICE, log, 0, __VA_ARGS__)
+#define ndk_log_info(log,...)                       ngx_log_error (NGX_LOG_INFO, log, 0, __VA_ARGS__)
+
+#define ndk_conf_log_stderr(cf,...)                 ngx_conf_log_error (NGX_LOG_STDERR, cf, 0, __VA_ARGS__)
+#define ndk_conf_log_emerg(cf,...)                  ngx_conf_log_error (NGX_LOG_EMERG, cf, 0, __VA_ARGS__)
+#define ndk_conf_log_alert(cf,...)                  ngx_conf_log_error (NGX_LOG_ALERT, cf, 0, __VA_ARGS__)
+#define ndk_conf_log_crit(cf,...)                   ngx_conf_log_error (NGX_LOG_CRIT, cf, 0, __VA_ARGS__)
+#define ndk_conf_log_err(cf,...)                    ngx_conf_log_error (NGX_LOG_ERR, cf, 0, __VA_ARGS__)
+#define ndk_conf_log_warning(cf,...)                ngx_conf_log_error (NGX_LOG_WARN, cf, 0, __VA_ARGS__)
+#define ndk_conf_log_notice(cf,...)                 ngx_conf_log_error (NGX_LOG_NOTICE, cf, 0, __VA_ARGS__)
+#define ndk_conf_log_info(cf,...)                   ngx_conf_log_error (NGX_LOG_INFO, cf, 0, __VA_ARGS__)
+
+#define ndk_request_log_stderr(r,...)               ndk_log_stderr (ndk_request_to_log(r), __VA_ARGS__)
+#define ndk_request_log_emerg(r,...)                ndk_log_emerg (ndk_request_to_log(r), __VA_ARGS__)
+#define ndk_request_log_alert(r,...)                ndk_log_alert (ndk_request_to_log(r), __VA_ARGS__)
+#define ndk_request_log_crit(r,...)                 ndk_log_crit (ndk_request_to_log(r), __VA_ARGS__)
+#define ndk_request_log_err(r,...)                  ndk_log_err (ndk_request_to_log(r), __VA_ARGS__)
+#define ndk_request_log_warning(r,...)              ndk_log_warning (ndk_request_to_log(r), __VA_ARGS__)
+#define ndk_request_log_notice(r,...)               ndk_log_notice (ndk_request_to_log(r), __VA_ARGS__)
+#define ndk_request_log_info(r,...)                 ndk_log_info (ndk_request_to_log(r), __VA_ARGS__)
+
+
+#if (NGX_DEBUG)
+
+#define ndk_log_debug_core(log,...)                 ngx_log_debug (NGX_LOG_DEBUG_CORE, log, 0, __VA_ARGS__)
+#define ndk_log_debug_alloc(log,...)                ngx_log_debug (NGX_LOG_DEBUG_ALLOC, log, 0, __VA_ARGS__)
+#define ndk_log_debug_mutex(log,...)                ngx_log_debug (NGX_LOG_DEBUG_MUTEX, log, 0, __VA_ARGS__)
+#define ndk_log_debug_event(log,...)                ngx_log_debug (NGX_LOG_DEBUG_EVENT, log, 0, __VA_ARGS__)
+#define ndk_log_debug_http(log,...)                 ngx_log_debug (NGX_LOG_DEBUG_HTTP, log, 0, __VA_ARGS__)
+#define ndk_log_debug_mail(log,...)                 ngx_log_debug (NGX_LOG_DEBUG_MAIL, log, 0, __VA_ARGS__)
+#define ndk_log_debug_mysql(log,...)                ngx_log_debug (NGX_LOG_DEBUG_MYSQL, log, 0, __VA_ARGS__)
+
+#define ndk_conf_log_debug_core(r,...)              ndk_log_debug_core (ndk_conf_to_log(r), __VA_ARGS__)
+#define ndk_conf_log_debug_alloc(r,...)             ndk_log_debug_alloc (ndk_conf_to_log(r), __VA_ARGS__)
+#define ndk_conf_log_debug_mutex(r,...)             ndk_log_debug_mutex (ndk_conf_to_log(r), __VA_ARGS__)
+#define ndk_conf_log_debug_event(r,...)             ndk_log_debug_event (ndk_conf_to_log(r), __VA_ARGS__)
+#define ndk_conf_log_debug_http(r,...)              ndk_log_debug_http (ndk_conf_to_log(r), __VA_ARGS__)
+#define ndk_conf_log_debug_mail(r,...)              ndk_log_debug_mail (ndk_conf_to_log(r), __VA_ARGS__)
+#define ndk_conf_log_debug_mysql(r,...)             ndk_log_debug_mysql (ndk_conf_to_log(r), __VA_ARGS__)
+
+#define ndk_request_log_debug_core(r,...)           ndk_log_debug_core (ndk_request_to_log(r), __VA_ARGS__)
+#define ndk_request_log_debug_alloc(r,...)          ndk_log_debug_alloc (ndk_request_to_log(r), __VA_ARGS__)
+#define ndk_request_log_debug_mutex(r,...)          ndk_log_debug_mutex (ndk_request_to_log(r), __VA_ARGS__)
+#define ndk_request_log_debug_event(r,...)          ndk_log_debug_event (ndk_request_to_log(r), __VA_ARGS__)
+#define ndk_request_log_debug_http(r,...)           ndk_log_debug_http (ndk_request_to_log(r), __VA_ARGS__)
+#define ndk_request_log_debug_mail(r,...)           ndk_log_debug_mail (ndk_request_to_log(r), __VA_ARGS__)
+#define ndk_request_log_debug_mysql(r,...)          ndk_log_debug_mysql (ndk_request_to_log(r), __VA_ARGS__)
+
+#else 
+
+#define ndk_log_debug_core(log,...)
+#define ndk_log_debug_alloc(log,...)
+#define ndk_log_debug_mutex(log,...)
+#define ndk_log_debug_event(log,...)
+#define ndk_log_debug_http(log,...)
+#define ndk_log_debug_mail(log,...)
+#define ndk_log_debug_mysql(log,...)
+
+#define ndk_conf_log_debug_core(r,...)
+#define ndk_conf_log_debug_alloc(r,...)
+#define ndk_conf_log_debug_mutex(r,...)
+#define ndk_conf_log_debug_event(r,...)
+#define ndk_conf_log_debug_http(r,...)
+#define ndk_conf_log_debug_mail(r,...)
+#define ndk_conf_log_debug_mysql(r,...)
+
+#define ndk_request_log_debug_core(r,...)
+#define ndk_request_log_debug_alloc(r,...)
+#define ndk_request_log_debug_mutex(r,...)
+#define ndk_request_log_debug_event(r,...)
+#define ndk_request_log_debug_http(r,...)
+#define ndk_request_log_debug_mail(r,...)
+#define ndk_request_log_debug_mysql(r,...)
+
+#endif
+
+
+/*********************************/
+
+#elif (NGX_HAVE_GCC_VARIADIC_MACROS)
+
+#define ndk_log_stderr(log,args...)                 ngx_log_error (NGX_LOG_STDERR, log, 0, args)
+#define ndk_log_emerg(log,args...)                  ngx_log_error (NGX_LOG_EMERG, log, 0, args)
+#define ndk_log_alert(log,args...)                  ngx_log_error (NGX_LOG_ALERT, log, 0, args)
+#define ndk_log_crit(log,args...)                   ngx_log_error (NGX_LOG_CRIT, log, 0, args)
+#define ndk_log_err(log,args...)                    ngx_log_error (NGX_LOG_ERR, log, 0, args)
+#define ndk_log_warning(log,args...)                ngx_log_error (NGX_LOG_WARN, log, 0, args)
+#define ndk_log_notice(log,args...)                 ngx_log_error (NGX_LOG_NOTICE, log, 0, args)
+#define ndk_log_info(log,args...)                   ngx_log_error (NGX_LOG_INFO, log, 0, args)
+
+#define ndk_log_debug_core(log,args...)             ngx_log_debug (NGX_LOG_DEBUG_CORE, log, 0, args)
+#define ndk_log_debug_alloc(log,args...)            ngx_log_debug (NGX_LOG_DEBUG_ALLOC, log, 0, args)
+#define ndk_log_debug_mutex(log,args...)            ngx_log_debug (NGX_LOG_DEBUG_MUTEX, log, 0, args)
+#define ndk_log_debug_event(log,args...)            ngx_log_debug (NGX_LOG_DEBUG_EVENT, log, 0, args)
+#define ndk_log_debug_http(log,args...)             ngx_log_debug (NGX_LOG_DEBUG_HTTP, log, 0, args)
+#define ndk_log_debug_mail(log,args...)             ngx_log_debug (NGX_LOG_DEBUG_MAIL, log, 0, args)
+#define ndk_log_debug_mysql(log,args...)            ngx_log_debug (NGX_LOG_DEBUG_MYSQL, log, 0, args)
+#define ndk_log_debug_script(log,args...)           ngx_log_debug (NGX_LOG_DEBUG_SCRIPT, log, 0, args)
+
+#define ndk_conf_log_stderr(cf,args...)             ngx_conf_log_error (NGX_LOG_STDERR, cf, 0, args)
+#define ndk_conf_log_emerg(cf,args...)              ngx_conf_log_error (NGX_LOG_EMERG, cf, 0, args)
+#define ndk_conf_log_alert(cf,args...)              ngx_conf_log_error (NGX_LOG_ALERT, cf, 0, args)
+#define ndk_conf_log_crit(cf,args...)               ngx_conf_log_error (NGX_LOG_CRIT, cf, 0, args)
+#define ndk_conf_log_err(cf,args...)                ngx_conf_log_error (NGX_LOG_ERR, cf, 0, args)
+#define ndk_conf_log_warning(cf,args...)            ngx_conf_log_error (NGX_LOG_WARN, cf, 0, args)
+#define ndk_conf_log_notice(cf,args...)             ngx_conf_log_error (NGX_LOG_NOTICE, cf, 0, args)
+#define ndk_conf_log_info(cf,args...)               ngx_conf_log_error (NGX_LOG_INFO, cf, 0, args)
+
+#define ndk_conf_log_debug_core(r,args...)          ndk_log_debug_core (ndk_conf_to_log(r), args)
+#define ndk_conf_log_debug_alloc(r,args...)         ndk_log_debug_alloc (ndk_conf_to_log(r), args)
+#define ndk_conf_log_debug_mutex(r,args...)         ndk_log_debug_mutex (ndk_conf_to_log(r), args)
+#define ndk_conf_log_debug_event(r,args...)         ndk_log_debug_event (ndk_conf_to_log(r), args)
+#define ndk_conf_log_debug_http(r,args...)          ndk_log_debug_http (ndk_conf_to_log(r), args)
+#define ndk_conf_log_debug_mail(r,args...)          ndk_log_debug_mail (ndk_conf_to_log(r), args)
+#define ndk_conf_log_debug_mysql(r,args...)         ndk_log_debug_mysql (ndk_conf_to_log(r), args)
+#define ndk_conf_log_debug_script(r,args...)        ndk_log_debug_script (ndk_conf_to_log(r), args)
+
+#define ndk_request_log_stderr(r,args...)           ndk_log_stderr (ndk_request_to_log(r), args)
+#define ndk_request_log_emerg(r,args...)            ndk_log_emerg (ndk_request_to_log(r), args)
+#define ndk_request_log_alert(r,args...)            ndk_log_alert (ndk_request_to_log(r), args)
+#define ndk_request_log_crit(r,args...)             ndk_log_crit (ndk_request_to_log(r), args)
+#define ndk_request_log_err(r,args...)              ndk_log_err (ndk_request_to_log(r), args)
+#define ndk_request_log_warning(r,args...)          ndk_log_warning (ndk_request_to_log(r), args)
+#define ndk_request_log_notice(r,args...)           ndk_log_notice (ndk_request_to_log(r), args)
+#define ndk_request_log_info(r,args...)             ndk_log_info (ndk_request_to_log(r), args)
+
+#define ndk_request_log_debug_core(r,args...)       ndk_log_debug_core (ndk_request_to_log(r), args)
+#define ndk_request_log_debug_alloc(r,args...)      ndk_log_debug_alloc (ndk_request_to_log(r), args)
+#define ndk_request_log_debug_mutex(r,args...)      ndk_log_debug_mutex (ndk_request_to_log(r), args)
+#define ndk_request_log_debug_event(r,args...)      ndk_log_debug_event (ndk_request_to_log(r), args)
+#define ndk_request_log_debug_http(r,args...)       ndk_log_debug_http (ndk_request_to_log(r), args)
+#define ndk_request_log_debug_mail(r,args...)       ndk_log_debug_mail (ndk_request_to_log(r), args)
+#define ndk_request_log_debug_mysql(r,args...)      ndk_log_debug_mysql (ndk_request_to_log(r), args)
+#define ndk_request_log_debug_script(r,args...)     ndk_log_debug_script (ndk_request_to_log(r), args)
+
+/*********************************/
+
+#else /* NO VARIADIC MACROS */
+
+/* #warning does not work on Windows */
+#pragma message("Nginx Devel Kit logging without variadic macros not yet implemented")
+
+#endif /* VARIADIC MACROS */

data/packaging/debian/debian_specs/nginx/modules/nginx-development-kit/src/ndk_parse.h

@@ -0,0 +1,67 @@
+
+
+
+#if (NGX_HAVE_LITTLE_ENDIAN && NGX_HAVE_NONALIGNED)
+
+#define ndk_str3_cmp(m, c0, c1, c2, c3)                                       \
+    *(uint32_t *) m == ((c3 << 24) | (c2 << 16) | (c1 << 8) | c0)
+
+#define ndk_str3Ocmp(m, c0, c1, c2, c3)                                       \
+    *(uint32_t *) m == ((c3 << 24) | (c2 << 16) | (c1 << 8) | c0)
+
+#define ndk_str4cmp(m, c0, c1, c2, c3)                                        \
+    *(uint32_t *) m == ((c3 << 24) | (c2 << 16) | (c1 << 8) | c0)
+
+#define ndk_str5cmp(m, c0, c1, c2, c3, c4)                                    \
+    *(uint32_t *) m == ((c3 << 24) | (c2 << 16) | (c1 << 8) | c0)             \
+        && m[4] == c4
+
+#define ndk_str6cmp(m, c0, c1, c2, c3, c4, c5)                                \
+    *(uint32_t *) m == ((c3 << 24) | (c2 << 16) | (c1 << 8) | c0)             \
+        && (((uint32_t *) m)[1] & 0xffff) == ((c5 << 8) | c4)
+
+#define ndk_str7_cmp(m, c0, c1, c2, c3, c4, c5, c6, c7)                       \
+    *(uint32_t *) m == ((c3 << 24) | (c2 << 16) | (c1 << 8) | c0)             \
+        && ((uint32_t *) m)[1] == ((c7 << 24) | (c6 << 16) | (c5 << 8) | c4)
+
+#define ndk_str8cmp(m, c0, c1, c2, c3, c4, c5, c6, c7)                        \
+    *(uint32_t *) m == ((c3 << 24) | (c2 << 16) | (c1 << 8) | c0)             \
+        && ((uint32_t *) m)[1] == ((c7 << 24) | (c6 << 16) | (c5 << 8) | c4)
+
+#define ndk_str9cmp(m, c0, c1, c2, c3, c4, c5, c6, c7, c8)                    \
+    *(uint32_t *) m == ((c3 << 24) | (c2 << 16) | (c1 << 8) | c0)             \
+        && ((uint32_t *) m)[1] == ((c7 << 24) | (c6 << 16) | (c5 << 8) | c4)  \
+        && m[8] == c8
+
+#else /* !(NGX_HAVE_LITTLE_ENDIAN && NGX_HAVE_NONALIGNED) */
+
+#define ndk_str3_cmp(m, c0, c1, c2, c3)                                       \
+    m[0] == c0 && m[1] == c1 && m[2] == c2
+
+#define ndk_str3Ocmp(m, c0, c1, c2, c3)                                       \
+    m[0] == c0 && m[2] == c2 && m[3] == c3
+
+#define ndk_str4cmp(m, c0, c1, c2, c3)                                        \
+    m[0] == c0 && m[1] == c1 && m[2] == c2 && m[3] == c3
+
+#define ndk_str5cmp(m, c0, c1, c2, c3, c4)                                    \
+    m[0] == c0 && m[1] == c1 && m[2] == c2 && m[3] == c3 && m[4] == c4
+
+#define ndk_str6cmp(m, c0, c1, c2, c3, c4, c5)                                \
+    m[0] == c0 && m[1] == c1 && m[2] == c2 && m[3] == c3                      \
+        && m[4] == c4 && m[5] == c5
+
+#define ndk_str7_cmp(m, c0, c1, c2, c3, c4, c5, c6, c7)                       \
+    m[0] == c0 && m[1] == c1 && m[2] == c2 && m[3] == c3                      \
+        && m[4] == c4 && m[5] == c5 && m[6] == c6
+
+#define ndk_str8cmp(m, c0, c1, c2, c3, c4, c5, c6, c7)                        \
+    m[0] == c0 && m[1] == c1 && m[2] == c2 && m[3] == c3                      \
+        && m[4] == c4 && m[5] == c5 && m[6] == c6 && m[7] == c7
+
+#define ndk_str9cmp(m, c0, c1, c2, c3, c4, c5, c6, c7, c8)                    \
+    m[0] == c0 && m[1] == c1 && m[2] == c2 && m[3] == c3                      \
+        && m[4] == c4 && m[5] == c5 && m[6] == c6 && m[7] == c7 && m[8] == c8
+
+#endif
+

data/packaging/debian/debian_specs/nginx/modules/nginx-development-kit/src/ndk_path.c

@@ -0,0 +1,583 @@
+
+
+
+/* This function cleans a path to its most basic form, performing the following transformations :
+ *
+ *  - ./ -> [empty]
+ *  - // -> /
+ *  - /base/parent/../ -> /base/
+ *
+ * If possible, it leaves the original string in place and does not copy characters, otherwise
+ * characters are copied.
+*/
+
+void
+ndk_clean_path (ngx_str_t *path, ngx_uint_t complex, size_t off)
+{
+    u_char         *s, *p, *m, *e, c, *l;
+    ngx_uint_t      root;
+
+    if (path->len == 1) {
+
+        if (path->data[0] == '.') {
+            path->len = 0;
+        }
+
+        return;
+    }
+
+    /* strip initial './' */
+
+    s = path->data;
+    e = s + path->len;
+
+    if (off) {
+        p = s + off;
+        goto check_basic;
+    }
+
+    if (*s == '/')
+        root = 1;
+    else
+        root = 0;
+
+    while (s < e) {
+
+        switch (*s) {
+
+        case    '/' :
+
+            /* '//' => '/' */
+
+            s++;
+            continue;
+
+        case    '.' :
+
+            if (s == e-1) {
+
+                if (root) {
+                    path->data[0] = '/';
+                    path->len = 1;
+                } else {
+                    path->len = 0;
+                }
+
+                return;
+            }
+
+            /* './' => '' */
+
+            if (s[1] == '/') {
+
+                s += 2;
+
+                if (s == e) {
+
+                    path->len = 0;
+                    return;
+                }
+
+                continue;
+            }
+        }
+
+        break;
+    }
+
+    if (root && *s != '/') {
+        s--;
+    }
+
+    p = s;
+
+check_basic :
+
+    for ( ; p<e; p++) {
+
+        if (*p == '/') {
+
+        new_dir_first :
+
+            if (e - p == 1)
+                break;
+
+            switch (p[1]) {
+
+            case    '/' :
+
+                /* '//' => '/' */
+
+                m = p + 2;
+                goto copy;
+
+            case    '.' :
+
+                if (e - p == 2)
+                    break;
+
+                switch (p[2]) {
+
+                case    '/' :
+
+                    /* './' => '' */
+
+                    m = p + 2;
+                    goto copy;
+
+                case    '.' :
+
+                    if (e - p == 3 || p[3] == '/') {
+
+                        if (p == s) {
+
+                            s += 3;
+                            continue;
+                        }
+
+                        if (p - s >= 2) {
+
+                            if (p[-1] == '.' && p[-2] == '.') {
+
+                                if (p - s == 2 || p[-3] == '/') {    /* = '../../' */
+
+                                    p += 2;     /* 3? */
+                                    continue;
+                                }
+                            }
+                        }
+
+                        m = p + 4;
+
+                        if (complex) {
+
+                            for (p--; p >= s; p--) {
+
+                                switch (*p) {
+
+                                case    '/' :
+                                    goto copy;
+
+                                case    '$' :
+
+                                    p = m - 1;
+
+                                    if (m == e)
+                                        goto end_basic;
+
+                                    goto new_dir_first;
+                                }
+                            }
+
+                        } else {
+
+                           for (p--; p > s; p--) {
+
+                                /* '/path/folder/../' => '/path/' */
+
+                                if (*p == '/')
+                                    break;
+                            }
+                        }
+
+                        goto copy;
+                    }
+                }
+            }
+        }
+    }
+
+end_basic :
+
+    path->data = s;
+    path->len = p - s;
+
+    return;
+
+copy :
+
+    p++;
+
+    if (m < e)
+        goto new_dir;
+
+    while (m < e) {       
+
+        c = *m;
+        *p = c;
+        p++;
+
+        if (c == '/') {
+
+            m++;
+
+        new_dir :
+
+            for ( ; m<e; m++) {
+
+                c = *m;
+                if (c != '/')
+                    break;
+            }
+
+            if (m == e)
+                break;
+
+            if (c == '.') {
+
+                if (e - m == 1)
+                    break;
+
+                switch (m[1]) {
+
+                case    '/' :
+
+                    /* './' => '' */
+
+                    m += 2;
+                    if (m == e)
+                        break;
+
+                    goto new_dir;
+
+                case    '.' :
+
+                    if (e - m == 2 || m[2] == '/') {
+
+                        if (m - s >= 3) {   /* NOTE : this is one higher than above because m has moved on 1 */
+
+                            if (p[-2] == '.' && p[-3] == '.') {
+
+                                if (m - s == 3 || p[-4] == '/') {    /* = '../../' */
+
+                                    p[0] = '.';
+                                    p[1] = '.';
+                                    p[2] = '/';
+                                    p += 3;
+                                    m += 3;
+                                    goto new_dir;
+                                }
+                            }
+                        }
+
+                        if (complex) {
+
+                            l = p;
+
+                            for (p -= 2; p >= s; p--) {
+
+                                switch (*p) {
+
+                                case    '/' :
+                                    break;
+
+                                case    '$' :
+
+                                    l[0] = '.';
+                                    l[1] = '.';
+                                    l[2] = '/';
+                                    p = l + 4;
+                                    break;
+
+                                default :
+                                    continue;
+                                }
+
+                                break;
+                            }
+
+                            m += 3;
+                            if (m == e)
+                                goto end;
+
+                            goto new_dir;
+
+                        } else {
+
+                            for (p -= 2; p > s; p--) {
+
+                                /* '/path/folder/../' => '/path/' */
+
+                                if (*p == '/')
+                                    break;
+                            }
+
+                            m += 3;
+                            if (m == e)
+                                goto end;
+
+                            goto new_dir;
+                        }
+                    }
+                }
+            }
+
+        } else {
+            m++;
+        }
+    }
+
+end :
+
+    path->data = s;
+    path->len = p - s;
+}
+
+
+/* This function converts a path to its directory version, and assumes that there is always space
+ * to allocatate an extra character on the end (which is only true if the provided strings always
+ * have NULL's at the end (hence the 'safe').
+*/
+
+void
+ndk_path_to_dir_safe (ngx_str_t *path, ngx_uint_t complex, size_t off)
+{
+    size_t   len;
+    u_char  *p, *m;
+
+    ndk_clean_path (path, complex, off);
+
+    len = path->len;
+    if (!len)
+        return;
+
+    p = path->data;
+    m = p + len - 1;
+
+    if (*m != '/') {
+
+        p [len] = '/';
+        path->len++;
+    }
+}
+
+
+/* Divides a path given by path/to/path1:path/to/path2 into separate strings and returns an
+ * array of these strings.
+*/
+
+ngx_array_t *
+ndk_split_path_create (ngx_conf_t *cf, ngx_str_t *path)
+{
+    ngx_str_t         *str;
+    int                n;
+    u_char            *m, *s, *e;
+    ngx_array_t       *a; 
+
+    if (path == NULL)
+        return  NULL;
+
+    n = ndk_strcntc (path, ':');
+
+    a = ngx_array_create (cf->pool, n + 1, sizeof (ngx_str_t));
+    if (a == NULL) {
+        return  NULL;
+    }
+
+    s = path->data;
+    e = s + path->len;
+
+    while (s < e) {
+
+        m = s;
+
+        while (m < e && *m != ':') m++;
+
+        if (m == s) {
+            s = m+1;
+            continue;
+        }
+
+        str = ngx_array_push (a);
+        if (str == NULL) {
+            return  NULL;
+        }
+
+        str->data = s;
+        str->len = m - s;
+
+        if (ngx_conf_full_name (cf->cycle, str, 0) == NGX_ERROR)
+            return  NULL;
+
+        s = m+1;
+    }
+
+    return  a;
+}
+
+
+
+ngx_array_t *
+ndk_split_path_create_raw (ngx_conf_t *cf, char *path)
+{
+    ngx_str_t         *str;
+    int                n;
+    char              *m, *s;
+    ngx_array_t       *a; 
+
+    if (path == NULL)
+        return  NULL;
+
+    n = ndk_strccnt (path, ':');
+
+    a = ngx_array_create (cf->pool, n + 1, sizeof (ngx_str_t));
+    if (a == NULL) {
+        return  NULL;
+    }
+
+    s = path;
+
+
+    while (*s != '\0') {
+
+        m = s;
+
+        while (*m != '\0' && *m != ':') m++;
+
+        if (m == s) {
+            s = m+1;
+            continue;
+        }
+
+        str = ngx_array_push (a);
+        if (str == NULL) {
+            return  NULL;
+        }
+
+        str->data = (u_char *) s;
+        str->len = m - s;
+
+        if (ngx_conf_full_name (cf->cycle, str, 0) == NGX_ERROR)
+            return  NULL;
+
+        if (*m == '\0')
+            break;
+
+        s = m+1;
+    }
+
+    return  a;
+}
+
+
+
+char *
+ndk_conf_set_full_path_slot (ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
+{
+    char  *p = conf;
+
+    ngx_str_t        *path, *value;
+    ngx_conf_post_t  *post;
+
+    path = (ngx_str_t *) (p + cmd->offset);
+
+    if (path->data) {
+        return "is duplicate";
+    }
+
+    value = cf->args->elts;
+
+    *path = value[1];
+
+    if (ngx_conf_full_name (cf->cycle, path, 0) == NGX_ERROR)
+        return  NGX_CONF_ERROR;
+
+    if (cmd->post) {
+        post = cmd->post;
+        return post->post_handler(cf, post, path);
+    }
+
+    return NGX_CONF_OK;
+}
+
+
+
+char *
+ndk_conf_set_split_path_slot (ngx_conf_t *cf, ngx_command_t *cmd, void *conf)     
+{
+    /* TODO : change to use the path func above */
+
+    char  *p = conf;
+
+    ngx_str_t         *value, *str;
+    ngx_array_t      **a;
+    ngx_conf_post_t   *post;
+    int                n;
+    u_char            *m, *s, *e;
+
+    a = (ngx_array_t **) (p + cmd->offset);
+
+    if (*a != NGX_CONF_UNSET_PTR) {
+        return  "is duplicate";
+    }
+
+    value = cf->args->elts;
+    value++;
+
+    n = ndk_strcntc (value, ':') + 1;
+
+    *a = ngx_array_create (cf->pool, n, sizeof (ngx_str_t));
+    if (*a == NULL) {
+        return  NGX_CONF_ERROR;
+    }
+
+    s = value->data;
+    e = s + value->len;
+
+    while (s < e) {
+
+        m = s;
+
+        while (m < e && *m != ':') m++;
+
+        if (m == s) {
+            s = m+1;
+            continue;
+        }
+
+        str = ngx_array_push (*a);
+        if (str == NULL) {
+            return  NGX_CONF_ERROR;
+        }
+
+        str->data = s;
+        str->len = m - s;
+
+        if (ngx_conf_full_name (cf->cycle, str, 0) == NGX_ERROR)
+            return  NGX_CONF_ERROR;
+
+        s = m+1;
+    }
+
+
+    if (cmd->post) {
+        post = cmd->post;
+        return  post->post_handler (cf, post, a);
+    }
+
+    return  NGX_CONF_OK;
+}
+
+
+
+char *
+ndk_conf_set_full_path (ngx_conf_t *cf, void *data, ngx_str_t *path)
+{
+    if (ngx_conf_full_name (cf->cycle, path, 0) == NGX_ERROR)
+        return  NGX_CONF_ERROR;
+
+    return  NGX_CONF_OK;
+}
+
+
+
+char *
+ndk_conf_set_full_conf_path (ngx_conf_t *cf, void *data, ngx_str_t *path)
+{
+    if (ngx_conf_full_name (cf->cycle, path, 1) == NGX_ERROR)
+        return  NGX_CONF_ERROR;
+
+    return  NGX_CONF_OK;
+}
+
+