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 PROTO=SMTP HELO= ADDR= LOGIN= NAME="
 543                           CRLF) - 1
 544                    + s->esmtp + s->smtp_helo.len
 545                    + s->connection->addr_text.len + s->login.len + s->host.len;
 546
 547         line.data = ngx_pnalloc(c->pool, line.len);
 548         if (line.data == NULL) {
 549             ngx_mail_proxy_internal_server_error(s);
 550             return;
 551         }
 552
 553         line.len = ngx_sprintf(line.data,
 554                        "XCLIENT PROTO=%sSMTP%s%V ADDR=%V%s%V NAME=%V" CRLF,
 555                        (s->esmtp ? "E" : ""),
 556                        (s->smtp_helo.len ? " HELO=" : ""), &s->smtp_helo,
 557                        &s->connection->addr_text,
 558                        (s->login.len ? " LOGIN=" : ""), &s->login, &s->host)
 559                    - line.data;
 560
 561         s->mail_state = (s->auth_method == NGX_MAIL_AUTH_NONE) ?
 562                             ngx_smtp_xclient_from : ngx_smtp_xclient;
 563
 564         break;
 565
 566     case ngx_smtp_helo_from:
 567     case ngx_smtp_xclient_from:
 568         ngx_log_debug0(NGX_LOG_DEBUG_MAIL, rev->log, 0,
 569                        "mail proxy send mail from");
 570
 571         s->connection->log->action = "sending MAIL FROM to upstream";
 572
 573         line.len = s->smtp_from.len + sizeof(CRLF) - 1;
 574         line.data = ngx_pnalloc(c->pool, line.len);
 575         if (line.data == NULL) {
 576             ngx_mail_proxy_internal_server_error(s);
 577             return;
 578         }
 579
 580         p = ngx_cpymem(line.data, s->smtp_from.data, s->smtp_from.len);
 581         *p++ = CR; *p = LF;
 582
 583         s->mail_state = ngx_smtp_from;
 584
 585         break;
 586
 587     case ngx_smtp_from:
 588         ngx_log_debug0(NGX_LOG_DEBUG_MAIL, rev->log, 0,
 589                        "mail proxy send rcpt to");
 590
 591         s->connection->log->action = "sending RCPT TO to upstream";
 592
 593         line.len = s->smtp_to.len + sizeof(CRLF) - 1;
 594         line.data = ngx_pnalloc(c->pool, line.len);
 595         if (line.data == NULL) {
 596             ngx_mail_proxy_internal_server_error(s);
 597             return;
 598         }
 599
 600         p = ngx_cpymem(line.data, s->smtp_to.data, s->smtp_to.len);
 601         *p++ = CR; *p = LF;
 602
 603         s->mail_state = ngx_smtp_to;
 604
 605         break;
 606
 607     case ngx_smtp_helo:
 608     case ngx_smtp_xclient:
 609     case ngx_smtp_to:
 610
 611         b = s->proxy->buffer;
 612
 613         if (s->auth_method == NGX_MAIL_AUTH_NONE) {
 614             b->pos = b->start;
 615
 616         } else {
 617             ngx_memcpy(b->start, smtp_auth_ok, sizeof(smtp_auth_ok) - 1);
 618             b->last = b->start + sizeof(smtp_auth_ok) - 1;
 619         }
 620
 621         s->connection->read->handler = ngx_mail_proxy_handler;
 622         s->connection->write->handler = ngx_mail_proxy_handler;
 623         rev->handler = ngx_mail_proxy_handler;
 624         c->write->handler = ngx_mail_proxy_handler;
 625
 626         pcf = ngx_mail_get_module_srv_conf(s, ngx_mail_proxy_module);
 627         ngx_add_timer(s->connection->read, pcf->timeout);
 628         ngx_del_timer(c->read);
 629
 630         c->log->action = NULL;
 631         ngx_log_error(NGX_LOG_INFO, c->log, 0, "client logged in");
 632
 633         ngx_mail_proxy_handler(s->connection->write);
 634
 635         return;
 636
 637     default:
 638 #if (NGX_SUPPRESS_WARN)
 639         line.len = 0;
 640         line.data = NULL;
 641 #endif
 642         break;
 643     }
 644
 645     if (c->send(c, line.data, line.len) < (ssize_t) line.len) {
 646         /*
 647          * we treat the incomplete sending as NGX_ERROR
 648          * because it is very strange here
 649          */
 650         ngx_mail_proxy_internal_server_error(s);
 651         return;
 652     }
 653
 654     s->proxy->buffer->pos = s->proxy->buffer->start;
 655     s->proxy->buffer->last = s->proxy->buffer->start;
 656 }
 657
 658
 659 static void
 660 ngx_mail_proxy_dummy_handler(ngx_event_t *wev)
 661 {
 662     ngx_connection_t    *c;
 663     ngx_mail_session_t  *s;
 664
 665     ngx_log_debug0(NGX_LOG_DEBUG_MAIL, wev->log, 0, "mail proxy dummy handler");
 666
 667     if (ngx_handle_write_event(wev, 0) != NGX_OK) {
 668         c = wev->data;
 669         s = c->data;
 670
 671         ngx_mail_proxy_close_session(s);
 672     }
 673 }
 674
 675
 676 static ngx_int_t
 677 ngx_mail_proxy_read_response(ngx_mail_session_t *s, ngx_uint_t state)
 678 {
 679     u_char                 *p;
 680     ssize_t                 n;
 681     ngx_buf_t              *b;
 682     ngx_mail_proxy_conf_t  *pcf;
 683
 684     s->connection->log->action = "reading response from upstream";
 685
 686     b = s->proxy->buffer;
 687
 688     n = s->proxy->upstream.connection->recv(s->proxy->upstream.connection,
 689                                             b->last, b->end - b->last);
 690
 691     if (n == NGX_ERROR || n == 0) {
 692         return NGX_ERROR;
 693     }
 694
 695     if (n == NGX_AGAIN) {
 696         return NGX_AGAIN;
 697     }
 698
 699     b->last += n;
 700
 701     if (b->last - b->pos < 5) {
 702         return NGX_AGAIN;
 703     }
 704
 705     if (*(b->last - 2) != CR || *(b->last - 1) != LF) {
 706         if (b->last == b->end) {
 707             *(b->last - 1) = '\0';
 708             ngx_log_error(NGX_LOG_ERR, s->connection->log, 0,
 709                           "upstream sent too long response line: \"%s\"",
 710                           b->pos);
 711             return NGX_ERROR;
 712         }
 713
 714         return NGX_AGAIN;
 715     }
 716
 717     p = b->pos;
 718
 719     switch (s->protocol) {
 720
 721     case NGX_MAIL_POP3_PROTOCOL:
 722         if (p[0] == '+' && p[1] == 'O' && p[2] == 'K') {
 723             return NGX_OK;
 724         }
 725         break;
 726
 727     case NGX_MAIL_IMAP_PROTOCOL:
 728         switch (state) {
 729
 730         case ngx_imap_start:
 731             if (p[0] == '*' && p[1] == ' ' && p[2] == 'O' && p[3] == 'K') {
 732                 return NGX_OK;
 733             }
 734             break;
 735
 736         case ngx_imap_login:
 737         case ngx_imap_user:
 738             if (p[0] == '+') {
 739                 return NGX_OK;
 740             }
 741             break;
 742
 743         case ngx_imap_passwd:
 744             if (ngx_strncmp(p, s->tag.data, s->tag.len) == 0) {
 745                 p += s->tag.len;
 746                 if (p[0] == 'O' && p[1] == 'K') {
 747                     return NGX_OK;
 748                 }
 749             }
 750             break;
 751         }
 752
 753         break;
 754
 755     default: /* NGX_MAIL_SMTP_PROTOCOL */
 756         switch (state) {
 757
 758         case ngx_smtp_start:
 759             if (p[0] == '2' && p[1] == '2' && p[2] == '0') {
 760                 return NGX_OK;
 761             }
 762             break;
 763
 764         case ngx_smtp_helo:
 765         case ngx_smtp_helo_xclient:
 766         case ngx_smtp_helo_from:
 767         case ngx_smtp_from:
 768             if (p[0] == '2' && p[1] == '5' && p[2] == '0') {
 769                 return NGX_OK;
 770             }
 771             break;
 772
 773         case ngx_smtp_xclient:
 774         case ngx_smtp_xclient_from:
 775             if (p[0] == '2' && (p[1] == '2' || p[1] == '5') && p[2] == '0') {
 776                 return NGX_OK;
 777             }
 778             break;
 779
 780         case ngx_smtp_to:
 781             return NGX_OK;
 782         }
 783
 784         break;
 785     }
 786
 787     pcf = ngx_mail_get_module_srv_conf(s, ngx_mail_proxy_module);
 788
 789     if (pcf->pass_error_message == 0) {
 790         *(b->last - 2) = '\0';
 791         ngx_log_error(NGX_LOG_ERR, s->connection->log, 0,
 792                       "upstream sent invalid response: \"%s\"", p);
 793         return NGX_ERROR;
 794     }
 795
 796     s->out.len = b->last - p - 2;
 797     s->out.data = p;
 798
 799     ngx_log_error(NGX_LOG_INFO, s->connection->log, 0,
 800                   "upstream sent invalid response: \"%V\"", &s->out);
 801
 802     s->out.len = b->last - b->pos;
 803     s->out.data = b->pos;
 804
 805     return NGX_ERROR;
 806 }
 807
 808
 809 static void
 810 ngx_mail_proxy_handler(ngx_event_t *ev)
 811 {
 812     char                   *action, *recv_action, *send_action;
 813     size_t                  size;
 814     ssize_t                 n;
 815     ngx_buf_t              *b;
 816     ngx_uint_t              do_write;
 817     ngx_connection_t       *c, *src, *dst;
 818     ngx_mail_session_t     *s;
 819     ngx_mail_proxy_conf_t  *pcf;
 820
 821     c = ev->data;
 822     s = c->data;
 823
 824     if (ev->timedout) {
 825         c->log->action = "proxying";
 826
 827         if (c == s->connection) {
 828             ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT,
 829                           "client timed out");
 830             c->timedout = 1;
 831
 832         } else {
 833             ngx_log_error(NGX_LOG_INFO, c->log, NGX_ETIMEDOUT,
 834                           "upstream timed out");
 835         }
 836
 837         ngx_mail_proxy_close_session(s);
 838         return;
 839     }
 840
 841     if (c == s->connection) {
 842         if (ev->write) {
 843             recv_action = "proxying and reading from upstream";
 844             send_action = "proxying and sending to client";
 845             src = s->proxy->upstream.connection;
 846             dst = c;
 847             b = s->proxy->buffer;
 848
 849         } else {
 850             recv_action = "proxying and reading from client";
 851             send_action = "proxying and sending to upstream";
 852             src = c;
 853             dst = s->proxy->upstream.connection;
 854             b = s->buffer;
 855         }
 856
 857     } else {
 858         if (ev->write) {
 859             recv_action = "proxying and reading from client";
 860             send_action = "proxying and sending to upstream";
 861             src = s->connection;
 862             dst = c;
 863             b = s->buffer;
 864
 865         } else {
 866             recv_action = "proxying and reading from upstream";
 867             send_action = "proxying and sending to client";
 868             src = c;
 869             dst = s->connection;
 870             b = s->proxy->buffer;
 871         }
 872     }
 873
 874     do_write = ev->write ? 1 : 0;
 875
 876     ngx_log_debug3(NGX_LOG_DEBUG_MAIL, ev->log, 0,
 877                    "mail proxy handler: %d, #%d > #%d",
 878                    do_write, src->fd, dst->fd);
 879
 880     for ( ;; ) {
 881
 882         if (do_write) {
 883
 884             size = b->last - b->pos;
 885
 886             if (size && dst->write->ready) {
 887                 c->log->action = send_action;
 888
 889                 n = dst->send(dst, b->pos, size);
 890
 891                 if (n == NGX_ERROR) {
 892                     ngx_mail_proxy_close_session(s);
 893                     return;
 894                 }
 895
 896                 if (n > 0) {
 897                     b->pos += n;
 898
 899                     if (b->pos == b->last) {
 900                         b->pos = b->start;
 901                         b->last = b->start;
 902                     }
 903                 }
 904             }
 905         }
 906
 907         size = b->end - b->last;
 908
 909         if (size && src->read->ready) {
 910             c->log->action = recv_action;
 911
 912             n = src->recv(src, b->last, size);
 913
 914             if (n == NGX_AGAIN || n == 0) {
 915                 break;
 916             }
 917
 918             if (n > 0) {
 919                 do_write = 1;
 920                 b->last += n;
 921
 922                 continue;
 923             }
 924
 925             if (n == NGX_ERROR) {
 926                 src->read->eof = 1;
 927             }
 928         }
 929
 930         break;
 931     }
 932
 933     c->log->action = "proxying";
 934
 935     if ((s->connection->read->eof && s->buffer->pos == s->buffer->last)
 936         || (s->proxy->upstream.connection->read->eof
 937             && s->proxy->buffer->pos == s->proxy->buffer->last)
 938         || (s->connection->read->eof
 939             && s->proxy->upstream.connection->read->eof))
 940     {
 941         action = c->log->action;
 942         c->log->action = NULL;
 943         ngx_log_error(NGX_LOG_INFO, c->log, 0, "proxied session done");
 944         c->log->action = action;
 945
 946         ngx_mail_proxy_close_session(s);
 947         return;
 948     }
 949
 950     if (ngx_handle_write_event(dst->write, 0) != NGX_OK) {
 951         ngx_mail_proxy_close_session(s);
 952         return;
 953     }
 954
 955     if (ngx_handle_read_event(dst->read, 0) != NGX_OK) {
 956         ngx_mail_proxy_close_session(s);
 957         return;
 958     }
 959
 960     if (ngx_handle_write_event(src->write, 0) != NGX_OK) {
 961         ngx_mail_proxy_close_session(s);
 962         return;
 963     }
 964
 965     if (ngx_handle_read_event(src->read, 0) != NGX_OK) {
 966         ngx_mail_proxy_close_session(s);
 967         return;
 968     }
 969
 970     if (c == s->connection) {
 971         pcf = ngx_mail_get_module_srv_conf(s, ngx_mail_proxy_module);
 972         ngx_add_timer(c->read, pcf->timeout);
 973     }
 974 }
 975
 976
 977 static void
 978 ngx_mail_proxy_upstream_error(ngx_mail_session_t *s)
 979 {
 980     if (s->proxy->upstream.connection) {
 981         ngx_log_debug1(NGX_LOG_DEBUG_MAIL, s->connection->log, 0,
 982                        "close mail proxy connection: %d",
 983                        s->proxy->upstream.connection->fd);
 984
 985         ngx_close_connection(s->proxy->upstream.connection);
 986     }
 987
 988     if (s->out.len == 0) {
 989         ngx_mail_session_internal_server_error(s);
 990         return;
 991     }
 992
 993     s->quit = 1;
 994     ngx_mail_send(s->connection->write);
 995 }
 996
 997
 998 static void
 999 ngx_mail_proxy_internal_server_error(ngx_mail_session_t *s)
1000 {
1001     if (s->proxy->upstream.connection) {
1002         ngx_log_debug1(NGX_LOG_DEBUG_MAIL, s->connection->log, 0,
1003                        "close mail proxy connection: %d",
1004                        s->proxy->upstream.connection->fd);
1005
1006         ngx_close_connection(s->proxy->upstream.connection);
1007     }
1008
1009     ngx_mail_session_internal_server_error(s);
1010 }
1011
1012
1013 static void
1014 ngx_mail_proxy_close_session(ngx_mail_session_t *s)
1015 {
1016     if (s->proxy->upstream.connection) {
1017         ngx_log_debug1(NGX_LOG_DEBUG_MAIL, s->connection->log, 0,
1018                        "close mail proxy connection: %d",
1019                        s->proxy->upstream.connection->fd);
1020
1021         ngx_close_connection(s->proxy->upstream.connection);
1022     }
1023
1024     ngx_mail_close_connection(s->connection);
1025 }
1026
1027
1028 static void *
1029 ngx_mail_proxy_create_conf(ngx_conf_t *cf)
1030 {
1031     ngx_mail_proxy_conf_t  *pcf;
1032
1033     pcf = ngx_pcalloc(cf->pool, sizeof(ngx_mail_proxy_conf_t));
1034     if (pcf == NULL) {
1035         return NGX_CONF_ERROR;
1036     }
1037
1038     pcf->enable = NGX_CONF_UNSET;
1039     pcf->pass_error_message = NGX_CONF_UNSET;
1040     pcf->xclient = NGX_CONF_UNSET;
1041     pcf->buffer_size = NGX_CONF_UNSET_SIZE;
1042     pcf->timeout = NGX_CONF_UNSET_MSEC;
1043
1044     return pcf;
1045 }
1046
1047
1048 static char *
1049 ngx_mail_proxy_merge_conf(ngx_conf_t *cf, void *parent, void *child)
1050 {
1051     ngx_mail_proxy_conf_t *prev = parent;
1052     ngx_mail_proxy_conf_t *conf = child;
1053
1054     ngx_conf_merge_value(conf->enable, prev->enable, 0);
1055     ngx_conf_merge_value(conf->pass_error_message, prev->pass_error_message, 0);
1056     ngx_conf_merge_value(conf->xclient, prev->xclient, 1);
1057     ngx_conf_merge_size_value(conf->buffer_size, prev->buffer_size,
1058                               (size_t) ngx_pagesize);
1059     ngx_conf_merge_msec_value(conf->timeout, prev->timeout, 24 * 60 * 60000);
1060
1061     return NGX_CONF_OK;
1062 }