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 = memreadline(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) CtdlLogPrintf(CTDL_DEBUG, "SMTP client: connected!\n");
1089                 if (sock < 0) {
1090                         if (errno > 0) {
1091                                 snprintf(dsn, SIZ, "%s", strerror(errno));
1092                         }
1093                         else {
1094                                 snprintf(dsn, SIZ, "Unable to connect to %s : %s\n", mx_host, mx_port);
1095                         }
1096                 }
1097         }
1098
1099         if (sock < 0) {
1100                 *status = 4;    /* dsn is already filled in */
1101                 return;
1102         }
1103
1104         CCC->sReadBuf = NewStrBuf();
1105         CCC->sMigrateBuf = NewStrBuf();
1106         CCC->sPos = NULL;
1107
1108         /* Process the SMTP greeting from the server */
1109         if (ml_sock_gets(&sock, buf) < 0) {
1110                 *status = 4;
1111                 strcpy(dsn, "Connection broken during SMTP conversation");
1112                 goto bail;
1113         }
1114         CtdlLogPrintf(CTDL_DEBUG, "<%s\n", buf);
1115         if (buf[0] != '2') {
1116                 if (buf[0] == '4') {
1117                         *status = 4;
1118                         safestrncpy(dsn, &buf[4], 1023);
1119                         goto bail;
1120                 }
1121                 else {
1122                         *status = 5;
1123                         safestrncpy(dsn, &buf[4], 1023);
1124                         goto bail;
1125                 }
1126         }
1127
1128         /* At this point we know we are talking to a real SMTP server */
1129
1130         /* Do a EHLO command.  If it fails, try the HELO command. */
1131         snprintf(buf, sizeof buf, "EHLO %s\r\n", config.c_fqdn);
1132         CtdlLogPrintf(CTDL_DEBUG, ">%s", buf);
1133         sock_write(&sock, buf, strlen(buf));
1134         if (ml_sock_gets(&sock, buf) < 0) {
1135                 *status = 4;
1136                 strcpy(dsn, "Connection broken during SMTP HELO");
1137                 goto bail;
1138         }
1139         CtdlLogPrintf(CTDL_DEBUG, "<%s\n", buf);
1140         if (buf[0] != '2') {
1141                 snprintf(buf, sizeof buf, "HELO %s\r\n", config.c_fqdn);
1142                 CtdlLogPrintf(CTDL_DEBUG, ">%s", buf);
1143                 sock_write(&sock, buf, strlen(buf));
1144                 if (ml_sock_gets(&sock, buf) < 0) {
1145                         *status = 4;
1146                         strcpy(dsn, "Connection broken during SMTP HELO");
1147                         goto bail;
1148                 }
1149         }
1150         if (buf[0] != '2') {
1151                 if (buf[0] == '4') {
1152                         *status = 4;
1153                         safestrncpy(dsn, &buf[4], 1023);
1154                         goto bail;
1155                 }
1156                 else {
1157                         *status = 5;
1158                         safestrncpy(dsn, &buf[4], 1023);
1159                         goto bail;
1160                 }
1161         }
1162
1163         /* Do an AUTH command if necessary */
1164         if (!IsEmptyStr(mx_user)) {
1165                 char encoded[1024];
1166                 sprintf(buf, "%s%c%s%c%s", mx_user, '\0', mx_user, '\0', mx_pass);
1167                 CtdlEncodeBase64(encoded, buf, strlen(mx_user) + strlen(mx_user) + strlen(mx_pass) + 2, 0);
1168                 snprintf(buf, sizeof buf, "AUTH PLAIN %s\r\n", encoded);
1169                 CtdlLogPrintf(CTDL_DEBUG, ">%s", buf);
1170                 sock_write(&sock, buf, strlen(buf));
1171                 if (ml_sock_gets(&sock, buf) < 0) {
1172                         *status = 4;
1173                         strcpy(dsn, "Connection broken during SMTP AUTH");
1174                         goto bail;
1175                 }
1176                 CtdlLogPrintf(CTDL_DEBUG, "<%s\n", buf);
1177                 if (buf[0] != '2') {
1178                         if (buf[0] == '4') {
1179                                 *status = 4;
1180                                 safestrncpy(dsn, &buf[4], 1023);
1181                                 goto bail;
1182                         }
1183                         else {
1184                                 *status = 5;
1185                                 safestrncpy(dsn, &buf[4], 1023);
1186                                 goto bail;
1187                         }
1188                 }
1189         }
1190
1191         /* previous command succeeded, now try the MAIL FROM: command */
1192         snprintf(buf, sizeof buf, "MAIL FROM:<%s>\r\n", envelope_from);
1193         CtdlLogPrintf(CTDL_DEBUG, ">%s", buf);
1194         sock_write(&sock, buf, strlen(buf));
1195         if (ml_sock_gets(&sock, buf) < 0) {
1196                 *status = 4;
1197                 strcpy(dsn, "Connection broken during SMTP MAIL");
1198                 goto bail;
1199         }
1200         CtdlLogPrintf(CTDL_DEBUG, "<%s\n", buf);
1201         if (buf[0] != '2') {
1202                 if (buf[0] == '4') {
1203                         *status = 4;
1204                         safestrncpy(dsn, &buf[4], 1023);
1205                         goto bail;
1206                 }
1207                 else {
1208                         *status = 5;
1209                         safestrncpy(dsn, &buf[4], 1023);
1210                         goto bail;
1211                 }
1212         }
1213
1214         /* MAIL succeeded, now try the RCPT To: command */
1215         snprintf(buf, sizeof buf, "RCPT TO:<%s@%s>\r\n", user, node);
1216         CtdlLogPrintf(CTDL_DEBUG, ">%s", buf);
1217         sock_write(&sock, buf, strlen(buf));
1218         if (ml_sock_gets(&sock, buf) < 0) {
1219                 *status = 4;
1220                 strcpy(dsn, "Connection broken during SMTP RCPT");
1221                 goto bail;
1222         }
1223         CtdlLogPrintf(CTDL_DEBUG, "<%s\n", buf);
1224         if (buf[0] != '2') {
1225                 if (buf[0] == '4') {
1226                         *status = 4;
1227                         safestrncpy(dsn, &buf[4], 1023);
1228                         goto bail;
1229                 }
1230                 else {
1231                         *status = 5;
1232                         safestrncpy(dsn, &buf[4], 1023);
1233                         goto bail;
1234                 }
1235         }
1236
1237         /* RCPT succeeded, now try the DATA command */
1238         CtdlLogPrintf(CTDL_DEBUG, ">DATA\n");
1239         sock_write(&sock, "DATA\r\n", 6);
1240         if (ml_sock_gets(&sock, buf) < 0) {
1241                 *status = 4;
1242                 strcpy(dsn, "Connection broken during SMTP DATA");
1243                 goto bail;
1244         }
1245         CtdlLogPrintf(CTDL_DEBUG, "<%s\n", buf);
1246         if (buf[0] != '3') {
1247                 if (buf[0] == '4') {
1248                         *status = 3;
1249                         safestrncpy(dsn, &buf[4], 1023);
1250                         goto bail;
1251                 }
1252                 else {
1253                         *status = 5;
1254                         safestrncpy(dsn, &buf[4], 1023);
1255                         goto bail;
1256                 }
1257         }
1258
1259         /* If we reach this point, the server is expecting data.*/
1260         sock_write(&sock, msgtext, msg_size);
1261         if (msgtext[msg_size-1] != 10) {
1262                 CtdlLogPrintf(CTDL_WARNING, "Possible problem: message did not "
1263                         "correctly terminate. (expecting 0x10, got 0x%02x)\n",
1264                                 buf[msg_size-1]);
1265                 sock_write(&sock, "\r\n", 2);
1266         }
1267
1268         sock_write(&sock, ".\r\n", 3);
1269         if (ml_sock_gets(&sock, buf) < 0) {
1270                 *status = 4;
1271                 strcpy(dsn, "Connection broken during SMTP message transmit");
1272                 goto bail;
1273         }
1274         CtdlLogPrintf(CTDL_DEBUG, "%s\n", buf);
1275         if (buf[0] != '2') {
1276                 if (buf[0] == '4') {
1277                         *status = 4;
1278                         safestrncpy(dsn, &buf[4], 1023);
1279                         goto bail;
1280                 }
1281                 else {
1282                         *status = 5;
1283                         safestrncpy(dsn, &buf[4], 1023);
1284                         goto bail;
1285                 }
1286         }
1287
1288         /* We did it! */
1289         safestrncpy(dsn, &buf[4], 1023);
1290         *status = 2;
1291
1292         CtdlLogPrintf(CTDL_DEBUG, ">QUIT\n");
1293         sock_write(&sock, "QUIT\r\n", 6);
1294         ml_sock_gets(&sock, buf);
1295         CtdlLogPrintf(CTDL_DEBUG, "<%s\n", buf);
1296         CtdlLogPrintf(CTDL_INFO, "SMTP client: delivery to <%s> @ <%s> (%s) succeeded\n",
1297                 user, node, name);
1298
1299 bail:   free(msgtext);
1300         FreeStrBuf(&CCC->sReadBuf);
1301         FreeStrBuf(&CCC->sMigrateBuf);
1302         if (sock != -1)
1303                 sock_close(sock);
1304
1305         /* Write something to the syslog (which may or may not be where the
1306          * rest of the Citadel logs are going; some sysadmins want LOG_MAIL).
1307          */
1308         if (enable_syslog) {
1309                 syslog((LOG_MAIL | LOG_INFO),
1310                         "%ld: to=<%s>, relay=%s, stat=%s",
1311                         msgnum,
1312                         addr,
1313                         mx_host,
1314                         dsn
1315                 );
1316         }
1317
1318         return;
1319 }
1320
1321
1322
1323 /*
1324  * smtp_do_bounce() is caled by smtp_do_procmsg() to scan a set of delivery
1325  * instructions for "5" codes (permanent fatal errors) and produce/deliver
1326  * a "bounce" message (delivery status notification).
1327  */
1328 void smtp_do_bounce(char *instr) {
1329         int i;
1330         int lines;
1331         int status;
1332         char buf[1024];
1333         char key[1024];
1334         char addr[1024];
1335         char dsn[1024];
1336         char bounceto[1024];
1337         StrBuf *boundary;
1338         int num_bounces = 0;
1339         int bounce_this = 0;
1340         long bounce_msgid = (-1);
1341         time_t submitted = 0L;
1342         struct CtdlMessage *bmsg = NULL;
1343         int give_up = 0;
1344         struct recptypes *valid;
1345         int successful_bounce = 0;
1346         static int seq = 0;
1347         StrBuf *BounceMB;
1348         long omsgid = (-1);
1349
1350         CtdlLogPrintf(CTDL_DEBUG, "smtp_do_bounce() called\n");
1351         strcpy(bounceto, "");
1352         boundary = NewStrBufPlain(HKEY("=_Citadel_Multipart_"));
1353         StrBufAppendPrintf(boundary, "%s_%04x%04x", config.c_fqdn, getpid(), ++seq);
1354         lines = num_tokens(instr, '\n');
1355
1356         /* See if it's time to give up on delivery of this message */
1357         for (i=0; i<lines; ++i) {
1358                 extract_token(buf, instr, i, '\n', sizeof buf);
1359                 extract_token(key, buf, 0, '|', sizeof key);
1360                 extract_token(addr, buf, 1, '|', sizeof addr);
1361                 if (!strcasecmp(key, "submitted")) {
1362                         submitted = atol(addr);
1363                 }
1364         }
1365
1366         if ( (time(NULL) - submitted) > SMTP_GIVE_UP ) {
1367                 give_up = 1;
1368         }
1369
1370         /* Start building our bounce message */
1371
1372         bmsg = (struct CtdlMessage *) malloc(sizeof(struct CtdlMessage));
1373         if (bmsg == NULL) return;
1374         memset(bmsg, 0, sizeof(struct CtdlMessage));
1375         BounceMB = NewStrBufPlain(NULL, 1024);
1376
1377         bmsg->cm_magic = CTDLMESSAGE_MAGIC;
1378         bmsg->cm_anon_type = MES_NORMAL;
1379         bmsg->cm_format_type = FMT_RFC822;
1380         bmsg->cm_fields['A'] = strdup("Citadel");
1381         bmsg->cm_fields['O'] = strdup(MAILROOM);
1382         bmsg->cm_fields['N'] = strdup(config.c_nodename);
1383         bmsg->cm_fields['U'] = strdup("Delivery Status Notification (Failure)");
1384         StrBufAppendBufPlain(BounceMB, HKEY("Content-type: multipart/mixed; boundary=\""), 0);
1385         StrBufAppendBuf(BounceMB, boundary, 0);
1386         StrBufAppendBufPlain(BounceMB, HKEY("\"\r\n"), 0);
1387         StrBufAppendBufPlain(BounceMB, HKEY("MIME-Version: 1.0\r\n"), 0);
1388         StrBufAppendBufPlain(BounceMB, HKEY("X-Mailer: " CITADEL "\r\n"), 0);
1389         StrBufAppendBufPlain(BounceMB, HKEY("\r\nThis is a multipart message in MIME format.\r\n\r\n"), 0);
1390         StrBufAppendBufPlain(BounceMB, HKEY("--"), 0);
1391         StrBufAppendBuf(BounceMB, boundary, 0);
1392         StrBufAppendBufPlain(BounceMB, HKEY("\r\n"), 0);
1393         StrBufAppendBufPlain(BounceMB, HKEY("Content-type: text/plain\r\n\r\n"), 0);
1394
1395         if (give_up) StrBufAppendBufPlain(BounceMB, HKEY(
1396 "A message you sent could not be delivered to some or all of its recipients\n"
1397 "due to prolonged unavailability of its destination(s).\n"
1398 "Giving up on the following addresses:\n\n"
1399                                                   ), 0);
1400
1401         else StrBufAppendBufPlain(BounceMB, HKEY(
1402 "A message you sent could not be delivered to some or all of its recipients.\n"
1403 "The following addresses were undeliverable:\n\n"
1404                                           ), 0);
1405
1406         /*
1407          * Now go through the instructions checking for stuff.
1408          */
1409         for (i=0; i<lines; ++i) {
1410                 long addrlen;
1411                 long dsnlen;
1412                 extract_token(buf, instr, i, '\n', sizeof buf);
1413                 extract_token(key, buf, 0, '|', sizeof key);
1414                 addrlen = extract_token(addr, buf, 1, '|', sizeof addr);
1415                 status = extract_int(buf, 2);
1416                 dsnlen = extract_token(dsn, buf, 3, '|', sizeof dsn);
1417                 bounce_this = 0;
1418
1419                 CtdlLogPrintf(CTDL_DEBUG, "key=<%s> addr=<%s> status=%d dsn=<%s>\n",
1420                         key, addr, status, dsn);
1421
1422                 if (!strcasecmp(key, "bounceto")) {
1423                         strcpy(bounceto, addr);
1424                 }
1425
1426                 if (!strcasecmp(key, "msgid")) {
1427                         omsgid = atol(addr);
1428                 }
1429
1430                 if (!strcasecmp(key, "remote")) {
1431                         if (status == 5) bounce_this = 1;
1432                         if (give_up) bounce_this = 1;
1433                 }
1434
1435                 if (bounce_this) {
1436                         ++num_bounces;
1437
1438                         StrBufAppendBufPlain(BounceMB, addr, addrlen, 0);
1439                         StrBufAppendBufPlain(BounceMB, HKEY(": "), 0);
1440                         StrBufAppendBufPlain(BounceMB, dsn, dsnlen, 0);
1441                         StrBufAppendBufPlain(BounceMB, HKEY("\r\n"), 0);
1442
1443                         remove_token(instr, i, '\n');
1444                         --i;
1445                         --lines;
1446                 }
1447         }
1448
1449         /* Attach the original message */
1450         if (omsgid >= 0) {
1451                 StrBufAppendBufPlain(BounceMB, HKEY("--"), 0);
1452                 StrBufAppendBuf(BounceMB, boundary, 0);
1453                 StrBufAppendBufPlain(BounceMB, HKEY("\r\n"), 0);
1454                 StrBufAppendBufPlain(BounceMB, HKEY("Content-type: message/rfc822\r\n"), 0);
1455                 StrBufAppendBufPlain(BounceMB, HKEY("Content-Transfer-Encoding: 7bit\r\n"), 0);
1456                 StrBufAppendBufPlain(BounceMB, HKEY("Content-Disposition: inline\r\n"), 0);
1457                 StrBufAppendBufPlain(BounceMB, HKEY("\r\n"), 0);
1458
1459                 CC->redirect_buffer = NewStrBufPlain(NULL, SIZ);
1460                 CtdlOutputMsg(omsgid, MT_RFC822, HEADERS_ALL, 0, 1, NULL, 0);
1461                 StrBufAppendBuf(BounceMB, CC->redirect_buffer, 0);
1462                 FreeStrBuf(&CC->redirect_buffer);
1463         }
1464
1465         /* Close the multipart MIME scope */
1466         StrBufAppendBufPlain(BounceMB, HKEY("--"), 0);
1467         StrBufAppendBuf(BounceMB, boundary, 0);
1468         StrBufAppendBufPlain(BounceMB, HKEY("--\r\n"), 0);
1469         bmsg->cm_fields['A'] = SmashStrBuf(&BounceMB);
1470         /* Deliver the bounce if there's anything worth mentioning */
1471         CtdlLogPrintf(CTDL_DEBUG, "num_bounces = %d\n", num_bounces);
1472         if (num_bounces > 0) {
1473
1474                 /* First try the user who sent the message */
1475                 CtdlLogPrintf(CTDL_DEBUG, "bounce to user? <%s>\n", bounceto);
1476                 if (IsEmptyStr(bounceto)) {
1477                         CtdlLogPrintf(CTDL_ERR, "No bounce address specified\n");
1478                         bounce_msgid = (-1L);
1479                 }
1480
1481                 /* Can we deliver the bounce to the original sender? */
1482                 valid = validate_recipients(bounceto, smtp_get_Recipients (), 0);
1483                 if (valid != NULL) {
1484                         if (valid->num_error == 0) {
1485                                 CtdlSubmitMsg(bmsg, valid, "", QP_EADDR);
1486                                 successful_bounce = 1;
1487                         }
1488                 }
1489
1490                 /* If not, post it in the Aide> room */
1491                 if (successful_bounce == 0) {
1492                         CtdlSubmitMsg(bmsg, NULL, config.c_aideroom, QP_EADDR);
1493                 }
1494
1495                 /* Free up the memory we used */
1496                 if (valid != NULL) {
1497                         free_recipients(valid);
1498                 }
1499         }
1500         FreeStrBuf(&boundary);
1501         CtdlFreeMessage(bmsg);
1502         CtdlLogPrintf(CTDL_DEBUG, "Done processing bounces\n");
1503 }
1504
1505
1506 /*
1507  * smtp_purge_completed_deliveries() is caled by smtp_do_procmsg() to scan a
1508  * set of delivery instructions for completed deliveries and remove them.
1509  *
1510  * It returns the number of incomplete deliveries remaining.
1511  */
1512 int smtp_purge_completed_deliveries(char *instr) {
1513         int i;
1514         int lines;
1515         int status;
1516         char buf[1024];
1517         char key[1024];
1518         char addr[1024];
1519         char dsn[1024];
1520         int completed;
1521         int incomplete = 0;
1522
1523         lines = num_tokens(instr, '\n');
1524         for (i=0; i<lines; ++i) {
1525                 extract_token(buf, instr, i, '\n', sizeof buf);
1526                 extract_token(key, buf, 0, '|', sizeof key);
1527                 extract_token(addr, buf, 1, '|', sizeof addr);
1528                 status = extract_int(buf, 2);
1529                 extract_token(dsn, buf, 3, '|', sizeof dsn);
1530
1531                 completed = 0;
1532
1533                 if (!strcasecmp(key, "remote")) {
1534                         if (status == 2) completed = 1;
1535                         else ++incomplete;
1536                 }
1537
1538                 if (completed) {
1539                         remove_token(instr, i, '\n');
1540                         --i;
1541                         --lines;
1542                 }
1543         }
1544
1545         return(incomplete);
1546 }
1547
1548
1549 /*
1550  * smtp_do_procmsg()
1551  *
1552  * Called by smtp_do_queue() to handle an individual message.
1553  */
1554 void smtp_do_procmsg(long msgnum, void *userdata) {
1555         struct CtdlMessage *msg = NULL;
1556         char *instr = NULL;
1557         char *results = NULL;
1558         int i;
1559         int lines;
1560         int status;
1561         char buf[1024];
1562         char key[1024];
1563         char addr[1024];
1564         char dsn[1024];
1565         char envelope_from[1024];
1566         long text_msgid = (-1);
1567         int incomplete_deliveries_remaining;
1568         time_t attempted = 0L;
1569         time_t last_attempted = 0L;
1570         time_t retry = SMTP_RETRY_INTERVAL;
1571
1572         CtdlLogPrintf(CTDL_DEBUG, "SMTP client: smtp_do_procmsg(%ld)\n", msgnum);
1573         strcpy(envelope_from, "");
1574
1575         msg = CtdlFetchMessage(msgnum, 1);
1576         if (msg == NULL) {
1577                 CtdlLogPrintf(CTDL_ERR, "SMTP client: tried %ld but no such message!\n", msgnum);
1578                 return;
1579         }
1580
1581         instr = strdup(msg->cm_fields['M']);
1582         CtdlFreeMessage(msg);
1583
1584         /* Strip out the headers amd any other non-instruction line */
1585         lines = num_tokens(instr, '\n');
1586         for (i=0; i<lines; ++i) {
1587                 extract_token(buf, instr, i, '\n', sizeof buf);
1588                 if (num_tokens(buf, '|') < 2) {
1589                         remove_token(instr, i, '\n');
1590                         --lines;
1591                         --i;
1592                 }
1593         }
1594
1595         /* Learn the message ID and find out about recent delivery attempts */
1596         lines = num_tokens(instr, '\n');
1597         for (i=0; i<lines; ++i) {
1598                 extract_token(buf, instr, i, '\n', sizeof buf);
1599                 extract_token(key, buf, 0, '|', sizeof key);
1600                 if (!strcasecmp(key, "msgid")) {
1601                         text_msgid = extract_long(buf, 1);
1602                 }
1603                 if (!strcasecmp(key, "envelope_from")) {
1604                         extract_token(envelope_from, buf, 1, '|', sizeof envelope_from);
1605                 }
1606                 if (!strcasecmp(key, "retry")) {
1607                         /* double the retry interval after each attempt */
1608                         retry = extract_long(buf, 1) * 2L;
1609                         if (retry > SMTP_RETRY_MAX) {
1610                                 retry = SMTP_RETRY_MAX;
1611                         }
1612                         remove_token(instr, i, '\n');
1613                 }
1614                 if (!strcasecmp(key, "attempted")) {
1615                         attempted = extract_long(buf, 1);
1616                         if (attempted > last_attempted)
1617                                 last_attempted = attempted;
1618                 }
1619         }
1620
1621         /*
1622          * Postpone delivery if we've already tried recently.
1623          */
1624         if (((time(NULL) - last_attempted) < retry) && (run_queue_now == 0)) {
1625                 CtdlLogPrintf(CTDL_DEBUG, "SMTP client: Retry time not yet reached.\n");
1626                 free(instr);
1627                 return;
1628         }
1629
1630
1631         /*
1632          * Bail out if there's no actual message associated with this
1633          */
1634         if (text_msgid < 0L) {
1635                 CtdlLogPrintf(CTDL_ERR, "SMTP client: no 'msgid' directive found!\n");
1636                 free(instr);
1637                 return;
1638         }
1639
1640         /* Plow through the instructions looking for 'remote' directives and
1641          * a status of 0 (no delivery yet attempted) or 3/4 (transient errors
1642          * were experienced and it's time to try again)
1643          */
1644         lines = num_tokens(instr, '\n');
1645         for (i=0; i<lines; ++i) {
1646                 extract_token(buf, instr, i, '\n', sizeof buf);
1647                 extract_token(key, buf, 0, '|', sizeof key);
1648                 extract_token(addr, buf, 1, '|', sizeof addr);
1649                 status = extract_int(buf, 2);
1650                 extract_token(dsn, buf, 3, '|', sizeof dsn);
1651                 if ( (!strcasecmp(key, "remote"))
1652                    && ((status==0)||(status==3)||(status==4)) ) {
1653
1654                         /* Remove this "remote" instruction from the set,
1655                          * but replace the set's final newline if
1656                          * remove_token() stripped it.  It has to be there.
1657                          */
1658                         remove_token(instr, i, '\n');
1659                         if (instr[strlen(instr)-1] != '\n') {
1660                                 strcat(instr, "\n");
1661                         }
1662
1663                         --i;
1664                         --lines;
1665                         CtdlLogPrintf(CTDL_DEBUG, "SMTP client: Trying <%s>\n", addr);
1666                         smtp_try(key, addr, &status, dsn, sizeof dsn, text_msgid, envelope_from);
1667                         if (status != 2) {
1668                                 if (results == NULL) {
1669                                         results = malloc(1024);
1670                                         memset(results, 0, 1024);
1671                                 }
1672                                 else {
1673                                         results = realloc(results, strlen(results) + 1024);
1674                                 }
1675                                 snprintf(&results[strlen(results)], 1024,
1676                                         "%s|%s|%d|%s\n",
1677                                         key, addr, status, dsn);
1678                         }
1679                 }
1680         }
1681
1682         if (results != NULL) {
1683                 instr = realloc(instr, strlen(instr) + strlen(results) + 2);
1684                 strcat(instr, results);
1685                 free(results);
1686         }
1687
1688
1689         /* Generate 'bounce' messages */
1690         smtp_do_bounce(instr);
1691
1692         /* Go through the delivery list, deleting completed deliveries */
1693         incomplete_deliveries_remaining =
1694                 smtp_purge_completed_deliveries(instr);
1695
1696
1697         /*
1698          * No delivery instructions remain, so delete both the instructions
1699          * message and the message message.
1700          */
1701         if (incomplete_deliveries_remaining <= 0) {
1702                 long delmsgs[2];
1703                 delmsgs[0] = msgnum;
1704                 delmsgs[1] = text_msgid;
1705                 CtdlDeleteMessages(SMTP_SPOOLOUT_ROOM, delmsgs, 2, "");
1706         }
1707
1708         /*
1709          * Uncompleted delivery instructions remain, so delete the old
1710          * instructions and replace with the updated ones.
1711          */
1712         if (incomplete_deliveries_remaining > 0) {
1713                 CtdlDeleteMessages(SMTP_SPOOLOUT_ROOM, &msgnum, 1, "");
1714                 msg = malloc(sizeof(struct CtdlMessage));
1715                 memset(msg, 0, sizeof(struct CtdlMessage));
1716                 msg->cm_magic = CTDLMESSAGE_MAGIC;
1717                 msg->cm_anon_type = MES_NORMAL;
1718                 msg->cm_format_type = FMT_RFC822;
1719                 msg->cm_fields['M'] = malloc(strlen(instr)+SIZ);
1720                 snprintf(msg->cm_fields['M'],
1721                         strlen(instr)+SIZ,
1722                         "Content-type: %s\n\n%s\n"
1723                         "attempted|%ld\n"
1724                         "retry|%ld\n",
1725                         SPOOLMIME, instr, (long)time(NULL), (long)retry );
1726                 CtdlSubmitMsg(msg, NULL, SMTP_SPOOLOUT_ROOM, QP_EADDR);
1727                 CtdlFreeMessage(msg);
1728         }
1729
1730         free(instr);
1731 }
1732
1733
1734
1735
1736 /*
1737  * smtp_do_queue()
1738  *
1739  * Run through the queue sending out messages.
1740  */
1741 void *smtp_do_queue(void *arg) {
1742         int num_processed = 0;
1743         struct CitContext smtp_queue_CC;
1744
1745         CtdlFillSystemContext(&smtp_queue_CC, "SMTP Send");
1746         citthread_setspecific(MyConKey, (void *)&smtp_queue_CC );
1747         CtdlLogPrintf(CTDL_INFO, "SMTP client: processing outbound queue\n");
1748
1749         if (CtdlGetRoom(&CC->room, SMTP_SPOOLOUT_ROOM) != 0) {
1750                 CtdlLogPrintf(CTDL_ERR, "Cannot find room <%s>\n", SMTP_SPOOLOUT_ROOM);
1751         }
1752         else {
1753                 num_processed = CtdlForEachMessage(MSGS_ALL, 0L, NULL, SPOOLMIME, NULL, smtp_do_procmsg, NULL);
1754         }
1755
1756         citthread_mutex_unlock (&smtp_send_lock);
1757         CtdlLogPrintf(CTDL_INFO, "SMTP client: queue run completed; %d messages processed\n", num_processed);
1758
1759         CtdlClearSystemContext();
1760         return(NULL);
1761 }
1762
1763
1764
1765 /*
1766  * smtp_queue_thread
1767  *
1768  * Create a thread to run the SMTP queue
1769  *
1770  * This was created as a response to a situation seen on Uncensored where a bad remote was holding
1771  * up SMTP sending for long times.
1772  * Converting to a thread does not fix the problem caused by the bad remote but it does prevent
1773  * the SMTP sending from stopping housekeeping and the EVT_TIMER event system which in turn prevented
1774  * other things from happening.
1775  */
1776 void smtp_queue_thread (void)
1777 {
1778         if (citthread_mutex_trylock (&smtp_send_lock)) {
1779                 CtdlLogPrintf(CTDL_DEBUG, "SMTP queue run already in progress\n");
1780         }
1781         else {
1782                 CtdlThreadCreate("SMTP Send", CTDLTHREAD_BIGSTACK, smtp_do_queue, NULL);
1783         }
1784 }
1785
1786
1787
1788 void smtp_server_going_down (void)
1789 {
1790         CtdlLogPrintf(CTDL_DEBUG, "SMTP module clean up for shutdown.\n");
1791
1792         citthread_mutex_destroy (&smtp_send_lock);
1793 }
1794
1795
1796
1797 /*****************************************************************************/
1798 /*                          SMTP UTILITY COMMANDS                            */
1799 /*****************************************************************************/
1800
1801 void cmd_smtp(char *argbuf) {
1802         char cmd[64];
1803         char node[256];
1804         char buf[1024];
1805         int i;
1806         int num_mxhosts;
1807
1808         if (CtdlAccessCheck(ac_aide)) return;
1809
1810         extract_token(cmd, argbuf, 0, '|', sizeof cmd);
1811
1812         if (!strcasecmp(cmd, "mx")) {
1813                 extract_token(node, argbuf, 1, '|', sizeof node);
1814                 num_mxhosts = getmx(buf, node);
1815                 cprintf("%d %d MX hosts listed for %s\n",
1816                         LISTING_FOLLOWS, num_mxhosts, node);
1817                 for (i=0; i<num_mxhosts; ++i) {
1818                         extract_token(node, buf, i, '|', sizeof node);
1819                         cprintf("%s\n", node);
1820                 }
1821                 cprintf("000\n");
1822                 return;
1823         }
1824
1825         else if (!strcasecmp(cmd, "runqueue")) {
1826                 run_queue_now = 1;
1827                 cprintf("%d All outbound SMTP will be retried now.\n", CIT_OK);
1828                 return;
1829         }
1830
1831         else {
1832                 cprintf("%d Invalid command.\n", ERROR + ILLEGAL_VALUE);
1833         }
1834
1835 }
1836
1837
1838 /*
1839  * Initialize the SMTP outbound queue
1840  */
1841 void smtp_init_spoolout(void) {
1842         struct ctdlroom qrbuf;
1843
1844         /*
1845          * Create the room.  This will silently fail if the room already
1846          * exists, and that's perfectly ok, because we want it to exist.
1847          */
1848         CtdlCreateRoom(SMTP_SPOOLOUT_ROOM, 3, "", 0, 1, 0, VIEW_MAILBOX);
1849
1850         /*
1851          * Make sure it's set to be a "system room" so it doesn't show up
1852          * in the <K>nown rooms list for Aides.
1853          */
1854         if (CtdlGetRoomLock(&qrbuf, SMTP_SPOOLOUT_ROOM) == 0) {
1855                 qrbuf.QRflags2 |= QR2_SYSTEM;
1856                 CtdlPutRoomLock(&qrbuf);
1857         }
1858 }
1859
1860
1861
1862
1863 /*****************************************************************************/
1864 /*                      MODULE INITIALIZATION STUFF                          */
1865 /*****************************************************************************/
1866 /*
1867  * This cleanup function blows away the temporary memory used by
1868  * the SMTP server.
1869  */
1870 void smtp_cleanup_function(void) {
1871
1872         /* Don't do this stuff if this is not an SMTP session! */
1873         if (CC->h_command_function != smtp_command_loop) return;
1874
1875         CtdlLogPrintf(CTDL_DEBUG, "Performing SMTP cleanup hook\n");
1876         free(SMTP);
1877 }
1878
1879
1880
1881 const char *CitadelServiceSMTP_MTA="SMTP-MTA";
1882 const char *CitadelServiceSMTPS_MTA="SMTPs-MTA";
1883 const char *CitadelServiceSMTP_MSA="SMTP-MSA";
1884 const char *CitadelServiceSMTP_LMTP="LMTP";
1885 const char *CitadelServiceSMTP_LMTP_UNF="LMTP-UnF";
1886
1887 CTDL_MODULE_INIT(smtp)
1888 {
1889         if (!threading)
1890         {
1891                 CtdlRegisterServiceHook(config.c_smtp_port,     /* SMTP MTA */
1892                                         NULL,
1893                                         smtp_mta_greeting,
1894                                         smtp_command_loop,
1895                                         NULL,
1896                                         CitadelServiceSMTP_MTA);
1897
1898 #ifdef HAVE_OPENSSL
1899                 CtdlRegisterServiceHook(config.c_smtps_port,
1900                                         NULL,
1901                                         smtps_greeting,
1902                                         smtp_command_loop,
1903                                         NULL,
1904                                         CitadelServiceSMTPS_MTA);
1905 #endif
1906
1907                 CtdlRegisterServiceHook(config.c_msa_port,      /* SMTP MSA */
1908                                         NULL,
1909                                         smtp_msa_greeting,
1910                                         smtp_command_loop,
1911                                         NULL,
1912                                         CitadelServiceSMTP_MSA);
1913
1914                 CtdlRegisterServiceHook(0,                      /* local LMTP */
1915                                         file_lmtp_socket,
1916                                         lmtp_greeting,
1917                                         smtp_command_loop,
1918                                         NULL,
1919                                         CitadelServiceSMTP_LMTP);
1920
1921                 CtdlRegisterServiceHook(0,                      /* local LMTP */
1922                                         file_lmtp_unfiltered_socket,
1923                                         lmtp_unfiltered_greeting,
1924                                         smtp_command_loop,
1925                                         NULL,
1926                                         CitadelServiceSMTP_LMTP_UNF);
1927
1928                 smtp_init_spoolout();
1929                 CtdlRegisterSessionHook(smtp_queue_thread, EVT_TIMER);
1930                 CtdlRegisterSessionHook(smtp_cleanup_function, EVT_STOP);
1931                 CtdlRegisterProtoHook(cmd_smtp, "SMTP", "SMTP utility commands");
1932                 CtdlRegisterCleanupHook (smtp_server_going_down);
1933                 citthread_mutex_init (&smtp_send_lock, NULL);
1934         }
1935
1936         /* return our Subversion id for the Log */
1937         return "$Id$";
1938 }