1 /* 2 * Copyright (c) 2008 The DragonFly Project. All rights reserved. 3 * 4 * This code is derived from software contributed to The DragonFly Project 5 * by Matthias Schmidt <matthias@dragonflybsd.org>, University of Marburg, 6 * Germany. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in 16 * the documentation and/or other materials provided with the 17 * distribution. 18 * 3. Neither the name of The DragonFly Project nor the names of its 19 * contributors may be used to endorse or promote products derived 20 * from this software without specific, prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 23 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 24 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 25 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 26 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 27 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, 28 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 29 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 30 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 31 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 32 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 33 * SUCH DAMAGE. 34 */ 35 36 #include <sys/param.h> 37 #include <sys/queue.h> 38 #include <sys/stat.h> 39 #include <sys/types.h> 40 #include <sys/socket.h> 41 #include <netinet/in.h> 42 #include <arpa/inet.h> 43 44 #include <openssl/ssl.h> 45 #include <openssl/err.h> 46 47 #include <err.h> 48 #include <errno.h> 49 #include <netdb.h> 50 #include <setjmp.h> 51 #include <signal.h> 52 #include <syslog.h> 53 #include <unistd.h> 54 55 #include "dma.h" 56 57 static jmp_buf timeout_alarm; 58 char neterr[BUF_SIZE]; 59 60 char * 61 ssl_errstr(void) 62 { 63 long oerr, nerr; 64 65 oerr = 0; 66 while ((nerr = ERR_get_error()) != 0) 67 oerr = nerr; 68 69 return (ERR_error_string(oerr, NULL)); 70 } 71 72 static void 73 sig_alarm(int signo) 74 { 75 (void)signo; /* so that gcc doesn't complain */ 76 longjmp(timeout_alarm, 1); 77 } 78 79 ssize_t 80 send_remote_command(int fd, const char* fmt, ...) 81 { 82 va_list va; 83 char cmd[4096]; 84 size_t len, pos; 85 int s; 86 ssize_t n; 87 88 va_start(va, fmt); 89 s = vsnprintf(cmd, sizeof(cmd) - 2, fmt, va); 90 va_end(va); 91 if (s == sizeof(cmd) - 2 || s < 0) { 92 strcpy(neterr, "Internal error: oversized command string"); 93 return (-1); 94 } 95 96 /* We *know* there are at least two more bytes available */ 97 strcat(cmd, "\r\n"); 98 len = strlen(cmd); 99 100 if (((config.features & SECURETRANS) != 0) && 101 ((config.features & NOSSL) == 0)) { 102 while ((s = SSL_write(config.ssl, (const char*)cmd, len)) <= 0) { 103 s = SSL_get_error(config.ssl, s); 104 if (s != SSL_ERROR_WANT_READ && 105 s != SSL_ERROR_WANT_WRITE) { 106 strncpy(neterr, ssl_errstr(), sizeof(neterr)); 107 return (-1); 108 } 109 } 110 } 111 else { 112 pos = 0; 113 while (pos < len) { 114 n = write(fd, cmd + pos, len - pos); 115 if (n < 0) 116 return (-1); 117 pos += n; 118 } 119 } 120 121 return (len); 122 } 123 124 int 125 read_remote(int fd, int extbufsize, char *extbuf) 126 { 127 ssize_t rlen = 0; 128 size_t pos, len; 129 char buff[BUF_SIZE]; 130 int done = 0, status = 0, extbufpos = 0; 131 132 if (signal(SIGALRM, sig_alarm) == SIG_ERR) { 133 snprintf(neterr, sizeof(neterr), "SIGALRM error: %s", 134 strerror(errno)); 135 return (-1); 136 } 137 if (setjmp(timeout_alarm) != 0) { 138 snprintf(neterr, sizeof(neterr), "Timeout reached"); 139 return (-1); 140 } 141 alarm(CON_TIMEOUT); 142 143 /* 144 * Remote reading code from femail.c written by Henning Brauer of 145 * OpenBSD and released under a BSD style license. 146 */ 147 for (len = pos = 0; !done; ) { 148 rlen = 0; 149 if (pos == 0 || 150 (pos > 0 && memchr(buff + pos, '\n', len - pos) == NULL)) { 151 memmove(buff, buff + pos, len - pos); 152 len -= pos; 153 pos = 0; 154 if (((config.features & SECURETRANS) != 0) && 155 (config.features & NOSSL) == 0) { 156 if ((rlen = SSL_read(config.ssl, buff + len, 157 sizeof(buff) - len)) == -1) { 158 strncpy(neterr, ssl_errstr(), sizeof(neterr)); 159 return (-1); 160 } 161 } else { 162 if ((rlen = read(fd, buff + len, sizeof(buff) - len)) == -1) { 163 strncpy(neterr, strerror(errno), sizeof(neterr)); 164 return (-1); 165 } 166 } 167 len += rlen; 168 } 169 /* 170 * If there is an external buffer with a size bigger than zero 171 * and as long as there is space in the external buffer and 172 * there are new characters read from the mailserver 173 * copy them to the external buffer 174 */ 175 if (extbufpos <= (extbufsize - 1) && rlen && extbufsize > 0 176 && extbuf != NULL) { 177 /* do not write over the bounds of the buffer */ 178 if(extbufpos + rlen > (extbufsize - 1)) { 179 rlen = extbufsize - extbufpos; 180 } 181 memcpy(extbuf + extbufpos, buff + len - rlen, rlen); 182 extbufpos += rlen; 183 } 184 for (; pos < len && buff[pos] >= '0' && buff[pos] <= '9'; pos++) 185 ; /* Do nothing */ 186 187 if (pos == len) 188 return (0); 189 190 if (buff[pos] == ' ') { 191 done = 1; 192 } else if (buff[pos] != '-') { 193 strcpy(neterr, "invalid syntax in reply from server"); 194 return (-1); 195 } 196 197 /* skip up to \n */ 198 for (; pos < len && buff[pos - 1] != '\n'; pos++) 199 ; /* Do nothing */ 200 201 } 202 alarm(0); 203 204 buff[len] = '\0'; 205 while (len > 0 && (buff[len - 1] == '\r' || buff[len - 1] == '\n')) 206 buff[--len] = '\0'; 207 snprintf(neterr, sizeof(neterr), "%s", buff); 208 status = atoi(buff); 209 return (status/100); 210 } 211 212 /* 213 * Handle SMTP authentication 214 */ 215 static int 216 smtp_login(int fd, char *login, char* password) 217 { 218 char *temp; 219 int len, res = 0; 220 221 res = smtp_auth_md5(fd, login, password); 222 if (res == 0) { 223 return (0); 224 } else if (res == -2) { 225 /* 226 * If the return code is -2, then then the login attempt failed, 227 * do not try other login mechanisms 228 */ 229 return (1); 230 } 231 232 if ((config.features & INSECURE) != 0 || 233 (config.features & SECURETRANS) != 0) { 234 /* Send AUTH command according to RFC 2554 */ 235 send_remote_command(fd, "AUTH LOGIN"); 236 if (read_remote(fd, 0, NULL) != 3) { 237 syslog(LOG_NOTICE, "remote delivery deferred:" 238 " AUTH login not available: %s", 239 neterr); 240 return (1); 241 } 242 243 len = base64_encode(login, strlen(login), &temp); 244 if (len < 0) { 245 encerr: 246 syslog(LOG_ERR, "can not encode auth reply: %m"); 247 return (1); 248 } 249 250 send_remote_command(fd, "%s", temp); 251 free(temp); 252 res = read_remote(fd, 0, NULL); 253 if (res != 3) { 254 syslog(LOG_NOTICE, "remote delivery %s: AUTH login failed: %s", 255 res == 5 ? "failed" : "deferred", neterr); 256 return (res == 5 ? -1 : 1); 257 } 258 259 len = base64_encode(password, strlen(password), &temp); 260 if (len < 0) 261 goto encerr; 262 263 send_remote_command(fd, "%s", temp); 264 free(temp); 265 res = read_remote(fd, 0, NULL); 266 if (res != 2) { 267 syslog(LOG_NOTICE, "remote delivery %s: Authentication failed: %s", 268 res == 5 ? "failed" : "deferred", neterr); 269 return (res == 5 ? -1 : 1); 270 } 271 } else { 272 syslog(LOG_WARNING, "non-encrypted SMTP login is disabled in config, so skipping it. "); 273 return (1); 274 } 275 276 return (0); 277 } 278 279 static int 280 open_connection(struct mx_hostentry *h) 281 { 282 int fd; 283 284 syslog(LOG_INFO, "trying remote delivery to %s [%s] pref %d", 285 h->host, h->addr, h->pref); 286 287 fd = socket(h->ai.ai_family, h->ai.ai_socktype, h->ai.ai_protocol); 288 if (fd < 0) { 289 syslog(LOG_INFO, "socket for %s [%s] failed: %m", 290 h->host, h->addr); 291 return (-1); 292 } 293 294 if (connect(fd, (struct sockaddr *)&h->sa, h->ai.ai_addrlen) < 0) { 295 syslog(LOG_INFO, "connect to %s [%s] failed: %m", 296 h->host, h->addr); 297 close(fd); 298 return (-1); 299 } 300 301 return (fd); 302 } 303 304 static void 305 close_connection(int fd) 306 { 307 if (config.ssl != NULL) { 308 if (((config.features & SECURETRANS) != 0) && 309 ((config.features & NOSSL) == 0)) 310 SSL_shutdown(config.ssl); 311 312 SSL_free(config.ssl); 313 } 314 315 close(fd); 316 } 317 318 static int 319 deliver_to_host(struct qitem *it, struct mx_hostentry *host, void *errmsgc) 320 { 321 struct authuser *a; 322 char line[1000]; 323 size_t linelen; 324 int fd, error = 0, do_auth = 0, res = 0; 325 326 if (fseek(it->mailf, 0, SEEK_SET) != 0) { 327 asprintf(errmsgc, "can not seek: %s", strerror(errno)); 328 return (-1); 329 } 330 331 fd = open_connection(host); 332 if (fd < 0) 333 return (1); 334 335 #define READ_REMOTE_CHECK(c, exp) \ 336 res = read_remote(fd, 0, NULL); \ 337 if (res == 5) { \ 338 syslog(LOG_ERR, "remote delivery to %s [%s] failed after %s: %s", \ 339 host->host, host->addr, c, neterr); \ 340 asprintf(errmsgc, "%s [%s] did not like our %s:\n%s", \ 341 host->host, host->addr, c, neterr); \ 342 return (-1); \ 343 } else if (res != exp) { \ 344 syslog(LOG_NOTICE, "remote delivery deferred: %s [%s] failed after %s: %s", \ 345 host->host, host->addr, c, neterr); \ 346 return (1); \ 347 } 348 349 /* Check first reply from remote host */ 350 config.features |= NOSSL; 351 READ_REMOTE_CHECK("connect", 2); 352 353 config.features &= ~NOSSL; 354 355 if ((config.features & SECURETRANS) != 0) { 356 error = smtp_init_crypto(fd, config.features); 357 if (error == 0) 358 syslog(LOG_DEBUG, "SSL initialization successful"); 359 else 360 goto out; 361 } 362 363 /* XXX allow HELO fallback */ 364 /* XXX record ESMTP keywords */ 365 send_remote_command(fd, "EHLO %s", hostname()); 366 READ_REMOTE_CHECK("EHLO", 2); 367 368 /* 369 * Use SMTP authentication if the user defined an entry for the remote 370 * or smarthost 371 */ 372 SLIST_FOREACH(a, &authusers, next) { 373 if (strcmp(a->host, host->host) == 0) { 374 do_auth = 1; 375 break; 376 } 377 } 378 379 if (do_auth == 1) { 380 /* 381 * Check if the user wants plain text login without using 382 * encryption. 383 */ 384 syslog(LOG_INFO, "using SMTP authentication for user %s", a->login); 385 error = smtp_login(fd, a->login, a->password); 386 if (error < 0) { 387 syslog(LOG_ERR, "remote delivery failed:" 388 " SMTP login failed: %m"); 389 asprintf(errmsgc, "SMTP login to %s failed", host->host); 390 return (-1); 391 } 392 /* SMTP login is not available, so try without */ 393 else if (error > 0) { 394 syslog(LOG_WARNING, "SMTP login not available. Trying without."); 395 } 396 } 397 398 /* XXX send ESMTP ENVID, RET (FULL/HDRS) and 8BITMIME */ 399 send_remote_command(fd, "MAIL FROM:<%s>", it->sender); 400 READ_REMOTE_CHECK("MAIL FROM", 2); 401 402 /* XXX send ESMTP ORCPT */ 403 send_remote_command(fd, "RCPT TO:<%s>", it->addr); 404 READ_REMOTE_CHECK("RCPT TO", 2); 405 406 send_remote_command(fd, "DATA"); 407 READ_REMOTE_CHECK("DATA", 3); 408 409 error = 0; 410 while (!feof(it->mailf)) { 411 if (fgets(line, sizeof(line), it->mailf) == NULL) 412 break; 413 linelen = strlen(line); 414 if (linelen == 0 || line[linelen - 1] != '\n') { 415 syslog(LOG_CRIT, "remote delivery failed: corrupted queue file"); 416 *(const char **)errmsgc = "corrupted queue file"; 417 error = -1; 418 goto out; 419 } 420 421 /* Remove trailing \n's and escape leading dots */ 422 trim_line(line); 423 424 /* 425 * If the first character is a dot, we escape it so the line 426 * length increases 427 */ 428 if (line[0] == '.') 429 linelen++; 430 431 if (send_remote_command(fd, "%s", line) != (ssize_t)linelen+1) { 432 syslog(LOG_NOTICE, "remote delivery deferred: write error"); 433 error = 1; 434 goto out; 435 } 436 } 437 438 send_remote_command(fd, "."); 439 READ_REMOTE_CHECK("final DATA", 2); 440 441 send_remote_command(fd, "QUIT"); 442 if (read_remote(fd, 0, NULL) != 2) 443 syslog(LOG_INFO, "remote delivery succeeded but QUIT failed: %s", neterr); 444 out: 445 446 close_connection(fd); 447 return (error); 448 } 449 450 int 451 deliver_remote(struct qitem *it, const char **errmsg) 452 { 453 /* asprintf can't take const */ 454 void *errmsgc = __DECONST(char **, errmsg); 455 struct mx_hostentry *hosts, *h; 456 const char *host; 457 int port; 458 int error = 1, smarthost = 0; 459 460 host = strrchr(it->addr, '@'); 461 /* Should not happen */ 462 if (host == NULL) { 463 asprintf(errmsgc, "Internal error: badly formed address %s", 464 it->addr); 465 return(-1); 466 } else { 467 /* Step over the @ */ 468 host++; 469 } 470 471 port = SMTP_PORT; 472 473 /* Smarthost support? */ 474 if (config.smarthost != NULL) { 475 host = config.smarthost; 476 port = config.port; 477 syslog(LOG_INFO, "using smarthost (%s:%i)", host, port); 478 smarthost = 1; 479 } 480 481 error = dns_get_mx_list(host, port, &hosts, smarthost); 482 if (error) { 483 syslog(LOG_NOTICE, "remote delivery %s: DNS failure (%s)", 484 error < 0 ? "failed" : "deferred", 485 host); 486 return (error); 487 } 488 489 for (h = hosts; *h->host != 0; h++) { 490 switch (deliver_to_host(it, h, errmsgc)) { 491 case 0: 492 /* success */ 493 error = 0; 494 goto out; 495 case 1: 496 /* temp failure */ 497 error = 1; 498 break; 499 default: 500 /* perm failure */ 501 error = -1; 502 goto out; 503 } 504 } 505 out: 506 free(hosts); 507 508 return (error); 509 } 510