nginxtra 1.0.15.0

data/src/nginx/src/core/ngx_parse.c

@@ -0,0 +1,249 @@
+
+/*
+ * Copyright (C) Igor Sysoev
+ * Copyright (C) Nginx, Inc.
+ */
+
+
+#include <ngx_config.h>
+#include <ngx_core.h>
+
+
+ssize_t
+ngx_parse_size(ngx_str_t *line)
+{
+    u_char     unit;
+    size_t     len;
+    ssize_t    size;
+    ngx_int_t  scale;
+
+    len = line->len;
+    unit = line->data[len - 1];
+
+    switch (unit) {
+    case 'K':
+    case 'k':
+        len--;
+        scale = 1024;
+        break;
+
+    case 'M':
+    case 'm':
+        len--;
+        scale = 1024 * 1024;
+        break;
+
+    default:
+        scale = 1;
+    }
+
+    size = ngx_atosz(line->data, len);
+    if (size == NGX_ERROR) {
+        return NGX_ERROR;
+    }
+
+    size *= scale;
+
+    return size;
+}
+
+
+off_t
+ngx_parse_offset(ngx_str_t *line)
+{
+    u_char     unit;
+    off_t      offset;
+    size_t     len;
+    ngx_int_t  scale;
+
+    len = line->len;
+    unit = line->data[len - 1];
+
+    switch (unit) {
+    case 'K':
+    case 'k':
+        len--;
+        scale = 1024;
+        break;
+
+    case 'M':
+    case 'm':
+        len--;
+        scale = 1024 * 1024;
+        break;
+
+    case 'G':
+    case 'g':
+        len--;
+        scale = 1024 * 1024 * 1024;
+        break;
+
+    default:
+        scale = 1;
+    }
+
+    offset = ngx_atoof(line->data, len);
+    if (offset == NGX_ERROR) {
+        return NGX_ERROR;
+    }
+
+    offset *= scale;
+
+    return offset;
+}
+
+
+ngx_int_t
+ngx_parse_time(ngx_str_t *line, ngx_uint_t is_sec)
+{
+    u_char      *p, *last;
+    ngx_int_t    value, total, scale;
+    ngx_uint_t   max, valid;
+    enum {
+        st_start = 0,
+        st_year,
+        st_month,
+        st_week,
+        st_day,
+        st_hour,
+        st_min,
+        st_sec,
+        st_msec,
+        st_last
+    } step;
+
+    valid = 0;
+    value = 0;
+    total = 0;
+    step = is_sec ? st_start : st_month;
+    scale = is_sec ? 1 : 1000;
+
+    p = line->data;
+    last = p + line->len;
+
+    while (p < last) {
+
+        if (*p >= '0' && *p <= '9') {
+            value = value * 10 + (*p++ - '0');
+            valid = 1;
+            continue;
+        }
+
+        switch (*p++) {
+
+        case 'y':
+            if (step > st_start) {
+                return NGX_ERROR;
+            }
+            step = st_year;
+            max = NGX_MAX_INT32_VALUE / (60 * 60 * 24 * 365);
+            scale = 60 * 60 * 24 * 365;
+            break;
+
+        case 'M':
+            if (step >= st_month) {
+                return NGX_ERROR;
+            }
+            step = st_month;
+            max = NGX_MAX_INT32_VALUE / (60 * 60 * 24 * 30);
+            scale = 60 * 60 * 24 * 30;
+            break;
+
+        case 'w':
+            if (step >= st_week) {
+                return NGX_ERROR;
+            }
+            step = st_week;
+            max = NGX_MAX_INT32_VALUE / (60 * 60 * 24 * 7);
+            scale = 60 * 60 * 24 * 7;
+            break;
+
+        case 'd':
+            if (step >= st_day) {
+                return NGX_ERROR;
+            }
+            step = st_day;
+            max = NGX_MAX_INT32_VALUE / (60 * 60 * 24);
+            scale = 60 * 60 * 24;
+            break;
+
+        case 'h':
+            if (step >= st_hour) {
+                return NGX_ERROR;
+            }
+            step = st_hour;
+            max = NGX_MAX_INT32_VALUE / (60 * 60);
+            scale = 60 * 60;
+            break;
+
+        case 'm':
+            if (*p == 's') {
+                if (is_sec || step >= st_msec) {
+                    return NGX_ERROR;
+                }
+                p++;
+                step = st_msec;
+                max = NGX_MAX_INT32_VALUE;
+                scale = 1;
+                break;
+            }
+
+            if (step >= st_min) {
+                return NGX_ERROR;
+            }
+            step = st_min;
+            max = NGX_MAX_INT32_VALUE / 60;
+            scale = 60;
+            break;
+
+        case 's':
+            if (step >= st_sec) {
+                return NGX_ERROR;
+            }
+            step = st_sec;
+            max = NGX_MAX_INT32_VALUE;
+            scale = 1;
+            break;
+
+        case ' ':
+            if (step >= st_sec) {
+                return NGX_ERROR;
+            }
+            step = st_last;
+            max = NGX_MAX_INT32_VALUE;
+            scale = 1;
+            break;
+
+        default:
+            return NGX_ERROR;
+        }
+
+        if (step != st_msec && !is_sec) {
+            scale *= 1000;
+            max /= 1000;
+        }
+
+        if ((ngx_uint_t) value > max) {
+            return NGX_ERROR;
+        }
+
+        total += value * scale;
+
+        if ((ngx_uint_t) total > NGX_MAX_INT32_VALUE) {
+            return NGX_ERROR;
+        }
+
+        value = 0;
+        scale = is_sec ? 1 : 1000;
+
+        while (p < last && *p == ' ') {
+            p++;
+        }
+    }
+
+    if (valid) {
+        return total + value * scale;
+    }
+
+    return NGX_ERROR;
+}

data/src/nginx/src/core/ngx_parse.h

@@ -0,0 +1,24 @@
+
+/*
+ * Copyright (C) Igor Sysoev
+ * Copyright (C) Nginx, Inc.
+ */
+
+
+#ifndef _NGX_PARSE_H_INCLUDED_
+#define _NGX_PARSE_H_INCLUDED_
+
+
+#include <ngx_config.h>
+#include <ngx_core.h>
+
+
+#define NGX_PARSE_LARGE_TIME  -2
+
+
+ssize_t ngx_parse_size(ngx_str_t *line);
+off_t ngx_parse_offset(ngx_str_t *line);
+ngx_int_t ngx_parse_time(ngx_str_t *line, ngx_uint_t is_sec);
+
+
+#endif /* _NGX_PARSE_H_INCLUDED_ */

data/src/nginx/src/core/ngx_queue.c

@@ -0,0 +1,80 @@
+
+/*
+ * Copyright (C) Igor Sysoev
+ * Copyright (C) Nginx, Inc.
+ */
+
+
+#include <ngx_config.h>
+#include <ngx_core.h>
+
+
+/*
+ * find the middle queue element if the queue has odd number of elements
+ * or the first element of the queue's second part otherwise
+ */
+
+ngx_queue_t *
+ngx_queue_middle(ngx_queue_t *queue)
+{
+    ngx_queue_t  *middle, *next;
+
+    middle = ngx_queue_head(queue);
+
+    if (middle == ngx_queue_last(queue)) {
+        return middle;
+    }
+
+    next = ngx_queue_head(queue);
+
+    for ( ;; ) {
+        middle = ngx_queue_next(middle);
+
+        next = ngx_queue_next(next);
+
+        if (next == ngx_queue_last(queue)) {
+            return middle;
+        }
+
+        next = ngx_queue_next(next);
+
+        if (next == ngx_queue_last(queue)) {
+            return middle;
+        }
+    }
+}
+
+
+/* the stable insertion sort */
+
+void
+ngx_queue_sort(ngx_queue_t *queue,
+    ngx_int_t (*cmp)(const ngx_queue_t *, const ngx_queue_t *))
+{
+    ngx_queue_t  *q, *prev, *next;
+
+    q = ngx_queue_head(queue);
+
+    if (q == ngx_queue_last(queue)) {
+        return;
+    }
+
+    for (q = ngx_queue_next(q); q != ngx_queue_sentinel(queue); q = next) {
+
+        prev = ngx_queue_prev(q);
+        next = ngx_queue_next(q);
+
+        ngx_queue_remove(q);
+
+        do {
+            if (cmp(prev, q) <= 0) {
+                break;
+            }
+
+            prev = ngx_queue_prev(prev);
+
+        } while (prev != ngx_queue_sentinel(queue));
+
+        ngx_queue_insert_after(prev, q);
+    }
+}

data/src/nginx/src/core/ngx_queue.h

@@ -0,0 +1,112 @@
+
+/*
+ * Copyright (C) Igor Sysoev
+ * Copyright (C) Nginx, Inc.
+ */
+
+
+#include <ngx_config.h>
+#include <ngx_core.h>
+
+
+#ifndef _NGX_QUEUE_H_INCLUDED_
+#define _NGX_QUEUE_H_INCLUDED_
+
+
+typedef struct ngx_queue_s  ngx_queue_t;
+
+struct ngx_queue_s {
+    ngx_queue_t  *prev;
+    ngx_queue_t  *next;
+};
+
+
+#define ngx_queue_init(q)                                                     \
+    (q)->prev = q;                                                            \
+    (q)->next = q
+
+
+#define ngx_queue_empty(h)                                                    \
+    (h == (h)->prev)
+
+
+#define ngx_queue_insert_head(h, x)                                           \
+    (x)->next = (h)->next;                                                    \
+    (x)->next->prev = x;                                                      \
+    (x)->prev = h;                                                            \
+    (h)->next = x
+
+
+#define ngx_queue_insert_after   ngx_queue_insert_head
+
+
+#define ngx_queue_insert_tail(h, x)                                           \
+    (x)->prev = (h)->prev;                                                    \
+    (x)->prev->next = x;                                                      \
+    (x)->next = h;                                                            \
+    (h)->prev = x
+
+
+#define ngx_queue_head(h)                                                     \
+    (h)->next
+
+
+#define ngx_queue_last(h)                                                     \
+    (h)->prev
+
+
+#define ngx_queue_sentinel(h)                                                 \
+    (h)
+
+
+#define ngx_queue_next(q)                                                     \
+    (q)->next
+
+
+#define ngx_queue_prev(q)                                                     \
+    (q)->prev
+
+
+#if (NGX_DEBUG)
+
+#define ngx_queue_remove(x)                                                   \
+    (x)->next->prev = (x)->prev;                                              \
+    (x)->prev->next = (x)->next;                                              \
+    (x)->prev = NULL;                                                         \
+    (x)->next = NULL
+
+#else
+
+#define ngx_queue_remove(x)                                                   \
+    (x)->next->prev = (x)->prev;                                              \
+    (x)->prev->next = (x)->next
+
+#endif
+
+
+#define ngx_queue_split(h, q, n)                                              \
+    (n)->prev = (h)->prev;                                                    \
+    (n)->prev->next = n;                                                      \
+    (n)->next = q;                                                            \
+    (h)->prev = (q)->prev;                                                    \
+    (h)->prev->next = h;                                                      \
+    (q)->prev = n;
+
+
+#define ngx_queue_add(h, n)                                                   \
+    (h)->prev->next = (n)->next;                                              \
+    (n)->next->prev = (h)->prev;                                              \
+    (h)->prev = (n)->prev;                                                    \
+    (h)->prev->next = h;
+
+
+#define ngx_queue_data(q, type, link)                                         \
+    (type *) ((u_char *) q - offsetof(type, link))
+
+
+ngx_queue_t *ngx_queue_middle(ngx_queue_t *queue);
+void ngx_queue_sort(ngx_queue_t *queue,
+    ngx_int_t (*cmp)(const ngx_queue_t *, const ngx_queue_t *));
+
+
+#endif /* _NGX_QUEUE_H_INCLUDED_ */