#include "smtp_util.h"
#include "event_client.h"
+#include "smtpqueue.h"
#ifdef EXPERIMENTAL_SMTP_EVENT_CLIENT
-
-int run_queue_now = 0; /* Set to 1 to ignore SMTP send retry times */
-int MsgCount = 0;
/*****************************************************************************/
/* SMTP CLIENT (OUTBOUND PROCESSING) STUFF */
/*****************************************************************************/
-
typedef enum _eSMTP_C_States {
eConnect,
eEHLO,
eMaxSMTPC
} eSMTP_C_States;
-const long SMTP_C_ReadTimeouts[eMaxSMTPC] = {
- 90, /* Greeting... */
- 30, /* EHLO */
- 30, /* HELO */
- 30, /* Auth */
- 30, /* From */
- 30, /* RCPT */
- 30, /* DATA */
- 90, /* DATABody */
- 900, /* end of body... */
- 30 /* QUIT */
+const double SMTP_C_ConnTimeout = 60.; /* 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 long SMTP_C_SendTimeouts[eMaxSMTPC] = {
-
-}; */
-const char *ReadErrors[eMaxSMTPC] = {
- "Connection broken during SMTP conversation",
- "Connection broken during SMTP EHLO",
- "Connection broken during SMTP HELO",
- "Connection broken during SMTP AUTH",
- "Connection broken during SMTP MAIL FROM",
- "Connection broken during SMTP RCPT",
- "Connection broken during SMTP DATA",
- "Connection broken during SMTP message transmit",
- ""/* quit reply, don't care. */
+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;
- int SMTPstatus;
+ struct ares_mx_reply *AllMX;
+ struct ares_mx_reply *CurrMX;
+ const char *mx_port;
+ const char *mx_host;
- int i_mx;
- int n_mx;
- int num_mxhosts;
- char mx_user[1024];
- char mx_pass[1024];
- char mx_host[1024];
- char mx_port[1024];
- char mxhosts[SIZ];
+ struct hostent *OneMX;
+ ParsedURL *Relay;
+ ParsedURL *pCurrRelay;
StrBuf *msgtext;
char *envelope_from;
char user[1024];
char node[1024];
char name[1024];
- char addr[SIZ];
- char dsn[1024];
- char envelope_from_buf[1024];
char mailfrom[1024];
} SmtpOutMsg;
-eNextState SMTP_C_DispatchReadDone(void *Data);
-eNextState SMTP_C_DispatchWriteDone(void *Data);
+void DeleteSmtpOutMsg(void *v)
+{
+ SmtpOutMsg *Msg = v;
+ ares_free_data(Msg->AllMX);
+
+ FreeStrBuf(&Msg->msgtext);
+ FreeAsyncIOContents(&Msg->IO);
+ free(Msg);
+}
+
+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_Terminate(AsyncIO *IO);
+eReadState SMTP_C_ReadServerStatus(AsyncIO *IO);
typedef eNextState (*SMTPReadHandler)(SmtpOutMsg *Msg);
typedef eNextState (*SMTPSendHandler)(SmtpOutMsg *Msg);
-eReadState SMTP_C_ReadServerStatus(AsyncIO *IO)
-{
- eReadState Finished = eBufferNotEmpty;
+#define SMTP_ERROR(WHICH_ERR, ERRSTR) do {\
+ SendMsg->MyQEntry->Status = WHICH_ERR; \
+ StrBufAppendBufPlain(SendMsg->MyQEntry->StatusMessage, HKEY(ERRSTR), 0); \
+ return eAbort; } \
+ while (0)
- while (Finished == eBufferNotEmpty) {
- Finished = StrBufChunkSipLine(IO->IOBuf, &IO->RecvBuf);
-
- switch (Finished) {
- case eMustReadMore: /// read new from socket...
- return Finished;
- break;
- case eBufferNotEmpty: /* shouldn't happen... */
- case eReadSuccess: /// done for now...
- if (StrLength(IO->IOBuf) < 4)
- continue;
- if (ChrPtr(IO->IOBuf)[3] == '-')
- Finished = eBufferNotEmpty;
- else
- return Finished;
- break;
- case eReadFail: /// WHUT?
- ///todo: shut down!
- break;
+#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)
+
+#define SMTP_IS_STATE(WHICH_STATE) (ChrPtr(SendMsg->IO.IOBuf)[0] == WHICH_STATE)
+
+#define SMTP_DBG_SEND() CtdlLogPrintf(CTDL_DEBUG, "SMTP client[%ld]: > %s\n", SendMsg->n, ChrPtr(SendMsg->IO.IOBuf))
+#define SMTP_DBG_READ() CtdlLogPrintf(CTDL_DEBUG, "SMTP client[%ld]: < %s\n", SendMsg->n, ChrPtr(SendMsg->IO.IOBuf))
+
+
+void FinalizeMessageSend(SmtpOutMsg *Msg)
+{
+ CtdlLogPrintf(CTDL_DEBUG, "SMTP: %s\n", __FUNCTION__);
+
+ if (DecreaseQReference(Msg->MyQItem))
+ {
+ 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);
+ CtdlSubmitMsg(msg, NULL, SMTP_SPOOLOUT_ROOM, QP_EADDR);
+ CtdlFreeMessage(msg);
+ }
+ else {
+ CtdlDeleteMessages(SMTP_SPOOLOUT_ROOM, &Msg->MyQItem->MessageID, 1, "");
+ FreeStrBuf(&MsgData);
}
+
+ RemoveQItem(Msg->MyQItem);
}
- return Finished;
+ DeleteSmtpOutMsg(Msg);
}
-
-/**
- * this one has to have the context for loading the message via the redirect buffer...
- */
-SmtpOutMsg *smtp_load_msg(long msgnum, const char *addr, char *envelope_from)
+eNextState mx_connect_relay_ip(AsyncIO *IO)
{
- CitContext *CCC=CC;
- SmtpOutMsg *SendMsg;
- SendMsg = (SmtpOutMsg *) malloc(sizeof(SmtpOutMsg));
+ SmtpOutMsg *SendMsg = IO->Data;
- memset(SendMsg, 0, sizeof(SmtpOutMsg));
- SendMsg->IO.sock = (-1);
+ CtdlLogPrintf(CTDL_DEBUG, "SMTP: %s\n", __FUNCTION__);
+
+ IO->IP6 = SendMsg->pCurrRelay->af == AF_INET6;
- SendMsg->n = MsgCount++;
- /* Load the message out of the database */
- CCC->redirect_buffer = NewStrBufPlain(NULL, SIZ);
- CtdlOutputMsg(msgnum, MT_RFC822, HEADERS_ALL, 0, 1, NULL, (ESC_DOT|SUPPRESS_ENV_TO) );
- SendMsg->msgtext = CCC->redirect_buffer;
- CCC->redirect_buffer = NULL;
- if ((StrLength(SendMsg->msgtext) > 0) &&
- ChrPtr(SendMsg->msgtext)[StrLength(SendMsg->msgtext) - 1] != '\n') {
- CtdlLogPrintf(CTDL_WARNING,
- "SMTP client[%ld]: Possible problem: message did not "
- "correctly terminate. (expecting 0x10, got 0x%02x)\n",
- SendMsg->n,
- ChrPtr(SendMsg->msgtext)[StrLength(SendMsg->msgtext) - 1] );
- StrBufAppendBufPlain(SendMsg->msgtext, HKEY("\r\n"), 0);
+ 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,
+ &SendMsg->pCurrRelay->Addr,
+ sizeof(struct in_addr));
+
+ addr->sin_family = AF_INET;
+ addr->sin_port = htons(IO->dport);
+ }
+
+
+
+/*
+
+ SendMsg->pCurrRelay->
+ if ((SendMsg->pCurrRelay != NULL) && (SendMsg->pCurrRelay->IsIP)) {
+ connect = 1;
+
+ }
+ unsigned long psaddr;
+
+
+ memcpy(&psaddr, hostent->h_addr_list[0], 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);
+
+
}
+*/
+ /// TODO: else fail!
+ InitEventIO(IO, SendMsg,
+ SMTP_C_ConnTimeout,
+ SMTP_C_ReadTimeouts[0],
+ 1);
+}
- safestrncpy(SendMsg->addr, addr, SIZ);
- safestrncpy(SendMsg->envelope_from_buf, envelope_from, 1024);
+void get_one_mx_host_ip_done(void *Ctx,
+ int status,
+ int timeouts,
+ struct hostent *hostent)
+{
+ AsyncIO *IO = (AsyncIO *) Ctx;
+ SmtpOutMsg *SendMsg = IO->Data;
- return SendMsg;
+ if ((status == ARES_SUCCESS) && (hostent != NULL) ) {
+
+ IO->IP6 = hostent->h_addrtype == AF_INET6;
+
+ memset(&IO->Addr, 0, sizeof(struct in6_addr));
+ if (IO->IP6) {
+ memcpy(&IO->Addr.sin6_addr.s6_addr,
+ IO->HEnt->h_addr_list[0],
+ sizeof(struct in6_addr));
+
+ IO->Addr.sin6_family = hostent->h_addrtype;
+ 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,
+ IO->HEnt->h_addr_list[0],
+ sizeof(struct in_addr));
+
+ addr->sin_family = hostent->h_addrtype;
+ addr->sin_port = htons(IO->dport);
+
+ }
+ SendMsg->IO.HEnt = hostent;
+ InitEventIO(IO, SendMsg,
+ SMTP_C_ConnTimeout,
+ SMTP_C_ReadTimeouts[0],
+ 1);
+ }
+}
+
+const unsigned short DefaultMXPort = 25;
+eNextState get_one_mx_host_ip(AsyncIO *IO)
+{
+ SmtpOutMsg * SendMsg = IO->Data;
+
+ //char *endpart;
+ //char buf[SIZ];
+
+ CtdlLogPrintf(CTDL_DEBUG, "SMTP: %s\n", __FUNCTION__);
+ SendMsg->IO.dport = DefaultMXPort;
+
+ SendMsg->mx_host = SendMsg->CurrMX->host;
+ SendMsg->CurrMX = SendMsg->CurrMX->next;
+
+ CtdlLogPrintf(CTDL_DEBUG,
+ "SMTP client[%ld]: looking up %s : %d ...\n",
+ SendMsg->n,
+ SendMsg->mx_host,
+ SendMsg->IO.dport);
+
+ ares_gethostbyname(SendMsg->IO.DNSChannel,
+ SendMsg->mx_host,
+ AF_INET6, /* it falls back to ipv4 in doubt... */
+ get_one_mx_host_ip_done,
+ &SendMsg->IO);
+}
+
+
+eNextState smtp_resolve_mx_done(AsyncIO *IO)
+{
+ SmtpOutMsg * SendMsg = IO->Data;
+
+ CtdlLogPrintf(CTDL_DEBUG, "SMTP: %s\n", __FUNCTION__);
+
+ SendMsg->IO.SendBuf.Buf = NewStrBufPlain(NULL, 1024);
+ SendMsg->IO.RecvBuf.Buf = NewStrBufPlain(NULL, 1024);
+ SendMsg->IO.IOBuf = NewStrBuf();
+ SendMsg->IO.ErrMsg = SendMsg->MyQEntry->StatusMessage;
+
+ SendMsg->CurrMX = SendMsg->AllMX = IO->VParsedDNSReply;
+ //// TODO: should we remove the current ares context???
+ get_one_mx_host_ip(IO);
+ return 0;
+}
+
+
+eNextState resolve_mx_records(AsyncIO *IO)
+{
+ SmtpOutMsg * SendMsg = IO->Data;
+
+ CtdlLogPrintf(CTDL_DEBUG, "SMTP: %s\n", __FUNCTION__);
+
+ if (!QueueQuery(ns_t_mx,
+ SendMsg->node,
+ &SendMsg->IO,
+ smtp_resolve_mx_done))
+ {
+ SendMsg->MyQEntry->Status = 5;
+ StrBufPrintf(SendMsg->MyQEntry->StatusMessage,
+ "No MX hosts found for <%s>", SendMsg->node);
+ return 0; ///////TODO: abort!
+ }
+ return 0;
}
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;
+ }
+
/* Parse out the host portion of the recipient address */
- process_rfc822_addr(SendMsg->addr, SendMsg->user, SendMsg->node, SendMsg->name);
+ 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);
SendMsg->envelope_from = SendMsg->mailfrom;
}
- return 0;
+ return 1;
}
-void resolve_mx_hosts(SmtpOutMsg *SendMsg)
-{
- /// well this is blocking and sux, but libevent jsut supports async dns since v2
- /* Figure out what mail exchanger host we have to connect to */
- SendMsg->num_mxhosts = getmx(SendMsg->mxhosts, SendMsg->node);
- CtdlLogPrintf(CTDL_DEBUG, "SMTP client[%ld]: Number of MX hosts for <%s> is %d [%s]\n",
- SendMsg->n, SendMsg->node, SendMsg->num_mxhosts, SendMsg->mxhosts);
- if (SendMsg->num_mxhosts < 1) {
- SendMsg->SMTPstatus = 5;
- snprintf(SendMsg->dsn, SIZ, "No MX hosts found for <%s>", SendMsg->node);
- return; ///////TODO: abort!
- }
-}
-/* TODO: abort... */
-#define SMTP_ERROR(WHICH_ERR, ERRSTR) {SendMsg->SMTPstatus = WHICH_ERR; memcpy(SendMsg->dsn, HKEY(ERRSTR) + 1); return eAbort; }
-#define SMTP_VERROR(WHICH_ERR) { SendMsg->SMTPstatus = WHICH_ERR; safestrncpy(SendMsg->dsn, &ChrPtr(SendMsg->IO.IOBuf)[4], sizeof(SendMsg->dsn)); return eAbort; }
-#define SMTP_IS_STATE(WHICH_STATE) (ChrPtr(SendMsg->IO.IOBuf)[0] == WHICH_STATE)
-#define SMTP_DBG_SEND() CtdlLogPrintf(CTDL_DEBUG, "SMTP client[%ld]: > %s\n", SendMsg->n, ChrPtr(SendMsg->IO.IOBuf))
-#define SMTP_DBG_READ() CtdlLogPrintf(CTDL_DEBUG, "SMTP client[%ld]: < %s\n", SendMsg->n, ChrPtr(SendMsg->IO.IOBuf))
-
-void connect_one_smtpsrv(SmtpOutMsg *SendMsg)
+void smtp_try(OneQueItem *MyQItem,
+ MailQEntry *MyQEntry,
+ StrBuf *MsgText,
+ int KeepMsgText, /* KeepMsgText allows us to use MsgText as ours. */
+ int MsgCount)
{
- char *endpart;
- char buf[SIZ];
+ SmtpOutMsg * SendMsg;
- extract_token(buf, SendMsg->mxhosts, SendMsg->n_mx, '|', sizeof(buf));
- strcpy(SendMsg->mx_user, "");
- strcpy(SendMsg->mx_pass, "");
- if (num_tokens(buf, '@') > 1) {
- strcpy (SendMsg->mx_user, buf);
- endpart = strrchr(SendMsg->mx_user, '@');
- *endpart = '\0';
- strcpy (SendMsg->mx_host, endpart + 1);
- endpart = strrchr(SendMsg->mx_user, ':');
- if (endpart != NULL) {
- strcpy(SendMsg->mx_pass, endpart+1);
- *endpart = '\0';
- }
+ CtdlLogPrintf(CTDL_DEBUG, "SMTP: %s\n", __FUNCTION__);
+
+ SendMsg = (SmtpOutMsg *) malloc(sizeof(SmtpOutMsg));
+ memset(SendMsg, 0, sizeof(SmtpOutMsg));
+ SendMsg->IO.sock = (-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.Timeout = SMTP_C_Timeout;
+
+ if (KeepMsgText) {
+ SendMsg->msgtext = MsgText;
}
- else
- strcpy (SendMsg->mx_host, buf);
- endpart = strrchr(SendMsg->mx_host, ':');
- if (endpart != 0){
- *endpart = '\0';
- strcpy(SendMsg->mx_port, endpart + 1);
- }
else {
- strcpy(SendMsg->mx_port, "25");
+ SendMsg->msgtext = NewStrBufDup(MsgText);
}
- CtdlLogPrintf(CTDL_DEBUG, "SMTP client[%ld]: connecting to %s : %s ...\n",
- SendMsg->n, SendMsg->mx_host, SendMsg->mx_port);
-
-}
-
-int connect_one_smtpsrv_xamine_result(void *Ctx)
-{
- SmtpOutMsg *SendMsg = Ctx;
- SendMsg->IO.SendBuf.fd =
- SendMsg->IO.RecvBuf.fd =
- SendMsg->IO.sock = sock_connect(SendMsg->mx_host, SendMsg->mx_port);
-
- snprintf(SendMsg->dsn, SIZ, "Could not connect: %s", strerror(errno));
- if (SendMsg->IO.sock >= 0)
- {
- CtdlLogPrintf(CTDL_DEBUG, "SMTP client[%ld]: connected!\n", SendMsg->n);
- int fdflags;
- fdflags = fcntl(SendMsg->IO.sock, F_GETFL);
- if (fdflags < 0)
- CtdlLogPrintf(CTDL_DEBUG,
- "SMTP client[%ld]: unable to get socket flags! %s \n",
- SendMsg->n, strerror(errno));
- fdflags = fdflags | O_NONBLOCK;
- if (fcntl(SendMsg->IO.sock, F_SETFL, fdflags) < 0)
- CtdlLogPrintf(CTDL_DEBUG,
- "SMTP client[%ld]: unable to set socket nonblocking flags! %s \n",
- SendMsg->n, strerror(errno));
- }
- if (SendMsg->IO.sock < 0) {
- if (errno > 0) {
- snprintf(SendMsg->dsn, SIZ, "%s", strerror(errno));
- }
+ if (smtp_resolve_recipients(SendMsg)) {
+ if (SendMsg->pCurrRelay == NULL)
+ QueueEventContext(&SendMsg->IO,
+ resolve_mx_records);
else {
- snprintf(SendMsg->dsn, SIZ, "Unable to connect to %s : %s\n",
- SendMsg->mx_host, SendMsg->mx_port);
+ if (SendMsg->pCurrRelay->IsIP) {
+ QueueEventContext(&SendMsg->IO,
+ mx_connect_relay_ip);
+ }
+ else {
+ QueueEventContext(&SendMsg->IO,
+ get_one_mx_host_ip);
+ }
}
}
- /// hier: naechsten mx ausprobieren.
- if (SendMsg->IO.sock < 0) {
- SendMsg->SMTPstatus = 4; /* dsn is already filled in */
- //// hier: abbrechen & bounce.
- return -1;
+ else {
+ if ((SendMsg==NULL) ||
+ (SendMsg->MyQEntry == NULL)) {
+ SendMsg->MyQEntry->Status = 5;
+ StrBufPlain(SendMsg->MyQEntry->StatusMessage,
+ HKEY("Invalid Recipient!"));
+ }
+ FinalizeMessageSend(SendMsg);
}
- SendMsg->IO.SendBuf.Buf = NewStrBuf();
- SendMsg->IO.RecvBuf.Buf = NewStrBuf();
- SendMsg->IO.IOBuf = NewStrBuf();
- InitEventIO(&SendMsg->IO, SendMsg,
- SMTP_C_DispatchReadDone,
- SMTP_C_DispatchWriteDone,
- SMTP_C_ReadServerStatus,
- 1);
- return 0;
}
+
+
+
+
+/*****************************************************************************/
+/* SMTP CLIENT STATE CALLBACKS */
+/*****************************************************************************/
eNextState SMTPC_read_greeting(SmtpOutMsg *SendMsg)
{
/* Process the SMTP greeting from the server */
if (!SMTP_IS_STATE('2')) {
if (SMTP_IS_STATE('4'))
- SMTP_VERROR(4)
+ SMTP_VERROR(4);
else
- SMTP_VERROR(5)
+ SMTP_VERROR(5);
}
return eSendReply;
}
if (SMTP_IS_STATE('2')) {
SendMsg->State ++;
- if (IsEmptyStr(SendMsg->mx_user))
+
+ if (SendMsg->pCurrRelay->User == NULL)
SendMsg->State ++; /* Skip auth... */
}
/* else we fall back to 'helo' */
if (!SMTP_IS_STATE('2')) {
if (SMTP_IS_STATE('4'))
- SMTP_VERROR(4)
+ SMTP_VERROR(4);
else
- SMTP_VERROR(5)
+ SMTP_VERROR(5);
}
- if (!IsEmptyStr(SendMsg->mx_user))
+ if (SendMsg->pCurrRelay->User == NULL)
SendMsg->State ++; /* Skip auth... */
return eSendReply;
}
/* Do an AUTH command if necessary */
sprintf(buf, "%s%c%s%c%s",
- SendMsg->mx_user, '\0',
- SendMsg->mx_user, '\0',
- SendMsg->mx_pass);
+ SendMsg->pCurrRelay->User, '\0',
+ SendMsg->pCurrRelay->User, '\0',
+ SendMsg->pCurrRelay->Pass);
CtdlEncodeBase64(encoded, buf,
- strlen(SendMsg->mx_user) +
- strlen(SendMsg->mx_user) +
- strlen(SendMsg->mx_pass) + 2, 0);
+ 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;
}
if (!SMTP_IS_STATE('2')) {
if (SMTP_IS_STATE('4'))
- SMTP_VERROR(4)
+ SMTP_VERROR(4);
else
- SMTP_VERROR(5)
+ SMTP_VERROR(5);
}
return eSendReply;
}
if (!SMTP_IS_STATE('2')) {
if (SMTP_IS_STATE('4'))
- SMTP_VERROR(4)
+ SMTP_VERROR(4);
else
- SMTP_VERROR(5)
+ SMTP_VERROR(5);
}
return eSendReply;
}
if (!SMTP_IS_STATE('2')) {
if (SMTP_IS_STATE('4'))
- SMTP_VERROR(4)
+ SMTP_VERROR(4);
else
- SMTP_VERROR(5)
+ SMTP_VERROR(5);
}
return eSendReply;
}
if (!SMTP_IS_STATE('3')) {
if (SMTP_IS_STATE('4'))
- SMTP_VERROR(3)
+ SMTP_VERROR(3);
else
- SMTP_VERROR(5)
+ SMTP_VERROR(5);
}
return eSendReply;
}
Buf = SendMsg->IO.SendBuf.Buf;
SendMsg->IO.SendBuf.Buf = SendMsg->msgtext;
SendMsg->msgtext = Buf;
- //// TODO timeout like that: (SendMsg->msg_size / 128) + 50);
SendMsg->State ++;
return eSendMore;
if (!SMTP_IS_STATE('2')) {
if (SMTP_IS_STATE('4'))
- SMTP_VERROR(4)
+ SMTP_VERROR(4);
else
- SMTP_VERROR(5)
+ SMTP_VERROR(5);
}
/* We did it! */
- safestrncpy(SendMsg->dsn, &ChrPtr(SendMsg->IO.RecvBuf.Buf)[4], 1023);
- SendMsg->SMTPstatus = 2;
+ StrBufPlain(SendMsg->MyQEntry->StatusMessage,
+ &ChrPtr(SendMsg->IO.RecvBuf.Buf)[4],
+ StrLength(SendMsg->IO.RecvBuf.Buf) - 4);
+ SendMsg->MyQEntry->Status = 2;
return eSendReply;
}
CtdlLogPrintf(CTDL_INFO, "SMTP client[%ld]: delivery to <%s> @ <%s> (%s) succeeded\n",
SendMsg->n, SendMsg->user, SendMsg->node, SendMsg->name);
- return eSendReply;
+ return eTerminateConnection;
}
eNextState SMTPC_read_dummy(SmtpOutMsg *SendMsg)
return eReadMessage;
}
-/*
- * smtp_do_bounce() is caled by smtp_do_procmsg() to scan a set of delivery
- * instructions for "5" codes (permanent fatal errors) and produce/deliver
- * a "bounce" message (delivery status notification).
- */
-void smtp_do_bounce(char *instr) {
- int i;
- int lines;
- int status;
- char buf[1024];
- char key[1024];
- char addr[1024];
- char dsn[1024];
- char bounceto[1024];
- StrBuf *boundary;
- int num_bounces = 0;
- int bounce_this = 0;
- long bounce_msgid = (-1);
- time_t submitted = 0L;
- struct CtdlMessage *bmsg = NULL;
- int give_up = 0;
- struct recptypes *valid;
- int successful_bounce = 0;
- static int seq = 0;
- StrBuf *BounceMB;
- long omsgid = (-1);
-
- CtdlLogPrintf(CTDL_DEBUG, "smtp_do_bounce() called\n");
- strcpy(bounceto, "");
- boundary = NewStrBufPlain(HKEY("=_Citadel_Multipart_"));
- StrBufAppendPrintf(boundary, "%s_%04x%04x", config.c_fqdn, getpid(), ++seq);
- lines = num_tokens(instr, '\n');
-
- /* See if it's time to give up on delivery of this message */
- for (i=0; i<lines; ++i) {
- extract_token(buf, instr, i, '\n', sizeof buf);
- extract_token(key, buf, 0, '|', sizeof key);
- extract_token(addr, buf, 1, '|', sizeof addr);
- if (!strcasecmp(key, "submitted")) {
- submitted = atol(addr);
- }
- }
-
- if ( (time(NULL) - submitted) > SMTP_GIVE_UP ) {
- give_up = 1;
- }
-
- /* Start building our bounce message */
-
- bmsg = (struct CtdlMessage *) malloc(sizeof(struct CtdlMessage));
- if (bmsg == NULL) return;
- memset(bmsg, 0, sizeof(struct CtdlMessage));
- BounceMB = NewStrBufPlain(NULL, 1024);
-
- bmsg->cm_magic = CTDLMESSAGE_MAGIC;
- bmsg->cm_anon_type = MES_NORMAL;
- bmsg->cm_format_type = FMT_RFC822;
- bmsg->cm_fields['A'] = strdup("Citadel");
- bmsg->cm_fields['O'] = strdup(MAILROOM);
- bmsg->cm_fields['N'] = strdup(config.c_nodename);
- bmsg->cm_fields['U'] = strdup("Delivery Status Notification (Failure)");
- StrBufAppendBufPlain(BounceMB, HKEY("Content-type: multipart/mixed; boundary=\""), 0);
- StrBufAppendBuf(BounceMB, boundary, 0);
- StrBufAppendBufPlain(BounceMB, HKEY("\"\r\n"), 0);
- StrBufAppendBufPlain(BounceMB, HKEY("MIME-Version: 1.0\r\n"), 0);
- StrBufAppendBufPlain(BounceMB, HKEY("X-Mailer: " CITADEL "\r\n"), 0);
- StrBufAppendBufPlain(BounceMB, HKEY("\r\nThis is a multipart message in MIME format.\r\n\r\n"), 0);
- StrBufAppendBufPlain(BounceMB, HKEY("--"), 0);
- StrBufAppendBuf(BounceMB, boundary, 0);
- StrBufAppendBufPlain(BounceMB, HKEY("\r\n"), 0);
- StrBufAppendBufPlain(BounceMB, HKEY("Content-type: text/plain\r\n\r\n"), 0);
-
- if (give_up) StrBufAppendBufPlain(BounceMB, HKEY(
-"A message you sent could not be delivered to some or all of its recipients\n"
-"due to prolonged unavailability of its destination(s).\n"
-"Giving up on the following addresses:\n\n"
- ), 0);
-
- else StrBufAppendBufPlain(BounceMB, HKEY(
-"A message you sent could not be delivered to some or all of its recipients.\n"
-"The following addresses were undeliverable:\n\n"
- ), 0);
-
- /*
- * Now go through the instructions checking for stuff.
- */
- for (i=0; i<lines; ++i) {
- long addrlen;
- long dsnlen;
- extract_token(buf, instr, i, '\n', sizeof buf);
- extract_token(key, buf, 0, '|', sizeof key);
- addrlen = extract_token(addr, buf, 1, '|', sizeof addr);
- status = extract_int(buf, 2);
- dsnlen = extract_token(dsn, buf, 3, '|', sizeof dsn);
- bounce_this = 0;
-
- CtdlLogPrintf(CTDL_DEBUG, "key=<%s> addr=<%s> status=%d dsn=<%s>\n",
- key, addr, status, dsn);
-
- if (!strcasecmp(key, "bounceto")) {
- strcpy(bounceto, addr);
- }
-
- if (!strcasecmp(key, "msgid")) {
- omsgid = atol(addr);
- }
-
- if (!strcasecmp(key, "remote")) {
- if (status == 5) bounce_this = 1;
- if (give_up) bounce_this = 1;
- }
-
- if (bounce_this) {
- ++num_bounces;
-
- StrBufAppendBufPlain(BounceMB, addr, addrlen, 0);
- StrBufAppendBufPlain(BounceMB, HKEY(": "), 0);
- StrBufAppendBufPlain(BounceMB, dsn, dsnlen, 0);
- StrBufAppendBufPlain(BounceMB, HKEY("\r\n"), 0);
-
- remove_token(instr, i, '\n');
- --i;
- --lines;
- }
- }
-
- /* Attach the original message */
- if (omsgid >= 0) {
- StrBufAppendBufPlain(BounceMB, HKEY("--"), 0);
- StrBufAppendBuf(BounceMB, boundary, 0);
- StrBufAppendBufPlain(BounceMB, HKEY("\r\n"), 0);
- StrBufAppendBufPlain(BounceMB, HKEY("Content-type: message/rfc822\r\n"), 0);
- StrBufAppendBufPlain(BounceMB, HKEY("Content-Transfer-Encoding: 7bit\r\n"), 0);
- StrBufAppendBufPlain(BounceMB, HKEY("Content-Disposition: inline\r\n"), 0);
- StrBufAppendBufPlain(BounceMB, HKEY("\r\n"), 0);
-
- CC->redirect_buffer = NewStrBufPlain(NULL, SIZ);
- CtdlOutputMsg(omsgid, MT_RFC822, HEADERS_ALL, 0, 1, NULL, 0);
- StrBufAppendBuf(BounceMB, CC->redirect_buffer, 0);
- FreeStrBuf(&CC->redirect_buffer);
- }
-
- /* Close the multipart MIME scope */
- StrBufAppendBufPlain(BounceMB, HKEY("--"), 0);
- StrBufAppendBuf(BounceMB, boundary, 0);
- StrBufAppendBufPlain(BounceMB, HKEY("--\r\n"), 0);
- if (bmsg->cm_fields['A'] != NULL)
- free(bmsg->cm_fields['A']);
- bmsg->cm_fields['A'] = SmashStrBuf(&BounceMB);
- /* Deliver the bounce if there's anything worth mentioning */
- CtdlLogPrintf(CTDL_DEBUG, "num_bounces = %d\n", num_bounces);
- if (num_bounces > 0) {
-
- /* First try the user who sent the message */
- CtdlLogPrintf(CTDL_DEBUG, "bounce to user? <%s>\n", bounceto);
- if (IsEmptyStr(bounceto)) {
- CtdlLogPrintf(CTDL_ERR, "No bounce address specified\n");
- bounce_msgid = (-1L);
- }
-
- /* Can we deliver the bounce to the original sender? */
- valid = validate_recipients(bounceto, smtp_get_Recipients (), 0);
- if (valid != NULL) {
- if (valid->num_error == 0) {
- CtdlSubmitMsg(bmsg, valid, "", QP_EADDR);
- successful_bounce = 1;
- }
- }
-
- /* If not, post it in the Aide> room */
- if (successful_bounce == 0) {
- CtdlSubmitMsg(bmsg, NULL, config.c_aideroom, QP_EADDR);
- }
-
- /* Free up the memory we used */
- if (valid != NULL) {
- free_recipients(valid);
- }
- }
- FreeStrBuf(&boundary);
- CtdlFreeMessage(bmsg);
- CtdlLogPrintf(CTDL_DEBUG, "Done processing bounces\n");
-}
-
-
-/*
- * smtp_purge_completed_deliveries() is caled by smtp_do_procmsg() to scan a
- * set of delivery instructions for completed deliveries and remove them.
- *
- * It returns the number of incomplete deliveries remaining.
- */
-int smtp_purge_completed_deliveries(char *instr) {
- int i;
- int lines;
- int status;
- char buf[1024];
- char key[1024];
- char addr[1024];
- char dsn[1024];
- int completed;
- int incomplete = 0;
-
- lines = num_tokens(instr, '\n');
- for (i=0; i<lines; ++i) {
- extract_token(buf, instr, i, '\n', sizeof buf);
- extract_token(key, buf, 0, '|', sizeof key);
- extract_token(addr, buf, 1, '|', sizeof addr);
- status = extract_int(buf, 2);
- extract_token(dsn, buf, 3, '|', sizeof dsn);
-
- completed = 0;
-
- if (!strcasecmp(key, "remote")) {
- if (status == 2) completed = 1;
- else ++incomplete;
- }
-
- if (completed) {
- remove_token(instr, i, '\n');
- --i;
- --lines;
- }
- }
-
- return(incomplete);
-}
-
-void smtp_try(const char *key, const char *addr, int *status,
- char *dsn, size_t n, long msgnum, char *envelope_from)
-{
- SmtpOutMsg * SmtpC = smtp_load_msg(msgnum, addr, envelope_from);
- smtp_resolve_recipients(SmtpC);
- resolve_mx_hosts(SmtpC);
- connect_one_smtpsrv(SmtpC);
- QueueEventContext(SmtpC, connect_one_smtpsrv_xamine_result);
-}
-
-/*
- * smtp_do_procmsg()
- *
- * Called by smtp_do_queue() to handle an individual message.
- */
-void smtp_do_procmsg(long msgnum, void *userdata) {
- struct CtdlMessage *msg = NULL;
- char *instr = NULL;
- char *results = NULL;
- int i;
- int lines;
- int status;
- char buf[1024];
- char key[1024];
- char addr[1024];
- char dsn[1024];
- char envelope_from[1024];
- long text_msgid = (-1);
- int incomplete_deliveries_remaining;
- time_t attempted = 0L;
- time_t last_attempted = 0L;
- time_t retry = SMTP_RETRY_INTERVAL;
-
- CtdlLogPrintf(CTDL_DEBUG, "SMTP client: smtp_do_procmsg(%ld)\n", msgnum);
- strcpy(envelope_from, "");
-
- msg = CtdlFetchMessage(msgnum, 1);
- if (msg == NULL) {
- CtdlLogPrintf(CTDL_ERR, "SMTP client: tried %ld but no such message!\n", msgnum);
- return;
- }
-
- instr = strdup(msg->cm_fields['M']);
- CtdlFreeMessage(msg);
-
- /* Strip out the headers amd any other non-instruction line */
- lines = num_tokens(instr, '\n');
- for (i=0; i<lines; ++i) {
- extract_token(buf, instr, i, '\n', sizeof buf);
- if (num_tokens(buf, '|') < 2) {
- remove_token(instr, i, '\n');
- --lines;
- --i;
- }
- }
-
- /* Learn the message ID and find out about recent delivery attempts */
- lines = num_tokens(instr, '\n');
- for (i=0; i<lines; ++i) {
- extract_token(buf, instr, i, '\n', sizeof buf);
- extract_token(key, buf, 0, '|', sizeof key);
- if (!strcasecmp(key, "msgid")) {
- text_msgid = extract_long(buf, 1);
- }
- if (!strcasecmp(key, "envelope_from")) {
- extract_token(envelope_from, buf, 1, '|', sizeof envelope_from);
- }
- if (!strcasecmp(key, "retry")) {
- /* double the retry interval after each attempt */
- retry = extract_long(buf, 1) * 2L;
- if (retry > SMTP_RETRY_MAX) {
- retry = SMTP_RETRY_MAX;
- }
- remove_token(instr, i, '\n');
- }
- if (!strcasecmp(key, "attempted")) {
- attempted = extract_long(buf, 1);
- if (attempted > last_attempted)
- last_attempted = attempted;
- }
- }
-
- /*
- * Postpone delivery if we've already tried recently.
- * /
- if (((time(NULL) - last_attempted) < retry) && (run_queue_now == 0)) {
- CtdlLogPrintf(CTDL_DEBUG, "SMTP client: Retry time not yet reached.\n");
- free(instr);
- return;
- }
-TMP TODO */
-
- /*
- * Bail out if there's no actual message associated with this
- */
- if (text_msgid < 0L) {
- CtdlLogPrintf(CTDL_ERR, "SMTP client: no 'msgid' directive found!\n");
- free(instr);
- return;
- }
-
- /* Plow through the instructions looking for 'remote' directives and
- * a status of 0 (no delivery yet attempted) or 3/4 (transient errors
- * were experienced and it's time to try again)
- */
- lines = num_tokens(instr, '\n');
- for (i=0; i<lines; ++i) {
- extract_token(buf, instr, i, '\n', sizeof buf);
- extract_token(key, buf, 0, '|', sizeof key);
- extract_token(addr, buf, 1, '|', sizeof addr);
- status = extract_int(buf, 2);
- extract_token(dsn, buf, 3, '|', sizeof dsn);
- if ( (!strcasecmp(key, "remote"))
- && ((status==0)||(status==3)||(status==4)) ) {
-
- /* Remove this "remote" instruction from the set,
- * but replace the set's final newline if
- * remove_token() stripped it. It has to be there.
- */
- remove_token(instr, i, '\n');
- if (instr[strlen(instr)-1] != '\n') {
- strcat(instr, "\n");
- }
-
- --i;
- --lines;
- CtdlLogPrintf(CTDL_DEBUG, "SMTP client: Trying <%s>\n", addr);
- smtp_try(key, addr, &status, dsn, sizeof dsn, text_msgid, envelope_from);
- if (status != 2) {
- if (results == NULL) {
- results = malloc(1024);
- memset(results, 0, 1024);
- }
- else {
- results = realloc(results, strlen(results) + 1024);
- }
- snprintf(&results[strlen(results)], 1024,
- "%s|%s|%d|%s\n",
- key, addr, status, dsn);
- }
- }
- }
-
- if (results != NULL) {
- instr = realloc(instr, strlen(instr) + strlen(results) + 2);
- strcat(instr, results);
- free(results);
- }
-
-
- /* Generate 'bounce' messages */
- smtp_do_bounce(instr);
-
- /* Go through the delivery list, deleting completed deliveries */
- incomplete_deliveries_remaining =
- smtp_purge_completed_deliveries(instr);
-
-
- /*
- * No delivery instructions remain, so delete both the instructions
- * message and the message message.
- */
- if (incomplete_deliveries_remaining <= 0) {
- long delmsgs[2];
- delmsgs[0] = msgnum;
- delmsgs[1] = text_msgid;
- CtdlDeleteMessages(SMTP_SPOOLOUT_ROOM, delmsgs, 2, "");
- }
-
- /*
- * Uncompleted delivery instructions remain, so delete the old
- * instructions and replace with the updated ones.
- */
- if (incomplete_deliveries_remaining > 0) {
- CtdlDeleteMessages(SMTP_SPOOLOUT_ROOM, &msgnum, 1, "");
- 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'] = malloc(strlen(instr)+SIZ);
- snprintf(msg->cm_fields['M'],
- strlen(instr)+SIZ,
- "Content-type: %s\n\n%s\n"
- "attempted|%ld\n"
- "retry|%ld\n",
- SPOOLMIME, instr, (long)time(NULL), (long)retry );
- CtdlSubmitMsg(msg, NULL, SMTP_SPOOLOUT_ROOM, QP_EADDR);
- CtdlFreeMessage(msg);
- }
-
- free(instr);
-}
-
/*****************************************************************************/
-/* SMTP UTILITY COMMANDS */
+/* SMTP CLIENT DISPATCHER */
/*****************************************************************************/
-
-void cmd_smtp(char *argbuf) {
- char cmd[64];
- char node[256];
- char buf[1024];
- int i;
- int num_mxhosts;
-
- if (CtdlAccessCheck(ac_aide)) return;
-
- extract_token(cmd, argbuf, 0, '|', sizeof cmd);
-
- if (!strcasecmp(cmd, "mx")) {
- extract_token(node, argbuf, 1, '|', sizeof node);
- num_mxhosts = getmx(buf, node);
- cprintf("%d %d MX hosts listed for %s\n",
- LISTING_FOLLOWS, num_mxhosts, node);
- for (i=0; i<num_mxhosts; ++i) {
- extract_token(node, buf, i, '|', sizeof node);
- cprintf("%s\n", node);
- }
- cprintf("000\n");
- return;
- }
-
- else if (!strcasecmp(cmd, "runqueue")) {
- run_queue_now = 1;
- cprintf("%d All outbound SMTP will be retried now.\n", CIT_OK);
- return;
- }
-
- else {
- cprintf("%d Invalid command.\n", ERROR + ILLEGAL_VALUE);
- }
-
-}
-
-
-/*
- * smtp_queue_thread()
- *
- * Run through the queue sending out messages.
- */
-void *smtp_queue_thread(void *arg) {
- int num_processed = 0;
- struct CitContext smtp_queue_CC;
-
- CtdlFillSystemContext(&smtp_queue_CC, "SMTP Send");
- citthread_setspecific(MyConKey, (void *)&smtp_queue_CC);
- CtdlLogPrintf(CTDL_DEBUG, "smtp_queue_thread() initializing\n");
-
- while (!CtdlThreadCheckStop()) {
-
- CtdlLogPrintf(CTDL_INFO, "SMTP client: processing outbound queue\n");
-
- if (CtdlGetRoom(&CC->room, SMTP_SPOOLOUT_ROOM) != 0) {
- CtdlLogPrintf(CTDL_ERR, "Cannot find room <%s>\n", SMTP_SPOOLOUT_ROOM);
- }
- else {
- num_processed = CtdlForEachMessage(MSGS_ALL, 0L, NULL, SPOOLMIME, NULL, smtp_do_procmsg, NULL);
- }
- CtdlLogPrintf(CTDL_INFO, "SMTP client: queue run completed; %d messages processed\n", num_processed);
- CtdlThreadSleep(60);
- }
-
- CtdlClearSystemContext();
- return(NULL);
-}
-
-
-/*
- * Initialize the SMTP outbound queue
- */
-void smtp_init_spoolout(void) {
- struct ctdlroom qrbuf;
-
- /*
- * Create the room. This will silently fail if the room already
- * exists, and that's perfectly ok, because we want it to exist.
- */
- CtdlCreateRoom(SMTP_SPOOLOUT_ROOM, 3, "", 0, 1, 0, VIEW_MAILBOX);
-
- /*
- * Make sure it's set to be a "system room" so it doesn't show up
- * in the <K>nown rooms list for Aides.
- */
- if (CtdlGetRoomLock(&qrbuf, SMTP_SPOOLOUT_ROOM) == 0) {
- qrbuf.QRflags2 |= QR2_SYSTEM;
- CtdlPutRoomLock(&qrbuf);
- }
-}
-
-
SMTPReadHandler ReadHandlers[eMaxSMTPC] = {
SMTPC_read_greeting,
SMTPC_read_EHLO_reply,
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,
SMTPC_send_QUIT
};
-eNextState SMTP_C_DispatchReadDone(void *Data)
+void SMTPSetTimeout(eNextState NextTCPState, SmtpOutMsg *pMsg)
{
- SmtpOutMsg *pMsg = Data;
- eNextState rc = ReadHandlers[pMsg->State](pMsg);
+ CtdlLogPrintf(CTDL_DEBUG, "SMTP: %s\n", __FUNCTION__);
+ double Timeout;
+ switch (NextTCPState) {
+ case eSendReply:
+ case eSendMore:
+ Timeout = SMTP_C_SendTimeouts[pMsg->State];
+ if (pMsg->State == eDATABody) {
+ /* if we're sending a huge message, we need more time. */
+ Timeout += StrLength(pMsg->msgtext) / 1024;
+ }
+ break;
+ case eReadMessage:
+ Timeout = SMTP_C_ReadTimeouts[pMsg->State];
+ if (pMsg->State == eDATATerminateBody) {
+ /*
+ * some mailservers take a nap before accepting the message
+ * content inspection and such.
+ */
+ Timeout += StrLength(pMsg->msgtext) / 1024;
+ }
+ break;
+ case eTerminateConnection:
+ case eAbort:
+ return;
+ }
+ SetNextTimeout(&pMsg->IO, Timeout);
+}
+eNextState SMTP_C_DispatchReadDone(AsyncIO *IO)
+{
+ CtdlLogPrintf(CTDL_DEBUG, "SMTP: %s\n", __FUNCTION__);
+ SmtpOutMsg *pMsg = IO->Data;
+ eNextState rc;
+
+ rc = ReadHandlers[pMsg->State](pMsg);
pMsg->State++;
+ SMTPSetTimeout(rc, pMsg);
+ return rc;
+}
+eNextState SMTP_C_DispatchWriteDone(AsyncIO *IO)
+{
+ CtdlLogPrintf(CTDL_DEBUG, "SMTP: %s\n", __FUNCTION__);
+ SmtpOutMsg *pMsg = IO->Data;
+ eNextState rc;
+
+ rc = SendHandlers[pMsg->State](pMsg);
+ SMTPSetTimeout(rc, pMsg);
return rc;
}
-eNextState SMTP_C_DispatchWriteDone(void *Data)
+
+/*****************************************************************************/
+/* SMTP CLIENT ERROR CATCHERS */
+/*****************************************************************************/
+eNextState SMTP_C_Terminate(AsyncIO *IO)
{
- SmtpOutMsg *pMsg = Data;
- return SendHandlers[pMsg->State](pMsg);
-
+ CtdlLogPrintf(CTDL_DEBUG, "SMTP: %s\n", __FUNCTION__);
+ SmtpOutMsg *pMsg = IO->Data;
+ FinalizeMessageSend(pMsg);
+ return 0;
+}
+eNextState SMTP_C_Timeout(AsyncIO *IO)
+{
+ CtdlLogPrintf(CTDL_DEBUG, "SMTP: %s\n", __FUNCTION__);
+ SmtpOutMsg *pMsg = IO->Data;
+ StrBufPlain(IO->ErrMsg, CKEY(ReadErrors[pMsg->State]));
+ FinalizeMessageSend(pMsg);
+ return 0;
+}
+eNextState SMTP_C_ConnFail(AsyncIO *IO)
+{
+ CtdlLogPrintf(CTDL_DEBUG, "SMTP: %s\n", __FUNCTION__);
+ SmtpOutMsg *pMsg = IO->Data;
+ FinalizeMessageSend(pMsg);
+ return 0;
}
-#endif
-CTDL_MODULE_INIT(smtp_eventclient)
+/**
+ * @brief lineread Handler; understands when to read more SMTP lines, and when this is a one-lined reply.
+ */
+eReadState SMTP_C_ReadServerStatus(AsyncIO *IO)
{
-#ifdef EXPERIMENTAL_SMTP_EVENT_CLIENT
- if (!threading)
- {
- smtp_init_spoolout();
- CtdlThreadCreate("SMTPEvent Send", CTDLTHREAD_BIGSTACK, smtp_queue_thread, NULL);
+ eReadState Finished = eBufferNotEmpty;
- CtdlRegisterProtoHook(cmd_smtp, "SMTP", "SMTP utility commands");
+ while (Finished == eBufferNotEmpty) {
+ Finished = StrBufChunkSipLine(IO->IOBuf, &IO->RecvBuf);
+
+ switch (Finished) {
+ case eMustReadMore: /// read new from socket...
+ return Finished;
+ break;
+ case eBufferNotEmpty: /* shouldn't happen... */
+ case eReadSuccess: /// done for now...
+ if (StrLength(IO->IOBuf) < 4)
+ continue;
+ if (ChrPtr(IO->IOBuf)[3] == '-')
+ Finished = eBufferNotEmpty;
+ else
+ return Finished;
+ break;
+ case eReadFail: /// WHUT?
+ ///todo: shut down!
+ break;
+ }
}
+ return Finished;
+}
+
#endif
-
- /* return our Subversion id for the Log */
+CTDL_MODULE_INIT(smtp_eventclient)
+{
return "smtpeventclient";
}
projects / citadel.git / blobdiff