|
0
|
1
|
|
|
2 /*
|
|
|
3 * Copyright (C) Igor Sysoev
|
|
|
4 */
|
|
|
5
|
|
|
6
|
|
|
7 #include <ngx_config.h>
|
|
|
8 #include <ngx_core.h>
|
|
|
9
|
|
|
10
|
|
112
|
11 ssize_t
|
|
|
12 ngx_parse_size(ngx_str_t *line)
|
|
0
|
13 {
|
|
372
|
14 u_char unit;
|
|
0
|
15 size_t len;
|
|
112
|
16 ssize_t size;
|
|
|
17 ngx_int_t scale;
|
|
0
|
18
|
|
|
19 len = line->len;
|
|
372
|
20 unit = line->data[len - 1];
|
|
0
|
21
|
|
372
|
22 switch (unit) {
|
|
0
|
23 case 'K':
|
|
|
24 case 'k':
|
|
|
25 len--;
|
|
|
26 scale = 1024;
|
|
|
27 break;
|
|
|
28
|
|
|
29 case 'M':
|
|
|
30 case 'm':
|
|
|
31 len--;
|
|
|
32 scale = 1024 * 1024;
|
|
|
33 break;
|
|
|
34
|
|
|
35 default:
|
|
|
36 scale = 1;
|
|
|
37 }
|
|
|
38
|
|
112
|
39 size = ngx_atosz(line->data, len);
|
|
0
|
40 if (size == NGX_ERROR) {
|
|
|
41 return NGX_ERROR;
|
|
|
42 }
|
|
|
43
|
|
|
44 size *= scale;
|
|
|
45
|
|
|
46 return size;
|
|
|
47 }
|
|
|
48
|
|
|
49
|
|
212
|
50 off_t
|
|
|
51 ngx_parse_offset(ngx_str_t *line)
|
|
|
52 {
|
|
372
|
53 u_char unit;
|
|
212
|
54 off_t offset;
|
|
|
55 size_t len;
|
|
|
56 ngx_int_t scale;
|
|
|
57
|
|
|
58 len = line->len;
|
|
372
|
59 unit = line->data[len - 1];
|
|
212
|
60
|
|
372
|
61 switch (unit) {
|
|
212
|
62 case 'K':
|
|
|
63 case 'k':
|
|
|
64 len--;
|
|
|
65 scale = 1024;
|
|
|
66 break;
|
|
|
67
|
|
|
68 case 'M':
|
|
|
69 case 'm':
|
|
|
70 len--;
|
|
|
71 scale = 1024 * 1024;
|
|
|
72 break;
|
|
|
73
|
|
|
74 case 'G':
|
|
|
75 case 'g':
|
|
|
76 len--;
|
|
|
77 scale = 1024 * 1024 * 1024;
|
|
|
78 break;
|
|
|
79
|
|
|
80 default:
|
|
|
81 scale = 1;
|
|
|
82 }
|
|
|
83
|
|
|
84 offset = ngx_atoof(line->data, len);
|
|
|
85 if (offset == NGX_ERROR) {
|
|
|
86 return NGX_ERROR;
|
|
|
87 }
|
|
|
88
|
|
|
89 offset *= scale;
|
|
|
90
|
|
|
91 return offset;
|
|
|
92 }
|
|
|
93
|
|
|
94
|
|
112
|
95 ngx_int_t
|
|
644
|
96 ngx_parse_time(ngx_str_t *line, ngx_uint_t is_sec)
|
|
0
|
97 {
|
|
372
|
98 u_char *p, *last;
|
|
200
|
99 ngx_int_t value, total, scale;
|
|
372
|
100 ngx_uint_t max, valid;
|
|
0
|
101 enum {
|
|
|
102 st_start = 0,
|
|
|
103 st_year,
|
|
|
104 st_month,
|
|
|
105 st_week,
|
|
|
106 st_day,
|
|
|
107 st_hour,
|
|
|
108 st_min,
|
|
|
109 st_sec,
|
|
|
110 st_msec,
|
|
|
111 st_last
|
|
|
112 } step;
|
|
|
113
|
|
372
|
114 valid = 0;
|
|
|
115 value = 0;
|
|
0
|
116 total = 0;
|
|
644
|
117 step = is_sec ? st_start : st_month;
|
|
|
118 scale = is_sec ? 1 : 1000;
|
|
0
|
119
|
|
372
|
120 p = line->data;
|
|
|
121 last = p + line->len;
|
|
0
|
122
|
|
372
|
123 while (p < last) {
|
|
0
|
124
|
|
372
|
125 if (*p >= '0' && *p <= '9') {
|
|
|
126 value = value * 10 + (*p++ - '0');
|
|
|
127 valid = 1;
|
|
|
128 continue;
|
|
0
|
129 }
|
|
|
130
|
|
372
|
131 switch (*p++) {
|
|
0
|
132
|
|
|
133 case 'y':
|
|
|
134 if (step > st_start) {
|
|
|
135 return NGX_ERROR;
|
|
|
136 }
|
|
|
137 step = st_year;
|
|
644
|
138 max = NGX_MAX_INT32_VALUE / (60 * 60 * 24 * 365);
|
|
0
|
139 scale = 60 * 60 * 24 * 365;
|
|
|
140 break;
|
|
|
141
|
|
|
142 case 'M':
|
|
644
|
143 if (step >= st_month) {
|
|
0
|
144 return NGX_ERROR;
|
|
|
145 }
|
|
|
146 step = st_month;
|
|
644
|
147 max = NGX_MAX_INT32_VALUE / (60 * 60 * 24 * 30);
|
|
0
|
148 scale = 60 * 60 * 24 * 30;
|
|
|
149 break;
|
|
|
150
|
|
|
151 case 'w':
|
|
644
|
152 if (step >= st_week) {
|
|
0
|
153 return NGX_ERROR;
|
|
|
154 }
|
|
|
155 step = st_week;
|
|
644
|
156 max = NGX_MAX_INT32_VALUE / (60 * 60 * 24 * 7);
|
|
0
|
157 scale = 60 * 60 * 24 * 7;
|
|
|
158 break;
|
|
|
159
|
|
|
160 case 'd':
|
|
644
|
161 if (step >= st_day) {
|
|
0
|
162 return NGX_ERROR;
|
|
|
163 }
|
|
|
164 step = st_day;
|
|
644
|
165 max = NGX_MAX_INT32_VALUE / (60 * 60 * 24);
|
|
0
|
166 scale = 60 * 60 * 24;
|
|
|
167 break;
|
|
|
168
|
|
|
169 case 'h':
|
|
644
|
170 if (step >= st_hour) {
|
|
0
|
171 return NGX_ERROR;
|
|
|
172 }
|
|
|
173 step = st_hour;
|
|
644
|
174 max = NGX_MAX_INT32_VALUE / (60 * 60);
|
|
0
|
175 scale = 60 * 60;
|
|
|
176 break;
|
|
|
177
|
|
|
178 case 'm':
|
|
372
|
179 if (*p == 's') {
|
|
644
|
180 if (is_sec || step >= st_msec) {
|
|
372
|
181 return NGX_ERROR;
|
|
|
182 }
|
|
|
183 p++;
|
|
|
184 step = st_msec;
|
|
644
|
185 max = NGX_MAX_INT32_VALUE;
|
|
372
|
186 scale = 1;
|
|
|
187 break;
|
|
|
188 }
|
|
|
189
|
|
644
|
190 if (step >= st_min) {
|
|
0
|
191 return NGX_ERROR;
|
|
|
192 }
|
|
|
193 step = st_min;
|
|
644
|
194 max = NGX_MAX_INT32_VALUE / 60;
|
|
0
|
195 scale = 60;
|
|
|
196 break;
|
|
|
197
|
|
|
198 case 's':
|
|
644
|
199 if (step >= st_sec) {
|
|
0
|
200 return NGX_ERROR;
|
|
|
201 }
|
|
|
202 step = st_sec;
|
|
644
|
203 max = NGX_MAX_INT32_VALUE;
|
|
0
|
204 scale = 1;
|
|
|
205 break;
|
|
|
206
|
|
372
|
207 case ' ':
|
|
644
|
208 if (step >= st_sec) {
|
|
372
|
209 return NGX_ERROR;
|
|
|
210 }
|
|
0
|
211 step = st_last;
|
|
644
|
212 max = NGX_MAX_INT32_VALUE;
|
|
0
|
213 scale = 1;
|
|
372
|
214 break;
|
|
0
|
215
|
|
372
|
216 default:
|
|
0
|
217 return NGX_ERROR;
|
|
|
218 }
|
|
|
219
|
|
644
|
220 if (step != st_msec && !is_sec) {
|
|
0
|
221 scale *= 1000;
|
|
|
222 max /= 1000;
|
|
|
223 }
|
|
|
224
|
|
372
|
225 if ((ngx_uint_t) value > max) {
|
|
|
226 return NGX_ERROR;
|
|
0
|
227 }
|
|
|
228
|
|
|
229 total += value * scale;
|
|
|
230
|
|
644
|
231 if ((ngx_uint_t) total > NGX_MAX_INT32_VALUE) {
|
|
372
|
232 return NGX_ERROR;
|
|
0
|
233 }
|
|
|
234
|
|
372
|
235 value = 0;
|
|
644
|
236 scale = is_sec ? 1 : 1000;
|
|
372
|
237
|
|
|
238 while (p < last && *p == ' ') {
|
|
|
239 p++;
|
|
0
|
240 }
|
|
|
241 }
|
|
|
242
|
|
372
|
243 if (valid) {
|
|
|
244 return total + value * scale;
|
|
|
245 }
|
|
|
246
|
|
|
247 return NGX_ERROR;
|
|
0
|
248 }
|
