citadel/modules/smtp/serv_smtp.c

   1 /*
   2  * $Id$
   3  *
   4  * This module is an SMTP and ESMTP implementation for the Citadel system.
   5  * It is compliant with all of the following:
   6  *
   7  * RFC  821 - Simple Mail Transfer Protocol
   8  * RFC  876 - Survey of SMTP Implementations
   9  * RFC 1047 - Duplicate messages and SMTP
  10  * RFC 1652 - 8 bit MIME
  11  * RFC 1869 - Extended Simple Mail Transfer Protocol
  12  * RFC 1870 - SMTP Service Extension for Message Size Declaration
  13  * RFC 2033 - Local Mail Transfer Protocol
  14  * RFC 2197 - SMTP Service Extension for Command Pipelining
  15  * RFC 2476 - Message Submission
  16  * RFC 2487 - SMTP Service Extension for Secure SMTP over TLS
  17  * RFC 2554 - SMTP Service Extension for Authentication
  18  * RFC 2821 - Simple Mail Transfer Protocol
  19  * RFC 2822 - Internet Message Format
  20  * RFC 2920 - SMTP Service Extension for Command Pipelining
  21  *
  22  * The VRFY and EXPN commands have been removed from this implementation
  23  * because nobody uses these commands anymore, except for spammers.
  24  *
  25  * Copyright (c) 1998-2009 by the citadel.org team
  26  *
  27  *  This program is free software; you can redistribute it and/or modify
  28  *  it under the terms of the GNU General Public License as published by
  29  *  the Free Software Foundation; either version 3 of the License, or
  30  *  (at your option) any later version.
  31  *
  32  *  This program is distributed in the hope that it will be useful,
  33  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  34  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  35  *  GNU General Public License for more details.
  36  *
  37  *  You should have received a copy of the GNU General Public License
  38  *  along with this program; if not, write to the Free Software
  39  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  40  */
  41
  42 #include "sysdep.h"
  43 #include <stdlib.h>
  44 #include <unistd.h>
  45 #include <stdio.h>
  46 #include <fcntl.h>
  47 #include <signal.h>
  48 #include <pwd.h>
  49 #include <errno.h>
  50 #include <sys/types.h>
  51 #include <syslog.h>
  52
  53 #if TIME_WITH_SYS_TIME
  54 # include <sys/time.h>
  55 # include <time.h>
  56 #else
  57 # if HAVE_SYS_TIME_H
  58 #  include <sys/time.h>
  59 # else
  60 #  include <time.h>
  61 # endif
  62 #endif
  63
  64 #include <sys/wait.h>
  65 #include <ctype.h>
  66 #include <string.h>
  67 #include <limits.h>
  68 #include <sys/socket.h>
  69 #include <netinet/in.h>
  70 #include <arpa/inet.h>
  71 #include <libcitadel.h>
  72 #include "citadel.h"
  73 #include "server.h"
  74 #include "citserver.h"
  75 #include "support.h"
  76 #include "config.h"
  77 #include "control.h"
  78 #include "user_ops.h"
  79 #include "database.h"
  80 #include "msgbase.h"
  81 #include "internet_addressing.h"
  82 #include "genstamp.h"
  83 #include "domain.h"
  84 #include "clientsocket.h"
  85 #include "locate_host.h"
  86 #include "citadel_dirs.h"
  87
  88
  89
  90 #ifndef HAVE_SNPRINTF
  91 #include "snprintf.h"
  92 #endif
  93
  94
  95 #include "ctdl_module.h"
  96
  97
  98
  99 typedef struct _citsmtp {               /* Information about the current session */
 100         int command_state;
 101         char helo_node[SIZ];
 102         char from[SIZ];
 103         char recipients[SIZ];
 104         int number_of_recipients;
 105         int delivery_mode;
 106         int message_originated_locally;
 107         int is_lmtp;
 108         int is_unfiltered;
 109         int is_msa;
 110 }citsmtp;
 111
 112 enum {                          /* Command states for login authentication */
 113         smtp_command,
 114         smtp_user,
 115         smtp_password,
 116         smtp_plain
 117 };
 118
 119 #define SMTP            ((citsmtp *)CC->session_specific_data)
 120
 121
 122 int run_queue_now = 0;  /* Set to 1 to ignore SMTP send retry times */
 123
 124 citthread_mutex_t smtp_send_lock;
 125
 126
 127 /*****************************************************************************/
 128 /*                      SMTP SERVER (INBOUND) STUFF                          */
 129 /*****************************************************************************/
 130
 131
 132 /*
 133  * Here's where our SMTP session begins its happy day.
 134  */
 135 void smtp_greeting(int is_msa)
 136 {
 137         citsmtp *sSMTP;
 138         char message_to_spammer[1024];
 139
 140         strcpy(CC->cs_clientname, "SMTP session");
 141         CC->internal_pgm = 1;
 142         CC->cs_flags |= CS_STEALTH;
 143         CC->session_specific_data = malloc(sizeof(citsmtp));
 144         memset(SMTP, 0, sizeof(citsmtp));
 145         sSMTP = SMTP;
 146         sSMTP->is_msa = is_msa;
 147
 148         /* If this config option is set, reject connections from problem
 149          * addresses immediately instead of after they execute a RCPT
 150          */
 151         if ( (config.c_rbl_at_greeting) && (sSMTP->is_msa == 0) ) {
 152                 if (rbl_check(message_to_spammer)) {
 153                         if (CtdlThreadCheckStop())
 154                                 cprintf("421 %s\r\n", message_to_spammer);
 155                         else
 156                                 cprintf("550 %s\r\n", message_to_spammer);
 157                         CC->kill_me = 1;
 158                         /* no need to free_recipients(valid), it's not allocated yet */
 159                         return;
 160                 }
 161         }
 162
 163         /* Otherwise we're either clean or we check later. */
 164
 165         if (CC->nologin==1) {
 166                 cprintf("500 Too many users are already online (maximum is %d)\r\n",
 167                         config.c_maxsessions
 168                 );
 169                 CC->kill_me = 1;
 170                 /* no need to free_recipients(valid), it's not allocated yet */
 171                 return;
 172         }
 173
 174         /* Note: the FQDN *must* appear as the first thing after the 220 code.
 175          * Some clients (including citmail.c) depend on it being there.
 176          */
 177         cprintf("220 %s ESMTP Citadel server ready.\r\n", config.c_fqdn);
 178 }
 179
 180
 181 /*
 182  * SMTPS is just like SMTP, except it goes crypto right away.
 183  */
 184 void smtps_greeting(void) {
 185         CtdlModuleStartCryptoMsgs(NULL, NULL, NULL);
 186 #ifdef HAVE_OPENSSL
 187         if (!CC->redirect_ssl) CC->kill_me = 1;         /* kill session if no crypto */
 188 #endif
 189         smtp_greeting(0);
 190 }
 191
 192
 193 /*
 194  * SMTP MSA port requires authentication.
 195  */
 196 void smtp_msa_greeting(void) {
 197         smtp_greeting(1);
 198 }
 199
 200
 201 /*
 202  * LMTP is like SMTP but with some extra bonus footage added.
 203  */
 204 void lmtp_greeting(void) {
 205         citsmtp *sSMTP;
 206
 207         smtp_greeting(0);
 208         sSMTP = SMTP;
 209         SMTP->is_lmtp = 1;
 210 }
 211
 212
 213 /*
 214  * Generic SMTP MTA greeting
 215  */
 216 void smtp_mta_greeting(void) {
 217         smtp_greeting(0);
 218 }
 219
 220
 221 /*
 222  * We also have an unfiltered LMTP socket that bypasses spam filters.
 223  */
 224 void lmtp_unfiltered_greeting(void) {
 225         citsmtp *sSMTP;
 226
 227         smtp_greeting(0);
 228         sSMTP = SMTP;
 229         sSMTP->is_lmtp = 1;
 230         sSMTP->is_unfiltered = 1;
 231 }
 232
 233
 234 /*
 235  * Login greeting common to all auth methods
 236  */
 237 void smtp_auth_greeting(void) {
 238                 cprintf("235 Hello, %s\r\n", CC->user.fullname);
 239                 CtdlLogPrintf(CTDL_NOTICE, "SMTP authenticated %s\n", CC->user.fullname);
 240                 CC->internal_pgm = 0;
 241                 CC->cs_flags &= ~CS_STEALTH;
 242 }
 243
 244
 245 /*
 246  * Implement HELO and EHLO commands.
 247  *
 248  * which_command:  0=HELO, 1=EHLO, 2=LHLO
 249  */
 250 void smtp_hello(char *argbuf, int which_command) {
 251         citsmtp *sSMTP = SMTP;
 252
 253         safestrncpy(sSMTP->helo_node, argbuf, sizeof sSMTP->helo_node);
 254
 255         if ( (which_command != 2) && (sSMTP->is_lmtp) ) {
 256                 cprintf("500 Only LHLO is allowed when running LMTP\r\n");
 257                 return;
 258         }
 259
 260         if ( (which_command == 2) && (sSMTP->is_lmtp == 0) ) {
 261                 cprintf("500 LHLO is only allowed when running LMTP\r\n");
 262                 return;
 263         }
 264
 265         if (which_command == 0) {
 266                 cprintf("250 Hello %s (%s [%s])\r\n",
 267                         sSMTP->helo_node,
 268                         CC->cs_host,
 269                         CC->cs_addr
 270                 );
 271         }
 272         else {
 273                 if (which_command == 1) {
 274                         cprintf("250-Hello %s (%s [%s])\r\n",
 275                                 sSMTP->helo_node,
 276                                 CC->cs_host,
 277                                 CC->cs_addr
 278                         );
 279                 }
 280                 else {
 281                         cprintf("250-Greetings and joyous salutations.\r\n");
 282                 }
 283                 cprintf("250-HELP\r\n");
 284                 cprintf("250-SIZE %ld\r\n", config.c_maxmsglen);
 285
 286 #ifdef HAVE_OPENSSL
 287                 /*
 288                  * Offer TLS, but only if TLS is not already active.
 289                  * Furthermore, only offer TLS when running on
 290                  * the SMTP-MSA port, not on the SMTP-MTA port, due to
 291                  * questionable reliability of TLS in certain sending MTA's.
 292                  */
 293                 if ( (!CC->redirect_ssl) && (sSMTP->is_msa) ) {
 294                         cprintf("250-STARTTLS\r\n");
 295                 }
 296 #endif  /* HAVE_OPENSSL */
 297
 298                 cprintf("250-AUTH LOGIN PLAIN\r\n"
 299                         "250-AUTH=LOGIN PLAIN\r\n"
 300                         "250 8BITMIME\r\n"
 301                 );
 302         }
 303 }
 304
 305
 306
 307 /*
 308  * Implement HELP command.
 309  */
 310 void smtp_help(void) {
 311         cprintf("214 RTFM http://www.ietf.org/rfc/rfc2821.txt\r\n");
 312 }
 313
 314
 315 /*
 316  *
 317  */
 318 void smtp_get_user(char *argbuf) {
 319         char buf[SIZ];
 320         char username[SIZ];
 321         citsmtp *sSMTP = SMTP;
 322
 323         CtdlDecodeBase64(username, argbuf, SIZ);
 324         /* CtdlLogPrintf(CTDL_DEBUG, "Trying <%s>\n", username); */
 325         if (CtdlLoginExistingUser(NULL, username) == login_ok) {
 326                 CtdlEncodeBase64(buf, "Password:", 9, 0);
 327                 cprintf("334 %s\r\n", buf);
 328                 sSMTP->command_state = smtp_password;
 329         }
 330         else {
 331                 cprintf("500 No such user.\r\n");
 332                 sSMTP->command_state = smtp_command;
 333         }
 334 }
 335
 336
 337 /*
 338  *
 339  */
 340 void smtp_get_pass(char *argbuf) {
 341         char password[SIZ];
 342         long len;
 343
 344         memset(password, 0, sizeof(password));
 345         len = CtdlDecodeBase64(password, argbuf, SIZ);
 346         /* CtdlLogPrintf(CTDL_DEBUG, "Trying <%s>\n", password); */
 347         if (CtdlTryPassword(password, len) == pass_ok) {
 348                 smtp_auth_greeting();
 349         }
 350         else {
 351                 cprintf("535 Authentication failed.\r\n");
 352         }
 353         SMTP->command_state = smtp_command;
 354 }
 355
 356
 357 /*
 358  * Back end for PLAIN auth method (either inline or multistate)
 359  */
 360 void smtp_try_plain(char *encoded_authstring) {
 361         char decoded_authstring[1024];
 362         char ident[256];
 363         char user[256];
 364         char pass[256];
 365         int result;
 366         long len;
 367
 368         CtdlDecodeBase64(decoded_authstring, encoded_authstring, strlen(encoded_authstring) );
 369         safestrncpy(ident, decoded_authstring, sizeof ident);
 370         safestrncpy(user, &decoded_authstring[strlen(ident) + 1], sizeof user);
 371         len = safestrncpy(pass, &decoded_authstring[strlen(ident) + strlen(user) + 2], sizeof pass);
 372         if (len == -1)
 373                 len = sizeof(pass) - 1;
 374
 375         SMTP->command_state = smtp_command;
 376
 377         if (!IsEmptyStr(ident)) {
 378                 result = CtdlLoginExistingUser(user, ident);
 379         }
 380         else {
 381                 result = CtdlLoginExistingUser(NULL, user);
 382         }
 383
 384         if (result == login_ok) {
 385                 if (CtdlTryPassword(pass, len) == pass_ok) {
 386                         smtp_auth_greeting();
 387                         return;
 388                 }
 389         }
 390         cprintf("504 Authentication failed.\r\n");
 391 }
 392
 393
 394 /*
 395  * Attempt to perform authenticated SMTP
 396  */
 397 void smtp_auth(char *argbuf) {
 398         char username_prompt[64];
 399         char method[64];
 400         char encoded_authstring[1024];
 401
 402         if (CC->logged_in) {
 403                 cprintf("504 Already logged in.\r\n");
 404                 return;
 405         }
 406
 407         extract_token(method, argbuf, 0, ' ', sizeof method);
 408
 409         if (!strncasecmp(method, "login", 5) ) {
 410                 if (strlen(argbuf) >= 7) {
 411                         smtp_get_user(&argbuf[6]);
 412                 }
 413                 else {
 414                         CtdlEncodeBase64(username_prompt, "Username:", 9, 0);
 415                         cprintf("334 %s\r\n", username_prompt);
 416                         SMTP->command_state = smtp_user;
 417                 }
 418                 return;
 419         }
 420
 421         if (!strncasecmp(method, "plain", 5) ) {
 422                 if (num_tokens(argbuf, ' ') < 2) {
 423                         cprintf("334 \r\n");
 424                         SMTP->command_state = smtp_plain;
 425                         return;
 426                 }
 427
 428                 extract_token(encoded_authstring, argbuf, 1, ' ', sizeof encoded_authstring);
 429
 430                 smtp_try_plain(encoded_authstring);
 431                 return;
 432         }
 433
 434         if (strncasecmp(method, "login", 5) ) {
 435                 cprintf("504 Unknown authentication method.\r\n");
 436                 return;
 437         }
 438
 439 }
 440
 441
 442 /*
 443  * Implements the RSET (reset state) command.
 444  * Currently this just zeroes out the state buffer.  If pointers to data
 445  * allocated with malloc() are ever placed in the state buffer, we have to
 446  * be sure to free() them first!
 447  *
 448  * Set do_response to nonzero to output the SMTP RSET response code.
 449  */
 450 void smtp_rset(int do_response) {
 451         int is_lmtp;
 452         int is_unfiltered;
 453         citsmtp *sSMTP = SMTP;
 454
 455         /*
 456          * Our entire SMTP state is discarded when a RSET command is issued,
 457          * but we need to preserve this one little piece of information, so
 458          * we save it for later.
 459          */
 460         is_lmtp = sSMTP->is_lmtp;
 461         is_unfiltered = sSMTP->is_unfiltered;
 462
 463         memset(sSMTP, 0, sizeof(citsmtp));
 464
 465         /*
 466          * It is somewhat ambiguous whether we want to log out when a RSET
 467          * command is issued.  Here's the code to do it.  It is commented out
 468          * because some clients (such as Pine) issue RSET commands before
 469          * each message, but still expect to be logged in.
 470          *
 471          * if (CC->logged_in) {
 472          *      logout(CC);
 473          * }
 474          */
 475
 476         /*
 477          * Reinstate this little piece of information we saved (see above).
 478          */
 479         sSMTP->is_lmtp = is_lmtp;
 480         sSMTP->is_unfiltered = is_unfiltered;
 481
 482         if (do_response) {
 483                 cprintf("250 Zap!\r\n");
 484         }
 485 }
 486
 487 /*
 488  * Clear out the portions of the state buffer that need to be cleared out
 489  * after the DATA command finishes.
 490  */
 491 void smtp_data_clear(void) {
 492         citsmtp *sSMTP = SMTP;
 493
 494         strcpy(sSMTP->from, "");
 495         strcpy(sSMTP->recipients, "");
 496         sSMTP->number_of_recipients = 0;
 497         sSMTP->delivery_mode = 0;
 498         sSMTP->message_originated_locally = 0;
 499 }
 500
 501 const char *smtp_get_Recipients(void)
 502 {
 503         citsmtp *sSMTP = SMTP;
 504
 505         if (sSMTP == NULL)
 506                 return NULL;
 507         else return sSMTP->from;
 508 }
 509
 510 /*
 511  * Implements the "MAIL FROM:" command
 512  */
 513 void smtp_mail(char *argbuf) {
 514         char user[SIZ];
 515         char node[SIZ];
 516         char name[SIZ];
 517         citsmtp *sSMTP = SMTP;
 518
 519         if (!IsEmptyStr(sSMTP->from)) {
 520                 cprintf("503 Only one sender permitted\r\n");
 521                 return;
 522         }
 523
 524         if (strncasecmp(argbuf, "From:", 5)) {
 525                 cprintf("501 Syntax error\r\n");
 526                 return;
 527         }
 528
 529         strcpy(sSMTP->from, &argbuf[5]);
 530         striplt(sSMTP->from);
 531         if (haschar(sSMTP->from, '<') > 0) {
 532                 stripallbut(sSMTP->from, '<', '>');
 533         }
 534
 535         /* We used to reject empty sender names, until it was brought to our
 536          * attention that RFC1123 5.2.9 requires that this be allowed.  So now
 537          * we allow it, but replace the empty string with a fake
 538          * address so we don't have to contend with the empty string causing
 539          * other code to fail when it's expecting something there.
 540          */
 541         if (IsEmptyStr(sSMTP->from)) {
 542                 strcpy(sSMTP->from, "someone@example.com");
 543         }
 544
 545         /* If this SMTP connection is from a logged-in user, force the 'from'
 546          * to be the user's Internet e-mail address as Citadel knows it.
 547          */
 548         if (CC->logged_in) {
 549                 safestrncpy(sSMTP->from, CC->cs_inet_email, sizeof sSMTP->from);
 550                 cprintf("250 Sender ok <%s>\r\n", sSMTP->from);
 551                 sSMTP->message_originated_locally = 1;
 552                 return;
 553         }
 554
 555         else if (sSMTP->is_lmtp) {
 556                 /* Bypass forgery checking for LMTP */
 557         }
 558
 559         /* Otherwise, make sure outsiders aren't trying to forge mail from
 560          * this system (unless, of course, c_allow_spoofing is enabled)
 561          */
 562         else if (config.c_allow_spoofing == 0) {
 563                 process_rfc822_addr(sSMTP->from, user, node, name);
 564                 if (CtdlHostAlias(node) != hostalias_nomatch) {
 565                         cprintf("550 You must log in to send mail from %s\r\n", node);
 566                         strcpy(sSMTP->from, "");
 567                         return;
 568                 }
 569         }
 570
 571         cprintf("250 Sender ok\r\n");
 572 }
 573
 574
 575
 576 /*
 577  * Implements the "RCPT To:" command
 578  */
 579 void smtp_rcpt(char *argbuf) {
 580         char recp[1024];
 581         char message_to_spammer[SIZ];
 582         struct recptypes *valid = NULL;
 583         citsmtp *sSMTP = SMTP;
 584
 585         if (IsEmptyStr(sSMTP->from)) {
 586                 cprintf("503 Need MAIL before RCPT\r\n");
 587                 return;
 588         }
 589
 590         if (strncasecmp(argbuf, "To:", 3)) {
 591                 cprintf("501 Syntax error\r\n");
 592                 return;
 593         }
 594
 595         if ( (sSMTP->is_msa) && (!CC->logged_in) ) {
 596                 cprintf("550 You must log in to send mail on this port.\r\n");
 597                 strcpy(sSMTP->from, "");
 598                 return;
 599         }
 600
 601         safestrncpy(recp, &argbuf[3], sizeof recp);
 602         striplt(recp);
 603         stripallbut(recp, '<', '>');
 604
 605         if ( (strlen(recp) + strlen(sSMTP->recipients) + 1 ) >= SIZ) {
 606                 cprintf("452 Too many recipients\r\n");
 607                 return;
 608         }
 609
 610         /* RBL check */
 611         if ( (!CC->logged_in)   /* Don't RBL authenticated users */
 612            && (!sSMTP->is_lmtp) ) {     /* Don't RBL LMTP clients */
 613                 if (config.c_rbl_at_greeting == 0) {    /* Don't RBL again if we already did it */
 614                         if (rbl_check(message_to_spammer)) {
 615                                 if (CtdlThreadCheckStop())
 616                                         cprintf("421 %s\r\n", message_to_spammer);
 617                                 else
 618                                         cprintf("550 %s\r\n", message_to_spammer);
 619                                 /* no need to free_recipients(valid), it's not allocated yet */
 620                                 return;
 621                         }
 622                 }
 623         }
 624
 625         valid = validate_recipients(recp,
 626                                     smtp_get_Recipients (),
 627                                     (sSMTP->is_lmtp)? POST_LMTP:
 628                                        (CC->logged_in)? POST_LOGGED_IN:
 629                                                         POST_EXTERNAL);
 630         if (valid->num_error != 0) {
 631                 cprintf("550 %s\r\n", valid->errormsg);
 632                 free_recipients(valid);
 633                 return;
 634         }
 635
 636         if (valid->num_internet > 0) {
 637                 if (CC->logged_in) {
 638                         if (CtdlCheckInternetMailPermission(&CC->user)==0) {
 639                                 cprintf("551 <%s> - you do not have permission to send Internet mail\r\n", recp);
 640                                 free_recipients(valid);
 641                                 return;
 642                         }
 643                 }
 644         }
 645
 646         if (valid->num_internet > 0) {
 647                 if ( (sSMTP->message_originated_locally == 0)
 648                    && (sSMTP->is_lmtp == 0) ) {
 649                         cprintf("551 <%s> - relaying denied\r\n", recp);
 650                         free_recipients(valid);
 651                         return;
 652                 }
 653         }
 654
 655         cprintf("250 RCPT ok <%s>\r\n", recp);
 656         if (!IsEmptyStr(sSMTP->recipients)) {
 657                 strcat(sSMTP->recipients, ",");
 658         }
 659         strcat(sSMTP->recipients, recp);
 660         sSMTP->number_of_recipients += 1;
 661         if (valid != NULL)  {
 662                 free_recipients(valid);
 663         }
 664 }
 665
 666
 667
 668
 669 /*
 670  * Implements the DATA command
 671  */
 672 void smtp_data(void) {
 673         StrBuf *body;
 674         char *defbody; //TODO: remove me
 675         struct CtdlMessage *msg = NULL;
 676         long msgnum = (-1L);
 677         char nowstamp[SIZ];
 678         struct recptypes *valid;
 679         int scan_errors;
 680         int i;
 681         char result[SIZ];
 682         citsmtp *sSMTP = SMTP;
 683
 684         if (IsEmptyStr(sSMTP->from)) {
 685                 cprintf("503 Need MAIL command first.\r\n");
 686                 return;
 687         }
 688
 689         if (sSMTP->number_of_recipients < 1) {
 690                 cprintf("503 Need RCPT command first.\r\n");
 691                 return;
 692         }
 693
 694         cprintf("354 Transmit message now - terminate with '.' by itself\r\n");
 695
 696         datestring(nowstamp, sizeof nowstamp, time(NULL), DATESTRING_RFC822);
 697         defbody = malloc(4096);
 698
 699         if (defbody != NULL) {
 700                 if (sSMTP->is_lmtp && (CC->cs_UDSclientUID != -1)) {
 701                         snprintf(defbody, 4096,
 702                                "Received: from %s (Citadel from userid %ld)\n"
 703                                "        by %s; %s\n",
 704                                sSMTP->helo_node,
 705                                (long int) CC->cs_UDSclientUID,
 706                                config.c_fqdn,
 707                                nowstamp);
 708                 }
 709                 else {
 710                         snprintf(defbody, 4096,
 711                                  "Received: from %s (%s [%s])\n"
 712                                  "      by %s; %s\n",
 713                                  sSMTP->helo_node,
 714                                  CC->cs_host,
 715                                  CC->cs_addr,
 716                                  config.c_fqdn,
 717                                  nowstamp);
 718                 }
 719         }
 720         body = CtdlReadMessageBodyBuf(HKEY("."), config.c_maxmsglen, defbody, 1, NULL);
 721         if (body == NULL) {
 722                 cprintf("550 Unable to save message: internal error.\r\n");
 723                 return;
 724         }
 725
 726         CtdlLogPrintf(CTDL_DEBUG, "Converting message...\n");
 727         msg = convert_internet_message_buf(&body);
 728
 729         /* If the user is locally authenticated, FORCE the From: header to
 730          * show up as the real sender.  Yes, this violates the RFC standard,
 731          * but IT MAKES SENSE.  If you prefer strict RFC adherence over
 732          * common sense, you can disable this in the configuration.
 733          *
 734          * We also set the "message room name" ('O' field) to MAILROOM
 735          * (which is Mail> on most systems) to prevent it from getting set
 736          * to something ugly like "0000058008.Sent Items>" when the message
 737          * is read with a Citadel client.
 738          */
 739         if ( (CC->logged_in) && (config.c_rfc822_strict_from == 0) ) {
 740                 if (msg->cm_fields['A'] != NULL) free(msg->cm_fields['A']);
 741                 if (msg->cm_fields['N'] != NULL) free(msg->cm_fields['N']);
 742                 if (msg->cm_fields['H'] != NULL) free(msg->cm_fields['H']);
 743                 if (msg->cm_fields['F'] != NULL) free(msg->cm_fields['F']);
 744                 if (msg->cm_fields['O'] != NULL) free(msg->cm_fields['O']);
 745                 msg->cm_fields['A'] = strdup(CC->user.fullname);
 746                 msg->cm_fields['N'] = strdup(config.c_nodename);
 747                 msg->cm_fields['H'] = strdup(config.c_humannode);
 748                 msg->cm_fields['F'] = strdup(CC->cs_inet_email);
 749                 msg->cm_fields['O'] = strdup(MAILROOM);
 750         }
 751
 752         /* Set the "envelope from" address */
 753         if (msg->cm_fields['P'] != NULL) {
 754                 free(msg->cm_fields['P']);
 755         }
 756         msg->cm_fields['P'] = strdup(sSMTP->from);
 757
 758         /* Set the "envelope to" address */
 759         if (msg->cm_fields['V'] != NULL) {
 760                 free(msg->cm_fields['V']);
 761         }
 762         msg->cm_fields['V'] = strdup(sSMTP->recipients);
 763
 764         /* Submit the message into the Citadel system. */
 765         valid = validate_recipients(sSMTP->recipients,
 766                                     smtp_get_Recipients (),
 767                                     (sSMTP->is_lmtp)? POST_LMTP:
 768                                        (CC->logged_in)? POST_LOGGED_IN:
 769                                                         POST_EXTERNAL);
 770
 771         /* If there are modules that want to scan this message before final
 772          * submission (such as virus checkers or spam filters), call them now
 773          * and give them an opportunity to reject the message.
 774          */
 775         if (sSMTP->is_unfiltered) {
 776                 scan_errors = 0;
 777         }
 778         else {
 779                 scan_errors = PerformMessageHooks(msg, EVT_SMTPSCAN);
 780         }
 781
 782         if (scan_errors > 0) {  /* We don't want this message! */
 783
 784                 if (msg->cm_fields['0'] == NULL) {
 785                         msg->cm_fields['0'] = strdup("Message rejected by filter");
 786                 }
 787
 788                 sprintf(result, "550 %s\r\n", msg->cm_fields['0']);
 789         }
 790
 791         else {                  /* Ok, we'll accept this message. */
 792                 msgnum = CtdlSubmitMsg(msg, valid, "", 0);
 793                 if (msgnum > 0L) {
 794                         sprintf(result, "250 Message accepted.\r\n");
 795                 }
 796                 else {
 797                         sprintf(result, "550 Internal delivery error\r\n");
 798                 }
 799         }
 800
 801         /* For SMTP and ESTMP, just print the result message.  For LMTP, we
 802          * have to print one result message for each recipient.  Since there
 803          * is nothing in Citadel which would cause different recipients to
 804          * have different results, we can get away with just spitting out the
 805          * same message once for each recipient.
 806          */
 807         if (sSMTP->is_lmtp) {
 808                 for (i=0; i<sSMTP->number_of_recipients; ++i) {
 809                         cprintf("%s", result);
 810                 }
 811         }
 812         else {
 813                 cprintf("%s", result);
 814         }
 815
 816         /* Write something to the syslog (which may or may not be where the
 817          * rest of the Citadel logs are going; some sysadmins want LOG_MAIL).
 818          */
 819         if (enable_syslog) {
 820                 syslog((LOG_MAIL | LOG_INFO),
 821                         "%ld: from=<%s>, nrcpts=%d, relay=%s [%s], stat=%s",
 822                         msgnum,
 823                         sSMTP->from,
 824                         sSMTP->number_of_recipients,
 825                         CC->cs_host,
 826                         CC->cs_addr,
 827                         result
 828                 );
 829         }
 830
 831         /* Clean up */
 832         CtdlFreeMessage(msg);
 833         free_recipients(valid);
 834         smtp_data_clear();      /* clear out the buffers now */
 835 }
 836
 837
 838 /*
 839  * implements the STARTTLS command (Citadel API version)
 840  */
 841 void smtp_starttls(void)
 842 {
 843         char ok_response[SIZ];
 844         char nosup_response[SIZ];
 845         char error_response[SIZ];
 846
 847         sprintf(ok_response,
 848                 "220 Begin TLS negotiation now\r\n");
 849         sprintf(nosup_response,
 850                 "554 TLS not supported here\r\n");
 851         sprintf(error_response,
 852                 "554 Internal error\r\n");
 853         CtdlModuleStartCryptoMsgs(ok_response, nosup_response, error_response);
 854         smtp_rset(0);
 855 }
 856
 857
 858
 859 /*
 860  * Main command loop for SMTP sessions.
 861  */
 862 void smtp_command_loop(void) {
 863         char cmdbuf[SIZ];
 864         citsmtp *sSMTP = SMTP;
 865
 866         if (sSMTP == NULL) {
 867                 CtdlLogPrintf(CTDL_EMERG, "Session SMTP data is null.  WTF?  We will crash now.\n");
 868         }
 869
 870         time(&CC->lastcmd);
 871         memset(cmdbuf, 0, sizeof cmdbuf); /* Clear it, just in case */
 872         if (client_getln(cmdbuf, sizeof cmdbuf) < 1) {
 873                 CtdlLogPrintf(CTDL_CRIT, "Client disconnected: ending session.\n");
 874                 CC->kill_me = 1;
 875                 return;
 876         }
 877         CtdlLogPrintf(CTDL_INFO, "SMTP server: %s\n", cmdbuf);
 878         while (strlen(cmdbuf) < 5) strcat(cmdbuf, " ");
 879
 880         if (sSMTP->command_state == smtp_user) {
 881                 smtp_get_user(cmdbuf);
 882         }
 883
 884         else if (sSMTP->command_state == smtp_password) {
 885                 smtp_get_pass(cmdbuf);
 886         }
 887
 888         else if (sSMTP->command_state == smtp_plain) {
 889                 smtp_try_plain(cmdbuf);
 890         }
 891
 892         else if (!strncasecmp(cmdbuf, "AUTH", 4)) {
 893                 smtp_auth(&cmdbuf[5]);
 894         }
 895
 896         else if (!strncasecmp(cmdbuf, "DATA", 4)) {
 897                 smtp_data();
 898         }
 899
 900         else if (!strncasecmp(cmdbuf, "HELO", 4)) {
 901                 smtp_hello(&cmdbuf[5], 0);
 902         }
 903
 904         else if (!strncasecmp(cmdbuf, "EHLO", 4)) {
 905                 smtp_hello(&cmdbuf[5], 1);
 906         }
 907
 908         else if (!strncasecmp(cmdbuf, "LHLO", 4)) {
 909                 smtp_hello(&cmdbuf[5], 2);
 910         }
 911
 912         else if (!strncasecmp(cmdbuf, "HELP", 4)) {
 913                 smtp_help();
 914         }
 915
 916         else if (!strncasecmp(cmdbuf, "MAIL", 4)) {
 917                 smtp_mail(&cmdbuf[5]);
 918         }
 919
 920         else if (!strncasecmp(cmdbuf, "NOOP", 4)) {
 921                 cprintf("250 NOOP\r\n");
 922         }
 923
 924         else if (!strncasecmp(cmdbuf, "QUIT", 4)) {
 925                 cprintf("221 Goodbye...\r\n");
 926                 CC->kill_me = 1;
 927                 return;
 928         }
 929
 930         else if (!strncasecmp(cmdbuf, "RCPT", 4)) {
 931                 smtp_rcpt(&cmdbuf[5]);
 932         }
 933
 934         else if (!strncasecmp(cmdbuf, "RSET", 4)) {
 935                 smtp_rset(1);
 936         }
 937 #ifdef HAVE_OPENSSL
 938         else if (!strcasecmp(cmdbuf, "STARTTLS")) {
 939                 smtp_starttls();
 940         }
 941 #endif
 942         else {
 943                 cprintf("502 I'm afraid I can't do that.\r\n");
 944         }
 945
 946
 947 }
 948
 949
 950
 951
 952 /*****************************************************************************/
 953 /*               SMTP CLIENT (OUTBOUND PROCESSING) STUFF                     */
 954 /*****************************************************************************/
 955
 956
 957
 958 /*
 959  * smtp_try()
 960  *
 961  * Called by smtp_do_procmsg() to attempt delivery to one SMTP host
 962  *
 963  */
 964 void smtp_try(const char *key, const char *addr, int *status,
 965               char *dsn, size_t n, long msgnum, char *envelope_from)
 966 {
 967         int sock = (-1);
 968         char mxhosts[1024];
 969         int num_mxhosts;
 970         int mx;
 971         int i;
 972         char user[1024], node[1024], name[1024];
 973         char buf[1024];
 974         char mailfrom[1024];
 975         char mx_user[256];
 976         char mx_pass[256];
 977         char mx_host[256];
 978         char mx_port[256];
 979         int lp, rp;
 980         char *msgtext;
 981         const char *ptr;
 982         size_t msg_size;
 983         int scan_done;
 984         CitContext *CCC=CC;
 985
 986
 987         /* Parse out the host portion of the recipient address */
 988         process_rfc822_addr(addr, user, node, name);
 989
 990         CtdlLogPrintf(CTDL_DEBUG, "SMTP client: Attempting delivery to <%s> @ <%s> (%s)\n",
 991                 user, node, name);
 992
 993         /* Load the message out of the database */
 994         CCC->redirect_buffer = NewStrBufPlain(NULL, SIZ);
 995         CtdlOutputMsg(msgnum, MT_RFC822, HEADERS_ALL, 0, 1, NULL, ESC_DOT);
 996         msg_size = StrLength(CC->redirect_buffer);
 997         msgtext = SmashStrBuf(&CC->redirect_buffer);
 998
 999         /* If no envelope_from is supplied, extract one from the message */
1000         if ( (envelope_from == NULL) || (IsEmptyStr(envelope_from)) ) {
1001                 strcpy(mailfrom, "");
1002                 scan_done = 0;
1003                 ptr = msgtext;
1004                 do {
1005                         if (ptr = cmemreadline(ptr, buf, sizeof buf), *ptr == 0) {
1006                                 scan_done = 1;
1007                         }
1008                         if (!strncasecmp(buf, "From:", 5)) {
1009                                 safestrncpy(mailfrom, &buf[5], sizeof mailfrom);
1010                                 striplt(mailfrom);
1011                                 for (i=0; mailfrom[i]; ++i) {
1012                                         if (!isprint(mailfrom[i])) {
1013                                                 strcpy(&mailfrom[i], &mailfrom[i+1]);
1014                                                 i=0;
1015                                         }
1016                                 }
1017
1018                                 /* Strip out parenthesized names */
1019                                 lp = (-1);
1020                                 rp = (-1);
1021                                 for (i=0; mailfrom[i]; ++i) {
1022                                         if (mailfrom[i] == '(') lp = i;
1023                                         if (mailfrom[i] == ')') rp = i;
1024                                 }
1025                                 if ((lp>0)&&(rp>lp)) {
1026                                         strcpy(&mailfrom[lp-1], &mailfrom[rp+1]);
1027                                 }
1028
1029                                 /* Prefer brokketized names */
1030                                 lp = (-1);
1031                                 rp = (-1);
1032                                 for (i=0; mailfrom[i]; ++i) {
1033                                         if (mailfrom[i] == '<') lp = i;
1034                                         if (mailfrom[i] == '>') rp = i;
1035                                 }
1036                                 if ( (lp>=0) && (rp>lp) ) {
1037                                         mailfrom[rp] = 0;
1038                                         strcpy(mailfrom, &mailfrom[lp]);
1039                                 }
1040
1041                                 scan_done = 1;
1042                         }
1043                 } while (scan_done == 0);
1044                 if (IsEmptyStr(mailfrom)) strcpy(mailfrom, "someone@somewhere.org");
1045                 stripallbut(mailfrom, '<', '>');
1046                 envelope_from = mailfrom;
1047         }
1048
1049         /* Figure out what mail exchanger host we have to connect to */
1050         num_mxhosts = getmx(mxhosts, node);
1051         CtdlLogPrintf(CTDL_DEBUG, "Number of MX hosts for <%s> is %d [%s]\n", node, num_mxhosts, mxhosts);
1052         if (num_mxhosts < 1) {
1053                 *status = 5;
1054                 snprintf(dsn, SIZ, "No MX hosts found for <%s>", node);
1055                 return;
1056         }
1057
1058         sock = (-1);
1059         for (mx=0; (mx<num_mxhosts && sock < 0); ++mx) {
1060                 char *endpart;
1061                 extract_token(buf, mxhosts, mx, '|', sizeof buf);
1062                 strcpy(mx_user, "");
1063                 strcpy(mx_pass, "");
1064                 if (num_tokens(buf, '@') > 1) {
1065                         strcpy (mx_user, buf);
1066                         endpart = strrchr(mx_user, '@');
1067                         *endpart = '\0';
1068                         strcpy (mx_host, endpart + 1);
1069                         endpart = strrchr(mx_user, ':');
1070                         if (endpart != NULL) {
1071                                 strcpy(mx_pass, endpart+1);
1072                                 *endpart = '\0';
1073                         }
1074                 }
1075                 else
1076                         strcpy (mx_host, buf);
1077                 endpart = strrchr(mx_host, ':');
1078                 if (endpart != 0){
1079                         *endpart = '\0';
1080                         strcpy(mx_port, endpart + 1);
1081                 }
1082                 else {
1083                         strcpy(mx_port, "25");
1084                 }
1085                 CtdlLogPrintf(CTDL_DEBUG, "SMTP client: connecting to %s : %s ...\n", mx_host, mx_port);
1086                 sock = sock_connect(mx_host, mx_port, "tcp");
1087                 snprintf(dsn, SIZ, "Could not connect: %s", strerror(errno));
1088                 if (sock >= 0)
1089                 {
1090                         CtdlLogPrintf(CTDL_DEBUG, "SMTP client: connected!\n");
1091                                 int fdflags;
1092                                 fdflags = fcntl(sock, F_GETFL);
1093                                 if (fdflags < 0)
1094                                         CtdlLogPrintf(CTDL_DEBUG,
1095                                                       "unable to get SMTP-Client socket flags! %s \n",
1096                                                       strerror(errno));
1097                                 fdflags = fdflags | O_NONBLOCK;
1098                                 if (fcntl(sock, F_SETFL, fdflags) < 0)
1099                                         CtdlLogPrintf(CTDL_DEBUG,
1100                                                       "unable to set SMTP-Client socket nonblocking flags! %s \n",
1101                                                       strerror(errno));
1102                 }
1103                 if (sock < 0) {
1104                         if (errno > 0) {
1105                                 snprintf(dsn, SIZ, "%s", strerror(errno));
1106                         }
1107                         else {
1108                                 snprintf(dsn, SIZ, "Unable to connect to %s : %s\n", mx_host, mx_port);
1109                         }
1110                 }
1111         }
1112
1113         if (sock < 0) {
1114                 *status = 4;    /* dsn is already filled in */
1115                 return;
1116         }
1117
1118         CCC->sReadBuf = NewStrBuf();
1119         CCC->sMigrateBuf = NewStrBuf();
1120         CCC->sPos = NULL;
1121
1122         /* Process the SMTP greeting from the server */
1123         if (ml_sock_gets(&sock, buf) < 0) {
1124                 *status = 4;
1125                 strcpy(dsn, "Connection broken during SMTP conversation");
1126                 goto bail;
1127         }
1128         CtdlLogPrintf(CTDL_DEBUG, "<%s\n", buf);
1129         if (buf[0] != '2') {
1130                 if (buf[0] == '4') {
1131                         *status = 4;
1132                         safestrncpy(dsn, &buf[4], 1023);
1133                         goto bail;
1134                 }
1135                 else {
1136                         *status = 5;
1137                         safestrncpy(dsn, &buf[4], 1023);
1138                         goto bail;
1139                 }
1140         }
1141
1142         /* At this point we know we are talking to a real SMTP server */
1143
1144         /* Do a EHLO command.  If it fails, try the HELO command. */
1145         snprintf(buf, sizeof buf, "EHLO %s\r\n", config.c_fqdn);
1146         CtdlLogPrintf(CTDL_DEBUG, ">%s", buf);
1147         sock_write(&sock, buf, strlen(buf));
1148         if (ml_sock_gets(&sock, buf) < 0) {
1149                 *status = 4;
1150                 strcpy(dsn, "Connection broken during SMTP HELO");
1151                 goto bail;
1152         }
1153         CtdlLogPrintf(CTDL_DEBUG, "<%s\n", buf);
1154         if (buf[0] != '2') {
1155                 snprintf(buf, sizeof buf, "HELO %s\r\n", config.c_fqdn);
1156                 CtdlLogPrintf(CTDL_DEBUG, ">%s", buf);
1157                 sock_write(&sock, buf, strlen(buf));
1158                 if (ml_sock_gets(&sock, buf) < 0) {
1159                         *status = 4;
1160                         strcpy(dsn, "Connection broken during SMTP HELO");
1161                         goto bail;
1162                 }
1163         }
1164         if (buf[0] != '2') {
1165                 if (buf[0] == '4') {
1166                         *status = 4;
1167                         safestrncpy(dsn, &buf[4], 1023);
1168                         goto bail;
1169                 }
1170                 else {
1171                         *status = 5;
1172                         safestrncpy(dsn, &buf[4], 1023);
1173                         goto bail;
1174                 }
1175         }
1176
1177         /* Do an AUTH command if necessary */
1178         if (!IsEmptyStr(mx_user)) {
1179                 char encoded[1024];
1180                 sprintf(buf, "%s%c%s%c%s", mx_user, '\0', mx_user, '\0', mx_pass);
1181                 CtdlEncodeBase64(encoded, buf, strlen(mx_user) + strlen(mx_user) + strlen(mx_pass) + 2, 0);
1182                 snprintf(buf, sizeof buf, "AUTH PLAIN %s\r\n", encoded);
1183                 CtdlLogPrintf(CTDL_DEBUG, ">%s", buf);
1184                 sock_write(&sock, buf, strlen(buf));
1185                 if (ml_sock_gets(&sock, buf) < 0) {
1186                         *status = 4;
1187                         strcpy(dsn, "Connection broken during SMTP AUTH");
1188                         goto bail;
1189                 }
1190                 CtdlLogPrintf(CTDL_DEBUG, "<%s\n", buf);
1191                 if (buf[0] != '2') {
1192                         if (buf[0] == '4') {
1193                                 *status = 4;
1194                                 safestrncpy(dsn, &buf[4], 1023);
1195                                 goto bail;
1196                         }
1197                         else {
1198                                 *status = 5;
1199                                 safestrncpy(dsn, &buf[4], 1023);
1200                                 goto bail;
1201                         }
1202                 }
1203         }
1204
1205         /* previous command succeeded, now try the MAIL FROM: command */
1206         snprintf(buf, sizeof buf, "MAIL FROM:<%s>\r\n", envelope_from);
1207         CtdlLogPrintf(CTDL_DEBUG, ">%s", buf);
1208         sock_write(&sock, buf, strlen(buf));
1209         if (ml_sock_gets(&sock, buf) < 0) {
1210                 *status = 4;
1211                 strcpy(dsn, "Connection broken during SMTP MAIL");
1212                 goto bail;
1213         }
1214         CtdlLogPrintf(CTDL_DEBUG, "<%s\n", buf);
1215         if (buf[0] != '2') {
1216                 if (buf[0] == '4') {
1217                         *status = 4;
1218                         safestrncpy(dsn, &buf[4], 1023);
1219                         goto bail;
1220                 }
1221                 else {
1222                         *status = 5;
1223                         safestrncpy(dsn, &buf[4], 1023);
1224                         goto bail;
1225                 }
1226         }
1227
1228         /* MAIL succeeded, now try the RCPT To: command */
1229         snprintf(buf, sizeof buf, "RCPT TO:<%s@%s>\r\n", user, node);
1230         CtdlLogPrintf(CTDL_DEBUG, ">%s", buf);
1231         sock_write(&sock, buf, strlen(buf));
1232         if (ml_sock_gets(&sock, buf) < 0) {
1233                 *status = 4;
1234                 strcpy(dsn, "Connection broken during SMTP RCPT");
1235                 goto bail;
1236         }
1237         CtdlLogPrintf(CTDL_DEBUG, "<%s\n", buf);
1238         if (buf[0] != '2') {
1239                 if (buf[0] == '4') {
1240                         *status = 4;
1241                         safestrncpy(dsn, &buf[4], 1023);
1242                         goto bail;
1243                 }
1244                 else {
1245                         *status = 5;
1246                         safestrncpy(dsn, &buf[4], 1023);
1247                         goto bail;
1248                 }
1249         }
1250
1251         /* RCPT succeeded, now try the DATA command */
1252         CtdlLogPrintf(CTDL_DEBUG, ">DATA\n");
1253         sock_write(&sock, "DATA\r\n", 6);
1254         if (ml_sock_gets(&sock, buf) < 0) {
1255                 *status = 4;
1256                 strcpy(dsn, "Connection broken during SMTP DATA");
1257                 goto bail;
1258         }
1259         CtdlLogPrintf(CTDL_DEBUG, "<%s\n", buf);
1260         if (buf[0] != '3') {
1261                 if (buf[0] == '4') {
1262                         *status = 3;
1263                         safestrncpy(dsn, &buf[4], 1023);
1264                         goto bail;
1265                 }
1266                 else {
1267                         *status = 5;
1268                         safestrncpy(dsn, &buf[4], 1023);
1269                         goto bail;
1270                 }
1271         }
1272
1273         /* If we reach this point, the server is expecting data.*/
1274         sock_write(&sock, msgtext, msg_size);
1275         if (msgtext[msg_size-1] != 10) {
1276                 CtdlLogPrintf(CTDL_WARNING, "Possible problem: message did not "
1277                         "correctly terminate. (expecting 0x10, got 0x%02x)\n",
1278                                 buf[msg_size-1]);
1279                 sock_write(&sock, "\r\n", 2);
1280         }
1281
1282         sock_write(&sock, ".\r\n", 3);
1283         if (ml_sock_gets(&sock, buf) < 0) {
1284                 *status = 4;
1285                 strcpy(dsn, "Connection broken during SMTP message transmit");
1286                 goto bail;
1287         }
1288         CtdlLogPrintf(CTDL_DEBUG, "%s\n", buf);
1289         if (buf[0] != '2') {
1290                 if (buf[0] == '4') {
1291                         *status = 4;
1292                         safestrncpy(dsn, &buf[4], 1023);
1293                         goto bail;
1294                 }
1295                 else {
1296                         *status = 5;
1297                         safestrncpy(dsn, &buf[4], 1023);
1298                         goto bail;
1299                 }
1300         }
1301
1302         /* We did it! */
1303         safestrncpy(dsn, &buf[4], 1023);
1304         *status = 2;
1305
1306         CtdlLogPrintf(CTDL_DEBUG, ">QUIT\n");
1307         sock_write(&sock, "QUIT\r\n", 6);
1308         ml_sock_gets(&sock, buf);
1309         CtdlLogPrintf(CTDL_DEBUG, "<%s\n", buf);
1310         CtdlLogPrintf(CTDL_INFO, "SMTP client: delivery to <%s> @ <%s> (%s) succeeded\n",
1311                 user, node, name);
1312
1313 bail:   free(msgtext);
1314         FreeStrBuf(&CCC->sReadBuf);
1315         FreeStrBuf(&CCC->sMigrateBuf);
1316         if (sock != -1)
1317                 sock_close(sock);
1318
1319         /* Write something to the syslog (which may or may not be where the
1320          * rest of the Citadel logs are going; some sysadmins want LOG_MAIL).
1321          */
1322         if (enable_syslog) {
1323                 syslog((LOG_MAIL | LOG_INFO),
1324                         "%ld: to=<%s>, relay=%s, stat=%s",
1325                         msgnum,
1326                         addr,
1327                         mx_host,
1328                         dsn
1329                 );
1330         }
1331
1332         return;
1333 }
1334
1335
1336
1337 /*
1338  * smtp_do_bounce() is caled by smtp_do_procmsg() to scan a set of delivery
1339  * instructions for "5" codes (permanent fatal errors) and produce/deliver
1340  * a "bounce" message (delivery status notification).
1341  */
1342 void smtp_do_bounce(char *instr) {
1343         int i;
1344         int lines;
1345         int status;
1346         char buf[1024];
1347         char key[1024];
1348         char addr[1024];
1349         char dsn[1024];
1350         char bounceto[1024];
1351         StrBuf *boundary;
1352         int num_bounces = 0;
1353         int bounce_this = 0;
1354         long bounce_msgid = (-1);
1355         time_t submitted = 0L;
1356         struct CtdlMessage *bmsg = NULL;
1357         int give_up = 0;
1358         struct recptypes *valid;
1359         int successful_bounce = 0;
1360         static int seq = 0;
1361         StrBuf *BounceMB;
1362         long omsgid = (-1);
1363
1364         CtdlLogPrintf(CTDL_DEBUG, "smtp_do_bounce() called\n");
1365         strcpy(bounceto, "");
1366         boundary = NewStrBufPlain(HKEY("=_Citadel_Multipart_"));
1367         StrBufAppendPrintf(boundary, "%s_%04x%04x", config.c_fqdn, getpid(), ++seq);
1368         lines = num_tokens(instr, '\n');
1369
1370         /* See if it's time to give up on delivery of this message */
1371         for (i=0; i<lines; ++i) {
1372                 extract_token(buf, instr, i, '\n', sizeof buf);
1373                 extract_token(key, buf, 0, '|', sizeof key);
1374                 extract_token(addr, buf, 1, '|', sizeof addr);
1375                 if (!strcasecmp(key, "submitted")) {
1376                         submitted = atol(addr);
1377                 }
1378         }
1379
1380         if ( (time(NULL) - submitted) > SMTP_GIVE_UP ) {
1381                 give_up = 1;
1382         }
1383
1384         /* Start building our bounce message */
1385
1386         bmsg = (struct CtdlMessage *) malloc(sizeof(struct CtdlMessage));
1387         if (bmsg == NULL) return;
1388         memset(bmsg, 0, sizeof(struct CtdlMessage));
1389         BounceMB = NewStrBufPlain(NULL, 1024);
1390
1391         bmsg->cm_magic = CTDLMESSAGE_MAGIC;
1392         bmsg->cm_anon_type = MES_NORMAL;
1393         bmsg->cm_format_type = FMT_RFC822;
1394         bmsg->cm_fields['A'] = strdup("Citadel");
1395         bmsg->cm_fields['O'] = strdup(MAILROOM);
1396         bmsg->cm_fields['N'] = strdup(config.c_nodename);
1397         bmsg->cm_fields['U'] = strdup("Delivery Status Notification (Failure)");
1398         StrBufAppendBufPlain(BounceMB, HKEY("Content-type: multipart/mixed; boundary=\""), 0);
1399         StrBufAppendBuf(BounceMB, boundary, 0);
1400         StrBufAppendBufPlain(BounceMB, HKEY("\"\r\n"), 0);
1401         StrBufAppendBufPlain(BounceMB, HKEY("MIME-Version: 1.0\r\n"), 0);
1402         StrBufAppendBufPlain(BounceMB, HKEY("X-Mailer: " CITADEL "\r\n"), 0);
1403         StrBufAppendBufPlain(BounceMB, HKEY("\r\nThis is a multipart message in MIME format.\r\n\r\n"), 0);
1404         StrBufAppendBufPlain(BounceMB, HKEY("--"), 0);
1405         StrBufAppendBuf(BounceMB, boundary, 0);
1406         StrBufAppendBufPlain(BounceMB, HKEY("\r\n"), 0);
1407         StrBufAppendBufPlain(BounceMB, HKEY("Content-type: text/plain\r\n\r\n"), 0);
1408
1409         if (give_up) StrBufAppendBufPlain(BounceMB, HKEY(
1410 "A message you sent could not be delivered to some or all of its recipients\n"
1411 "due to prolonged unavailability of its destination(s).\n"
1412 "Giving up on the following addresses:\n\n"
1413                                                   ), 0);
1414
1415         else StrBufAppendBufPlain(BounceMB, HKEY(
1416 "A message you sent could not be delivered to some or all of its recipients.\n"
1417 "The following addresses were undeliverable:\n\n"
1418                                           ), 0);
1419
1420         /*
1421          * Now go through the instructions checking for stuff.
1422          */
1423         for (i=0; i<lines; ++i) {
1424                 long addrlen;
1425                 long dsnlen;
1426                 extract_token(buf, instr, i, '\n', sizeof buf);
1427                 extract_token(key, buf, 0, '|', sizeof key);
1428                 addrlen = extract_token(addr, buf, 1, '|', sizeof addr);
1429                 status = extract_int(buf, 2);
1430                 dsnlen = extract_token(dsn, buf, 3, '|', sizeof dsn);
1431                 bounce_this = 0;
1432
1433                 CtdlLogPrintf(CTDL_DEBUG, "key=<%s> addr=<%s> status=%d dsn=<%s>\n",
1434                         key, addr, status, dsn);
1435
1436                 if (!strcasecmp(key, "bounceto")) {
1437                         strcpy(bounceto, addr);
1438                 }
1439
1440                 if (!strcasecmp(key, "msgid")) {
1441                         omsgid = atol(addr);
1442                 }
1443
1444                 if (!strcasecmp(key, "remote")) {
1445                         if (status == 5) bounce_this = 1;
1446                         if (give_up) bounce_this = 1;
1447                 }
1448
1449                 if (bounce_this) {
1450                         ++num_bounces;
1451
1452                         StrBufAppendBufPlain(BounceMB, addr, addrlen, 0);
1453                         StrBufAppendBufPlain(BounceMB, HKEY(": "), 0);
1454                         StrBufAppendBufPlain(BounceMB, dsn, dsnlen, 0);
1455                         StrBufAppendBufPlain(BounceMB, HKEY("\r\n"), 0);
1456
1457                         remove_token(instr, i, '\n');
1458                         --i;
1459                         --lines;
1460                 }
1461         }
1462
1463         /* Attach the original message */
1464         if (omsgid >= 0) {
1465                 StrBufAppendBufPlain(BounceMB, HKEY("--"), 0);
1466                 StrBufAppendBuf(BounceMB, boundary, 0);
1467                 StrBufAppendBufPlain(BounceMB, HKEY("\r\n"), 0);
1468                 StrBufAppendBufPlain(BounceMB, HKEY("Content-type: message/rfc822\r\n"), 0);
1469                 StrBufAppendBufPlain(BounceMB, HKEY("Content-Transfer-Encoding: 7bit\r\n"), 0);
1470                 StrBufAppendBufPlain(BounceMB, HKEY("Content-Disposition: inline\r\n"), 0);
1471                 StrBufAppendBufPlain(BounceMB, HKEY("\r\n"), 0);
1472
1473                 CC->redirect_buffer = NewStrBufPlain(NULL, SIZ);
1474                 CtdlOutputMsg(omsgid, MT_RFC822, HEADERS_ALL, 0, 1, NULL, 0);
1475                 StrBufAppendBuf(BounceMB, CC->redirect_buffer, 0);
1476                 FreeStrBuf(&CC->redirect_buffer);
1477         }
1478
1479         /* Close the multipart MIME scope */
1480         StrBufAppendBufPlain(BounceMB, HKEY("--"), 0);
1481         StrBufAppendBuf(BounceMB, boundary, 0);
1482         StrBufAppendBufPlain(BounceMB, HKEY("--\r\n"), 0);
1483         bmsg->cm_fields['A'] = SmashStrBuf(&BounceMB);
1484         /* Deliver the bounce if there's anything worth mentioning */
1485         CtdlLogPrintf(CTDL_DEBUG, "num_bounces = %d\n", num_bounces);
1486         if (num_bounces > 0) {
1487
1488                 /* First try the user who sent the message */
1489                 CtdlLogPrintf(CTDL_DEBUG, "bounce to user? <%s>\n", bounceto);
1490                 if (IsEmptyStr(bounceto)) {
1491                         CtdlLogPrintf(CTDL_ERR, "No bounce address specified\n");
1492                         bounce_msgid = (-1L);
1493                 }
1494
1495                 /* Can we deliver the bounce to the original sender? */
1496                 valid = validate_recipients(bounceto, smtp_get_Recipients (), 0);
1497                 if (valid != NULL) {
1498                         if (valid->num_error == 0) {
1499                                 CtdlSubmitMsg(bmsg, valid, "", QP_EADDR);
1500                                 successful_bounce = 1;
1501                         }
1502                 }
1503
1504                 /* If not, post it in the Aide> room */
1505                 if (successful_bounce == 0) {
1506                         CtdlSubmitMsg(bmsg, NULL, config.c_aideroom, QP_EADDR);
1507                 }
1508
1509                 /* Free up the memory we used */
1510                 if (valid != NULL) {
1511                         free_recipients(valid);
1512                 }
1513         }
1514         FreeStrBuf(&boundary);
1515         CtdlFreeMessage(bmsg);
1516         CtdlLogPrintf(CTDL_DEBUG, "Done processing bounces\n");
1517 }
1518
1519
1520 /*
1521  * smtp_purge_completed_deliveries() is caled by smtp_do_procmsg() to scan a
1522  * set of delivery instructions for completed deliveries and remove them.
1523  *
1524  * It returns the number of incomplete deliveries remaining.
1525  */
1526 int smtp_purge_completed_deliveries(char *instr) {
1527         int i;
1528         int lines;
1529         int status;
1530         char buf[1024];
1531         char key[1024];
1532         char addr[1024];
1533         char dsn[1024];
1534         int completed;
1535         int incomplete = 0;
1536
1537         lines = num_tokens(instr, '\n');
1538         for (i=0; i<lines; ++i) {
1539                 extract_token(buf, instr, i, '\n', sizeof buf);
1540                 extract_token(key, buf, 0, '|', sizeof key);
1541                 extract_token(addr, buf, 1, '|', sizeof addr);
1542                 status = extract_int(buf, 2);
1543                 extract_token(dsn, buf, 3, '|', sizeof dsn);
1544
1545                 completed = 0;
1546
1547                 if (!strcasecmp(key, "remote")) {
1548                         if (status == 2) completed = 1;
1549                         else ++incomplete;
1550                 }
1551
1552                 if (completed) {
1553                         remove_token(instr, i, '\n');
1554                         --i;
1555                         --lines;
1556                 }
1557         }
1558
1559         return(incomplete);
1560 }
1561
1562
1563 /*
1564  * smtp_do_procmsg()
1565  *
1566  * Called by smtp_do_queue() to handle an individual message.
1567  */
1568 void smtp_do_procmsg(long msgnum, void *userdata) {
1569         struct CtdlMessage *msg = NULL;
1570         char *instr = NULL;
1571         char *results = NULL;
1572         int i;
1573         int lines;
1574         int status;
1575         char buf[1024];
1576         char key[1024];
1577         char addr[1024];
1578         char dsn[1024];
1579         char envelope_from[1024];
1580         long text_msgid = (-1);
1581         int incomplete_deliveries_remaining;
1582         time_t attempted = 0L;
1583         time_t last_attempted = 0L;
1584         time_t retry = SMTP_RETRY_INTERVAL;
1585
1586         CtdlLogPrintf(CTDL_DEBUG, "SMTP client: smtp_do_procmsg(%ld)\n", msgnum);
1587         strcpy(envelope_from, "");
1588
1589         msg = CtdlFetchMessage(msgnum, 1);
1590         if (msg == NULL) {
1591                 CtdlLogPrintf(CTDL_ERR, "SMTP client: tried %ld but no such message!\n", msgnum);
1592                 return;
1593         }
1594
1595         instr = strdup(msg->cm_fields['M']);
1596         CtdlFreeMessage(msg);
1597
1598         /* Strip out the headers amd any other non-instruction line */
1599         lines = num_tokens(instr, '\n');
1600         for (i=0; i<lines; ++i) {
1601                 extract_token(buf, instr, i, '\n', sizeof buf);
1602                 if (num_tokens(buf, '|') < 2) {
1603                         remove_token(instr, i, '\n');
1604                         --lines;
1605                         --i;
1606                 }
1607         }
1608
1609         /* Learn the message ID and find out about recent delivery attempts */
1610         lines = num_tokens(instr, '\n');
1611         for (i=0; i<lines; ++i) {
1612                 extract_token(buf, instr, i, '\n', sizeof buf);
1613                 extract_token(key, buf, 0, '|', sizeof key);
1614                 if (!strcasecmp(key, "msgid")) {
1615                         text_msgid = extract_long(buf, 1);
1616                 }
1617                 if (!strcasecmp(key, "envelope_from")) {
1618                         extract_token(envelope_from, buf, 1, '|', sizeof envelope_from);
1619                 }
1620                 if (!strcasecmp(key, "retry")) {
1621                         /* double the retry interval after each attempt */
1622                         retry = extract_long(buf, 1) * 2L;
1623                         if (retry > SMTP_RETRY_MAX) {
1624                                 retry = SMTP_RETRY_MAX;
1625                         }
1626                         remove_token(instr, i, '\n');
1627                 }
1628                 if (!strcasecmp(key, "attempted")) {
1629                         attempted = extract_long(buf, 1);
1630                         if (attempted > last_attempted)
1631                                 last_attempted = attempted;
1632                 }
1633         }
1634
1635         /*
1636          * Postpone delivery if we've already tried recently.
1637          */
1638         if (((time(NULL) - last_attempted) < retry) && (run_queue_now == 0)) {
1639                 CtdlLogPrintf(CTDL_DEBUG, "SMTP client: Retry time not yet reached.\n");
1640                 free(instr);
1641                 return;
1642         }
1643
1644
1645         /*
1646          * Bail out if there's no actual message associated with this
1647          */
1648         if (text_msgid < 0L) {
1649                 CtdlLogPrintf(CTDL_ERR, "SMTP client: no 'msgid' directive found!\n");
1650                 free(instr);
1651                 return;
1652         }
1653
1654         /* Plow through the instructions looking for 'remote' directives and
1655          * a status of 0 (no delivery yet attempted) or 3/4 (transient errors
1656          * were experienced and it's time to try again)
1657          */
1658         lines = num_tokens(instr, '\n');
1659         for (i=0; i<lines; ++i) {
1660                 extract_token(buf, instr, i, '\n', sizeof buf);
1661                 extract_token(key, buf, 0, '|', sizeof key);
1662                 extract_token(addr, buf, 1, '|', sizeof addr);
1663                 status = extract_int(buf, 2);
1664                 extract_token(dsn, buf, 3, '|', sizeof dsn);
1665                 if ( (!strcasecmp(key, "remote"))
1666                    && ((status==0)||(status==3)||(status==4)) ) {
1667
1668                         /* Remove this "remote" instruction from the set,
1669                          * but replace the set's final newline if
1670                          * remove_token() stripped it.  It has to be there.
1671                          */
1672                         remove_token(instr, i, '\n');
1673                         if (instr[strlen(instr)-1] != '\n') {
1674                                 strcat(instr, "\n");
1675                         }
1676
1677                         --i;
1678                         --lines;
1679                         CtdlLogPrintf(CTDL_DEBUG, "SMTP client: Trying <%s>\n", addr);
1680                         smtp_try(key, addr, &status, dsn, sizeof dsn, text_msgid, envelope_from);
1681                         if (status != 2) {
1682                                 if (results == NULL) {
1683                                         results = malloc(1024);
1684                                         memset(results, 0, 1024);
1685                                 }
1686                                 else {
1687                                         results = realloc(results, strlen(results) + 1024);
1688                                 }
1689                                 snprintf(&results[strlen(results)], 1024,
1690                                         "%s|%s|%d|%s\n",
1691                                         key, addr, status, dsn);
1692                         }
1693                 }
1694         }
1695
1696         if (results != NULL) {
1697                 instr = realloc(instr, strlen(instr) + strlen(results) + 2);
1698                 strcat(instr, results);
1699                 free(results);
1700         }
1701
1702
1703         /* Generate 'bounce' messages */
1704         smtp_do_bounce(instr);
1705
1706         /* Go through the delivery list, deleting completed deliveries */
1707         incomplete_deliveries_remaining =
1708                 smtp_purge_completed_deliveries(instr);
1709
1710
1711         /*
1712          * No delivery instructions remain, so delete both the instructions
1713          * message and the message message.
1714          */
1715         if (incomplete_deliveries_remaining <= 0) {
1716                 long delmsgs[2];
1717                 delmsgs[0] = msgnum;
1718                 delmsgs[1] = text_msgid;
1719                 CtdlDeleteMessages(SMTP_SPOOLOUT_ROOM, delmsgs, 2, "");
1720         }
1721
1722         /*
1723          * Uncompleted delivery instructions remain, so delete the old
1724          * instructions and replace with the updated ones.
1725          */
1726         if (incomplete_deliveries_remaining > 0) {
1727                 CtdlDeleteMessages(SMTP_SPOOLOUT_ROOM, &msgnum, 1, "");
1728                 msg = malloc(sizeof(struct CtdlMessage));
1729                 memset(msg, 0, sizeof(struct CtdlMessage));
1730                 msg->cm_magic = CTDLMESSAGE_MAGIC;
1731                 msg->cm_anon_type = MES_NORMAL;
1732                 msg->cm_format_type = FMT_RFC822;
1733                 msg->cm_fields['M'] = malloc(strlen(instr)+SIZ);
1734                 snprintf(msg->cm_fields['M'],
1735                         strlen(instr)+SIZ,
1736                         "Content-type: %s\n\n%s\n"
1737                         "attempted|%ld\n"
1738                         "retry|%ld\n",
1739                         SPOOLMIME, instr, (long)time(NULL), (long)retry );
1740                 CtdlSubmitMsg(msg, NULL, SMTP_SPOOLOUT_ROOM, QP_EADDR);
1741                 CtdlFreeMessage(msg);
1742         }
1743
1744         free(instr);
1745 }
1746
1747
1748
1749
1750 /*
1751  * smtp_do_queue()
1752  *
1753  * Run through the queue sending out messages.
1754  */
1755 void *smtp_do_queue(void *arg) {
1756         int num_processed = 0;
1757         struct CitContext smtp_queue_CC;
1758
1759         CtdlFillSystemContext(&smtp_queue_CC, "SMTP Send");
1760         citthread_setspecific(MyConKey, (void *)&smtp_queue_CC );
1761         CtdlLogPrintf(CTDL_INFO, "SMTP client: processing outbound queue\n");
1762
1763         if (CtdlGetRoom(&CC->room, SMTP_SPOOLOUT_ROOM) != 0) {
1764                 CtdlLogPrintf(CTDL_ERR, "Cannot find room <%s>\n", SMTP_SPOOLOUT_ROOM);
1765         }
1766         else {
1767                 num_processed = CtdlForEachMessage(MSGS_ALL, 0L, NULL, SPOOLMIME, NULL, smtp_do_procmsg, NULL);
1768         }
1769
1770         citthread_mutex_unlock (&smtp_send_lock);
1771         CtdlLogPrintf(CTDL_INFO, "SMTP client: queue run completed; %d messages processed\n", num_processed);
1772
1773         CtdlClearSystemContext();
1774         return(NULL);
1775 }
1776
1777
1778
1779 /*
1780  * smtp_queue_thread
1781  *
1782  * Create a thread to run the SMTP queue
1783  *
1784  * This was created as a response to a situation seen on Uncensored where a bad remote was holding
1785  * up SMTP sending for long times.
1786  * Converting to a thread does not fix the problem caused by the bad remote but it does prevent
1787  * the SMTP sending from stopping housekeeping and the EVT_TIMER event system which in turn prevented
1788  * other things from happening.
1789  */
1790 void smtp_queue_thread (void)
1791 {
1792         if (citthread_mutex_trylock (&smtp_send_lock)) {
1793                 CtdlLogPrintf(CTDL_DEBUG, "SMTP queue run already in progress\n");
1794         }
1795         else {
1796                 CtdlThreadCreate("SMTP Send", CTDLTHREAD_BIGSTACK, smtp_do_queue, NULL);
1797         }
1798 }
1799
1800
1801
1802 void smtp_server_going_down (void)
1803 {
1804         CtdlLogPrintf(CTDL_DEBUG, "SMTP module clean up for shutdown.\n");
1805
1806         citthread_mutex_destroy (&smtp_send_lock);
1807 }
1808
1809
1810
1811 /*****************************************************************************/
1812 /*                          SMTP UTILITY COMMANDS                            */
1813 /*****************************************************************************/
1814
1815 void cmd_smtp(char *argbuf) {
1816         char cmd[64];
1817         char node[256];
1818         char buf[1024];
1819         int i;
1820         int num_mxhosts;
1821
1822         if (CtdlAccessCheck(ac_aide)) return;
1823
1824         extract_token(cmd, argbuf, 0, '|', sizeof cmd);
1825
1826         if (!strcasecmp(cmd, "mx")) {
1827                 extract_token(node, argbuf, 1, '|', sizeof node);
1828                 num_mxhosts = getmx(buf, node);
1829                 cprintf("%d %d MX hosts listed for %s\n",
1830                         LISTING_FOLLOWS, num_mxhosts, node);
1831                 for (i=0; i<num_mxhosts; ++i) {
1832                         extract_token(node, buf, i, '|', sizeof node);
1833                         cprintf("%s\n", node);
1834                 }
1835                 cprintf("000\n");
1836                 return;
1837         }
1838
1839         else if (!strcasecmp(cmd, "runqueue")) {
1840                 run_queue_now = 1;
1841                 cprintf("%d All outbound SMTP will be retried now.\n", CIT_OK);
1842                 return;
1843         }
1844
1845         else {
1846                 cprintf("%d Invalid command.\n", ERROR + ILLEGAL_VALUE);
1847         }
1848
1849 }
1850
1851
1852 /*
1853  * Initialize the SMTP outbound queue
1854  */
1855 void smtp_init_spoolout(void) {
1856         struct ctdlroom qrbuf;
1857
1858         /*
1859          * Create the room.  This will silently fail if the room already
1860          * exists, and that's perfectly ok, because we want it to exist.
1861          */
1862         CtdlCreateRoom(SMTP_SPOOLOUT_ROOM, 3, "", 0, 1, 0, VIEW_MAILBOX);
1863
1864         /*
1865          * Make sure it's set to be a "system room" so it doesn't show up
1866          * in the <K>nown rooms list for Aides.
1867          */
1868         if (CtdlGetRoomLock(&qrbuf, SMTP_SPOOLOUT_ROOM) == 0) {
1869                 qrbuf.QRflags2 |= QR2_SYSTEM;
1870                 CtdlPutRoomLock(&qrbuf);
1871         }
1872 }
1873
1874
1875
1876
1877 /*****************************************************************************/
1878 /*                      MODULE INITIALIZATION STUFF                          */
1879 /*****************************************************************************/
1880 /*
1881  * This cleanup function blows away the temporary memory used by
1882  * the SMTP server.
1883  */
1884 void smtp_cleanup_function(void) {
1885
1886         /* Don't do this stuff if this is not an SMTP session! */
1887         if (CC->h_command_function != smtp_command_loop) return;
1888
1889         CtdlLogPrintf(CTDL_DEBUG, "Performing SMTP cleanup hook\n");
1890         free(SMTP);
1891 }
1892
1893
1894
1895 const char *CitadelServiceSMTP_MTA="SMTP-MTA";
1896 const char *CitadelServiceSMTPS_MTA="SMTPs-MTA";
1897 const char *CitadelServiceSMTP_MSA="SMTP-MSA";
1898 const char *CitadelServiceSMTP_LMTP="LMTP";
1899 const char *CitadelServiceSMTP_LMTP_UNF="LMTP-UnF";
1900
1901 CTDL_MODULE_INIT(smtp)
1902 {
1903         if (!threading)
1904         {
1905                 CtdlRegisterServiceHook(config.c_smtp_port,     /* SMTP MTA */
1906                                         NULL,
1907                                         smtp_mta_greeting,
1908                                         smtp_command_loop,
1909                                         NULL,
1910                                         CitadelServiceSMTP_MTA);
1911
1912 #ifdef HAVE_OPENSSL
1913                 CtdlRegisterServiceHook(config.c_smtps_port,
1914                                         NULL,
1915                                         smtps_greeting,
1916                                         smtp_command_loop,
1917                                         NULL,
1918                                         CitadelServiceSMTPS_MTA);
1919 #endif
1920
1921                 CtdlRegisterServiceHook(config.c_msa_port,      /* SMTP MSA */
1922                                         NULL,
1923                                         smtp_msa_greeting,
1924                                         smtp_command_loop,
1925                                         NULL,
1926                                         CitadelServiceSMTP_MSA);
1927
1928                 CtdlRegisterServiceHook(0,                      /* local LMTP */
1929                                         file_lmtp_socket,
1930                                         lmtp_greeting,
1931                                         smtp_command_loop,
1932                                         NULL,
1933                                         CitadelServiceSMTP_LMTP);
1934
1935                 CtdlRegisterServiceHook(0,                      /* local LMTP */
1936                                         file_lmtp_unfiltered_socket,
1937                                         lmtp_unfiltered_greeting,
1938                                         smtp_command_loop,
1939                                         NULL,
1940                                         CitadelServiceSMTP_LMTP_UNF);
1941
1942                 smtp_init_spoolout();
1943                 CtdlRegisterSessionHook(smtp_queue_thread, EVT_TIMER);
1944                 CtdlRegisterSessionHook(smtp_cleanup_function, EVT_STOP);
1945                 CtdlRegisterProtoHook(cmd_smtp, "SMTP", "SMTP utility commands");
1946                 CtdlRegisterCleanupHook (smtp_server_going_down);
1947                 citthread_mutex_init (&smtp_send_lock, NULL);
1948         }
1949
1950         /* return our Subversion id for the Log */
1951         return "$Id$";
1952 }