Mercurial > hg > nginx

comparison src/http/ngx_http_parse.c @ 7:b5481d6fbbd4

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
nginx-0.0.1-2002-08-29-20:59:54 import
author Igor Sysoev <igor@sysoev.ru>
date Thu, 29 Aug 2002 16:59:54 +0000
parents d220029ac7f3
children 6f58641241bb
comparison
equal deleted inserted replaced
6:669801705ab1 7:b5481d6fbbd4
1 1
2 #include <ngx_config.h> 2 #include <ngx_config.h>
3 #include <ngx_core.h>
3 #include <ngx_http.h> 4 #include <ngx_http.h>
4 5
5 int ngx_read_http_request_line(ngx_http_request_t *r) 6 int ngx_read_http_request_line(ngx_http_request_t *r)
6 { 7 {
7 char ch; 8 char ch;
8 char *buff = r->buff->buff; 9 char *p = r->header_in->pos.mem;
9 char *p = r->buff->pos;
10 enum { 10 enum {
11 rl_start = 0, 11 sw_start = 0,
12 rl_space_after_method, 12 sw_space_after_method,
13 rl_spaces_before_uri, 13 sw_spaces_before_uri,
14 rl_after_slash_in_uri, 14 sw_after_slash_in_uri,
15 rl_check_uri, 15 sw_check_uri,
16 rl_uri, 16 sw_uri,
17 rl_http_09, 17 sw_http_09,
18 rl_http_version, 18 sw_http_version,
19 rl_first_major_digit, 19 sw_first_major_digit,
20 rl_major_digit, 20 sw_major_digit,
21 rl_first_minor_digit, 21 sw_first_minor_digit,
22 rl_minor_digit, 22 sw_minor_digit,
23 rl_almost_done, 23 sw_almost_done,
24 rl_done 24 sw_done
25 } state = r->state; 25 } state = r->state;
26 26
27 while (p < r->buff->last && state < rl_done) { 27 while (p < r->header_in->last.mem && state < sw_done) {
28 ch = *p++; 28 ch = *p++;
29 29
30 /* 30 /*
31 printf("\nstate: %d, pos: %x, end: %x, char: '%c' buf: %s", 31 printf("\nstate: %d, pos: %x, end: %x, char: '%c' buf: %s",
32 state, p, r->buff->last, ch, p); 32 state, p, r->header_in->last, ch, p);
33 */ 33 */
34 34
35 /* GCC complie it as jump table */ 35 /* GCC compiles switch as jump table */
36 36
37 switch (state) { 37 switch (state) {
38 38
39 /* HTTP methods: GET, HEAD, POST */ 39 /* HTTP methods: GET, HEAD, POST */
40 case rl_start: 40 case sw_start:
41 switch (ch) { 41 switch (ch) {
42 case 'G': 42 case 'G':
43 if (p + 1 >= r->buff->last) 43 if (p + 1 >= r->header_in->last.mem)
44 return 0; 44 return NGX_AGAIN;
45 45
46 if (*p != 'E' || *(p + 1) != 'T') 46 if (*p != 'E' || *(p + 1) != 'T')
47 return NGX_HTTP_INVALID_METHOD; 47 return NGX_HTTP_INVALID_METHOD;
48 48
49 r->method = NGX_HTTP_GET; 49 r->method = NGX_HTTP_GET;
50 p += 2; 50 p += 2;
51 break; 51 break;
52 52
53 case 'H': 53 case 'H':
54 if (p + 2 >= r->buff->last) 54 if (p + 2 >= r->header_in->last.mem)
55 return 0; 55 return NGX_AGAIN;
56 56
57 if (*p != 'E' || *(p + 1) != 'A' || *(p + 2) != 'D') 57 if (*p != 'E' || *(p + 1) != 'A' || *(p + 2) != 'D')
58 return NGX_HTTP_INVALID_METHOD; 58 return NGX_HTTP_INVALID_METHOD;
59 59
60 r->method = NGX_HTTP_HEAD; 60 r->method = NGX_HTTP_HEAD;
61 p += 3; 61 p += 3;
62 break; 62 break;
63 63
64 case 'P': 64 case 'P':
65 if (p + 2 >= r->buff->last) 65 if (p + 2 >= r->header_in->last.mem)
66 return 0; 66 return NGX_AGAIN;
67 67
68 if (*p != 'O' || *(p + 1) != 'S' || *(p + 2) != 'T') 68 if (*p != 'O' || *(p + 1) != 'S' || *(p + 2) != 'T')
69 return NGX_HTTP_INVALID_METHOD; 69 return NGX_HTTP_INVALID_METHOD;
70 70
71 r->method = NGX_HTTP_POST; 71 r->method = NGX_HTTP_POST;
74 74
75 default: 75 default:
76 return NGX_HTTP_INVALID_METHOD; 76 return NGX_HTTP_INVALID_METHOD;
77 } 77 }
78 78
79 state = rl_space_after_method; 79 state = sw_space_after_method;
80 break; 80 break;
81 81
82 /* single space after method */ 82 /* single space after method */
83 case rl_space_after_method: 83 case sw_space_after_method:
84 switch (ch) { 84 switch (ch) {
85 case ' ': 85 case ' ':
86 state = rl_spaces_before_uri; 86 state = sw_spaces_before_uri;
87 break; 87 break;
88 default: 88 default:
89 return NGX_HTTP_INVALID_METHOD; 89 return NGX_HTTP_INVALID_METHOD;
90 } 90 }
91 break; 91 break;
92 92
93 /* space* before URI */ 93 /* space* before URI */
94 case rl_spaces_before_uri: 94 case sw_spaces_before_uri:
95 switch (ch) { 95 switch (ch) {
96 case '/': 96 case '/':
97 r->uri_start = p - 1; 97 r->uri_start = p - 1;
98 state = rl_after_slash_in_uri; 98 state = sw_after_slash_in_uri;
99 break; 99 break;
100 case ' ': 100 case ' ':
101 break; 101 break;
102 default: 102 default:
103 r->unusual_uri = 1; 103 r->unusual_uri = 1;
104 r->uri_start = p - 1; 104 r->uri_start = p - 1;
105 state = rl_uri; 105 state = sw_uri;
106 break; 106 break;
107 } 107 }
108 break; 108 break;
109 109
110 /* check dot after slash */ 110 /* check dot after slash */
111 case rl_after_slash_in_uri: 111 case sw_after_slash_in_uri:
112 switch (ch) { 112 switch (ch) {
113 case CR: 113 case CR:
114 r->uri_end = p - 1; 114 r->uri_end = p - 1;
115 r->http_minor = 9; 115 r->http_minor = 9;
116 state = rl_almost_done; 116 state = sw_almost_done;
117 break; 117 break;
118 case LF: 118 case LF:
119 r->uri_end = p - 1; 119 r->uri_end = p - 1;
120 r->http_minor = 9; 120 r->http_minor = 9;
121 state = rl_done; 121 state = sw_done;
122 break; 122 break;
123 case ' ': 123 case ' ':
124 r->uri_end = p - 1; 124 r->uri_end = p - 1;
125 state = rl_http_09; 125 state = sw_http_09;
126 break; 126 break;
127 case '.': 127 case '.':
128 r->complex_uri = 1; 128 r->complex_uri = 1;
129 state = rl_uri; 129 state = sw_uri;
130 break; 130 break;
131 case '/': 131 case '/':
132 r->complex_uri = 1; 132 r->complex_uri = 1;
133 state = rl_uri; 133 state = sw_uri;
134 break; 134 break;
135 case '?': 135 case '?':
136 r->args_start = p; 136 r->args_start = p;
137 state = rl_uri; 137 state = sw_uri;
138 break; 138 break;
139 default: 139 default:
140 state = rl_check_uri; 140 state = sw_check_uri;
141 break; 141 break;
142 } 142 }
143 break; 143 break;
144 144
145 /* check slash in URI */ 145 /* check slash in URI */
146 case rl_check_uri: 146 case sw_check_uri:
147 switch (ch) { 147 switch (ch) {
148 case CR: 148 case CR:
149 r->uri_end = p - 1; 149 r->uri_end = p - 1;
150 r->http_minor = 9; 150 r->http_minor = 9;
151 state = rl_almost_done; 151 state = sw_almost_done;
152 break; 152 break;
153 case LF: 153 case LF:
154 r->uri_end = p - 1; 154 r->uri_end = p - 1;
155 r->http_minor = 9; 155 r->http_minor = 9;
156 state = rl_done; 156 state = sw_done;
157 break; 157 break;
158 case ' ': 158 case ' ':
159 r->uri_end = p - 1; 159 r->uri_end = p - 1;
160 state = rl_http_09; 160 state = sw_http_09;
161 break; 161 break;
162 case '.': 162 case '.':
163 r->uri_ext = p; 163 r->uri_ext = p;
164 break; 164 break;
165 case '/': 165 case '/':
166 r->uri_ext = NULL; 166 r->uri_ext = NULL;
167 state = rl_after_slash_in_uri; 167 state = sw_after_slash_in_uri;
168 break; 168 break;
169 case '?': 169 case '?':
170 r->args_start = p; 170 r->args_start = p;
171 state = rl_uri; 171 state = sw_uri;
172 break; 172 break;
173 } 173 }
174 break; 174 break;
175 175
176 /* URI */ 176 /* URI */
177 case rl_uri: 177 case sw_uri:
178 switch (ch) { 178 switch (ch) {
179 case CR: 179 case CR:
180 r->uri_end = p - 1; 180 r->uri_end = p - 1;
181 r->http_minor = 9; 181 r->http_minor = 9;
182 state = rl_almost_done; 182 state = sw_almost_done;
183 break; 183 break;
184 case LF: 184 case LF:
185 r->uri_end = p - 1; 185 r->uri_end = p - 1;
186 r->http_minor = 9; 186 r->http_minor = 9;
187 state = rl_done; 187 state = sw_done;
188 break; 188 break;
189 case ' ': 189 case ' ':
190 r->uri_end = p - 1; 190 r->uri_end = p - 1;
191 state = rl_http_09; 191 state = sw_http_09;
192 break; 192 break;
193 } 193 }
194 break; 194 break;
195 195
196 /* space+ after URI */ 196 /* space+ after URI */
197 case rl_http_09: 197 case sw_http_09:
198 switch (ch) { 198 switch (ch) {
199 case ' ': 199 case ' ':
200 break; 200 break;
201 case CR: 201 case CR:
202 r->http_minor = 9; 202 r->http_minor = 9;
203 state = rl_almost_done; 203 state = sw_almost_done;
204 break; 204 break;
205 case LF: 205 case LF:
206 r->http_minor = 9; 206 r->http_minor = 9;
207 state = rl_done; 207 state = sw_done;
208 break; 208 break;
209 case 'H': 209 case 'H':
210 state = rl_http_version; 210 state = sw_http_version;
211 break; 211 break;
212 default: 212 default:
213 return NGX_HTTP_INVALID_REQUEST; 213 return NGX_HTTP_INVALID_REQUEST;
214 } 214 }
215 break; 215 break;
216 216
217 /* TTP/ */ 217 /* TTP/ */
218 case rl_http_version: 218 case sw_http_version:
219 if (p + 2 >= r->buff->last) { 219 if (p + 2 >= r->header_in->last.mem) {
220 r->state = rl_http_version; 220 r->state = sw_http_version;
221 r->buff->pos = p - 1; 221 r->header_in->pos.mem = p - 1;
222 return 0; 222 return NGX_AGAIN;
223 } 223 }
224 224
225 if (ch != 'T' || *p != 'T' || *(p + 1) != 'P' || *(p + 2) != '/') 225 if (ch != 'T' || *p != 'T' || *(p + 1) != 'P' || *(p + 2) != '/')
226 return NGX_HTTP_INVALID_REQUEST; 226 return NGX_HTTP_INVALID_REQUEST;
227 227
228 p += 3; 228 p += 3;
229 state = rl_first_major_digit; 229 state = sw_first_major_digit;
230 break; 230 break;
231 231
232 /* first digit of major HTTP version */ 232 /* first digit of major HTTP version */
233 case rl_first_major_digit: 233 case sw_first_major_digit:
234 if (ch < '1' || ch > '9') 234 if (ch < '1' || ch > '9')
235 return NGX_HTTP_INVALID_REQUEST; 235 return NGX_HTTP_INVALID_REQUEST;
236 236
237 r->http_major = ch - '0'; 237 r->http_major = ch - '0';
238 state = rl_major_digit; 238 state = sw_major_digit;
239 break; 239 break;
240 240
241 /* major HTTP version or dot */ 241 /* major HTTP version or dot */
242 case rl_major_digit: 242 case sw_major_digit:
243 if (ch == '.') { 243 if (ch == '.') {
244 state = rl_first_minor_digit; 244 state = sw_first_minor_digit;
245 break; 245 break;
246 } 246 }
247 247
248 if (ch < '0' || ch > '9') 248 if (ch < '0' || ch > '9')
249 return NGX_HTTP_INVALID_REQUEST; 249 return NGX_HTTP_INVALID_REQUEST;
250 250
251 r->http_major = r->http_major * 10 + ch - '0'; 251 r->http_major = r->http_major * 10 + ch - '0';
252 break; 252 break;
253 253
254 /* first digit of minor HTTP version */ 254 /* first digit of minor HTTP version */
255 case rl_first_minor_digit: 255 case sw_first_minor_digit:
256 if (ch < '0' || ch > '9') 256 if (ch < '0' || ch > '9')
257 return NGX_HTTP_INVALID_REQUEST; 257 return NGX_HTTP_INVALID_REQUEST;
258 258
259 r->http_minor = ch - '0'; 259 r->http_minor = ch - '0';
260 260
261 state = rl_minor_digit; 261 state = sw_minor_digit;
262 break; 262 break;
263 263
264 /* minor HTTP version or end of request line */ 264 /* minor HTTP version or end of request line */
265 case rl_minor_digit: 265 case sw_minor_digit:
266 if (ch == CR) { 266 if (ch == CR) {
267 state = rl_almost_done; 267 state = sw_almost_done;
268 break; 268 break;
269 } 269 }
270 270
271 if (ch == LF) { 271 if (ch == LF) {
272 state = rl_done; 272 state = sw_done;
273 break; 273 break;
274 } 274 }
275 275
276 if (ch < '0' || ch > '9') 276 if (ch < '0' || ch > '9')
277 return NGX_HTTP_INVALID_REQUEST; 277 return NGX_HTTP_INVALID_REQUEST;
278 278
279 r->http_minor = r->http_minor * 10 + ch - '0'; 279 r->http_minor = r->http_minor * 10 + ch - '0';
280 break; 280 break;
281 281
282 /* end of request line */ 282 /* end of request line */
283 case rl_almost_done: 283 case sw_almost_done:
284 switch (ch) { 284 switch (ch) {
285 case LF: 285 case LF:
286 state = rl_done; 286 state = sw_done;
287 break; 287 break;
288 default: 288 default:
289 return NGX_HTTP_INVALID_METHOD; 289 return NGX_HTTP_INVALID_REQUEST;
290 } 290 }
291 break; 291 break;
292 } 292 }
293 } 293 }
294 294
295 r->buff->pos = p; 295 r->header_in->pos.mem = p;
296 296
297 if (state == rl_done) { 297 if (state == sw_done) {
298 r->http_version = r->http_major * 1000 + r->http_minor; 298 r->http_version = r->http_major * 1000 + r->http_minor;
299 r->state = rl_start; 299 r->state = sw_start;
300 return 1; 300 if (r->http_version == 9 && r->method == NGX_HTTP_HEAD)
301 return NGX_HTTP_INVALID_HEAD;
302 else
303 return NGX_OK;
301 } else { 304 } else {
302 r->state = state; 305 r->state = state;
303 return 0; 306 return NGX_AGAIN;
304 } 307 }
305 } 308 }
306 309
307 int ngx_read_http_header_line(ngx_http_request_t *r) 310 int ngx_read_http_header_line(ngx_http_request_t *r)
308 { 311 {
309 char c, ch; 312 char c, ch;
310 char *buff = r->buff->buff; 313 char *p = r->header_in->pos.mem;
311 char *p = r->buff->pos;
312 enum { 314 enum {
313 hl_start = 0, 315 sw_start = 0,
314 hl_name, 316 sw_name,
315 hl_space_before_value, 317 sw_space_before_value,
316 hl_value, 318 sw_value,
317 hl_space_after_value, 319 sw_space_after_value,
318 hl_almost_done, 320 sw_almost_done,
319 header_almost_done, 321 sw_header_almost_done,
320 hl_done, 322 sw_done,
321 header_done 323 sw_header_done
322 } state = r->state; 324 } state = r->state;
323 325
324 while (p < r->buff->last && state < hl_done) { 326 while (p < r->header_in->last.mem && state < sw_done) {
325 ch = *p++; 327 ch = *p++;
326 328
327 /* 329 /*
328 printf("\nstate: %d, pos: %x, end: %x, char: '%c' buf: %s", 330 printf("\nstate: %d, pos: %x, end: %x, char: '%c' buf: %s",
329 state, p, r->buff->last, ch, p); 331 state, p, r->header_in->last.mem, ch, p);
330 */ 332 */
331 333
332 switch (state) { 334 switch (state) {
333 335
334 /* first char */ 336 /* first char */
335 case hl_start: 337 case sw_start:
336 switch (ch) { 338 switch (ch) {
337 case CR: 339 case CR:
338 r->header_end = p - 1; 340 r->header_end = p - 1;
339 state = header_almost_done; 341 state = sw_header_almost_done;
340 break; 342 break;
341 case LF: 343 case LF:
342 r->header_end = p - 1; 344 r->header_end = p - 1;
343 state = header_done; 345 state = sw_header_done;
344 break; 346 break;
345 default: 347 default:
346 state = hl_name; 348 state = sw_name;
347 r->header_name_start = p - 1; 349 r->header_name_start = p - 1;
348 350
349 c = ch | 0x20; 351 c = ch | 0x20;
350 if (c >= 'a' && c <= 'z') 352 if (c >= 'a' && c <= 'z')
351 break; 353 break;
360 362
361 } 363 }
362 break; 364 break;
363 365
364 /* header name */ 366 /* header name */
365 case hl_name: 367 case sw_name:
366 c = ch | 0x20; 368 c = ch | 0x20;
367 if (c >= 'a' && c <= 'z') 369 if (c >= 'a' && c <= 'z')
368 break; 370 break;
369 371
370 if (ch == ':') { 372 if (ch == ':') {
371 r->header_name_end = p - 1; 373 r->header_name_end = p - 1;
372 state = hl_space_before_value; 374 state = sw_space_before_value;
373 break; 375 break;
374 } 376 }
375 377
376 if (ch == '-') 378 if (ch == '-')
377 break; 379 break;
380 break; 382 break;
381 383
382 return NGX_HTTP_INVALID_HEADER; 384 return NGX_HTTP_INVALID_HEADER;
383 385
384 /* space* before header value */ 386 /* space* before header value */
385 case hl_space_before_value: 387 case sw_space_before_value:
386 switch (ch) { 388 switch (ch) {
387 case ' ': 389 case ' ':
388 break; 390 break;
389 case CR: 391 case CR:
390 r->header_start = r->header_end = p - 1; 392 r->header_start = r->header_end = p - 1;
391 state = hl_almost_done; 393 state = sw_almost_done;
392 break; 394 break;
393 case LF: 395 case LF:
394 r->header_start = r->header_end = p - 1; 396 r->header_start = r->header_end = p - 1;
395 state = hl_done; 397 state = sw_done;
396 break; 398 break;
397 default: 399 default:
398 r->header_start = p - 1; 400 r->header_start = p - 1;
399 state = hl_value; 401 state = sw_value;
400 break; 402 break;
401 } 403 }
402 break; 404 break;
403 405
404 /* header value */ 406 /* header value */
405 case hl_value: 407 case sw_value:
406 switch (ch) { 408 switch (ch) {
407 case ' ': 409 case ' ':
408 r->header_end = p - 1; 410 r->header_end = p - 1;
409 state = hl_space_after_value; 411 state = sw_space_after_value;
410 break; 412 break;
411 case CR: 413 case CR:
412 r->header_end = p - 1; 414 r->header_end = p - 1;
413 state = hl_almost_done; 415 state = sw_almost_done;
414 break; 416 break;
415 case LF: 417 case LF:
416 r->header_end = p - 1; 418 r->header_end = p - 1;
417 state = hl_done; 419 state = sw_done;
418 break; 420 break;
419 } 421 }
420 break; 422 break;
421 423
422 /* space* before end of header line */ 424 /* space* before end of header line */
423 case hl_space_after_value: 425 case sw_space_after_value:
424 switch (ch) { 426 switch (ch) {
425 case ' ': 427 case ' ':
426 break; 428 break;
427 case CR: 429 case CR:
428 state = hl_almost_done; 430 state = sw_almost_done;
429 break; 431 break;
430 case LF: 432 case LF:
431 state = hl_done; 433 state = sw_done;
432 break; 434 break;
433 default: 435 default:
434 state = hl_value; 436 state = sw_value;
435 break; 437 break;
436 } 438 }
437 break; 439 break;
438 440
439 /* end of header line */ 441 /* end of header line */
440 case hl_almost_done: 442 case sw_almost_done:
441 switch (ch) { 443 switch (ch) {
442 case LF: 444 case LF:
443 state = hl_done; 445 state = sw_done;
444 break; 446 break;
445 default: 447 default:
446 return NGX_HTTP_INVALID_HEADER; 448 return NGX_HTTP_INVALID_HEADER;
447 } 449 }
448 break; 450 break;
449 451
450 /* end of header */ 452 /* end of header */
451 case header_almost_done: 453 case sw_header_almost_done:
452 switch (ch) { 454 switch (ch) {
453 case LF: 455 case LF:
454 state = header_done; 456 state = sw_header_done;
455 break; 457 break;
456 default: 458 default:
457 return NGX_HTTP_INVALID_HEADER; 459 return NGX_HTTP_INVALID_HEADER;
458 } 460 }
459 break; 461 break;
460 } 462 }
461 } 463 }
462 464
463 r->buff->pos = p; 465 r->header_in->pos.mem = p;
464 466
465 if (state == hl_done) { 467 if (state == sw_done) {
466 r->state = hl_start; 468 r->state = sw_start;
467 return 1; 469 return NGX_OK;
468 } else if (state == header_done) { 470 } else if (state == sw_header_done) {
469 r->state = hl_start; 471 r->state = sw_start;
470 return 2; 472 return NGX_HTTP_HEADER_DONE;
471 } else { 473 } else {
472 r->state = state; 474 r->state = state;
473 return 0; 475 return NGX_AGAIN;
474 } 476 }
475 } 477 }