One Level Up Top Level

src/mail/ngx_mail_parse.c - nginx

Data types defined

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>
  10. #include <ngx_event.h>
  11. #include <ngx_mail.h>
  12. #include <ngx_mail_pop3_module.h>
  13. #include <ngx_mail_imap_module.h>
  14. #include <ngx_mail_smtp_module.h>


  17. ngx_int_t
  18. ‌ngx_mail_pop3_parse_command(ngx_mail_session_t *s)
  19. {
  20.     u_char      ch, *p, *c, c0, c1, c2, c3;
  21.     ngx_str_t  *arg;
  22. ‌    enum {
  23.         sw_start = 0,
  24.         sw_command,
  25.         sw_invalid,
  26.         sw_spaces_before_argument,
  27.         sw_argument,
  28.         sw_almost_done
  29.     } state;

  31.     state = s->state;

  33.     for (p = s->buffer->pos; p < s->buffer->last; p++) {
  34.         ch = *p;

  36.         switch (state) {

  38.         /* POP3 command */
  39.         case sw_start:
  40.             s->cmd_start = p;
  41.             state = sw_command;

  43.             /* fall through */

  45.         case sw_command:
  46.             if (ch == ' ' || ch == CR || ch == LF) {
  47.                 c = s->cmd_start;

  49.                 if (p - c == 4) {

  51.                     c0 = ngx_toupper(c[0]);
  52.                     c1 = ngx_toupper(c[1]);
  53.                     c2 = ngx_toupper(c[2]);
  54.                     c3 = ngx_toupper(c[3]);

  56.                     if (c0 == 'U' && c1 == 'S' && c2 == 'E' && c3 == 'R')
  57.                     {
  58.                         s->command = NGX_POP3_USER;

  60.                     } else if (c0 == 'P' && c1 == 'A' && c2 == 'S' && c3 == 'S')
  61.                     {
  62.                         s->command = NGX_POP3_PASS;

  64.                     } else if (c0 == 'A' && c1 == 'P' && c2 == 'O' && c3 == 'P')
  65.                     {
  66.                         s->command = NGX_POP3_APOP;

  68.                     } else if (c0 == 'Q' && c1 == 'U' && c2 == 'I' && c3 == 'T')
  69.                     {
  70.                         s->command = NGX_POP3_QUIT;

  72.                     } else if (c0 == 'C' && c1 == 'A' && c2 == 'P' && c3 == 'A')
  73.                     {
  74.                         s->command = NGX_POP3_CAPA;

  76.                     } else if (c0 == 'A' && c1 == 'U' && c2 == 'T' && c3 == 'H')
  77.                     {
  78.                         s->command = NGX_POP3_AUTH;

  80.                     } else if (c0 == 'N' && c1 == 'O' && c2 == 'O' && c3 == 'P')
  81.                     {
  82.                         s->command = NGX_POP3_NOOP;
  83. #if (NGX_MAIL_SSL)
  84.                     } else if (c0 == 'S' && c1 == 'T' && c2 == 'L' && c3 == 'S')
  85.                     {
  86.                         s->command = NGX_POP3_STLS;
  87. #endif
  88.                     } else {
  89.                         goto invalid;
  90.                     }

  92.                 } else {
  93.                     goto invalid;
  94.                 }

  96.                 s->cmd.data = s->cmd_start;
  97.                 s->cmd.len = p - s->cmd_start;

  99.                 switch (ch) {
  100.                 case ' ':
  101.                     state = sw_spaces_before_argument;
  102.                     break;
  103.                 case CR:
  104.                     state = sw_almost_done;
  105.                     break;
  106.                 case LF:
  107.                     goto done;
  108.                 }
  109.                 break;
  110.             }

  112.             if ((ch < 'A' || ch > 'Z') && (ch < 'a' || ch > 'z')) {
  113.                 goto invalid;
  114.             }

  116.             break;

  118.         case sw_invalid:
  119.             goto invalid;

  121.         case sw_spaces_before_argument:
  122.             switch (ch) {
  123.             case ' ':
  124.                 break;
  125.             case CR:
  126.                 state = sw_almost_done;
  127.                 break;
  128.             case LF:
  129.                 goto done;
  130.             default:
  131.                 if (s->args.nelts <= 2) {
  132.                     state = sw_argument;
  133.                     s->arg_start = p;
  134.                     break;
  135.                 }
  136.                 goto invalid;
  137.             }
  138.             break;

  140.         case sw_argument:
  141.             switch (ch) {

  143.             case ' ':

  145.                 /*
  146.                  * the space should be considered as part of the at username
  147.                  * or password, but not of argument in other commands
  148.                  */

  150.                 if (s->command == NGX_POP3_USER
  151.                     || s->command == NGX_POP3_PASS)
  152.                 {
  153.                     break;
  154.                 }

  156.                 /* fall through */

  158.             case CR:
  159.             case LF:
  160.                 arg = ngx_array_push(&s->args);
  161.                 if (arg == NULL) {
  162.                     return NGX_ERROR;
  163.                 }
  164.                 arg->len = p - s->arg_start;
  165.                 arg->data = s->arg_start;
  166.                 s->arg_start = NULL;

  168.                 switch (ch) {
  169.                 case ' ':
  170.                     state = sw_spaces_before_argument;
  171.                     break;
  172.                 case CR:
  173.                     state = sw_almost_done;
  174.                     break;
  175.                 case LF:
  176.                     goto done;
  177.                 }
  178.                 break;

  180.             default:
  181.                 break;
  182.             }
  183.             break;

  185.         case sw_almost_done:
  186.             switch (ch) {
  187.             case LF:
  188.                 goto done;
  189.             default:
  190.                 goto invalid;
  191.             }
  192.         }
  193.     }

  195.     s->buffer->pos = p;
  196.     s->state = state;

  198.     return NGX_AGAIN;

  200. done:

  202.     s->buffer->pos = p + 1;
  203.     s->state = (s->command != NGX_POP3_AUTH) ? sw_start : sw_argument;

  205.     return NGX_OK;

  207. invalid:

  209.     s->state = sw_invalid;

  211.     /* skip invalid command till LF */

  213.     for ( /* void */ ; p < s->buffer->last; p++) {
  214.         if (*p == LF) {
  215.             s->state = sw_start;
  216.             s->buffer->pos = p + 1;
  217.             return NGX_MAIL_PARSE_INVALID_COMMAND;
  218.         }
  219.     }

  221.     s->buffer->pos = p;

  223.     return NGX_AGAIN;
  224. }


  227. ngx_int_t
  228. ‌ngx_mail_imap_parse_command(ngx_mail_session_t *s)
  229. {
  230.     u_char      ch, *p, *c, *dst, *src, *end;
  231.     ngx_str_t  *arg;
  232. ‌    enum {
  233.         sw_start = 0,
  234.         sw_tag,
  235.         sw_invalid,
  236.         sw_spaces_before_command,
  237.         sw_command,
  238.         sw_spaces_before_argument,
  239.         sw_argument,
  240.         sw_backslash,
  241.         sw_literal,
  242.         sw_no_sync_literal_argument,
  243.         sw_start_literal_argument,
  244.         sw_literal_argument,
  245.         sw_end_literal_argument,
  246.         sw_almost_done
  247.     } state;

  249.     state = s->state;

  251.     for (p = s->buffer->pos; p < s->buffer->last; p++) {
  252.         ch = *p;

  254.         switch (state) {

  256.         /* IMAP tag */
  257.         case sw_start:
  258.             s->tag_start = p;
  259.             state = sw_tag;

  261.             /* fall through */

  263.         case sw_tag:
  264.             switch (ch) {
  265.             case ' ':
  266.                 s->tag.len = p - s->tag_start + 1;
  267.                 s->tag.data = s->tag_start;
  268.                 state = sw_spaces_before_command;
  269.                 break;
  270.             case CR:
  271.             case LF:
  272.                 goto invalid;
  273.             default:
  274.                 if ((ch < 'A' || ch > 'Z') && (ch < 'a' || ch > 'z')
  275.                     && (ch < '0' || ch > '9') && ch != '-' && ch != '.'
  276.                     && ch != '_')
  277.                 {
  278.                     goto invalid;
  279.                 }
  280.                 if (p - s->tag_start > 31) {
  281.                     goto invalid;
  282.                 }
  283.                 break;
  284.             }
  285.             break;

  287.         case sw_invalid:
  288.             goto invalid;

  290.         case sw_spaces_before_command:
  291.             switch (ch) {
  292.             case ' ':
  293.                 break;
  294.             case CR:
  295.             case LF:
  296.                 goto invalid;
  297.             default:
  298.                 s->cmd_start = p;
  299.                 state = sw_command;
  300.                 break;
  301.             }
  302.             break;

  304.         case sw_command:
  305.             if (ch == ' ' || ch == CR || ch == LF) {

  307.                 c = s->cmd_start;

  309.                 switch (p - c) {

  311.                 case 4:
  312.                     if ((c[0] == 'N' || c[0] == 'n')
  313.                         && (c[1] == 'O'|| c[1] == 'o')
  314.                         && (c[2] == 'O'|| c[2] == 'o')
  315.                         && (c[3] == 'P'|| c[3] == 'p'))
  316.                     {
  317.                         s->command = NGX_IMAP_NOOP;

  319.                     } else {
  320.                         goto invalid;
  321.                     }
  322.                     break;

  324.                 case 5:
  325.                     if ((c[0] == 'L'|| c[0] == 'l')
  326.                         && (c[1] == 'O'|| c[1] == 'o')
  327.                         && (c[2] == 'G'|| c[2] == 'g')
  328.                         && (c[3] == 'I'|| c[3] == 'i')
  329.                         && (c[4] == 'N'|| c[4] == 'n'))
  330.                     {
  331.                         s->command = NGX_IMAP_LOGIN;

  333.                     } else {
  334.                         goto invalid;
  335.                     }
  336.                     break;

  338.                 case 6:
  339.                     if ((c[0] == 'L'|| c[0] == 'l')
  340.                         && (c[1] == 'O'|| c[1] == 'o')
  341.                         && (c[2] == 'G'|| c[2] == 'g')
  342.                         && (c[3] == 'O'|| c[3] == 'o')
  343.                         && (c[4] == 'U'|| c[4] == 'u')
  344.                         && (c[5] == 'T'|| c[5] == 't'))
  345.                     {
  346.                         s->command = NGX_IMAP_LOGOUT;

  348.                     } else {
  349.                         goto invalid;
  350.                     }
  351.                     break;

  353. #if (NGX_MAIL_SSL)
  354.                 case 8:
  355.                     if ((c[0] == 'S'|| c[0] == 's')
  356.                         && (c[1] == 'T'|| c[1] == 't')
  357.                         && (c[2] == 'A'|| c[2] == 'a')
  358.                         && (c[3] == 'R'|| c[3] == 'r')
  359.                         && (c[4] == 'T'|| c[4] == 't')
  360.                         && (c[5] == 'T'|| c[5] == 't')
  361.                         && (c[6] == 'L'|| c[6] == 'l')
  362.                         && (c[7] == 'S'|| c[7] == 's'))
  363.                     {
  364.                         s->command = NGX_IMAP_STARTTLS;

  366.                     } else {
  367.                         goto invalid;
  368.                     }
  369.                     break;
  370. #endif

  372.                 case 10:
  373.                     if ((c[0] == 'C'|| c[0] == 'c')
  374.                         && (c[1] == 'A'|| c[1] == 'a')
  375.                         && (c[2] == 'P'|| c[2] == 'p')
  376.                         && (c[3] == 'A'|| c[3] == 'a')
  377.                         && (c[4] == 'B'|| c[4] == 'b')
  378.                         && (c[5] == 'I'|| c[5] == 'i')
  379.                         && (c[6] == 'L'|| c[6] == 'l')
  380.                         && (c[7] == 'I'|| c[7] == 'i')
  381.                         && (c[8] == 'T'|| c[8] == 't')
  382.                         && (c[9] == 'Y'|| c[9] == 'y'))
  383.                     {
  384.                         s->command = NGX_IMAP_CAPABILITY;

  386.                     } else {
  387.                         goto invalid;
  388.                     }
  389.                     break;

  391.                 case 12:
  392.                     if ((c[0] == 'A'|| c[0] == 'a')
  393.                         && (c[1] == 'U'|| c[1] == 'u')
  394.                         && (c[2] == 'T'|| c[2] == 't')
  395.                         && (c[3] == 'H'|| c[3] == 'h')
  396.                         && (c[4] == 'E'|| c[4] == 'e')
  397.                         && (c[5] == 'N'|| c[5] == 'n')
  398.                         && (c[6] == 'T'|| c[6] == 't')
  399.                         && (c[7] == 'I'|| c[7] == 'i')
  400.                         && (c[8] == 'C'|| c[8] == 'c')
  401.                         && (c[9] == 'A'|| c[9] == 'a')
  402.                         && (c[10] == 'T'|| c[10] == 't')
  403.                         && (c[11] == 'E'|| c[11] == 'e'))
  404.                     {
  405.                         s->command = NGX_IMAP_AUTHENTICATE;

  407.                     } else {
  408.                         goto invalid;
  409.                     }
  410.                     break;

  412.                 default:
  413.                     goto invalid;
  414.                 }

  416.                 s->cmd.data = s->cmd_start;
  417.                 s->cmd.len = p - s->cmd_start;

  419.                 switch (ch) {
  420.                 case ' ':
  421.                     state = sw_spaces_before_argument;
  422.                     break;
  423.                 case CR:
  424.                     state = sw_almost_done;
  425.                     break;
  426.                 case LF:
  427.                     goto done;
  428.                 }
  429.                 break;
  430.             }

  432.             if ((ch < 'A' || ch > 'Z') && (ch < 'a' || ch > 'z')) {
  433.                 goto invalid;
  434.             }

  436.             break;

  438.         case sw_spaces_before_argument:
  439.             switch (ch) {
  440.             case ' ':
  441.                 break;
  442.             case CR:
  443.                 state = sw_almost_done;
  444.                 break;
  445.             case LF:
  446.                 goto done;
  447.             case '"':
  448.                 if (s->args.nelts <= 2) {
  449.                     s->quoted = 1;
  450.                     s->arg_start = p + 1;
  451.                     state = sw_argument;
  452.                     break;
  453.                 }
  454.                 goto invalid;
  455.             case '{':
  456.                 if (s->args.nelts <= 2) {
  457.                     state = sw_literal;
  458.                     break;
  459.                 }
  460.                 goto invalid;
  461.             default:
  462.                 if (s->args.nelts <= 2) {
  463.                     s->arg_start = p;
  464.                     state = sw_argument;
  465.                     break;
  466.                 }
  467.                 goto invalid;
  468.             }
  469.             break;

  471.         case sw_argument:
  472.             if (ch == ' ' && s->quoted) {
  473.                 break;
  474.             }

  476.             switch (ch) {
  477.             case '"':
  478.                 if (!s->quoted) {
  479.                     break;
  480.                 }
  481.                 s->quoted = 0;
  482.                 /* fall through */
  483.             case ' ':
  484.             case CR:
  485.             case LF:
  486.                 arg = ngx_array_push(&s->args);
  487.                 if (arg == NULL) {
  488.                     return NGX_ERROR;
  489.                 }
  490.                 arg->len = p - s->arg_start;
  491.                 arg->data = s->arg_start;

  493.                 if (s->backslash) {
  494.                     dst = s->arg_start;
  495.                     end = p;

  497.                     for (src = dst; src < end; dst++) {
  498.                         *dst = *src;
  499.                         if (*src++ == '\\') {
  500.                             *dst = *src++;
  501.                         }
  502.                     }

  504.                     arg->len = dst - s->arg_start;
  505.                     s->backslash = 0;
  506.                 }

  508.                 s->arg_start = NULL;

  510.                 switch (ch) {
  511.                 case '"':
  512.                 case ' ':
  513.                     state = sw_spaces_before_argument;
  514.                     break;
  515.                 case CR:
  516.                     state = sw_almost_done;
  517.                     break;
  518.                 case LF:
  519.                     goto done;
  520.                 }
  521.                 break;
  522.             case '\\':
  523.                 if (s->quoted) {
  524.                     s->backslash = 1;
  525.                     state = sw_backslash;
  526.                 }
  527.                 break;
  528.             }
  529.             break;

  531.         case sw_backslash:
  532.             switch (ch) {
  533.             case CR:
  534.             case LF:
  535.                 goto invalid;
  536.             default:
  537.                 state = sw_argument;
  538.             }
  539.             break;

  541.         case sw_literal:
  542.             if (s->literal_len > NGX_MAX_SIZE_T_VALUE / 10) {
  543.                 goto invalid;
  544.             }
  545.             if (ch >= '0' && ch <= '9') {
  546.                 s->literal_len = s->literal_len * 10 + (ch - '0');
  547.                 break;
  548.             }
  549.             if (ch == '}') {
  550.                 state = sw_start_literal_argument;
  551.                 break;
  552.             }
  553.             if (ch == '+') {
  554.                 state = sw_no_sync_literal_argument;
  555.                 break;
  556.             }
  557.             goto invalid;

  559.         case sw_no_sync_literal_argument:
  560.             if (ch == '}') {
  561.                 s->no_sync_literal = 1;
  562.                 state = sw_start_literal_argument;
  563.                 break;
  564.             }
  565.             goto invalid;

  567.         case sw_start_literal_argument:
  568.             switch (ch) {
  569.             case CR:
  570.                 break;
  571.             case LF:
  572.                 s->buffer->pos = p + 1;
  573.                 s->arg_start = p + 1;
  574.                 if (s->no_sync_literal == 0) {
  575.                     s->state = sw_literal_argument;
  576.                     return NGX_IMAP_NEXT;
  577.                 }
  578.                 state = sw_literal_argument;
  579.                 s->no_sync_literal = 0;
  580.                 break;
  581.             default:
  582.                 goto invalid;
  583.             }
  584.             break;

  586.         case sw_literal_argument:
  587.             if (s->literal_len && --s->literal_len) {
  588.                 break;
  589.             }

  591.             arg = ngx_array_push(&s->args);
  592.             if (arg == NULL) {
  593.                 return NGX_ERROR;
  594.             }
  595.             arg->len = p + 1 - s->arg_start;
  596.             arg->data = s->arg_start;
  597.             s->arg_start = NULL;
  598.             state = sw_end_literal_argument;

  600.             break;

  602.         case sw_end_literal_argument:
  603.             switch (ch) {
  604.             case ' ':
  605.                 state = sw_spaces_before_argument;
  606.                 break;
  607.             case CR:
  608.                 state = sw_almost_done;
  609.                 break;
  610.             case LF:
  611.                 goto done;
  612.             default:
  613.                 goto invalid;
  614.             }
  615.             break;

  617.         case sw_almost_done:
  618.             switch (ch) {
  619.             case LF:
  620.                 goto done;
  621.             default:
  622.                 goto invalid;
  623.             }
  624.         }
  625.     }

  627.     s->buffer->pos = p;
  628.     s->state = state;

  630.     return NGX_AGAIN;

  632. done:

  634.     s->buffer->pos = p + 1;
  635.     s->state = (s->command != NGX_IMAP_AUTHENTICATE) ? sw_start : sw_argument;

  637.     return NGX_OK;

  639. invalid:

  641.     s->state = sw_invalid;
  642.     s->quoted = 0;
  643.     s->backslash = 0;
  644.     s->no_sync_literal = 0;
  645.     s->literal_len = 0;

  647.     /* skip invalid command till LF */

  649.     for ( /* void */ ; p < s->buffer->last; p++) {
  650.         if (*p == LF) {
  651.             s->state = sw_start;
  652.             s->buffer->pos = p + 1;

  654.             /* detect non-synchronizing literals */

  656.             if ((size_t) (p - s->buffer->start) > sizeof("{1+}") - 1) {
  657.                 p--;

  659.                 if (*p == CR) {
  660.                     p--;
  661.                 }

  663.                 if (*p == '}' && *(p - 1) == '+') {
  664.                     s->quit = 1;
  665.                 }
  666.             }

  668.             return NGX_MAIL_PARSE_INVALID_COMMAND;
  669.         }
  670.     }

  672.     s->buffer->pos = p;

  674.     return NGX_AGAIN;
  675. }


  678. ngx_int_t
  679. ‌ngx_mail_smtp_parse_command(ngx_mail_session_t *s)
  680. {
  681.     u_char      ch, *p, *c, c0, c1, c2, c3;
  682.     ngx_str_t  *arg;
  683. ‌    enum {
  684.         sw_start = 0,
  685.         sw_command,
  686.         sw_invalid,
  687.         sw_spaces_before_argument,
  688.         sw_argument,
  689.         sw_almost_done
  690.     } state;

  692.     state = s->state;

  694.     for (p = s->buffer->pos; p < s->buffer->last; p++) {
  695.         ch = *p;

  697.         switch (state) {

  699.         /* SMTP command */
  700.         case sw_start:
  701.             s->cmd_start = p;
  702.             state = sw_command;

  704.             /* fall through */

  706.         case sw_command:
  707.             if (ch == ' ' || ch == CR || ch == LF) {
  708.                 c = s->cmd_start;

  710.                 if (p - c == 4) {

  712.                     c0 = ngx_toupper(c[0]);
  713.                     c1 = ngx_toupper(c[1]);
  714.                     c2 = ngx_toupper(c[2]);
  715.                     c3 = ngx_toupper(c[3]);

  717.                     if (c0 == 'H' && c1 == 'E' && c2 == 'L' && c3 == 'O')
  718.                     {
  719.                         s->command = NGX_SMTP_HELO;

  721.                     } else if (c0 == 'E' && c1 == 'H' && c2 == 'L' && c3 == 'O')
  722.                     {
  723.                         s->command = NGX_SMTP_EHLO;

  725.                     } else if (c0 == 'Q' && c1 == 'U' && c2 == 'I' && c3 == 'T')
  726.                     {
  727.                         s->command = NGX_SMTP_QUIT;

  729.                     } else if (c0 == 'A' && c1 == 'U' && c2 == 'T' && c3 == 'H')
  730.                     {
  731.                         s->command = NGX_SMTP_AUTH;

  733.                     } else if (c0 == 'N' && c1 == 'O' && c2 == 'O' && c3 == 'P')
  734.                     {
  735.                         s->command = NGX_SMTP_NOOP;

  737.                     } else if (c0 == 'M' && c1 == 'A' && c2 == 'I' && c3 == 'L')
  738.                     {
  739.                         s->command = NGX_SMTP_MAIL;

  741.                     } else if (c0 == 'R' && c1 == 'S' && c2 == 'E' && c3 == 'T')
  742.                     {
  743.                         s->command = NGX_SMTP_RSET;

  745.                     } else if (c0 == 'R' && c1 == 'C' && c2 == 'P' && c3 == 'T')
  746.                     {
  747.                         s->command = NGX_SMTP_RCPT;

  749.                     } else if (c0 == 'V' && c1 == 'R' && c2 == 'F' && c3 == 'Y')
  750.                     {
  751.                         s->command = NGX_SMTP_VRFY;

  753.                     } else if (c0 == 'E' && c1 == 'X' && c2 == 'P' && c3 == 'N')
  754.                     {
  755.                         s->command = NGX_SMTP_EXPN;

  757.                     } else if (c0 == 'H' && c1 == 'E' && c2 == 'L' && c3 == 'P')
  758.                     {
  759.                         s->command = NGX_SMTP_HELP;

  761.                     } else {
  762.                         goto invalid;
  763.                     }
  764. #if (NGX_MAIL_SSL)
  765.                 } else if (p - c == 8) {

  767.                     if ((c[0] == 'S'|| c[0] == 's')
  768.                         && (c[1] == 'T'|| c[1] == 't')
  769.                         && (c[2] == 'A'|| c[2] == 'a')
  770.                         && (c[3] == 'R'|| c[3] == 'r')
  771.                         && (c[4] == 'T'|| c[4] == 't')
  772.                         && (c[5] == 'T'|| c[5] == 't')
  773.                         && (c[6] == 'L'|| c[6] == 'l')
  774.                         && (c[7] == 'S'|| c[7] == 's'))
  775.                     {
  776.                         s->command = NGX_SMTP_STARTTLS;

  778.                     } else {
  779.                         goto invalid;
  780.                     }
  781. #endif
  782.                 } else {
  783.                     goto invalid;
  784.                 }

  786.                 s->cmd.data = s->cmd_start;
  787.                 s->cmd.len = p - s->cmd_start;

  789.                 switch (ch) {
  790.                 case ' ':
  791.                     state = sw_spaces_before_argument;
  792.                     break;
  793.                 case CR:
  794.                     state = sw_almost_done;
  795.                     break;
  796.                 case LF:
  797.                     goto done;
  798.                 }
  799.                 break;
  800.             }

  802.             if ((ch < 'A' || ch > 'Z') && (ch < 'a' || ch > 'z')) {
  803.                 goto invalid;
  804.             }

  806.             break;

  808.         case sw_invalid:
  809.             goto invalid;

  811.         case sw_spaces_before_argument:
  812.             switch (ch) {
  813.             case ' ':
  814.                 break;
  815.             case CR:
  816.                 state = sw_almost_done;
  817.                 break;
  818.             case LF:
  819.                 goto done;
  820.             default:
  821.                 if (s->args.nelts <= 10) {
  822.                     state = sw_argument;
  823.                     s->arg_start = p;
  824.                     break;
  825.                 }
  826.                 goto invalid;
  827.             }
  828.             break;

  830.         case sw_argument:
  831.             switch (ch) {
  832.             case ' ':
  833.             case CR:
  834.             case LF:
  835.                 arg = ngx_array_push(&s->args);
  836.                 if (arg == NULL) {
  837.                     return NGX_ERROR;
  838.                 }
  839.                 arg->len = p - s->arg_start;
  840.                 arg->data = s->arg_start;
  841.                 s->arg_start = NULL;

  843.                 switch (ch) {
  844.                 case ' ':
  845.                     state = sw_spaces_before_argument;
  846.                     break;
  847.                 case CR:
  848.                     state = sw_almost_done;
  849.                     break;
  850.                 case LF:
  851.                     goto done;
  852.                 }
  853.                 break;

  855.             default:
  856.                 break;
  857.             }
  858.             break;

  860.         case sw_almost_done:
  861.             switch (ch) {
  862.             case LF:
  863.                 goto done;
  864.             default:
  865.                 goto invalid;
  866.             }
  867.         }
  868.     }

  870.     s->buffer->pos = p;
  871.     s->state = state;

  873.     return NGX_AGAIN;

  875. done:

  877.     s->buffer->pos = p + 1;
  878.     s->state = (s->command != NGX_SMTP_AUTH) ? sw_start : sw_argument;

  880.     return NGX_OK;

  882. invalid:

  884.     s->state = sw_invalid;

  886.     /* skip invalid command till LF */

  888.     for ( /* void */ ; p < s->buffer->last; p++) {
  889.         if (*p == LF) {
  890.             s->state = sw_start;
  891.             s->buffer->pos = p + 1;
  892.             return NGX_MAIL_PARSE_INVALID_COMMAND;
  893.         }
  894.     }

  896.     s->buffer->pos = p;

  898.     return NGX_AGAIN;
  899. }


  902. ngx_int_t
  903. ‌ngx_mail_auth_parse(ngx_mail_session_t *s, ngx_connection_t *c)
  904. {
  905.     ngx_str_t                 *arg;

  907. #if (NGX_MAIL_SSL)
  908.     if (ngx_mail_starttls_only(s, c)) {
  909.         return NGX_MAIL_PARSE_INVALID_COMMAND;
  910.     }
  911. #endif

  913.     if (s->args.nelts == 0) {
  914.         return NGX_MAIL_PARSE_INVALID_COMMAND;
  915.     }

  917.     arg = s->args.elts;

  919.     if (arg[0].len == 5) {

  921.         if (ngx_strncasecmp(arg[0].data, (u_char *) "LOGIN", 5) == 0) {

  923.             if (s->args.nelts == 1) {
  924.                 return NGX_MAIL_AUTH_LOGIN;
  925.             }

  927.             if (s->args.nelts == 2) {
  928.                 return NGX_MAIL_AUTH_LOGIN_USERNAME;
  929.             }

  931.             return NGX_MAIL_PARSE_INVALID_COMMAND;
  932.         }

  934.         if (ngx_strncasecmp(arg[0].data, (u_char *) "PLAIN", 5) == 0) {

  936.             if (s->args.nelts == 1) {
  937.                 return NGX_MAIL_AUTH_PLAIN;
  938.             }

  940.             if (s->args.nelts == 2) {
  941.                 return ngx_mail_auth_plain(s, c, 1);
  942.             }
  943.         }

  945.         return NGX_MAIL_PARSE_INVALID_COMMAND;
  946.     }

  948.     if (arg[0].len == 8) {

  950.         if (ngx_strncasecmp(arg[0].data, (u_char *) "CRAM-MD5", 8) == 0) {

  952.             if (s->args.nelts != 1) {
  953.                 return NGX_MAIL_PARSE_INVALID_COMMAND;
  954.             }

  956.             return NGX_MAIL_AUTH_CRAM_MD5;
  957.         }

  959.         if (ngx_strncasecmp(arg[0].data, (u_char *) "EXTERNAL", 8) == 0) {

  961.             if (s->args.nelts == 1) {
  962.                 return NGX_MAIL_AUTH_EXTERNAL;
  963.             }

  965.             if (s->args.nelts == 2) {
  966.                 return ngx_mail_auth_external(s, c, 1);
  967.             }
  968.         }

  970.         return NGX_MAIL_PARSE_INVALID_COMMAND;
  971.     }

  973.     return NGX_MAIL_PARSE_INVALID_COMMAND;
  974. }

One Level Up Top Level