One Level Up Top Level

src/core/ngx_parse.c - nginx-1.7.10

Functions defined

Source code


  2. /*
  3. * Copyright (C) Igor Sysoev
  4. * Copyright (C) Nginx, Inc.
  5. */


  8. #include <ngx_config.h>
  9. #include <ngx_core.h>


  12. ssize_t
  13. ‌ngx_parse_size(ngx_str_t *line)
  14. {
  15.     u_char     unit;
  16.     size_t     len;
  17.     ssize_t    size;
  18.     ngx_int_t  scale;

  20.     len = line->len;
  21.     unit = line->data[len - 1];

  23.     switch (unit) {
  24.     case 'K':
  25.     case 'k':
  26.         len--;
  27.         scale = 1024;
  28.         break;

  30.     case 'M':
  31.     case 'm':
  32.         len--;
  33.         scale = 1024 * 1024;
  34.         break;

  36.     default:
  37.         scale = 1;
  38.     }

  40.     size = ngx_atosz(line->data, len);
  41.     if (size == NGX_ERROR) {
  42.         return NGX_ERROR;
  43.     }

  45.     size *= scale;

  47.     return size;
  48. }


  51. off_t
  52. ‌ngx_parse_offset(ngx_str_t *line)
  53. {
  54.     u_char     unit;
  55.     off_t      offset;
  56.     size_t     len;
  57.     ngx_int_t  scale;

  59.     len = line->len;
  60.     unit = line->data[len - 1];

  62.     switch (unit) {
  63.     case 'K':
  64.     case 'k':
  65.         len--;
  66.         scale = 1024;
  67.         break;

  69.     case 'M':
  70.     case 'm':
  71.         len--;
  72.         scale = 1024 * 1024;
  73.         break;

  75.     case 'G':
  76.     case 'g':
  77.         len--;
  78.         scale = 1024 * 1024 * 1024;
  79.         break;

  81.     default:
  82.         scale = 1;
  83.     }

  85.     offset = ngx_atoof(line->data, len);
  86.     if (offset == NGX_ERROR) {
  87.         return NGX_ERROR;
  88.     }

  90.     offset *= scale;

  92.     return offset;
  93. }


  96. ngx_int_t
  97. ‌ngx_parse_time(ngx_str_t *line, ngx_uint_t is_sec)
  98. {
  99.     u_char      *p, *last;
  100.     ngx_int_t    value, total, scale;
  101.     ngx_uint_t   max, valid;
  102.     enum {
  103.         st_start = 0,
  104.         st_year,
  105.         st_month,
  106.         st_week,
  107.         st_day,
  108.         st_hour,
  109.         st_min,
  110.         st_sec,
  111.         st_msec,
  112.         st_last
  113.     } step;

  115.     valid = 0;
  116.     value = 0;
  117.     total = 0;
  118.     step = is_sec ? st_start : st_month;
  119.     scale = is_sec ? 1 : 1000;

  121.     p = line->data;
  122.     last = p + line->len;

  124.     while (p < last) {

  126.         if (*p >= '0' && *p <= '9') {
  127.             value = value * 10 + (*p++ - '0');
  128.             valid = 1;
  129.             continue;
  130.         }

  132.         switch (*p++) {

  134.         case 'y':
  135.             if (step > st_start) {
  136.                 return NGX_ERROR;
  137.             }
  138.             step = st_year;
  139.             max = NGX_MAX_INT32_VALUE / (60 * 60 * 24 * 365);
  140.             scale = 60 * 60 * 24 * 365;
  141.             break;

  143.         case 'M':
  144.             if (step >= st_month) {
  145.                 return NGX_ERROR;
  146.             }
  147.             step = st_month;
  148.             max = NGX_MAX_INT32_VALUE / (60 * 60 * 24 * 30);
  149.             scale = 60 * 60 * 24 * 30;
  150.             break;

  152.         case 'w':
  153.             if (step >= st_week) {
  154.                 return NGX_ERROR;
  155.             }
  156.             step = st_week;
  157.             max = NGX_MAX_INT32_VALUE / (60 * 60 * 24 * 7);
  158.             scale = 60 * 60 * 24 * 7;
  159.             break;

  161.         case 'd':
  162.             if (step >= st_day) {
  163.                 return NGX_ERROR;
  164.             }
  165.             step = st_day;
  166.             max = NGX_MAX_INT32_VALUE / (60 * 60 * 24);
  167.             scale = 60 * 60 * 24;
  168.             break;

  170.         case 'h':
  171.             if (step >= st_hour) {
  172.                 return NGX_ERROR;
  173.             }
  174.             step = st_hour;
  175.             max = NGX_MAX_INT32_VALUE / (60 * 60);
  176.             scale = 60 * 60;
  177.             break;

  179.         case 'm':
  180.             if (*p == 's') {
  181.                 if (is_sec || step >= st_msec) {
  182.                     return NGX_ERROR;
  183.                 }
  184.                 p++;
  185.                 step = st_msec;
  186.                 max = NGX_MAX_INT32_VALUE;
  187.                 scale = 1;
  188.                 break;
  189.             }

  191.             if (step >= st_min) {
  192.                 return NGX_ERROR;
  193.             }
  194.             step = st_min;
  195.             max = NGX_MAX_INT32_VALUE / 60;
  196.             scale = 60;
  197.             break;

  199.         case 's':
  200.             if (step >= st_sec) {
  201.                 return NGX_ERROR;
  202.             }
  203.             step = st_sec;
  204.             max = NGX_MAX_INT32_VALUE;
  205.             scale = 1;
  206.             break;

  208.         case ' ':
  209.             if (step >= st_sec) {
  210.                 return NGX_ERROR;
  211.             }
  212.             step = st_last;
  213.             max = NGX_MAX_INT32_VALUE;
  214.             scale = 1;
  215.             break;

  217.         default:
  218.             return NGX_ERROR;
  219.         }

  221.         if (step != st_msec && !is_sec) {
  222.             scale *= 1000;
  223.             max /= 1000;
  224.         }

  226.         if ((ngx_uint_t) value > max) {
  227.             return NGX_ERROR;
  228.         }

  230.         total += value * scale;

  232.         if ((ngx_uint_t) total > NGX_MAX_INT32_VALUE) {
  233.             return NGX_ERROR;
  234.         }

  236.         value = 0;
  237.         scale = is_sec ? 1 : 1000;

  239.         while (p < last && *p == ' ') {
  240.             p++;
  241.         }
  242.     }

  244.     if (valid) {
  245.         return total + value * scale;
  246.     }

  248.     return NGX_ERROR;
  249. }

One Level Up Top Level