|
76
|
1
|
|
|
2 /*
|
|
|
3 * Copyright (C) Igor Sysoev
|
|
|
4 */
|
|
|
5
|
|
|
6
|
|
|
7 #include <ngx_config.h>
|
|
|
8 #include <ngx_core.h>
|
|
|
9 #include <ngx_event.h>
|
|
|
10 #include <ngx_imap.h>
|
|
|
11
|
|
|
12
|
|
|
13 ngx_int_t ngx_imap_parse_command(ngx_imap_session_t *s)
|
|
|
14 {
|
|
|
15 u_char ch, *p, *c;
|
|
|
16 ngx_str_t *arg;
|
|
|
17 enum {
|
|
|
18 sw_start = 0,
|
|
|
19 sw_spaces_before_command,
|
|
|
20 sw_command,
|
|
|
21 sw_spaces_before_argument,
|
|
|
22 sw_argument,
|
|
92
|
23 sw_backslash,
|
|
76
|
24 sw_literal,
|
|
92
|
25 sw_no_sync_literal_argument,
|
|
76
|
26 sw_start_literal_argument,
|
|
|
27 sw_literal_argument,
|
|
|
28 sw_end_literal_argument,
|
|
|
29 sw_almost_done
|
|
|
30 } state;
|
|
|
31
|
|
|
32 state = s->state;
|
|
|
33
|
|
|
34 for (p = s->buffer->pos; p < s->buffer->last; p++) {
|
|
|
35 ch = *p;
|
|
|
36
|
|
|
37 switch (state) {
|
|
|
38
|
|
|
39 /* IMAP tag */
|
|
|
40 case sw_start:
|
|
|
41 switch (ch) {
|
|
|
42 case ' ':
|
|
|
43 s->tag.len = p - s->buffer->start + 1;
|
|
|
44 s->tag.data = s->buffer->start;
|
|
|
45 state = sw_spaces_before_command;
|
|
|
46 break;
|
|
|
47 case CR:
|
|
|
48 s->state = sw_start;
|
|
|
49 return NGX_IMAP_PARSE_INVALID_COMMAND;
|
|
|
50 case LF:
|
|
|
51 s->state = sw_start;
|
|
|
52 return NGX_IMAP_PARSE_INVALID_COMMAND;
|
|
|
53 }
|
|
|
54 break;
|
|
|
55
|
|
|
56 case sw_spaces_before_command:
|
|
|
57 switch (ch) {
|
|
|
58 case ' ':
|
|
|
59 break;
|
|
|
60 case CR:
|
|
|
61 s->state = sw_start;
|
|
|
62 return NGX_IMAP_PARSE_INVALID_COMMAND;
|
|
|
63 case LF:
|
|
|
64 s->state = sw_start;
|
|
|
65 return NGX_IMAP_PARSE_INVALID_COMMAND;
|
|
|
66 default:
|
|
|
67 s->cmd_start = p;
|
|
|
68 state = sw_command;
|
|
|
69 break;
|
|
|
70 }
|
|
|
71 break;
|
|
|
72
|
|
|
73 case sw_command:
|
|
|
74 if (ch == ' ' || ch == CR || ch == LF) {
|
|
|
75
|
|
|
76 c = s->cmd_start;
|
|
|
77
|
|
|
78 switch (p - c) {
|
|
|
79
|
|
|
80 case 4:
|
|
|
81 if ((c[0] == 'N' || c[0] == 'n')
|
|
|
82 && (c[1] == 'O'|| c[1] == 'o')
|
|
|
83 && (c[2] == 'O'|| c[2] == 'o')
|
|
|
84 && (c[3] == 'P'|| c[3] == 'p'))
|
|
|
85 {
|
|
|
86 s->command = NGX_IMAP_NOOP;
|
|
|
87
|
|
|
88 } else {
|
|
|
89 goto invalid;
|
|
|
90 }
|
|
|
91 break;
|
|
|
92
|
|
|
93 case 5:
|
|
|
94 if ((c[0] == 'L'|| c[0] == 'l')
|
|
|
95 && (c[1] == 'O'|| c[1] == 'o')
|
|
|
96 && (c[2] == 'G'|| c[2] == 'g')
|
|
|
97 && (c[3] == 'I'|| c[3] == 'i')
|
|
|
98 && (c[4] == 'N'|| c[4] == 'n'))
|
|
|
99 {
|
|
|
100 s->command = NGX_IMAP_LOGIN;
|
|
|
101
|
|
|
102 } else {
|
|
|
103 goto invalid;
|
|
|
104 }
|
|
|
105 break;
|
|
|
106
|
|
|
107 case 6:
|
|
|
108 if ((c[0] == 'L'|| c[0] == 'l')
|
|
|
109 && (c[1] == 'O'|| c[1] == 'o')
|
|
|
110 && (c[2] == 'G'|| c[2] == 'g')
|
|
|
111 && (c[3] == 'O'|| c[3] == 'o')
|
|
|
112 && (c[4] == 'U'|| c[4] == 'u')
|
|
|
113 && (c[5] == 'T'|| c[5] == 't'))
|
|
|
114 {
|
|
|
115 s->command = NGX_IMAP_LOGOUT;
|
|
|
116
|
|
|
117 } else {
|
|
|
118 goto invalid;
|
|
|
119 }
|
|
|
120 break;
|
|
|
121
|
|
132
|
122 #if (NGX_IMAP_SSL)
|
|
|
123 case 8:
|
|
|
124 if ((c[0] == 'S'|| c[0] == 's')
|
|
|
125 && (c[1] == 'T'|| c[1] == 't')
|
|
|
126 && (c[2] == 'A'|| c[2] == 'a')
|
|
|
127 && (c[3] == 'R'|| c[3] == 'r')
|
|
|
128 && (c[4] == 'T'|| c[4] == 't')
|
|
|
129 && (c[5] == 'T'|| c[5] == 't')
|
|
|
130 && (c[6] == 'L'|| c[6] == 'l')
|
|
|
131 && (c[7] == 'S'|| c[7] == 's'))
|
|
|
132 {
|
|
|
133 s->command = NGX_IMAP_STARTTLS;
|
|
|
134
|
|
|
135 } else {
|
|
|
136 goto invalid;
|
|
|
137 }
|
|
|
138 break;
|
|
|
139 #endif
|
|
|
140
|
|
76
|
141 case 10:
|
|
|
142 if ((c[0] == 'C'|| c[0] == 'c')
|
|
|
143 && (c[1] == 'A'|| c[1] == 'a')
|
|
|
144 && (c[2] == 'P'|| c[2] == 'p')
|
|
|
145 && (c[3] == 'A'|| c[3] == 'a')
|
|
|
146 && (c[4] == 'B'|| c[4] == 'b')
|
|
|
147 && (c[5] == 'I'|| c[5] == 'i')
|
|
|
148 && (c[6] == 'L'|| c[6] == 'l')
|
|
|
149 && (c[7] == 'I'|| c[7] == 'i')
|
|
|
150 && (c[8] == 'T'|| c[8] == 't')
|
|
|
151 && (c[9] == 'Y'|| c[9] == 'y'))
|
|
|
152 {
|
|
|
153 s->command = NGX_IMAP_CAPABILITY;
|
|
|
154
|
|
|
155 } else {
|
|
|
156 goto invalid;
|
|
|
157 }
|
|
|
158 break;
|
|
|
159
|
|
|
160 default:
|
|
|
161 goto invalid;
|
|
|
162 }
|
|
|
163
|
|
|
164 switch (ch) {
|
|
|
165 case ' ':
|
|
|
166 state = sw_spaces_before_argument;
|
|
|
167 break;
|
|
|
168 case CR:
|
|
|
169 state = sw_almost_done;
|
|
|
170 break;
|
|
|
171 case LF:
|
|
|
172 goto done;
|
|
|
173 }
|
|
|
174 break;
|
|
|
175 }
|
|
|
176
|
|
|
177 if ((ch < 'A' || ch > 'Z') && (ch < 'a' || ch > 'z')) {
|
|
|
178 goto invalid;
|
|
|
179 }
|
|
|
180
|
|
|
181 break;
|
|
|
182
|
|
|
183 case sw_spaces_before_argument:
|
|
|
184 switch (ch) {
|
|
|
185 case ' ':
|
|
|
186 break;
|
|
|
187 case CR:
|
|
|
188 state = sw_almost_done;
|
|
|
189 s->arg_end = p;
|
|
|
190 break;
|
|
|
191 case LF:
|
|
|
192 s->arg_end = p;
|
|
|
193 goto done;
|
|
|
194 case '"':
|
|
|
195 if (s->args.nelts <= 2) {
|
|
|
196 s->quoted = 1;
|
|
|
197 s->arg_start = p + 1;
|
|
|
198 state = sw_argument;
|
|
|
199 break;
|
|
|
200 }
|
|
|
201 goto invalid;
|
|
|
202 case '{':
|
|
|
203 if (s->args.nelts <= 2) {
|
|
|
204 state = sw_literal;
|
|
|
205 break;
|
|
|
206 }
|
|
|
207 goto invalid;
|
|
|
208 default:
|
|
|
209 if (s->args.nelts <= 2) {
|
|
|
210 s->arg_start = p;
|
|
|
211 state = sw_argument;
|
|
|
212 break;
|
|
|
213 }
|
|
|
214 goto invalid;
|
|
|
215 }
|
|
|
216 break;
|
|
|
217
|
|
|
218 case sw_argument:
|
|
|
219 switch (ch) {
|
|
|
220 case '"':
|
|
|
221 if (!s->quoted) {
|
|
|
222 break;
|
|
|
223 }
|
|
|
224 s->quoted = 0;
|
|
|
225 /* fall through */
|
|
|
226 case ' ':
|
|
|
227 case CR:
|
|
|
228 case LF:
|
|
|
229 arg = ngx_array_push(&s->args);
|
|
|
230 if (arg == NULL) {
|
|
|
231 return NGX_ERROR;
|
|
|
232 }
|
|
|
233 arg->len = p - s->arg_start;
|
|
|
234 arg->data = s->arg_start;
|
|
|
235 s->arg_start = NULL;
|
|
|
236
|
|
|
237 switch (ch) {
|
|
|
238 case '"':
|
|
|
239 case ' ':
|
|
|
240 state = sw_spaces_before_argument;
|
|
|
241 break;
|
|
|
242 case CR:
|
|
|
243 state = sw_almost_done;
|
|
|
244 break;
|
|
|
245 case LF:
|
|
|
246 goto done;
|
|
|
247 }
|
|
|
248 break;
|
|
92
|
249 case '\\':
|
|
|
250 if (s->quoted) {
|
|
|
251 s->backslash = 1;
|
|
|
252 state = sw_backslash;
|
|
|
253 }
|
|
|
254 break;
|
|
|
255 }
|
|
|
256 break;
|
|
|
257
|
|
|
258 case sw_backslash:
|
|
|
259 switch (ch) {
|
|
|
260 case CR:
|
|
|
261 case LF:
|
|
|
262 goto invalid;
|
|
|
263 default:
|
|
|
264 state = sw_argument;
|
|
76
|
265 }
|
|
|
266 break;
|
|
|
267
|
|
|
268 case sw_literal:
|
|
|
269 if (ch >= '0' && ch <= '9') {
|
|
|
270 s->literal_len = s->literal_len * 10 + (ch - '0');
|
|
|
271 break;
|
|
|
272 }
|
|
|
273 if (ch == '}') {
|
|
|
274 state = sw_start_literal_argument;
|
|
|
275 break;
|
|
|
276 }
|
|
92
|
277 if (ch == '+') {
|
|
|
278 state = sw_no_sync_literal_argument;
|
|
|
279 break;
|
|
|
280 }
|
|
|
281 goto invalid;
|
|
|
282
|
|
|
283 case sw_no_sync_literal_argument:
|
|
|
284 if (ch == '}') {
|
|
|
285 s->no_sync_literal = 1;
|
|
|
286 state = sw_start_literal_argument;
|
|
|
287 break;
|
|
|
288 }
|
|
76
|
289 goto invalid;
|
|
|
290
|
|
|
291 case sw_start_literal_argument:
|
|
|
292 switch (ch) {
|
|
|
293 case CR:
|
|
|
294 break;
|
|
|
295 case LF:
|
|
|
296 s->buffer->pos = p + 1;
|
|
|
297 s->arg_start = p + 1;
|
|
92
|
298 if (s->no_sync_literal == 0) {
|
|
|
299 s->state = sw_literal_argument;
|
|
|
300 return NGX_IMAP_NEXT;
|
|
|
301 }
|
|
|
302 state = sw_literal_argument;
|
|
|
303 s->no_sync_literal = 0;
|
|
|
304 break;
|
|
|
305 default:
|
|
|
306 goto invalid;
|
|
76
|
307 }
|
|
92
|
308 break;
|
|
76
|
309
|
|
|
310 case sw_literal_argument:
|
|
78
|
311 if (s->literal_len && --s->literal_len) {
|
|
76
|
312 break;
|
|
|
313 }
|
|
|
314
|
|
|
315 arg = ngx_array_push(&s->args);
|
|
|
316 if (arg == NULL) {
|
|
|
317 return NGX_ERROR;
|
|
|
318 }
|
|
|
319 arg->len = p + 1 - s->arg_start;
|
|
|
320 arg->data = s->arg_start;
|
|
|
321 s->arg_start = NULL;
|
|
|
322 state = sw_end_literal_argument;
|
|
|
323
|
|
|
324 break;
|
|
|
325
|
|
|
326 case sw_end_literal_argument:
|
|
|
327 switch (ch) {
|
|
|
328 case '{':
|
|
|
329 if (s->args.nelts <= 2) {
|
|
|
330 state = sw_literal;
|
|
|
331 break;
|
|
|
332 }
|
|
|
333 goto invalid;
|
|
|
334 case CR:
|
|
|
335 state = sw_almost_done;
|
|
|
336 break;
|
|
|
337 case LF:
|
|
|
338 goto done;
|
|
|
339 default:
|
|
78
|
340 state = sw_spaces_before_argument;
|
|
|
341 break;
|
|
76
|
342 }
|
|
|
343 break;
|
|
|
344
|
|
|
345 case sw_almost_done:
|
|
|
346 switch (ch) {
|
|
|
347 case LF:
|
|
|
348 goto done;
|
|
|
349 default:
|
|
|
350 goto invalid;
|
|
|
351 }
|
|
|
352 }
|
|
|
353 }
|
|
|
354
|
|
|
355 s->buffer->pos = p;
|
|
|
356 s->state = state;
|
|
|
357
|
|
|
358 return NGX_AGAIN;
|
|
|
359
|
|
|
360 done:
|
|
|
361
|
|
|
362 s->buffer->pos = p + 1;
|
|
|
363
|
|
|
364 if (s->arg_start) {
|
|
|
365 arg = ngx_array_push(&s->args);
|
|
|
366 if (arg == NULL) {
|
|
|
367 return NGX_ERROR;
|
|
|
368 }
|
|
|
369 arg->len = s->arg_end - s->arg_start;
|
|
|
370 arg->data = s->arg_start;
|
|
92
|
371
|
|
76
|
372 s->arg_start = NULL;
|
|
|
373 s->cmd_start = NULL;
|
|
|
374 s->quoted = 0;
|
|
92
|
375 s->no_sync_literal = 0;
|
|
76
|
376 s->literal_len = 0;
|
|
|
377 }
|
|
|
378
|
|
|
379 s->state = sw_start;
|
|
|
380
|
|
|
381 return NGX_OK;
|
|
|
382
|
|
|
383 invalid:
|
|
|
384
|
|
|
385 s->state = sw_start;
|
|
|
386 s->quoted = 0;
|
|
92
|
387 s->no_sync_literal = 0;
|
|
76
|
388 s->literal_len = 0;
|
|
|
389
|
|
|
390 return NGX_IMAP_PARSE_INVALID_COMMAND;
|
|
|
391 }
|
|
|
392
|
|
|
393
|
|
|
394 ngx_int_t ngx_pop3_parse_command(ngx_imap_session_t *s)
|
|
|
395 {
|
|
|
396 u_char ch, *p, *c, c0, c1, c2, c3;
|
|
|
397 ngx_str_t *arg;
|
|
|
398 enum {
|
|
|
399 sw_start = 0,
|
|
|
400 sw_spaces_before_argument,
|
|
|
401 sw_argument,
|
|
|
402 sw_almost_done
|
|
|
403 } state;
|
|
|
404
|
|
|
405 state = s->state;
|
|
|
406
|
|
|
407 for (p = s->buffer->pos; p < s->buffer->last; p++) {
|
|
|
408 ch = *p;
|
|
|
409
|
|
|
410 switch (state) {
|
|
|
411
|
|
|
412 /* POP3 command */
|
|
|
413 case sw_start:
|
|
|
414 if (ch == ' ' || ch == CR || ch == LF) {
|
|
|
415 c = s->buffer->start;
|
|
|
416
|
|
|
417 if (p - c == 4) {
|
|
|
418
|
|
|
419 c0 = ngx_toupper(c[0]);
|
|
|
420 c1 = ngx_toupper(c[1]);
|
|
|
421 c2 = ngx_toupper(c[2]);
|
|
|
422 c3 = ngx_toupper(c[3]);
|
|
|
423
|
|
|
424 if (c0 == 'U' && c1 == 'S' && c2 == 'E' && c3 == 'R')
|
|
|
425 {
|
|
|
426 s->command = NGX_POP3_USER;
|
|
|
427
|
|
|
428 } else if (c0 == 'P' && c1 == 'A' && c2 == 'S' && c3 == 'S')
|
|
|
429 {
|
|
|
430 s->command = NGX_POP3_PASS;
|
|
|
431
|
|
|
432 } else if (c0 == 'Q' && c1 == 'U' && c2 == 'I' && c3 == 'T')
|
|
|
433 {
|
|
|
434 s->command = NGX_POP3_QUIT;
|
|
|
435
|
|
|
436 } else if (c0 == 'C' && c1 == 'A' && c2 == 'P' && c3 == 'A')
|
|
|
437 {
|
|
|
438 s->command = NGX_POP3_CAPA;
|
|
|
439
|
|
|
440 } else if (c0 == 'N' && c1 == 'O' && c2 == 'O' && c3 == 'P')
|
|
|
441 {
|
|
|
442 s->command = NGX_POP3_NOOP;
|
|
132
|
443 #if (NGX_IMAP_SSL)
|
|
|
444 } else if (c0 == 'S' && c1 == 'T' && c2 == 'L' && c3 == 'S')
|
|
|
445 {
|
|
|
446 s->command = NGX_POP3_STLS;
|
|
|
447 #endif
|
|
76
|
448 } else {
|
|
|
449 goto invalid;
|
|
|
450 }
|
|
|
451
|
|
|
452 } else {
|
|
|
453 goto invalid;
|
|
|
454 }
|
|
|
455
|
|
|
456 switch (ch) {
|
|
|
457 case ' ':
|
|
|
458 state = sw_spaces_before_argument;
|
|
|
459 break;
|
|
|
460 case CR:
|
|
|
461 state = sw_almost_done;
|
|
|
462 break;
|
|
|
463 case LF:
|
|
|
464 goto done;
|
|
|
465 }
|
|
|
466 break;
|
|
|
467 }
|
|
|
468
|
|
|
469 if ((ch < 'A' || ch > 'Z') && (ch < 'a' || ch > 'z')) {
|
|
|
470 goto invalid;
|
|
|
471 }
|
|
|
472
|
|
|
473 break;
|
|
|
474
|
|
|
475 case sw_spaces_before_argument:
|
|
|
476 switch (ch) {
|
|
|
477 case ' ':
|
|
|
478 break;
|
|
|
479 case CR:
|
|
|
480 state = sw_almost_done;
|
|
|
481 s->arg_end = p;
|
|
|
482 break;
|
|
|
483 case LF:
|
|
|
484 s->arg_end = p;
|
|
|
485 goto done;
|
|
|
486 default:
|
|
|
487 if (s->args.nelts <= 2) {
|
|
|
488 state = sw_argument;
|
|
|
489 s->arg_start = p;
|
|
|
490 break;
|
|
|
491 }
|
|
|
492 goto invalid;
|
|
|
493 }
|
|
|
494 break;
|
|
|
495
|
|
|
496 case sw_argument:
|
|
|
497 switch (ch) {
|
|
92
|
498
|
|
126
|
499 /*
|
|
92
|
500 * the space should be considered part of the at username
|
|
|
501 * or password, but not of argument in other commands
|
|
|
502 *
|
|
|
503 * case ' ':
|
|
|
504 */
|
|
|
505
|
|
76
|
506 case CR:
|
|
|
507 case LF:
|
|
|
508 arg = ngx_array_push(&s->args);
|
|
|
509 if (arg == NULL) {
|
|
|
510 return NGX_ERROR;
|
|
|
511 }
|
|
|
512 arg->len = p - s->arg_start;
|
|
|
513 arg->data = s->arg_start;
|
|
|
514 s->arg_start = NULL;
|
|
|
515
|
|
|
516 switch (ch) {
|
|
|
517 case ' ':
|
|
|
518 state = sw_spaces_before_argument;
|
|
|
519 break;
|
|
|
520 case CR:
|
|
|
521 state = sw_almost_done;
|
|
|
522 break;
|
|
|
523 case LF:
|
|
|
524 goto done;
|
|
|
525 }
|
|
|
526 break;
|
|
|
527
|
|
|
528 default:
|
|
|
529 break;
|
|
|
530 }
|
|
|
531 break;
|
|
|
532
|
|
|
533 case sw_almost_done:
|
|
|
534 switch (ch) {
|
|
|
535 case LF:
|
|
|
536 goto done;
|
|
|
537 default:
|
|
|
538 goto invalid;
|
|
|
539 }
|
|
|
540 }
|
|
|
541 }
|
|
|
542
|
|
|
543 s->buffer->pos = p;
|
|
|
544 s->state = state;
|
|
|
545
|
|
|
546 return NGX_AGAIN;
|
|
|
547
|
|
|
548 done:
|
|
|
549
|
|
|
550 s->buffer->pos = p + 1;
|
|
|
551
|
|
|
552 if (s->arg_start) {
|
|
|
553 arg = ngx_array_push(&s->args);
|
|
|
554 if (arg == NULL) {
|
|
|
555 return NGX_ERROR;
|
|
|
556 }
|
|
|
557 arg->len = s->arg_end - s->arg_start;
|
|
|
558 arg->data = s->arg_start;
|
|
|
559 s->arg_start = NULL;
|
|
|
560 }
|
|
|
561
|
|
|
562 s->state = sw_start;
|
|
|
563
|
|
|
564 return NGX_OK;
|
|
|
565
|
|
|
566 invalid:
|
|
|
567
|
|
|
568 s->state = sw_start;
|
|
|
569
|
|
|
570 return NGX_IMAP_PARSE_INVALID_COMMAND;
|
|
|
571 }
|
