X-Git-Url: https://code.citadel.org/?a=blobdiff_plain;f=citadel%2Fmodules%2Fsmtp%2Fserv_smtpeventclient.c;h=f6a4116492b4fb662543e3e8a3921be585f78fad;hb=f95c2fe7adf28661d9d0ac7dbab858b40de2c296;hp=591d5d59d03f4b2229f3e6b5eaf9bf0f2d46de12;hpb=2b1af802b6361c71b7d2376cc8b5812918beb47f;p=citadel.git diff --git a/citadel/modules/smtp/serv_smtpeventclient.c b/citadel/modules/smtp/serv_smtpeventclient.c index 591d5d59d..f6a411649 100644 --- a/citadel/modules/smtp/serv_smtpeventclient.c +++ b/citadel/modules/smtp/serv_smtpeventclient.c @@ -16,7 +16,7 @@ * RFC 2821 - Simple Mail Transfer Protocol * RFC 2822 - Internet Message Format * RFC 2920 - SMTP Service Extension for Command Pipelining - * + * * The VRFY and EXPN commands have been removed from this implementation * because nobody uses these commands anymore, except for spammers. * @@ -88,172 +88,121 @@ #include "smtp_util.h" #include "event_client.h" #include "smtpqueue.h" +#include "smtp_clienthandlers.h" -#ifdef EXPERIMENTAL_SMTP_EVENT_CLIENT -/*****************************************************************************/ -/* SMTP CLIENT (OUTBOUND PROCESSING) STUFF */ -/*****************************************************************************/ - -typedef enum _eSMTP_C_States { - eConnect, - eEHLO, - eHELO, - eSMTPAuth, - eFROM, - eRCPT, - eDATA, - eDATABody, - eDATATerminateBody, - eQUIT, - eMaxSMTPC -} eSMTP_C_States; - -const double SMTP_C_ConnTimeout = 300.; /* wail 1 minute for connections... */ -const double SMTP_C_ReadTimeouts[eMaxSMTPC] = { - 300., /* Greeting... */ - 30., /* EHLO */ - 30., /* HELO */ - 30., /* Auth */ - 30., /* From */ - 90., /* RCPT */ - 30., /* DATA */ - 90., /* DATABody */ - 90., /* end of body... */ - 30. /* QUIT */ -}; -const double SMTP_C_SendTimeouts[eMaxSMTPC] = { - 90., /* Greeting... */ - 30., /* EHLO */ - 30., /* HELO */ - 30., /* Auth */ - 30., /* From */ - 30., /* RCPT */ - 30., /* DATA */ - 90., /* DATABody */ - 900., /* end of body... */ - 30. /* QUIT */ -}; - -static const ConstStr ReadErrors[eMaxSMTPC] = { - {HKEY("Connection broken during SMTP conversation")}, - {HKEY("Connection broken during SMTP EHLO")}, - {HKEY("Connection broken during SMTP HELO")}, - {HKEY("Connection broken during SMTP AUTH")}, - {HKEY("Connection broken during SMTP MAIL FROM")}, - {HKEY("Connection broken during SMTP RCPT")}, - {HKEY("Connection broken during SMTP DATA")}, - {HKEY("Connection broken during SMTP message transmit")}, - {HKEY("")}/* quit reply, don't care. */ -}; - - -typedef struct _stmp_out_msg { - MailQEntry *MyQEntry; - OneQueItem *MyQItem; - long n; - AsyncIO IO; - - eSMTP_C_States State; - - struct ares_mx_reply *AllMX; - struct ares_mx_reply *CurrMX; - const char *mx_port; - const char *mx_host; - - struct hostent *OneMX; - - ParsedURL *Relay; - ParsedURL *pCurrRelay; - StrBuf *msgtext; - char *envelope_from; - char user[1024]; - char node[1024]; - char name[1024]; - char mailfrom[1024]; -} SmtpOutMsg; - +const unsigned short DefaultMXPort = 25; void DeleteSmtpOutMsg(void *v) { SmtpOutMsg *Msg = v; ares_free_data(Msg->AllMX); - + if (Msg->HostLookup.VParsedDNSReply != NULL) + Msg->HostLookup.DNSReplyFree(Msg->HostLookup.VParsedDNSReply); + FreeURL(&Msg->Relay); FreeStrBuf(&Msg->msgtext); FreeAsyncIOContents(&Msg->IO); + memset (Msg, 0, sizeof(SmtpOutMsg)); /* just to be shure... */ free(Msg); } +eNextState SMTP_C_Shutdown(AsyncIO *IO); eNextState SMTP_C_Timeout(AsyncIO *IO); eNextState SMTP_C_ConnFail(AsyncIO *IO); eNextState SMTP_C_DispatchReadDone(AsyncIO *IO); eNextState SMTP_C_DispatchWriteDone(AsyncIO *IO); +eNextState SMTP_C_DNSFail(AsyncIO *IO); eNextState SMTP_C_Terminate(AsyncIO *IO); eReadState SMTP_C_ReadServerStatus(AsyncIO *IO); -typedef eNextState (*SMTPReadHandler)(SmtpOutMsg *Msg); -typedef eNextState (*SMTPSendHandler)(SmtpOutMsg *Msg); +eNextState mx_connect_ip(AsyncIO *IO); +eNextState get_one_mx_host_ip(AsyncIO *IO); +/****************************************************************************** + * So, we're finished with sending (regardless of success or failure) * + * This Message might be referenced by several Queue-Items, if we're the last,* + * we need to free the memory and send bounce messages (on terminal failure) * + * else we just free our SMTP-Message struct. * + ******************************************************************************/ +void FinalizeMessageSend(SmtpOutMsg *Msg) +{ + int IDestructQueItem; + int nRemain; + StrBuf *MsgData; + AsyncIO *IO = &Msg->IO; + EVS_syslog(LOG_DEBUG, "SMTP: %s\n", __FUNCTION__); -#define SMTP_ERROR(WHICH_ERR, ERRSTR) do {\ - SendMsg->MyQEntry->Status = WHICH_ERR; \ - StrBufAppendBufPlain(SendMsg->MyQEntry->StatusMessage, HKEY(ERRSTR), 0); \ - return eAbort; } \ - while (0) + IDestructQueItem = DecreaseQReference(Msg->MyQItem); -#define SMTP_VERROR(WHICH_ERR) do {\ - SendMsg->MyQEntry->Status = WHICH_ERR; \ - StrBufPlain(SendMsg->MyQEntry->StatusMessage, \ - ChrPtr(SendMsg->IO.IOBuf) + 4, \ - StrLength(SendMsg->IO.IOBuf) - 4); \ - return eAbort; } \ - while (0) + nRemain = CountActiveQueueEntries(Msg->MyQItem); -#define SMTP_IS_STATE(WHICH_STATE) (ChrPtr(SendMsg->IO.IOBuf)[0] == WHICH_STATE) + if ((nRemain > 0) || IDestructQueItem) + MsgData = SerializeQueueItem(Msg->MyQItem); + else + MsgData = NULL; -#define SMTP_DBG_SEND() CtdlLogPrintf(CTDL_DEBUG, "SMTP client[%ld]: > %s\n", SendMsg->n, ChrPtr(SendMsg->IO.SendBuf.Buf)) -#define SMTP_DBG_READ() CtdlLogPrintf(CTDL_DEBUG, "SMTP client[%ld]: < %s\n", SendMsg->n, ChrPtr(SendMsg->IO.IOBuf)) + /* + * Uncompleted delivery instructions remain, so delete the old + * instructions and replace with the updated ones. + */ + EVS_syslog(LOG_DEBUG, "SMTPQD: %ld", Msg->MyQItem->QueMsgID); + CtdlDeleteMessages(SMTP_SPOOLOUT_ROOM, &Msg->MyQItem->QueMsgID, 1, ""); + if (IDestructQueItem) + smtpq_do_bounce(Msg->MyQItem,Msg->msgtext); -void FinalizeMessageSend(SmtpOutMsg *Msg) -{ - CtdlLogPrintf(CTDL_DEBUG, "SMTP: %s\n", __FUNCTION__); - - if (DecreaseQReference(Msg->MyQItem)) + if (nRemain > 0) { - int nRemain; - StrBuf *MsgData; - - nRemain = CountActiveQueueEntries(Msg->MyQItem); - - MsgData = SerializeQueueItem(Msg->MyQItem); - /* - * Uncompleted delivery instructions remain, so delete the old - * instructions and replace with the updated ones. - */ - CtdlDeleteMessages(SMTP_SPOOLOUT_ROOM, &Msg->MyQItem->QueMsgID, 1, ""); - smtpq_do_bounce(Msg->MyQItem, - Msg->msgtext); - if (nRemain > 0) { - struct CtdlMessage *msg; - msg = malloc(sizeof(struct CtdlMessage)); - memset(msg, 0, sizeof(struct CtdlMessage)); - msg->cm_magic = CTDLMESSAGE_MAGIC; - msg->cm_anon_type = MES_NORMAL; - msg->cm_format_type = FMT_RFC822; - msg->cm_fields['M'] = SmashStrBuf(&MsgData); + struct CtdlMessage *msg; + msg = malloc(sizeof(struct CtdlMessage)); + memset(msg, 0, sizeof(struct CtdlMessage)); + msg->cm_magic = CTDLMESSAGE_MAGIC; + msg->cm_anon_type = MES_NORMAL; + msg->cm_format_type = FMT_RFC822; + msg->cm_fields['M'] = SmashStrBuf(&MsgData); + Msg->MyQItem->QueMsgID = CtdlSubmitMsg(msg, NULL, SMTP_SPOOLOUT_ROOM, QP_EADDR); - CtdlFreeMessage(msg); - } - else { - CtdlDeleteMessages(SMTP_SPOOLOUT_ROOM, &Msg->MyQItem->MessageID, 1, ""); - FreeStrBuf(&MsgData); - } - - RemoveQItem(Msg->MyQItem); + EVS_syslog(LOG_DEBUG, "SMTPQ: %ld", Msg->MyQItem->QueMsgID); + CtdlFreeMessage(msg); } + else { + CtdlDeleteMessages(SMTP_SPOOLOUT_ROOM, + &Msg->MyQItem->MessageID, + 1, + ""); + FreeStrBuf(&MsgData); + } + if (IDestructQueItem) + RemoveQItem(Msg->MyQItem); + + RemoveContext(Msg->IO.CitContext); DeleteSmtpOutMsg(Msg); } +eNextState FailOneAttempt(AsyncIO *IO) +{ + SmtpOutMsg *SendMsg = IO->Data; + + if (SendMsg->MyQEntry->Status == 2) + return eAbort; + + /* + * possible ways here: + * - connection timeout + * - + */ + StopClientWatchers(IO); + + if (SendMsg->pCurrRelay != NULL) + SendMsg->pCurrRelay = SendMsg->pCurrRelay->Next; + + if (SendMsg->pCurrRelay == NULL) + return eAbort; + if (SendMsg->pCurrRelay->IsIP) + return mx_connect_ip(IO); + else + return get_one_mx_host_ip(IO); +} + void SetConnectStatus(AsyncIO *IO) { @@ -264,349 +213,298 @@ void SetConnectStatus(AsyncIO *IO) buf[0] = '\0'; - if (IO->IP6) { - src = &IO->Addr.sin6_addr; + if (IO->ConnectMe->IPv6) { + src = &IO->ConnectMe->Addr.sin6_addr; } else { - unsigned long psaddr; - struct sockaddr_in *addr = (struct sockaddr_in *)&IO->Addr; + struct sockaddr_in *addr = (struct sockaddr_in *)&IO->ConnectMe->Addr; src = &addr->sin_addr.s_addr; - memcpy(&psaddr, &addr->sin_addr.s_addr, sizeof(psaddr)); -/// psaddr = ntohl(psaddr); -/* - CtdlLogPrintf(CTDL_DEBUG, - "SMTP client[%ld]: connecting to %s [%ld.%ld.%ld.%ld:%d] ...\n", - SendMsg->n, - SendMsg->mx_host, - (psaddr >> 24) & 0xFF, - (psaddr >> 16) & 0xFF, - (psaddr >> 8) & 0xFF, - (psaddr >> 0) & 0xFF, - SendMsg->IO.dport); - - SendMsg->MyQEntry->Status = 5; - StrBufPrintf(SendMsg->MyQEntry->StatusMessage, - "Timeout while connecting %s [%ld.%ld.%ld.%ld:%d] ", - SendMsg->mx_host, - (psaddr >> 24) & 0xFF, - (psaddr >> 16) & 0xFF, - (psaddr >> 8) & 0xFF, - (psaddr >> 0) & 0xFF, - SendMsg->IO.dport); - -*/ } - inet_ntop((IO->IP6)?AF_INET6:AF_INET, + inet_ntop((IO->ConnectMe->IPv6)?AF_INET6:AF_INET, src, - buf, sizeof(buf)); + buf, + sizeof(buf)); + + if (SendMsg->mx_host == NULL) + SendMsg->mx_host = ""; - CtdlLogPrintf(CTDL_DEBUG, - "SMTP client[%ld]: connecting to %s [%s]:%d ...\n", - SendMsg->n, - SendMsg->mx_host, - buf, - SendMsg->IO.dport); + EVS_syslog(LOG_DEBUG, + "SMTP client[%ld]: connecting to %s [%s]:%d ...\n", + SendMsg->n, + SendMsg->mx_host, + buf, + SendMsg->IO.ConnectMe->Port); SendMsg->MyQEntry->Status = 5; StrBufPrintf(SendMsg->MyQEntry->StatusMessage, "Timeout while connecting %s [%s]:%d ", SendMsg->mx_host, buf, - SendMsg->IO.dport); + SendMsg->IO.ConnectMe->Port); + SendMsg->IO.NextState = eConnect; } -eNextState mx_connect_relay_ip(AsyncIO *IO) +/***************************************************************************** + * So we connect our Relay IP here. * + *****************************************************************************/ +eNextState mx_connect_ip(AsyncIO *IO) { - SmtpOutMsg *SendMsg = IO->Data; - CtdlLogPrintf(CTDL_DEBUG, "SMTP: %s\n", __FUNCTION__); - - IO->IP6 = SendMsg->pCurrRelay->af == AF_INET6; + EVS_syslog(LOG_DEBUG, "SMTP: %s\n", __FUNCTION__); - if (SendMsg->pCurrRelay->Port != 0) - IO->dport = SendMsg->pCurrRelay->Port; - - memset(&IO->Addr, 0, sizeof(struct in6_addr)); - if (IO->IP6) { - memcpy(&IO->Addr.sin6_addr.s6_addr, - &SendMsg->pCurrRelay->Addr, - sizeof(struct in6_addr)); - - IO->Addr.sin6_family = AF_INET6; - IO->Addr.sin6_port = htons(IO->dport); - } - else { - struct sockaddr_in *addr = (struct sockaddr_in*) &IO->Addr; - /* Bypass the ns lookup result like this: IO->Addr.sin_addr.s_addr = inet_addr("127.0.0.1"); */ - memcpy(&addr->sin_addr,///.s_addr, - &SendMsg->pCurrRelay->Addr, - sizeof(struct in_addr)); - - addr->sin_family = AF_INET; - addr->sin_port = htons(IO->dport); - } + IO->ConnectMe = SendMsg->pCurrRelay; + /* Bypass the ns lookup result like this: IO->Addr.sin_addr.s_addr = inet_addr("127.0.0.1"); */ SetConnectStatus(IO); return InitEventIO(IO, SendMsg, SMTP_C_ConnTimeout, SMTP_C_ReadTimeouts[0], - 1); + 1); } -void get_one_mx_host_ip_done(void *Ctx, - int status, - int timeouts, - struct hostent *hostent) +eNextState get_one_mx_host_ip_done(AsyncIO *IO) { - AsyncIO *IO = (AsyncIO *) Ctx; SmtpOutMsg *SendMsg = IO->Data; - eNextState State = eAbort; + struct hostent *hostent; - if ((status == ARES_SUCCESS) && (hostent != NULL) ) { - - IO->IP6 = hostent->h_addrtype == AF_INET6; - IO->HEnt = hostent; + QueryCbDone(IO); - memset(&IO->Addr, 0, sizeof(struct in6_addr)); - if (IO->IP6) { - memcpy(&IO->Addr.sin6_addr.s6_addr, + hostent = SendMsg->HostLookup.VParsedDNSReply; + if ((SendMsg->HostLookup.DNSStatus == ARES_SUCCESS) && + (hostent != NULL) ) { + memset(&SendMsg->pCurrRelay->Addr, 0, sizeof(struct in6_addr)); + if (SendMsg->pCurrRelay->IPv6) { + memcpy(&SendMsg->pCurrRelay->Addr.sin6_addr.s6_addr, &hostent->h_addr_list[0], sizeof(struct in6_addr)); - IO->Addr.sin6_family = hostent->h_addrtype; - IO->Addr.sin6_port = htons(IO->dport); + SendMsg->pCurrRelay->Addr.sin6_family = hostent->h_addrtype; + SendMsg->pCurrRelay->Addr.sin6_port = htons(DefaultMXPort); } else { - struct sockaddr_in *addr = (struct sockaddr_in*) &IO->Addr; + struct sockaddr_in *addr = (struct sockaddr_in*) &SendMsg->pCurrRelay->Addr; /* Bypass the ns lookup result like this: IO->Addr.sin_addr.s_addr = inet_addr("127.0.0.1"); */ // addr->sin_addr.s_addr = htonl((uint32_t)&hostent->h_addr_list[0]); - memcpy(&addr->sin_addr.s_addr, hostent->h_addr_list[0], sizeof(uint32_t)); + memcpy(&addr->sin_addr.s_addr, + hostent->h_addr_list[0], + sizeof(uint32_t)); addr->sin_family = hostent->h_addrtype; - addr->sin_port = htons(IO->dport); + addr->sin_port = htons(DefaultMXPort); } - SendMsg->IO.HEnt = hostent; - SetConnectStatus(IO); - State = InitEventIO(IO, SendMsg, - SMTP_C_ConnTimeout, - SMTP_C_ReadTimeouts[0], - 1); + SendMsg->mx_host = SendMsg->pCurrRelay->Host; + return mx_connect_ip(IO); } - if (State == eAbort) - SMTP_C_Terminate(IO); + else // TODO: here we need to find out whether there are more mx'es, backup relay, and so on + return FailOneAttempt(IO); } -const unsigned short DefaultMXPort = 25; eNextState get_one_mx_host_ip(AsyncIO *IO) { SmtpOutMsg * SendMsg = IO->Data; - const char *Hostname; - //char *endpart; - //char buf[SIZ]; - InitC_ares_dns(IO); + /* + * here we start with the lookup of one host. it might be... + * - the relay host *sigh* + * - the direct hostname if there was no mx record + * - one of the mx'es + */ - if (SendMsg->CurrMX) { - SendMsg->mx_host = SendMsg->CurrMX->host; - SendMsg->CurrMX = SendMsg->CurrMX->next; - } - - if (SendMsg->pCurrRelay != NULL) Hostname = SendMsg->pCurrRelay->Host; - else if (SendMsg->mx_host != NULL) Hostname = SendMsg->mx_host; - else Hostname = SendMsg->node; + InitC_ares_dns(IO); - CtdlLogPrintf(CTDL_DEBUG, "SMTP: %s\n", __FUNCTION__); + EVS_syslog(LOG_DEBUG, "SMTP: %s\n", __FUNCTION__); - CtdlLogPrintf(CTDL_DEBUG, - "SMTP client[%ld]: looking up %s : %d ...\n", - SendMsg->n, - Hostname, - SendMsg->IO.dport); + EVS_syslog(LOG_DEBUG, + "SMTP client[%ld]: looking up %s-Record %s : %d ...\n", + SendMsg->n, + (SendMsg->pCurrRelay->IPv6)? "aaaa": "a", + SendMsg->pCurrRelay->Host, + SendMsg->pCurrRelay->Port); - ares_gethostbyname(SendMsg->IO.DNSChannel, - Hostname, - AF_INET6, /* it falls back to ipv4 in doubt... */ - get_one_mx_host_ip_done, - &SendMsg->IO); + if (!QueueQuery((SendMsg->pCurrRelay->IPv6)? ns_t_aaaa : ns_t_a, + SendMsg->pCurrRelay->Host, + &SendMsg->IO, + &SendMsg->HostLookup, + get_one_mx_host_ip_done)) + { + SendMsg->MyQEntry->Status = 5; + StrBufPrintf(SendMsg->MyQEntry->StatusMessage, + "No MX hosts found for <%s>", SendMsg->node); + SendMsg->IO.NextState = eTerminateConnection; + return IO->NextState; + } + IO->NextState = eReadDNSReply; return IO->NextState; } -eNextState smtp_resolve_mx_done(AsyncIO *IO) +/***************************************************************************** + * here we try to find out about the MX records for our recipients. * + *****************************************************************************/ +eNextState smtp_resolve_mx_record_done(AsyncIO *IO) { SmtpOutMsg * SendMsg = IO->Data; + ParsedURL **pp; - CtdlLogPrintf(CTDL_DEBUG, "SMTP: %s\n", __FUNCTION__); + QueryCbDone(IO); - SendMsg->IO.SendBuf.Buf = NewStrBufPlain(NULL, 1024); - SendMsg->IO.RecvBuf.Buf = NewStrBufPlain(NULL, 1024); - SendMsg->IO.IOBuf = NewStrBuf(); - SendMsg->IO.ErrMsg = SendMsg->MyQEntry->StatusMessage; + EVS_syslog(LOG_DEBUG, "SMTP: %s\n", __FUNCTION__); + pp = &SendMsg->Relay; + while ((pp != NULL) && (*pp != NULL) && ((*pp)->Next != NULL)) + pp = &(*pp)->Next; - SendMsg->CurrMX = SendMsg->AllMX = IO->VParsedDNSReply; - //// TODO: should we remove the current ares context??? - get_one_mx_host_ip(IO); - return IO->NextState; + if ((IO->DNSQuery->DNSStatus == ARES_SUCCESS) && + (IO->DNSQuery->VParsedDNSReply != NULL)) + { /* ok, we found mx records. */ + SendMsg->IO.ErrMsg = SendMsg->MyQEntry->StatusMessage; + + SendMsg->CurrMX = SendMsg->AllMX + = IO->DNSQuery->VParsedDNSReply; + while (SendMsg->CurrMX) { + int i; + for (i = 0; i < 2; i++) { + ParsedURL *p; + + p = (ParsedURL*) malloc(sizeof(ParsedURL)); + memset(p, 0, sizeof(ParsedURL)); + p->IsIP = 0; + p->Port = DefaultMXPort; + p->IPv6 = i == 1; + p->Host = SendMsg->CurrMX->host; + + *pp = p; + pp = &p->Next; + } + SendMsg->CurrMX = SendMsg->CurrMX->next; + } + SendMsg->CXFlags = SendMsg->CXFlags & F_HAVE_MX; + } + else { /* else fall back to the plain hostname */ + int i; + for (i = 0; i < 2; i++) { + ParsedURL *p; + + p = (ParsedURL*) malloc(sizeof(ParsedURL)); + memset(p, 0, sizeof(ParsedURL)); + p->IsIP = 0; + p->Port = DefaultMXPort; + p->IPv6 = i == 1; + p->Host = SendMsg->node; + + *pp = p; + pp = &p->Next; + } + SendMsg->CXFlags = SendMsg->CXFlags & F_DIRECT; + } + *pp = SendMsg->MyQItem->FallBackHost; + SendMsg->pCurrRelay = SendMsg->Relay; + return get_one_mx_host_ip(IO); } - eNextState resolve_mx_records(AsyncIO *IO) { SmtpOutMsg * SendMsg = IO->Data; - CtdlLogPrintf(CTDL_DEBUG, "SMTP: %s\n", __FUNCTION__); - + EVS_syslog(LOG_DEBUG, "SMTP: %s\n", __FUNCTION__); + /* start resolving MX records here. */ if (!QueueQuery(ns_t_mx, SendMsg->node, &SendMsg->IO, - smtp_resolve_mx_done)) + &SendMsg->MxLookup, + smtp_resolve_mx_record_done)) { SendMsg->MyQEntry->Status = 5; StrBufPrintf(SendMsg->MyQEntry->StatusMessage, "No MX hosts found for <%s>", SendMsg->node); return IO->NextState; } - return eAbort; + SendMsg->IO.NextState = eReadDNSReply; + return IO->NextState; } -int smtp_resolve_recipients(SmtpOutMsg *SendMsg) + +/****************************************************************************** + * so, we're going to start a SMTP delivery. lets get it on. * + ******************************************************************************/ + +SmtpOutMsg *new_smtp_outmsg(OneQueItem *MyQItem, + MailQEntry *MyQEntry, + int MsgCount) { - const char *ptr; - char buf[1024]; - int scan_done; - int lp, rp; - int i; - - CtdlLogPrintf(CTDL_DEBUG, "SMTP: %s\n", __FUNCTION__); - - if ((SendMsg==NULL) || - (SendMsg->MyQEntry == NULL) || - (StrLength(SendMsg->MyQEntry->Recipient) == 0)) { - return 0; - } + SmtpOutMsg * SendMsg; - /* Parse out the host portion of the recipient address */ - process_rfc822_addr(ChrPtr(SendMsg->MyQEntry->Recipient), - SendMsg->user, - SendMsg->node, - SendMsg->name); - - CtdlLogPrintf(CTDL_DEBUG, "SMTP client[%ld]: Attempting delivery to <%s> @ <%s> (%s)\n", - SendMsg->n, SendMsg->user, SendMsg->node, SendMsg->name); - /* If no envelope_from is supplied, extract one from the message */ - if ( (SendMsg->envelope_from == NULL) || - (IsEmptyStr(SendMsg->envelope_from)) ) { - SendMsg->mailfrom[0] = '\0'; - scan_done = 0; - ptr = ChrPtr(SendMsg->msgtext); - do { - if (ptr = cmemreadline(ptr, buf, sizeof buf), *ptr == 0) { - scan_done = 1; - } - if (!strncasecmp(buf, "From:", 5)) { - safestrncpy(SendMsg->mailfrom, &buf[5], sizeof SendMsg->mailfrom); - striplt(SendMsg->mailfrom); - for (i=0; SendMsg->mailfrom[i]; ++i) { - if (!isprint(SendMsg->mailfrom[i])) { - strcpy(&SendMsg->mailfrom[i], &SendMsg->mailfrom[i+1]); - i=0; - } - } - - /* Strip out parenthesized names */ - lp = (-1); - rp = (-1); - for (i=0; !IsEmptyStr(SendMsg->mailfrom + i); ++i) { - if (SendMsg->mailfrom[i] == '(') lp = i; - if (SendMsg->mailfrom[i] == ')') rp = i; - } - if ((lp>0)&&(rp>lp)) { - strcpy(&SendMsg->mailfrom[lp-1], &SendMsg->mailfrom[rp+1]); - } - - /* Prefer brokketized names */ - lp = (-1); - rp = (-1); - for (i=0; !IsEmptyStr(SendMsg->mailfrom + i); ++i) { - if (SendMsg->mailfrom[i] == '<') lp = i; - if (SendMsg->mailfrom[i] == '>') rp = i; - } - if ( (lp>=0) && (rp>lp) ) { - SendMsg->mailfrom[rp] = 0; - memmove(SendMsg->mailfrom, - &SendMsg->mailfrom[lp + 1], - rp - lp); - } - - scan_done = 1; - } - } while (scan_done == 0); - if (IsEmptyStr(SendMsg->mailfrom)) strcpy(SendMsg->mailfrom, "someone@somewhere.org"); - stripallbut(SendMsg->mailfrom, '<', '>'); - SendMsg->envelope_from = SendMsg->mailfrom; - } + SendMsg = (SmtpOutMsg *) malloc(sizeof(SmtpOutMsg)); + memset(SendMsg, 0, sizeof(SmtpOutMsg)); - return 1; -} + SendMsg->n = MsgCount; + SendMsg->MyQEntry = MyQEntry; + SendMsg->MyQItem = MyQItem; + SendMsg->pCurrRelay = MyQItem->URL; + SendMsg->IO.Data = SendMsg; + SendMsg->IO.SendDone = SMTP_C_DispatchWriteDone; + SendMsg->IO.ReadDone = SMTP_C_DispatchReadDone; + SendMsg->IO.Terminate = SMTP_C_Terminate; + SendMsg->IO.LineReader = SMTP_C_ReadServerStatus; + SendMsg->IO.ConnFail = SMTP_C_ConnFail; + SendMsg->IO.DNSFail = SMTP_C_DNSFail; + SendMsg->IO.Timeout = SMTP_C_Timeout; + SendMsg->IO.ShutdownAbort = SMTP_C_Shutdown; -void smtp_try(OneQueItem *MyQItem, - MailQEntry *MyQEntry, - StrBuf *MsgText, - int KeepMsgText, /* KeepMsgText allows us to use MsgText as ours. */ - int MsgCount) -{ - SmtpOutMsg * SendMsg; + SendMsg->IO.SendBuf.Buf = NewStrBufPlain(NULL, 1024); + SendMsg->IO.RecvBuf.Buf = NewStrBufPlain(NULL, 1024); + SendMsg->IO.IOBuf = NewStrBuf(); - CtdlLogPrintf(CTDL_DEBUG, "SMTP: %s\n", __FUNCTION__); + SendMsg->IO.NextState = eReadMessage; + + return SendMsg; +} - SendMsg = (SmtpOutMsg *) malloc(sizeof(SmtpOutMsg)); - memset(SendMsg, 0, sizeof(SmtpOutMsg)); - SendMsg->IO.sock = (-1); - SendMsg->IO.NextState = eReadMessage; - SendMsg->n = MsgCount++; - SendMsg->MyQEntry = MyQEntry; - SendMsg->MyQItem = MyQItem; - SendMsg->pCurrRelay = MyQItem->URL; - - SendMsg->IO.dport = DefaultMXPort; - SendMsg->IO.Data = SendMsg; - SendMsg->IO.SendDone = SMTP_C_DispatchWriteDone; - SendMsg->IO.ReadDone = SMTP_C_DispatchReadDone; - SendMsg->IO.Terminate = SMTP_C_Terminate; - SendMsg->IO.LineReader = SMTP_C_ReadServerStatus; - SendMsg->IO.ConnFail = SMTP_C_ConnFail; - SendMsg->IO.Timeout = SMTP_C_Timeout; - - if (KeepMsgText) { - SendMsg->msgtext = MsgText; - } - else { - SendMsg->msgtext = NewStrBufDup(MsgText); - } +void smtp_try_one_queue_entry(OneQueItem *MyQItem, + MailQEntry *MyQEntry, + StrBuf *MsgText, + int KeepMsgText, /* KeepMsgText allows us to use MsgText as ours. */ + int MsgCount) +{ + SmtpOutMsg *SendMsg; + syslog(LOG_DEBUG, "SMTP: %s\n", __FUNCTION__); + + SendMsg = new_smtp_outmsg(MyQItem, MyQEntry, MsgCount); + if (KeepMsgText) SendMsg->msgtext = MsgText; + else SendMsg->msgtext = NewStrBufDup(MsgText); + if (smtp_resolve_recipients(SendMsg)) { + CitContext *SubC; + SubC = CloneContext (CC); + SubC->session_specific_data = (char*) SendMsg; + SendMsg->IO.CitContext = SubC; + + syslog(LOG_DEBUG, "SMTP Starting: [%ld] <%s> \n", + SendMsg->MyQItem->MessageID, + ChrPtr(SendMsg->MyQEntry->Recipient)); if (SendMsg->pCurrRelay == NULL) QueueEventContext(&SendMsg->IO, resolve_mx_records); - else { + else { /* oh... via relay host */ if (SendMsg->pCurrRelay->IsIP) { QueueEventContext(&SendMsg->IO, - mx_connect_relay_ip); + mx_connect_ip); } - else { + else { /* uneducated admin has chosen to add DNS to the equation... */ QueueEventContext(&SendMsg->IO, get_one_mx_host_ip); } } } else { + /* No recipients? well fail then. */ if ((SendMsg==NULL) || (SendMsg->MyQEntry == NULL)) { SendMsg->MyQEntry->Status = 5; @@ -621,296 +519,20 @@ void smtp_try(OneQueItem *MyQItem, -/*****************************************************************************/ -/* SMTP CLIENT STATE CALLBACKS */ -/*****************************************************************************/ -eNextState SMTPC_read_greeting(SmtpOutMsg *SendMsg) -{ - /* Process the SMTP greeting from the server */ - SMTP_DBG_READ(); - - if (!SMTP_IS_STATE('2')) { - if (SMTP_IS_STATE('4')) - SMTP_VERROR(4); - else - SMTP_VERROR(5); - } - return eSendReply; -} - -eNextState SMTPC_send_EHLO(SmtpOutMsg *SendMsg) -{ - /* At this point we know we are talking to a real SMTP server */ - - /* Do a EHLO command. If it fails, try the HELO command. */ - StrBufPrintf(SendMsg->IO.SendBuf.Buf, - "EHLO %s\r\n", config.c_fqdn); - - SMTP_DBG_SEND(); - return eReadMessage; -} - -eNextState SMTPC_read_EHLO_reply(SmtpOutMsg *SendMsg) -{ - SMTP_DBG_READ(); - - if (SMTP_IS_STATE('2')) { - SendMsg->State ++; - - if ((SendMsg->pCurrRelay == NULL) || - (SendMsg->pCurrRelay->User == NULL)) - SendMsg->State ++; /* Skip auth... */ - } - /* else we fall back to 'helo' */ - return eSendReply; -} - -eNextState STMPC_send_HELO(SmtpOutMsg *SendMsg) -{ - StrBufPrintf(SendMsg->IO.SendBuf.Buf, - "HELO %s\r\n", config.c_fqdn); - - SMTP_DBG_SEND(); - return eReadMessage; -} - -eNextState SMTPC_read_HELO_reply(SmtpOutMsg *SendMsg) -{ - SMTP_DBG_READ(); - - if (!SMTP_IS_STATE('2')) { - if (SMTP_IS_STATE('4')) - SMTP_VERROR(4); - else - SMTP_VERROR(5); - } - if ((SendMsg->pCurrRelay == NULL) || - (SendMsg->pCurrRelay->User == NULL)) - SendMsg->State ++; /* Skip auth... */ - return eSendReply; -} - -eNextState SMTPC_send_auth(SmtpOutMsg *SendMsg) -{ - char buf[SIZ]; - char encoded[1024]; - - if ((SendMsg->pCurrRelay == NULL) || - (SendMsg->pCurrRelay->User == NULL)) - SendMsg->State ++; /* Skip auth, shouldn't even come here!... */ - else { - /* Do an AUTH command if necessary */ - sprintf(buf, "%s%c%s%c%s", - SendMsg->pCurrRelay->User, '\0', - SendMsg->pCurrRelay->User, '\0', - SendMsg->pCurrRelay->Pass); - CtdlEncodeBase64(encoded, buf, - strlen(SendMsg->pCurrRelay->User) * 2 + - strlen(SendMsg->pCurrRelay->Pass) + 2, 0); - StrBufPrintf(SendMsg->IO.SendBuf.Buf, - "AUTH PLAIN %s\r\n", encoded); - } - SMTP_DBG_SEND(); - return eReadMessage; -} - -eNextState SMTPC_read_auth_reply(SmtpOutMsg *SendMsg) -{ - /* Do an AUTH command if necessary */ - - SMTP_DBG_READ(); - - if (!SMTP_IS_STATE('2')) { - if (SMTP_IS_STATE('4')) - SMTP_VERROR(4); - else - SMTP_VERROR(5); - } - return eSendReply; -} - -eNextState SMTPC_send_FROM(SmtpOutMsg *SendMsg) -{ - /* previous command succeeded, now try the MAIL FROM: command */ - StrBufPrintf(SendMsg->IO.SendBuf.Buf, - "MAIL FROM:<%s>\r\n", - SendMsg->envelope_from); - - SMTP_DBG_SEND(); - return eReadMessage; -} - -eNextState SMTPC_read_FROM_reply(SmtpOutMsg *SendMsg) -{ - SMTP_DBG_READ(); - - if (!SMTP_IS_STATE('2')) { - if (SMTP_IS_STATE('4')) - SMTP_VERROR(4); - else - SMTP_VERROR(5); - } - return eSendReply; -} - - -eNextState SMTPC_send_RCPT(SmtpOutMsg *SendMsg) -{ - /* MAIL succeeded, now try the RCPT To: command */ - StrBufPrintf(SendMsg->IO.SendBuf.Buf, - "RCPT TO:<%s@%s>\r\n", - SendMsg->user, - SendMsg->node); - - SMTP_DBG_SEND(); - return eReadMessage; -} - -eNextState SMTPC_read_RCPT_reply(SmtpOutMsg *SendMsg) -{ - SMTP_DBG_READ(); - - if (!SMTP_IS_STATE('2')) { - if (SMTP_IS_STATE('4')) - SMTP_VERROR(4); - else - SMTP_VERROR(5); - } - return eSendReply; -} - -eNextState SMTPC_send_DATAcmd(SmtpOutMsg *SendMsg) -{ - /* RCPT succeeded, now try the DATA command */ - StrBufPlain(SendMsg->IO.SendBuf.Buf, - HKEY("DATA\r\n")); - - SMTP_DBG_SEND(); - return eReadMessage; -} - -eNextState SMTPC_read_DATAcmd_reply(SmtpOutMsg *SendMsg) -{ - SMTP_DBG_READ(); - - if (!SMTP_IS_STATE('3')) { - if (SMTP_IS_STATE('4')) - SMTP_VERROR(3); - else - SMTP_VERROR(5); - } - return eSendReply; -} - -eNextState SMTPC_send_data_body(SmtpOutMsg *SendMsg) -{ - StrBuf *Buf; - /* If we reach this point, the server is expecting data.*/ - - Buf = SendMsg->IO.SendBuf.Buf; - SendMsg->IO.SendBuf.Buf = SendMsg->msgtext; - SendMsg->msgtext = Buf; - SendMsg->State ++; - - return eSendMore; -} - -eNextState SMTPC_send_terminate_data_body(SmtpOutMsg *SendMsg) -{ - StrBuf *Buf; - - Buf = SendMsg->IO.SendBuf.Buf; - SendMsg->IO.SendBuf.Buf = SendMsg->msgtext; - SendMsg->msgtext = Buf; - - StrBufPlain(SendMsg->IO.SendBuf.Buf, - HKEY(".\r\n")); - - return eReadMessage; - -} - -eNextState SMTPC_read_data_body_reply(SmtpOutMsg *SendMsg) -{ - SMTP_DBG_READ(); - - if (!SMTP_IS_STATE('2')) { - if (SMTP_IS_STATE('4')) - SMTP_VERROR(4); - else - SMTP_VERROR(5); - } - - /* We did it! */ - StrBufPlain(SendMsg->MyQEntry->StatusMessage, - &ChrPtr(SendMsg->IO.RecvBuf.Buf)[4], - StrLength(SendMsg->IO.RecvBuf.Buf) - 4); - SendMsg->MyQEntry->Status = 2; - return eSendReply; -} - -eNextState SMTPC_send_QUIT(SmtpOutMsg *SendMsg) -{ - StrBufPlain(SendMsg->IO.SendBuf.Buf, - HKEY("QUIT\r\n")); - - SMTP_DBG_SEND(); - return eReadMessage; -} - -eNextState SMTPC_read_QUIT_reply(SmtpOutMsg *SendMsg) -{ - SMTP_DBG_READ(); - - CtdlLogPrintf(CTDL_INFO, "SMTP client[%ld]: delivery to <%s> @ <%s> (%s) succeeded\n", - SendMsg->n, SendMsg->user, SendMsg->node, SendMsg->name); - return eTerminateConnection; -} - -eNextState SMTPC_read_dummy(SmtpOutMsg *SendMsg) -{ - return eSendReply; -} - -eNextState SMTPC_send_dummy(SmtpOutMsg *SendMsg) -{ - return eReadMessage; -} - /*****************************************************************************/ /* SMTP CLIENT DISPATCHER */ /*****************************************************************************/ -SMTPReadHandler ReadHandlers[eMaxSMTPC] = { - SMTPC_read_greeting, - SMTPC_read_EHLO_reply, - SMTPC_read_HELO_reply, - SMTPC_read_auth_reply, - SMTPC_read_FROM_reply, - SMTPC_read_RCPT_reply, - SMTPC_read_DATAcmd_reply, - SMTPC_read_dummy, - SMTPC_read_data_body_reply, - SMTPC_read_QUIT_reply -}; -SMTPSendHandler SendHandlers[eMaxSMTPC] = { - SMTPC_send_dummy, /* we don't send a greeting, the server does... */ - SMTPC_send_EHLO, - STMPC_send_HELO, - SMTPC_send_auth, - SMTPC_send_FROM, - SMTPC_send_RCPT, - SMTPC_send_DATAcmd, - SMTPC_send_data_body, - SMTPC_send_terminate_data_body, - SMTPC_send_QUIT -}; void SMTPSetTimeout(eNextState NextTCPState, SmtpOutMsg *pMsg) { - CtdlLogPrintf(CTDL_DEBUG, "SMTP: %s\n", __FUNCTION__); - double Timeout; + double Timeout = 0.0; + AsyncIO *IO = &pMsg->IO; + + EVS_syslog(LOG_DEBUG, "SMTP: %s\n", __FUNCTION__); + switch (NextTCPState) { + case eSendFile: case eSendReply: case eSendMore: Timeout = SMTP_C_SendTimeouts[pMsg->State]; @@ -929,6 +551,13 @@ void SMTPSetTimeout(eNextState NextTCPState, SmtpOutMsg *pMsg) Timeout += StrLength(pMsg->msgtext) / 1024; } break; + case eSendDNSQuery: + case eReadDNSReply: + case eDBQuery: + case eReadFile: + case eReadMore: + case eReadPayload: + case eConnect: case eTerminateConnection: case eAbort: return; @@ -937,18 +566,21 @@ void SMTPSetTimeout(eNextState NextTCPState, SmtpOutMsg *pMsg) } eNextState SMTP_C_DispatchReadDone(AsyncIO *IO) { - CtdlLogPrintf(CTDL_DEBUG, "SMTP: %s\n", __FUNCTION__); + EVS_syslog(LOG_DEBUG, "SMTP: %s\n", __FUNCTION__); SmtpOutMsg *pMsg = IO->Data; eNextState rc; rc = ReadHandlers[pMsg->State](pMsg); - pMsg->State++; - SMTPSetTimeout(rc, pMsg); + if (rc != eAbort) + { + pMsg->State++; + SMTPSetTimeout(rc, pMsg); + } return rc; } eNextState SMTP_C_DispatchWriteDone(AsyncIO *IO) { - CtdlLogPrintf(CTDL_DEBUG, "SMTP: %s\n", __FUNCTION__); + EVS_syslog(LOG_DEBUG, "SMTP: %s\n", __FUNCTION__); SmtpOutMsg *pMsg = IO->Data; eNextState rc; @@ -963,23 +595,43 @@ eNextState SMTP_C_DispatchWriteDone(AsyncIO *IO) /*****************************************************************************/ eNextState SMTP_C_Terminate(AsyncIO *IO) { - CtdlLogPrintf(CTDL_DEBUG, "SMTP: %s\n", __FUNCTION__); SmtpOutMsg *pMsg = IO->Data; + + EVS_syslog(LOG_DEBUG, "SMTP: %s\n", __FUNCTION__); FinalizeMessageSend(pMsg); return eAbort; } eNextState SMTP_C_Timeout(AsyncIO *IO) { - CtdlLogPrintf(CTDL_DEBUG, "SMTP: %s\n", __FUNCTION__); SmtpOutMsg *pMsg = IO->Data; + + EVS_syslog(LOG_DEBUG, "SMTP: %s\n", __FUNCTION__); StrBufPlain(IO->ErrMsg, CKEY(ReadErrors[pMsg->State])); - FinalizeMessageSend(pMsg); - return eAbort; + return FailOneAttempt(IO); } eNextState SMTP_C_ConnFail(AsyncIO *IO) { - CtdlLogPrintf(CTDL_DEBUG, "SMTP: %s\n", __FUNCTION__); SmtpOutMsg *pMsg = IO->Data; + + EVS_syslog(LOG_DEBUG, "SMTP: %s\n", __FUNCTION__); + StrBufPlain(IO->ErrMsg, CKEY(ReadErrors[pMsg->State])); + return FailOneAttempt(IO); +} +eNextState SMTP_C_DNSFail(AsyncIO *IO) +{ + SmtpOutMsg *pMsg = IO->Data; + + EVS_syslog(LOG_DEBUG, "SMTP: %s\n", __FUNCTION__); + StrBufPlain(IO->ErrMsg, CKEY(ReadErrors[pMsg->State])); + return FailOneAttempt(IO); +} +eNextState SMTP_C_Shutdown(AsyncIO *IO) +{ + EVS_syslog(LOG_DEBUG, "SMTP: %s\n", __FUNCTION__); + SmtpOutMsg *pMsg = IO->Data; + + pMsg->MyQEntry->Status = 3; + StrBufPlain(pMsg->MyQEntry->StatusMessage, HKEY("server shutdown during message submit.")); FinalizeMessageSend(pMsg); return eAbort; } @@ -1016,7 +668,6 @@ eReadState SMTP_C_ReadServerStatus(AsyncIO *IO) return Finished; } -#endif CTDL_MODULE_INIT(smtp_eventclient) { return "smtpeventclient";