nginx/src/mail/ngx_mail_proxy_module.c

   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_event_connect.h>
  11 #include <ngx_mail.h>
  12
  13
  14 typedef struct {
  15     ngx_flag_t  enable;
  16     ngx_flag_t  pass_error_message;
  17     ngx_flag_t  xclient;
  18     size_t      buffer_size;
  19     ngx_msec_t  timeout;
  20 } ngx_mail_proxy_conf_t;
  21
  22
  23 static void ngx_mail_proxy_block_read(ngx_event_t *rev);
  24 static void ngx_mail_proxy_pop3_handler(ngx_event_t *rev);
  25 static void ngx_mail_proxy_imap_handler(ngx_event_t *rev);
  26 static void ngx_mail_proxy_smtp_handler(ngx_event_t *rev);
  27 static void ngx_mail_proxy_dummy_handler(ngx_event_t *ev);
  28 static ngx_int_t ngx_mail_proxy_read_response(ngx_mail_session_t *s,
  29     ngx_uint_t state);
  30 static void ngx_mail_proxy_handler(ngx_event_t *ev);
  31 static void ngx_mail_proxy_upstream_error(ngx_mail_session_t *s);
  32 static void ngx_mail_proxy_internal_server_error(ngx_mail_session_t *s);
  33 static void ngx_mail_proxy_close_session(ngx_mail_session_t *s);
  34 static void *ngx_mail_proxy_create_conf(ngx_conf_t *cf);
  35 static char *ngx_mail_proxy_merge_conf(ngx_conf_t *cf, void *parent,
  36     void *child);
  37
  38
  39 static ngx_command_t  ngx_mail_proxy_commands[] = {
  40
  41     { ngx_string("proxy"),
  42       NGX_MAIL_MAIN_CONF|NGX_MAIL_SRV_CONF|NGX_CONF_FLAG,
  43       ngx_conf_set_flag_slot,
  44       NGX_MAIL_SRV_CONF_OFFSET,
  45       offsetof(ngx_mail_proxy_conf_t, enable),
  46       NULL },
  47
  48     { ngx_string("proxy_buffer"),
  49       NGX_MAIL_MAIN_CONF|NGX_MAIL_SRV_CONF|NGX_CONF_TAKE1,
  50       ngx_conf_set_size_slot,
  51       NGX_MAIL_SRV_CONF_OFFSET,
  52       offsetof(ngx_mail_proxy_conf_t, buffer_size),
  53       NULL },
  54
  55     { ngx_string("proxy_timeout"),
  56       NGX_MAIL_MAIN_CONF|NGX_MAIL_SRV_CONF|NGX_CONF_TAKE1,
  57       ngx_conf_set_msec_slot,
  58       NGX_MAIL_SRV_CONF_OFFSET,
  59       offsetof(ngx_mail_proxy_conf_t, timeout),
  60       NULL },
  61
  62     { ngx_string("proxy_pass_error_message"),
  63       NGX_MAIL_MAIN_CONF|NGX_MAIL_SRV_CONF|NGX_CONF_TAKE1,
  64       ngx_conf_set_flag_slot,
  65       NGX_MAIL_SRV_CONF_OFFSET,
  66       offsetof(ngx_mail_proxy_conf_t, pass_error_message),
  67       NULL },
  68
  69     { ngx_string("xclient"),
  70       NGX_MAIL_MAIN_CONF|NGX_MAIL_SRV_CONF|NGX_CONF_FLAG,
  71       ngx_conf_set_flag_slot,
  72       NGX_MAIL_SRV_CONF_OFFSET,
  73       offsetof(ngx_mail_proxy_conf_t, xclient),
  74       NULL },
  75
  76       ngx_null_command
  77 };
  78
  79
  80 static ngx_mail_module_t  ngx_mail_proxy_module_ctx = {
  81     NULL,                                  /* protocol */
  82
  83     NULL,                                  /* create main configuration */
  84     NULL,                                  /* init main configuration */
  85
  86     ngx_mail_proxy_create_conf,            /* create server configuration */
  87     ngx_mail_proxy_merge_conf              /* merge server configuration */
  88 };
  89
  90
  91 ngx_module_t  ngx_mail_proxy_module = {
  92     NGX_MODULE_V1,
  93     &ngx_mail_proxy_module_ctx,            /* module context */
  94     ngx_mail_proxy_commands,               /* module directives */
  95     NGX_MAIL_MODULE,                       /* module type */
  96     NULL,                                  /* init master */
  97     NULL,                                  /* init module */
  98     NULL,                                  /* init process */
  99     NULL,                                  /* init thread */
 100     NULL,                                  /* exit thread */
 101     NULL,                                  /* exit process */
 102     NULL,                                  /* exit master */
 103     NGX_MODULE_V1_PADDING
 104 };
 105
 106
 107 static u_char  smtp_auth_ok[] = "235 2.0.0 OK" CRLF;
 108
 109
 110 void
 111 ngx_mail_proxy_init(ngx_mail_session_t *s, ngx_peer_addr_t *peer)
 112 {
 113     int                        keepalive;
 114     ngx_int_t                  rc;
 115     ngx_mail_proxy_ctx_t      *p;
 116     ngx_mail_proxy_conf_t     *pcf;
 117     ngx_mail_core_srv_conf_t  *cscf;
 118
 119     s->connection->log->action = "connecting to upstream";
 120
 121     cscf = ngx_mail_get_module_srv_conf(s, ngx_mail_core_module);
 122
 123     if (cscf->so_keepalive) {
 124         keepalive = 1;
 125
 126         if (setsockopt(s->connection->fd, SOL_SOCKET, SO_KEEPALIVE,
 127                        (const void *) &keepalive, sizeof(int))
 128                 == -1)
 129         {
 130             ngx_log_error(NGX_LOG_ALERT, s->connection->log, ngx_socket_errno,
 131                           "setsockopt(SO_KEEPALIVE) failed");
 132         }
 133     }
 134
 135     p = ngx_pcalloc(s->connection->pool, sizeof(ngx_mail_proxy_ctx_t));
 136     if (p == NULL) {
 137         ngx_mail_session_internal_server_error(s);
 138         return;
 139     }
 140
 141     s->proxy = p;
 142
 143     p->upstream.sockaddr = peer->sockaddr;
 144     p->upstream.socklen = peer->socklen;
 145     p->upstream.name = &peer->name;
 146     p->upstream.get = ngx_event_get_peer;
 147     p->upstream.log = s->connection->log;
 148     p->upstream.log_error = NGX_ERROR_ERR;
 149
 150     rc = ngx_event_connect_peer(&p->upstream);
 151
 152     if (rc == NGX_ERROR || rc == NGX_BUSY || rc == NGX_DECLINED) {
 153         ngx_mail_proxy_internal_server_error(s);
 154         return;
 155     }
 156
 157     ngx_add_timer(p->upstream.connection->read, cscf->timeout);
 158
 159     p->upstream.connection->data = s;
 160     p->upstream.connection->pool = s->connection->pool;
 161
 162     s->connection->read->handler = ngx_mail_proxy_block_read;
 163     p->upstream.connection->write->handler = ngx_mail_proxy_dummy_handler;
 164
 165     pcf = ngx_mail_get_module_srv_conf(s, ngx_mail_proxy_module);
 166
 167     s->proxy->buffer = ngx_create_temp_buf(s->connection->pool,
 168                                            pcf->buffer_size);
 169     if (s->proxy->buffer == NULL) {
 170         ngx_mail_proxy_internal_server_error(s);
 171         return;
 172     }
 173
 174     s->out.len = 0;
 175
 176     switch (s->protocol) {
 177
 178     case NGX_MAIL_POP3_PROTOCOL:
 179         p->upstream.connection->read->handler = ngx_mail_proxy_pop3_handler;
 180         s->mail_state = ngx_pop3_start;
 181         break;
 182
 183     case NGX_MAIL_IMAP_PROTOCOL:
 184         p->upstream.connection->read->handler = ngx_mail_proxy_imap_handler;
 185         s->mail_state = ngx_imap_start;
 186         break;
 187
 188     default: /* NGX_MAIL_SMTP_PROTOCOL */
 189         p->upstream.connection->read->handler = ngx_mail_proxy_smtp_handler;
 190         s->mail_state = ngx_smtp_start;
 191         break;
 192     }
 193 }
 194
 195
 196 static void
 197 ngx_mail_proxy_block_read(ngx_event_t *rev)
 198 {
 199     ngx_connection_t    *c;
 200     ngx_mail_session_t  *s;
 201
 202     ngx_log_debug0(NGX_LOG_DEBUG_MAIL, rev->log, 0, "mail proxy block read");
 203
 204     if (ngx_handle_read_event(rev, 0) != NGX_OK) {
 205         c = rev->data;
 206         s = c->data;
 207
 208         ngx_mail_proxy_close_session(s);
 209     }
 210 }
 211
 212
 213 static void
 214 ngx_mail_proxy_pop3_handler(ngx_event_t *rev)
 215 {
 216     u_char                 *p;
 217     ngx_int_t               rc;
 218     ngx_str_t               line;
 219     ngx_connection_t       *c;
 220     ngx_mail_session_t     *s;
 221     ngx_mail_proxy_conf_t  *pcf;
 222
 223     ngx_log_debug0(NGX_LOG_DEBUG_MAIL, rev->log, 0,
 224                    "mail proxy pop3 auth handler");
 225
 226     c = rev->data;
 227     s = c->data;
 228
 229     if (rev->timedout) {
 230         ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT,
 231                       "upstream timed out");
 232         c->timedout = 1;
 233         ngx_mail_proxy_internal_server_error(s);
 234         return;
 235     }
 236
 237     rc = ngx_mail_proxy_read_response(s, 0);
 238
 239     if (rc == NGX_AGAIN) {
 240         return;
 241     }
 242
 243     if (rc == NGX_ERROR) {
 244         ngx_mail_proxy_upstream_error(s);
 245         return;
 246     }
 247
 248     switch (s->mail_state) {
 249
 250     case ngx_pop3_start:
 251         ngx_log_debug0(NGX_LOG_DEBUG_MAIL, rev->log, 0, "mail proxy send user");
 252
 253         s->connection->log->action = "sending user name to upstream";
 254
 255         line.len = sizeof("USER ")  - 1 + s->login.len + 2;
 256         line.data = ngx_pnalloc(c->pool, line.len);
 257         if (line.data == NULL) {
 258             ngx_mail_proxy_internal_server_error(s);
 259             return;
 260         }
 261
 262         p = ngx_cpymem(line.data, "USER ", sizeof("USER ") - 1);
 263         p = ngx_cpymem(p, s->login.data, s->login.len);
 264         *p++ = CR; *p = LF;
 265
 266         s->mail_state = ngx_pop3_user;
 267         break;
 268
 269     case ngx_pop3_user:
 270         ngx_log_debug0(NGX_LOG_DEBUG_MAIL, rev->log, 0, "mail proxy send pass");
 271
 272         s->connection->log->action = "sending password to upstream";
 273
 274         line.len = sizeof("PASS ")  - 1 + s->passwd.len + 2;
 275         line.data = ngx_pnalloc(c->pool, line.len);
 276         if (line.data == NULL) {
 277             ngx_mail_proxy_internal_server_error(s);
 278             return;
 279         }
 280
 281         p = ngx_cpymem(line.data, "PASS ", sizeof("PASS ") - 1);
 282         p = ngx_cpymem(p, s->passwd.data, s->passwd.len);
 283         *p++ = CR; *p = LF;
 284
 285         s->mail_state = ngx_pop3_passwd;
 286         break;
 287
 288     case ngx_pop3_passwd:
 289         s->connection->read->handler = ngx_mail_proxy_handler;
 290         s->connection->write->handler = ngx_mail_proxy_handler;
 291         rev->handler = ngx_mail_proxy_handler;
 292         c->write->handler = ngx_mail_proxy_handler;
 293
 294         pcf = ngx_mail_get_module_srv_conf(s, ngx_mail_proxy_module);
 295         ngx_add_timer(s->connection->read, pcf->timeout);
 296         ngx_del_timer(c->read);
 297
 298         c->log->action = NULL;
 299         ngx_log_error(NGX_LOG_INFO, c->log, 0, "client logged in");
 300
 301         ngx_mail_proxy_handler(s->connection->write);
 302
 303         return;
 304
 305     default:
 306 #if (NGX_SUPPRESS_WARN)
 307         line.len = 0;
 308         line.data = NULL;
 309 #endif
 310         break;
 311     }
 312
 313     if (c->send(c, line.data, line.len) < (ssize_t) line.len) {
 314         /*
 315          * we treat the incomplete sending as NGX_ERROR
 316          * because it is very strange here
 317          */
 318         ngx_mail_proxy_internal_server_error(s);
 319         return;
 320     }
 321
 322     s->proxy->buffer->pos = s->proxy->buffer->start;
 323     s->proxy->buffer->last = s->proxy->buffer->start;
 324 }
 325
 326
 327 static void
 328 ngx_mail_proxy_imap_handler(ngx_event_t *rev)
 329 {
 330     u_char                 *p;
 331     ngx_int_t               rc;
 332     ngx_str_t               line;
 333     ngx_connection_t       *c;
 334     ngx_mail_session_t     *s;
 335     ngx_mail_proxy_conf_t  *pcf;
 336
 337     ngx_log_debug0(NGX_LOG_DEBUG_MAIL, rev->log, 0,
 338                    "mail proxy imap auth handler");
 339
 340     c = rev->data;
 341     s = c->data;
 342
 343     if (rev->timedout) {
 344         ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT,
 345                       "upstream timed out");
 346         c->timedout = 1;
 347         ngx_mail_proxy_internal_server_error(s);
 348         return;
 349     }
 350
 351     rc = ngx_mail_proxy_read_response(s, s->mail_state);
 352
 353     if (rc == NGX_AGAIN) {
 354         return;
 355     }
 356
 357     if (rc == NGX_ERROR) {
 358         ngx_mail_proxy_upstream_error(s);
 359         return;
 360     }
 361
 362     switch (s->mail_state) {
 363
 364     case ngx_imap_start:
 365         ngx_log_debug0(NGX_LOG_DEBUG_MAIL, rev->log, 0,
 366                        "mail proxy send login");
 367
 368         s->connection->log->action = "sending LOGIN command to upstream";
 369
 370         line.len = s->tag.len + sizeof("LOGIN ") - 1
 371                    + 1 + NGX_SIZE_T_LEN + 1 + 2;
 372         line.data = ngx_pnalloc(c->pool, line.len);
 373         if (line.data == NULL) {
 374             ngx_mail_proxy_internal_server_error(s);
 375             return;
 376         }
 377
 378         line.len = ngx_sprintf(line.data, "%VLOGIN {%uz}" CRLF,
 379                                &s->tag, s->login.len)
 380                    - line.data;
 381
 382         s->mail_state = ngx_imap_login;
 383         break;
 384
 385     case ngx_imap_login:
 386         ngx_log_debug0(NGX_LOG_DEBUG_MAIL, rev->log, 0, "mail proxy send user");
 387
 388         s->connection->log->action = "sending user name to upstream";
 389
 390         line.len = s->login.len + 1 + 1 + NGX_SIZE_T_LEN + 1 + 2;
 391         line.data = ngx_pnalloc(c->pool, line.len);
 392         if (line.data == NULL) {
 393             ngx_mail_proxy_internal_server_error(s);
 394             return;
 395         }
 396
 397         line.len = ngx_sprintf(line.data, "%V {%uz}" CRLF,
 398                                &s->login, s->passwd.len)
 399                    - line.data;
 400
 401         s->mail_state = ngx_imap_user;
 402         break;
 403
 404     case ngx_imap_user:
 405         ngx_log_debug0(NGX_LOG_DEBUG_MAIL, rev->log, 0,
 406                        "mail proxy send passwd");
 407
 408         s->connection->log->action = "sending password to upstream";
 409
 410         line.len = s->passwd.len + 2;
 411         line.data = ngx_pnalloc(c->pool, line.len);
 412         if (line.data == NULL) {
 413             ngx_mail_proxy_internal_server_error(s);
 414             return;
 415         }
 416
 417         p = ngx_cpymem(line.data, s->passwd.data, s->passwd.len);
 418         *p++ = CR; *p = LF;
 419
 420         s->mail_state = ngx_imap_passwd;
 421         break;
 422
 423     case ngx_imap_passwd:
 424         s->connection->read->handler = ngx_mail_proxy_handler;
 425         s->connection->write->handler = ngx_mail_proxy_handler;
 426         rev->handler = ngx_mail_proxy_handler;
 427         c->write->handler = ngx_mail_proxy_handler;
 428
 429         pcf = ngx_mail_get_module_srv_conf(s, ngx_mail_proxy_module);
 430         ngx_add_timer(s->connection->read, pcf->timeout);
 431         ngx_del_timer(c->read);
 432
 433         c->log->action = NULL;
 434         ngx_log_error(NGX_LOG_INFO, c->log, 0, "client logged in");
 435
 436         ngx_mail_proxy_handler(s->connection->write);
 437
 438         return;
 439
 440     default:
 441 #if (NGX_SUPPRESS_WARN)
 442         line.len = 0;
 443         line.data = NULL;
 444 #endif
 445         break;
 446     }
 447
 448     if (c->send(c, line.data, line.len) < (ssize_t) line.len) {
 449         /*
 450          * we treat the incomplete sending as NGX_ERROR
 451          * because it is very strange here
 452          */
 453         ngx_mail_proxy_internal_server_error(s);
 454         return;
 455     }
 456
 457     s->proxy->buffer->pos = s->proxy->buffer->start;
 458     s->proxy->buffer->last = s->proxy->buffer->start;
 459 }
 460
 461
 462 static void
 463 ngx_mail_proxy_smtp_handler(ngx_event_t *rev)
 464 {
 465     u_char                    *p;
 466     ngx_int_t                  rc;
 467     ngx_str_t                  line;
 468     ngx_buf_t                 *b;
 469     ngx_connection_t          *c;
 470     ngx_mail_session_t        *s;
 471     ngx_mail_proxy_conf_t     *pcf;
 472     ngx_mail_core_srv_conf_t  *cscf;
 473
 474     ngx_log_debug0(NGX_LOG_DEBUG_MAIL, rev->log, 0,
 475                    "mail proxy smtp auth handler");
 476
 477     c = rev->data;
 478     s = c->data;
 479
 480     if (rev->timedout) {
 481         ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT,
 482                       "upstream timed out");
 483         c->timedout = 1;
 484         ngx_mail_proxy_internal_server_error(s);
 485         return;
 486     }
 487
 488     rc = ngx_mail_proxy_read_response(s, s->mail_state);
 489
 490     if (rc == NGX_AGAIN) {
 491         return;
 492     }
 493
 494     if (rc == NGX_ERROR) {
 495         ngx_mail_proxy_upstream_error(s);
 496         return;
 497     }
 498
 499     switch (s->mail_state) {
 500
 501     case ngx_smtp_start:
 502         ngx_log_debug0(NGX_LOG_DEBUG_MAIL, rev->log, 0, "mail proxy send ehlo");
 503
 504         s->connection->log->action = "sending HELO/EHLO to upstream";
 505
 506         cscf = ngx_mail_get_module_srv_conf(s, ngx_mail_core_module);
 507
 508         line.len = sizeof("HELO ")  - 1 + cscf->server_name.len + 2;
 509         line.data = ngx_pnalloc(c->pool, line.len);
 510         if (line.data == NULL) {
 511             ngx_mail_proxy_internal_server_error(s);
 512             return;
 513         }
 514
 515         pcf = ngx_mail_get_module_srv_conf(s, ngx_mail_proxy_module);
 516
 517         p = ngx_cpymem(line.data,
 518                        ((s->esmtp || pcf->xclient) ? "EHLO " : "HELO "),
 519                        sizeof("HELO ") - 1);
 520
 521         p = ngx_cpymem(p, cscf->server_name.data, cscf->server_name.len);
 522         *p++ = CR; *p = LF;
 523
 524         if (pcf->xclient) {
 525             s->mail_state = ngx_smtp_helo_xclient;
 526
 527         } else if (s->auth_method == NGX_MAIL_AUTH_NONE) {
 528             s->mail_state = ngx_smtp_helo_from;
 529
 530         } else {
 531             s->mail_state = ngx_smtp_helo;
 532         }
 533
 534         break;
 535
 536     case ngx_smtp_helo_xclient:
 537         ngx_log_debug0(NGX_LOG_DEBUG_MAIL, rev->log, 0,
 538                        "mail proxy send xclient");
 539
 540         s->connection->log->action = "sending XCLIENT to upstream";
 541
 542         line.len = sizeof("XCLIENT ADDR= LOGIN= NAME="
 543                           CRLF) - 1
 544                    + s->connection->addr_text.len + s->login.len + s->host.len;
 545
 546         line.data = ngx_pnalloc(c->pool, line.len);
 547         if (line.data == NULL) {
 548             ngx_mail_proxy_internal_server_error(s);
 549             return;
 550         }
 551
 552         line.len = ngx_sprintf(line.data,
 553                        "XCLIENT ADDR=%V%s%V NAME=%V" CRLF,
 554                        &s->connection->addr_text,
 555                        (s->login.len ? " LOGIN=" : ""), &s->login, &s->host)
 556                    - line.data;
 557
 558         if (s->smtp_helo.len) {
 559             s->mail_state = ngx_smtp_xclient_helo;
 560
 561         } else if (s->auth_method == NGX_MAIL_AUTH_NONE) {
 562             s->mail_state = ngx_smtp_xclient_from;
 563
 564         } else {
 565             s->mail_state = ngx_smtp_xclient;
 566         }
 567
 568         break;
 569
 570     case ngx_smtp_xclient_helo:
 571         ngx_log_debug0(NGX_LOG_DEBUG_MAIL, rev->log, 0,
 572                        "mail proxy send client ehlo");
 573
 574         s->connection->log->action = "sending client HELO/EHLO to upstream";
 575
 576         line.len = sizeof("HELO " CRLF) - 1 + s->smtp_helo.len;
 577
 578         line.data = ngx_pnalloc(c->pool, line.len);
 579         if (line.data == NULL) {
 580             ngx_mail_proxy_internal_server_error(s);
 581             return;
 582         }
 583
 584         line.len = ngx_sprintf(line.data,
 585                        ((s->esmtp) ? "EHLO %V" CRLF : "HELO %V" CRLF),
 586                        &s->smtp_helo)
 587                    - line.data;
 588
 589         s->mail_state = (s->auth_method == NGX_MAIL_AUTH_NONE) ?
 590                             ngx_smtp_helo_from : ngx_smtp_helo;
 591
 592         break;
 593
 594     case ngx_smtp_helo_from:
 595     case ngx_smtp_xclient_from:
 596         ngx_log_debug0(NGX_LOG_DEBUG_MAIL, rev->log, 0,
 597                        "mail proxy send mail from");
 598
 599         s->connection->log->action = "sending MAIL FROM to upstream";
 600
 601         line.len = s->smtp_from.len + sizeof(CRLF) - 1;
 602         line.data = ngx_pnalloc(c->pool, line.len);
 603         if (line.data == NULL) {
 604             ngx_mail_proxy_internal_server_error(s);
 605             return;
 606         }
 607
 608         p = ngx_cpymem(line.data, s->smtp_from.data, s->smtp_from.len);
 609         *p++ = CR; *p = LF;
 610
 611         s->mail_state = ngx_smtp_from;
 612
 613         break;
 614
 615     case ngx_smtp_from:
 616         ngx_log_debug0(NGX_LOG_DEBUG_MAIL, rev->log, 0,
 617                        "mail proxy send rcpt to");
 618
 619         s->connection->log->action = "sending RCPT TO to upstream";
 620
 621         line.len = s->smtp_to.len + sizeof(CRLF) - 1;
 622         line.data = ngx_pnalloc(c->pool, line.len);
 623         if (line.data == NULL) {
 624             ngx_mail_proxy_internal_server_error(s);
 625             return;
 626         }
 627
 628         p = ngx_cpymem(line.data, s->smtp_to.data, s->smtp_to.len);
 629         *p++ = CR; *p = LF;
 630
 631         s->mail_state = ngx_smtp_to;
 632
 633         break;
 634
 635     case ngx_smtp_helo:
 636     case ngx_smtp_xclient:
 637     case ngx_smtp_to:
 638
 639         b = s->proxy->buffer;
 640
 641         if (s->auth_method == NGX_MAIL_AUTH_NONE) {
 642             b->pos = b->start;
 643
 644         } else {
 645             ngx_memcpy(b->start, smtp_auth_ok, sizeof(smtp_auth_ok) - 1);
 646             b->last = b->start + sizeof(smtp_auth_ok) - 1;
 647         }
 648
 649         s->connection->read->handler = ngx_mail_proxy_handler;
 650         s->connection->write->handler = ngx_mail_proxy_handler;
 651         rev->handler = ngx_mail_proxy_handler;
 652         c->write->handler = ngx_mail_proxy_handler;
 653
 654         pcf = ngx_mail_get_module_srv_conf(s, ngx_mail_proxy_module);
 655         ngx_add_timer(s->connection->read, pcf->timeout);
 656         ngx_del_timer(c->read);
 657
 658         c->log->action = NULL;
 659         ngx_log_error(NGX_LOG_INFO, c->log, 0, "client logged in");
 660
 661         ngx_mail_proxy_handler(s->connection->write);
 662
 663         return;
 664
 665     default:
 666 #if (NGX_SUPPRESS_WARN)
 667         line.len = 0;
 668         line.data = NULL;
 669 #endif
 670         break;
 671     }
 672
 673     if (c->send(c, line.data, line.len) < (ssize_t) line.len) {
 674         /*
 675          * we treat the incomplete sending as NGX_ERROR
 676          * because it is very strange here
 677          */
 678         ngx_mail_proxy_internal_server_error(s);
 679         return;
 680     }
 681
 682     s->proxy->buffer->pos = s->proxy->buffer->start;
 683     s->proxy->buffer->last = s->proxy->buffer->start;
 684 }
 685
 686
 687 static void
 688 ngx_mail_proxy_dummy_handler(ngx_event_t *wev)
 689 {
 690     ngx_connection_t    *c;
 691     ngx_mail_session_t  *s;
 692
 693     ngx_log_debug0(NGX_LOG_DEBUG_MAIL, wev->log, 0, "mail proxy dummy handler");
 694
 695     if (ngx_handle_write_event(wev, 0) != NGX_OK) {
 696         c = wev->data;
 697         s = c->data;
 698
 699         ngx_mail_proxy_close_session(s);
 700     }
 701 }
 702
 703
 704 static ngx_int_t
 705 ngx_mail_proxy_read_response(ngx_mail_session_t *s, ngx_uint_t state)
 706 {
 707     u_char                 *p;
 708     ssize_t                 n;
 709     ngx_buf_t              *b;
 710     ngx_mail_proxy_conf_t  *pcf;
 711
 712     s->connection->log->action = "reading response from upstream";
 713
 714     b = s->proxy->buffer;
 715
 716     n = s->proxy->upstream.connection->recv(s->proxy->upstream.connection,
 717                                             b->last, b->end - b->last);
 718
 719     if (n == NGX_ERROR || n == 0) {
 720         return NGX_ERROR;
 721     }
 722
 723     if (n == NGX_AGAIN) {
 724         return NGX_AGAIN;
 725     }
 726
 727     b->last += n;
 728
 729     if (b->last - b->pos < 5) {
 730         return NGX_AGAIN;
 731     }
 732
 733     if (*(b->last - 2) != CR || *(b->last - 1) != LF) {
 734         if (b->last == b->end) {
 735             *(b->last - 1) = '\0';
 736             ngx_log_error(NGX_LOG_ERR, s->connection->log, 0,
 737                           "upstream sent too long response line: \"%s\"",
 738                           b->pos);
 739             return NGX_ERROR;
 740         }
 741
 742         return NGX_AGAIN;
 743     }
 744
 745     p = b->pos;
 746
 747     switch (s->protocol) {
 748
 749     case NGX_MAIL_POP3_PROTOCOL:
 750         if (p[0] == '+' && p[1] == 'O' && p[2] == 'K') {
 751             return NGX_OK;
 752         }
 753         break;
 754
 755     case NGX_MAIL_IMAP_PROTOCOL:
 756         switch (state) {
 757
 758         case ngx_imap_start:
 759             if (p[0] == '*' && p[1] == ' ' && p[2] == 'O' && p[3] == 'K') {
 760                 return NGX_OK;
 761             }
 762             break;
 763
 764         case ngx_imap_login:
 765         case ngx_imap_user:
 766             if (p[0] == '+') {
 767                 return NGX_OK;
 768             }
 769             break;
 770
 771         case ngx_imap_passwd:
 772             if (ngx_strncmp(p, s->tag.data, s->tag.len) == 0) {
 773                 p += s->tag.len;
 774                 if (p[0] == 'O' && p[1] == 'K') {
 775                     return NGX_OK;
 776                 }
 777             }
 778             break;
 779         }
 780
 781         break;
 782
 783     default: /* NGX_MAIL_SMTP_PROTOCOL */
 784         switch (state) {
 785
 786         case ngx_smtp_start:
 787             if (p[0] == '2' && p[1] == '2' && p[2] == '0') {
 788                 return NGX_OK;
 789             }
 790             break;
 791
 792         case ngx_smtp_helo:
 793         case ngx_smtp_helo_xclient:
 794         case ngx_smtp_helo_from:
 795         case ngx_smtp_from:
 796             if (p[0] == '2' && p[1] == '5' && p[2] == '0') {
 797                 return NGX_OK;
 798             }
 799             break;
 800
 801         case ngx_smtp_xclient:
 802         case ngx_smtp_xclient_from:
 803         case ngx_smtp_xclient_helo:
 804             if (p[0] == '2' && (p[1] == '2' || p[1] == '5') && p[2] == '0') {
 805                 return NGX_OK;
 806             }
 807             break;
 808
 809         case ngx_smtp_to:
 810             return NGX_OK;
 811         }
 812
 813         break;
 814     }
 815
 816     pcf = ngx_mail_get_module_srv_conf(s, ngx_mail_proxy_module);
 817
 818     if (pcf->pass_error_message == 0) {
 819         *(b->last - 2) = '\0';
 820         ngx_log_error(NGX_LOG_ERR, s->connection->log, 0,
 821                       "upstream sent invalid response: \"%s\"", p);
 822         return NGX_ERROR;
 823     }
 824
 825     s->out.len = b->last - p - 2;
 826     s->out.data = p;
 827
 828     ngx_log_error(NGX_LOG_INFO, s->connection->log, 0,
 829                   "upstream sent invalid response: \"%V\"", &s->out);
 830
 831     s->out.len = b->last - b->pos;
 832     s->out.data = b->pos;
 833
 834     return NGX_ERROR;
 835 }
 836
 837
 838 static void
 839 ngx_mail_proxy_handler(ngx_event_t *ev)
 840 {
 841     char                   *action, *recv_action, *send_action;
 842     size_t                  size;
 843     ssize_t                 n;
 844     ngx_buf_t              *b;
 845     ngx_uint_t              do_write;
 846     ngx_connection_t       *c, *src, *dst;
 847     ngx_mail_session_t     *s;
 848     ngx_mail_proxy_conf_t  *pcf;
 849
 850     c = ev->data;
 851     s = c->data;
 852
 853     if (ev->timedout) {
 854         c->log->action = "proxying";
 855
 856         if (c == s->connection) {
 857             ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT,
 858                           "client timed out");
 859             c->timedout = 1;
 860
 861         } else {
 862             ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT,
 863                           "upstream timed out");
 864         }
 865
 866         ngx_mail_proxy_close_session(s);
 867         return;
 868     }
 869
 870     if (c == s->connection) {
 871         if (ev->write) {
 872             recv_action = "proxying and reading from upstream";
 873             send_action = "proxying and sending to client";
 874             src = s->proxy->upstream.connection;
 875             dst = c;
 876             b = s->proxy->buffer;
 877
 878         } else {
 879             recv_action = "proxying and reading from client";
 880             send_action = "proxying and sending to upstream";
 881             src = c;
 882             dst = s->proxy->upstream.connection;
 883             b = s->buffer;
 884         }
 885
 886     } else {
 887         if (ev->write) {
 888             recv_action = "proxying and reading from client";
 889             send_action = "proxying and sending to upstream";
 890             src = s->connection;
 891             dst = c;
 892             b = s->buffer;
 893
 894         } else {
 895             recv_action = "proxying and reading from upstream";
 896             send_action = "proxying and sending to client";
 897             src = c;
 898             dst = s->connection;
 899             b = s->proxy->buffer;
 900         }
 901     }
 902
 903     do_write = ev->write ? 1 : 0;
 904
 905     ngx_log_debug3(NGX_LOG_DEBUG_MAIL, ev->log, 0,
 906                    "mail proxy handler: %d, #%d > #%d",
 907                    do_write, src->fd, dst->fd);
 908
 909     for ( ;; ) {
 910
 911         if (do_write) {
 912
 913             size = b->last - b->pos;
 914
 915             if (size && dst->write->ready) {
 916                 c->log->action = send_action;
 917
 918                 n = dst->send(dst, b->pos, size);
 919
 920                 if (n == NGX_ERROR) {
 921                     ngx_mail_proxy_close_session(s);
 922                     return;
 923                 }
 924
 925                 if (n > 0) {
 926                     b->pos += n;
 927
 928                     if (b->pos == b->last) {
 929                         b->pos = b->start;
 930                         b->last = b->start;
 931                     }
 932                 }
 933             }
 934         }
 935
 936         size = b->end - b->last;
 937
 938         if (size && src->read->ready) {
 939             c->log->action = recv_action;
 940
 941             n = src->recv(src, b->last, size);
 942
 943             if (n == NGX_AGAIN || n == 0) {
 944                 break;
 945             }
 946
 947             if (n > 0) {
 948                 do_write = 1;
 949                 b->last += n;
 950
 951                 continue;
 952             }
 953
 954             if (n == NGX_ERROR) {
 955                 src->read->eof = 1;
 956             }
 957         }
 958
 959         break;
 960     }
 961
 962     c->log->action = "proxying";
 963
 964     if ((s->connection->read->eof && s->buffer->pos == s->buffer->last)
 965         || (s->proxy->upstream.connection->read->eof
 966             && s->proxy->buffer->pos == s->proxy->buffer->last)
 967         || (s->connection->read->eof
 968             && s->proxy->upstream.connection->read->eof))
 969     {
 970         action = c->log->action;
 971         c->log->action = NULL;
 972         ngx_log_error(NGX_LOG_INFO, c->log, 0, "proxied session done");
 973         c->log->action = action;
 974
 975         ngx_mail_proxy_close_session(s);
 976         return;
 977     }
 978
 979     if (ngx_handle_write_event(dst->write, 0) != NGX_OK) {
 980         ngx_mail_proxy_close_session(s);
 981         return;
 982     }
 983
 984     if (ngx_handle_read_event(dst->read, 0) != NGX_OK) {
 985         ngx_mail_proxy_close_session(s);
 986         return;
 987     }
 988
 989     if (ngx_handle_write_event(src->write, 0) != NGX_OK) {
 990         ngx_mail_proxy_close_session(s);
 991         return;
 992     }
 993
 994     if (ngx_handle_read_event(src->read, 0) != NGX_OK) {
 995         ngx_mail_proxy_close_session(s);
 996         return;
 997     }
 998
 999     if (c == s->connection) {
1000         pcf = ngx_mail_get_module_srv_conf(s, ngx_mail_proxy_module);
1001         ngx_add_timer(c->read, pcf->timeout);
1002     }
1003 }
1004
1005
1006 static void
1007 ngx_mail_proxy_upstream_error(ngx_mail_session_t *s)
1008 {
1009     if (s->proxy->upstream.connection) {
1010         ngx_log_debug1(NGX_LOG_DEBUG_MAIL, s->connection->log, 0,
1011                        "close mail proxy connection: %d",
1012                        s->proxy->upstream.connection->fd);
1013
1014         ngx_close_connection(s->proxy->upstream.connection);
1015     }
1016
1017     if (s->out.len == 0) {
1018         ngx_mail_session_internal_server_error(s);
1019         return;
1020     }
1021
1022     s->quit = 1;
1023     ngx_mail_send(s->connection->write);
1024 }
1025
1026
1027 static void
1028 ngx_mail_proxy_internal_server_error(ngx_mail_session_t *s)
1029 {
1030     if (s->proxy->upstream.connection) {
1031         ngx_log_debug1(NGX_LOG_DEBUG_MAIL, s->connection->log, 0,
1032                        "close mail proxy connection: %d",
1033                        s->proxy->upstream.connection->fd);
1034
1035         ngx_close_connection(s->proxy->upstream.connection);
1036     }
1037
1038     ngx_mail_session_internal_server_error(s);
1039 }
1040
1041
1042 static void
1043 ngx_mail_proxy_close_session(ngx_mail_session_t *s)
1044 {
1045     if (s->proxy->upstream.connection) {
1046         ngx_log_debug1(NGX_LOG_DEBUG_MAIL, s->connection->log, 0,
1047                        "close mail proxy connection: %d",
1048                        s->proxy->upstream.connection->fd);
1049
1050         ngx_close_connection(s->proxy->upstream.connection);
1051     }
1052
1053     ngx_mail_close_connection(s->connection);
1054 }
1055
1056
1057 static void *
1058 ngx_mail_proxy_create_conf(ngx_conf_t *cf)
1059 {
1060     ngx_mail_proxy_conf_t  *pcf;
1061
1062     pcf = ngx_pcalloc(cf->pool, sizeof(ngx_mail_proxy_conf_t));
1063     if (pcf == NULL) {
1064         return NGX_CONF_ERROR;
1065     }
1066
1067     pcf->enable = NGX_CONF_UNSET;
1068     pcf->pass_error_message = NGX_CONF_UNSET;
1069     pcf->xclient = NGX_CONF_UNSET;
1070     pcf->buffer_size = NGX_CONF_UNSET_SIZE;
1071     pcf->timeout = NGX_CONF_UNSET_MSEC;
1072
1073     return pcf;
1074 }
1075
1076
1077 static char *
1078 ngx_mail_proxy_merge_conf(ngx_conf_t *cf, void *parent, void *child)
1079 {
1080     ngx_mail_proxy_conf_t *prev = parent;
1081     ngx_mail_proxy_conf_t *conf = child;
1082
1083     ngx_conf_merge_value(conf->enable, prev->enable, 0);
1084     ngx_conf_merge_value(conf->pass_error_message, prev->pass_error_message, 0);
1085     ngx_conf_merge_value(conf->xclient, prev->xclient, 1);
1086     ngx_conf_merge_size_value(conf->buffer_size, prev->buffer_size,
1087                               (size_t) ngx_pagesize);
1088     ngx_conf_merge_msec_value(conf->timeout, prev->timeout, 24 * 60 * 60000);
1089
1090     return NGX_CONF_OK;
1091 }