#include "event_client.h"
#ifdef EXPERIMENTAL_SMTP_EVENT_CLIENT
+HashList *QItemHandlers = NULL;
+
+citthread_mutex_t ActiveQItemsLock;
+HashList *ActiveQItems = NULL;
int run_queue_now = 0; /* Set to 1 to ignore SMTP send retry times */
int MsgCount = 0;
/*****************************************************************************/
-/* SMTP CLIENT (OUTBOUND PROCESSING) STUFF */
+/* SMTP CLIENT (Queue Management) STUFF */
/*****************************************************************************/
+#define MaxAttempts 15
+typedef struct _delivery_attempt {
+ time_t when;
+ time_t retry;
+}DeliveryAttempt;
+
+typedef struct _mailq_entry {
+ DeliveryAttempt Attempts[MaxAttempts];
+ int nAttempts;
+ StrBuf *Recipient;
+ StrBuf *StatusMessage;
+ int Status;
+ int n;
+ int Active;
+}MailQEntry;
+void FreeMailQEntry(void *qv)
+{
+ MailQEntry *Q = qv;
+ FreeStrBuf(&Q->Recipient);
+ FreeStrBuf(&Q->StatusMessage);
+ free(Q);
+}
+
+typedef struct queueitem {
+ long MessageID;
+ long QueMsgID;
+ int FailNow;
+ HashList *MailQEntries;
+ MailQEntry *Current; /* copy of the currently parsed item in the MailQEntries list; if null add a new one. */
+ DeliveryAttempt LastAttempt;
+ long ActiveDeliveries;
+ StrBuf *EnvelopeFrom;
+ StrBuf *BounceTo;
+} OneQueItem;
+typedef void (*QItemHandler)(OneQueItem *Item, StrBuf *Line, const char **Pos);
+
+/*****************************************************************************/
+/* SMTP CLIENT (OUTBOUND PROCESSING) STUFF */
+/*****************************************************************************/
typedef enum _eSMTP_C_States {
eConnect,
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;
+
+ struct hostent *OneMX;
- 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];
-
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;
+void DeleteSmtpOutMsg(void *v)
+{
+ SmtpOutMsg *Msg = v;
+
+ ares_free_data(Msg->AllMX);
+ FreeStrBuf(&Msg->msgtext);
+ FreeAsyncIOContents(&Msg->IO);
+ free(Msg);
+}
+eNextState SMTP_C_Timeout(void *Data);
+eNextState SMTP_C_ConnFail(void *Data);
eNextState SMTP_C_DispatchReadDone(void *Data);
eNextState SMTP_C_DispatchWriteDone(void *Data);
-
+eNextState SMTP_C_Terminate(void *Data);
+eNextState SMTP_C_MXLookup(void *Data);
typedef eNextState (*SMTPReadHandler)(SmtpOutMsg *Msg);
typedef eNextState (*SMTPSendHandler)(SmtpOutMsg *Msg);
+
+
+void FreeQueItem(OneQueItem **Item)
+{
+ DeleteHash(&(*Item)->MailQEntries);
+ FreeStrBuf(&(*Item)->EnvelopeFrom);
+ FreeStrBuf(&(*Item)->BounceTo);
+ free(*Item);
+ Item = NULL;
+}
+void HFreeQueItem(void *Item)
+{
+ FreeQueItem((OneQueItem**)&Item);
+}
+
+
+/* inspect recipients with a status of:
+ * - 0 (no delivery yet attempted)
+ * - 3/4 (transient errors
+ * were experienced and it's time to try again)
+ */
+int CountActiveQueueEntries(OneQueItem *MyQItem)
+{
+ HashPos *It;
+ long len;
+ const char *Key;
+ void *vQE;
+
+ MyQItem->ActiveDeliveries = 0;
+ It = GetNewHashPos(MyQItem->MailQEntries, 0);
+ while (GetNextHashPos(MyQItem->MailQEntries, It, &len, &Key, &vQE))
+ {
+ MailQEntry *ThisItem = vQE;
+ if ((ThisItem->Status == 0) ||
+ (ThisItem->Status == 3) ||
+ (ThisItem->Status == 4))
+ {
+ MyQItem->ActiveDeliveries++;
+ ThisItem->Active = 1;
+ }
+ else
+ ThisItem->Active = 0;
+ }
+ DeleteHashPos(&It);
+ return MyQItem->ActiveDeliveries;
+}
+
+OneQueItem *DeserializeQueueItem(StrBuf *RawQItem, long QueMsgID)
+{
+ OneQueItem *Item;
+ const char *pLine = NULL;
+ StrBuf *Line;
+ StrBuf *Token;
+ void *v;
+
+ Item = (OneQueItem*)malloc(sizeof(OneQueItem));
+ memset(Item, 0, sizeof(OneQueItem));
+ Item->LastAttempt.retry = SMTP_RETRY_INTERVAL;
+ Item->MessageID = -1;
+ Item->QueMsgID = QueMsgID;
+
+ citthread_mutex_lock(&ActiveQItemsLock);
+ if (GetHash(ActiveQItems,
+ IKEY(Item->QueMsgID),
+ &v))
+ {
+ /* WHOOPS. somebody else is already working on this. */
+ citthread_mutex_unlock(&ActiveQItemsLock);
+ FreeQueItem(&Item);
+ return NULL;
+ }
+ else {
+ /* mark our claim on this. */
+ Put(ActiveQItems,
+ IKEY(Item->QueMsgID),
+ Item,
+ HFreeQueItem);
+ citthread_mutex_unlock(&ActiveQItemsLock);
+ }
+
+ Token = NewStrBuf();
+ Line = NewStrBufPlain(NULL, 128);
+ while (pLine != StrBufNOTNULL) {
+ const char *pItemPart = NULL;
+ void *vHandler;
+
+ StrBufExtract_NextToken(Line, RawQItem, &pLine, '\n');
+ if (StrLength(Line) == 0) continue;
+ StrBufExtract_NextToken(Token, Line, &pItemPart, '|');
+ if (GetHash(QItemHandlers, SKEY(Token), &vHandler))
+ {
+ QItemHandler H;
+ H = (QItemHandler) vHandler;
+ H(Item, Line, &pItemPart);
+ }
+ }
+ FreeStrBuf(&Line);
+ FreeStrBuf(&Token);
+ return Item;
+}
+
+StrBuf *SerializeQueueItem(OneQueItem *MyQItem)
+{
+ StrBuf *QMessage;
+ HashPos *It;
+ const char *Key;
+ long len;
+ void *vQE;
+
+ QMessage = NewStrBufPlain(NULL, SIZ);
+ StrBufPrintf(QMessage, "Content-type: %s\n", SPOOLMIME);
+
+// "attempted|%ld\n" "retry|%ld\n",, (long)time(NULL), (long)retry );
+ StrBufAppendBufPlain(QMessage, HKEY("\nmsgid|"), 0);
+ StrBufAppendPrintf(QMessage, "%ld", MyQItem->MessageID);
+
+ if (StrLength(MyQItem->BounceTo) > 0) {
+ StrBufAppendBufPlain(QMessage, HKEY("\nbounceto|"), 0);
+ StrBufAppendBuf(QMessage, MyQItem->BounceTo, 0);
+ }
+
+ if (StrLength(MyQItem->EnvelopeFrom) > 0) {
+ StrBufAppendBufPlain(QMessage, HKEY("\nenvelope_from|"), 0);
+ StrBufAppendBuf(QMessage, MyQItem->EnvelopeFrom, 0);
+ }
+
+ It = GetNewHashPos(MyQItem->MailQEntries, 0);
+ while (GetNextHashPos(MyQItem->MailQEntries, It, &len, &Key, &vQE))
+ {
+ MailQEntry *ThisItem = vQE;
+ int i;
+
+ if (!ThisItem->Active)
+ continue; /* skip already sent ones from the spoolfile. */
+
+ for (i=0; i < ThisItem->nAttempts; i++) {
+ StrBufAppendBufPlain(QMessage, HKEY("\nretry|"), 0);
+ StrBufAppendPrintf(QMessage, "%ld",
+ ThisItem->Attempts[i].retry);
+
+ StrBufAppendBufPlain(QMessage, HKEY("\nattempted|"), 0);
+ StrBufAppendPrintf(QMessage, "%ld",
+ ThisItem->Attempts[i].when);
+ }
+ StrBufAppendBufPlain(QMessage, HKEY("\nremote|"), 0);
+ StrBufAppendBuf(QMessage, ThisItem->Recipient, 0);
+ StrBufAppendBufPlain(QMessage, HKEY("|"), 0);
+ StrBufAppendPrintf(QMessage, "%d", ThisItem->Status);
+ StrBufAppendBufPlain(QMessage, HKEY("|"), 0);
+ StrBufAppendBuf(QMessage, ThisItem->StatusMessage, 0);
+ }
+ DeleteHashPos(&It);
+ StrBufAppendBufPlain(QMessage, HKEY("\n"), 0);
+ return QMessage;
+}
+
+void FinalizeMessageSend(SmtpOutMsg *Msg)
+{
+ int IDestructQueItem;
+ HashPos *It;
+
+ citthread_mutex_lock(&ActiveQItemsLock);
+ Msg->MyQItem->ActiveDeliveries--;
+ IDestructQueItem = Msg->MyQItem->ActiveDeliveries == 0;
+ citthread_mutex_unlock(&ActiveQItemsLock);
+
+ if (IDestructQueItem) {
+ int nRemain;
+ StrBuf *MsgData;
+
+ nRemain = CountActiveQueueEntries(Msg->MyQItem);
+
+ if (nRemain > 0)
+ 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, "");
+
+ /* Generate 'bounce' messages * /
+ smtp_do_bounce(instr); */
+ 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);
+ }
+ It = GetNewHashPos(Msg->MyQItem->MailQEntries, 0);
+ citthread_mutex_lock(&ActiveQItemsLock);
+ {
+ GetHashPosFromKey(ActiveQItems, IKEY(Msg->MyQItem->MessageID), It);
+ DeleteEntryFromHash(ActiveQItems, It);
+ }
+ citthread_mutex_unlock(&ActiveQItemsLock);
+ DeleteHashPos(&It);
+ }
+
+/// TODO : else free message...
+ close(Msg->IO.sock);
+ DeleteSmtpOutMsg(Msg);
+}
+
eReadState SMTP_C_ReadServerStatus(AsyncIO *IO)
{
eReadState Finished = eBufferNotEmpty;
return Finished;
}
-
-
-
/**
* 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)
+StrBuf *smtp_load_msg(OneQueItem *MyQItem)
{
CitContext *CCC=CC;
- SmtpOutMsg *SendMsg;
+ StrBuf *SendMsg;
- SendMsg = (SmtpOutMsg *) malloc(sizeof(SmtpOutMsg));
-
- memset(SendMsg, 0, sizeof(SmtpOutMsg));
- SendMsg->IO.sock = (-1);
-
- 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;
+ CtdlOutputMsg(MyQItem->MessageID, MT_RFC822, HEADERS_ALL, 0, 1, NULL, (ESC_DOT|SUPPRESS_ENV_TO) );
+ SendMsg = CCC->redirect_buffer;
CCC->redirect_buffer = NULL;
- if ((StrLength(SendMsg->msgtext) > 0) &&
- ChrPtr(SendMsg->msgtext)[StrLength(SendMsg->msgtext) - 1] != '\n') {
+ if ((StrLength(SendMsg) > 0) &&
+ ChrPtr(SendMsg)[StrLength(SendMsg) - 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);
+ MsgCount, //yes uncool, but best choice here...
+ ChrPtr(SendMsg)[StrLength(SendMsg) - 1] );
+ StrBufAppendBufPlain(SendMsg, HKEY("\r\n"), 0);
}
-
- safestrncpy(SendMsg->addr, addr, SIZ);
- safestrncpy(SendMsg->envelope_from_buf, envelope_from, 1024);
-
return SendMsg;
}
int i;
/* 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);
return 0;
}
-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_ERROR(WHICH_ERR, ERRSTR) {SendMsg->MyQEntry->Status = WHICH_ERR; StrBufAppendBufPlain(SendMsg->MyQEntry->StatusMessage, HKEY(ERRSTR), 0); return eAbort; }
+#define SMTP_VERROR(WHICH_ERR) { SendMsg->MyQEntry->Status = WHICH_ERR; StrBufAppendBufPlain(SendMsg->MyQEntry->StatusMessage, &ChrPtr(SendMsg->IO.IOBuf)[4], -1, 0); 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 get_one_mx_host_name_done(void *Ctx,
+ int status,
+ int timeouts,
+ struct hostent *hostent)
+{
+ AsyncIO *IO = Ctx;
+ SmtpOutMsg *SendMsg = IO->Data;
+ if ((status == ARES_SUCCESS) && (hostent != NULL) ) {
+
+ SendMsg->IO.HEnt = hostent;
+ InitEventIO(IO, SendMsg,
+ SMTP_C_DispatchReadDone,
+ SMTP_C_DispatchWriteDone,
+ SMTP_C_Terminate,
+ SMTP_C_Timeout,
+ SMTP_C_ConnFail,
+ SMTP_C_ReadServerStatus,
+ 1);
+
+ }
+}
+
+const unsigned short DefaultMXPort = 25;
void connect_one_smtpsrv(SmtpOutMsg *SendMsg)
{
- char *endpart;
- char buf[SIZ];
+ //char *endpart;
+ //char buf[SIZ];
+
+ SendMsg->IO.dport = DefaultMXPort;
- extract_token(buf, SendMsg->mxhosts, SendMsg->n_mx, '|', sizeof(buf));
- strcpy(SendMsg->mx_user, "");
- strcpy(SendMsg->mx_pass, "");
+
+/* TODO: Relay!
+ *SendMsg->mx_user = '\0';
+ *SendMsg->mx_pass = '\0';
if (num_tokens(buf, '@') > 1) {
strcpy (SendMsg->mx_user, buf);
endpart = strrchr(SendMsg->mx_user, '@');
strcpy(SendMsg->mx_pass, endpart+1);
*endpart = '\0';
}
- }
- 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");
}
- 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)
+ else
+*/
+ SendMsg->mx_host = SendMsg->CurrMX->host;
+ SendMsg->CurrMX = SendMsg->CurrMX->next;
+
+ CtdlLogPrintf(CTDL_DEBUG,
+ "SMTP client[%ld]: connecting to %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_name_done,
+ &SendMsg->IO);
+/*
+ if (!QueueQuery(ns_t_a,
+ SendMsg->mx_host,
+ &SendMsg->IO,
+ connect_one_smtpsrv_xamine_result))
{
- 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));
- }
- else {
- snprintf(SendMsg->dsn, SIZ, "Unable to connect to %s : %s\n",
- SendMsg->mx_host, SendMsg->mx_port);
- }
+ /// TODO: abort
}
- /// hier: naechsten mx ausprobieren.
- if (SendMsg->IO.sock < 0) {
- SendMsg->SMTPstatus = 4; /* dsn is already filled in */
- //// hier: abbrechen & bounce.
- return -1;
- }
- 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;
+*/
}
+
eNextState SMTPC_read_greeting(SmtpOutMsg *SendMsg)
{
/* Process the SMTP greeting from the server */
}
/* 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);
- }
- }
+eNextState smtp_resolve_mx_done(void *data)
+{/// VParsedDNSReply
+ AsyncIO *IO = data;
+ SmtpOutMsg * SendMsg = IO->Data;
- if ( (time(NULL) - submitted) > SMTP_GIVE_UP ) {
- give_up = 1;
- }
+ SendMsg->IO.SendBuf.Buf = NewStrBufPlain(NULL, 1024);
+ SendMsg->IO.RecvBuf.Buf = NewStrBufPlain(NULL, 1024);
+ SendMsg->IO.IOBuf = NewStrBuf();
+ SendMsg->IO.ErrMsg = SendMsg->MyQEntry->StatusMessage;
- /* 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);
+ //// connect_one_smtpsrv_xamine_result
+ SendMsg->CurrMX = SendMsg->AllMX = IO->VParsedDNSReply;
+ //// TODO: should we remove the current ares context???
+ connect_one_smtpsrv(SendMsg);
+ return 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;
- }
+int resolve_mx_records(void *Ctx)
+{
+ SmtpOutMsg * SendMsg = Ctx;
- if (bounce_this) {
- ++num_bounces;
+ 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;
+}
- StrBufAppendBufPlain(BounceMB, addr, addrlen, 0);
- StrBufAppendBufPlain(BounceMB, HKEY(": "), 0);
- StrBufAppendBufPlain(BounceMB, dsn, dsnlen, 0);
- StrBufAppendBufPlain(BounceMB, HKEY("\r\n"), 0);
+void smtp_try(OneQueItem *MyQItem,
+ MailQEntry *MyQEntry,
+ StrBuf *MsgText,
+ int KeepMsgText) /* KeepMsgText allows us to use MsgText as ours. */
+{
+ SmtpOutMsg * SendMsg;
- remove_token(instr, i, '\n');
- --i;
- --lines;
- }
- }
+ SendMsg = (SmtpOutMsg *) malloc(sizeof(SmtpOutMsg));
+ memset(SendMsg, 0, sizeof(SmtpOutMsg));
+ SendMsg->IO.sock = (-1);
+ SendMsg->n = MsgCount++;
+ SendMsg->MyQEntry = MyQEntry;
+ SendMsg->MyQItem = MyQItem;
+ SendMsg->IO.Data = SendMsg;
+ if (KeepMsgText)
+ SendMsg->msgtext = MsgText;
+ else
+ SendMsg->msgtext = NewStrBufDup(MsgText);
+
+ smtp_resolve_recipients(SendMsg);
+
+ QueueEventContext(SendMsg,
+ &SendMsg->IO,
+ resolve_mx_records);
+}
- /* 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;
- }
- }
+void NewMailQEntry(OneQueItem *Item)
+{
+ Item->Current = (MailQEntry*) malloc(sizeof(MailQEntry));
+ memset(Item->Current, 0, sizeof(MailQEntry));
- /* If not, post it in the Aide> room */
- if (successful_bounce == 0) {
- CtdlSubmitMsg(bmsg, NULL, config.c_aideroom, QP_EADDR);
- }
+ if (Item->MailQEntries == NULL)
+ Item->MailQEntries = NewHash(1, Flathash);
+ Item->Current->n = GetCount(Item->MailQEntries);
+ Put(Item->MailQEntries, IKEY(Item->Current->n), Item->Current, FreeMailQEntry);
+}
- /* Free up the memory we used */
- if (valid != NULL) {
- free_recipients(valid);
- }
- }
- FreeStrBuf(&boundary);
- CtdlFreeMessage(bmsg);
- CtdlLogPrintf(CTDL_DEBUG, "Done processing bounces\n");
+void QItem_Handle_MsgID(OneQueItem *Item, StrBuf *Line, const char **Pos)
+{
+ Item->MessageID = StrBufExtractNext_int(Line, Pos, '|');
}
+void QItem_Handle_EnvelopeFrom(OneQueItem *Item, StrBuf *Line, const char **Pos)
+{
+ if (Item->EnvelopeFrom == NULL)
+ Item->EnvelopeFrom = NewStrBufPlain(NULL, StrLength(Line));
+ StrBufExtract_NextToken(Item->EnvelopeFrom, Line, Pos, '|');
+}
-/*
- * 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;
- }
+void QItem_Handle_BounceTo(OneQueItem *Item, StrBuf *Line, const char **Pos)
+{
+ if (Item->BounceTo == NULL)
+ Item->BounceTo = NewStrBufPlain(NULL, StrLength(Line));
+ StrBufExtract_NextToken(Item->BounceTo, Line, Pos, '|');
+}
+
+void QItem_Handle_Recipient(OneQueItem *Item, StrBuf *Line, const char **Pos)
+{
+ if (Item->Current == NULL)
+ NewMailQEntry(Item);
+ if (Item->Current->Recipient == NULL)
+ Item->Current->Recipient = NewStrBufPlain(NULL, StrLength(Line));
+ StrBufExtract_NextToken(Item->Current->Recipient, Line, Pos, '|');
+ Item->Current->Status = StrBufExtractNext_int(Line, Pos, '|');
+ StrBufExtract_NextToken(Item->Current->StatusMessage, Line, Pos, '|');
+ Item->Current = NULL; // TODO: is this always right?
+}
- if (completed) {
- remove_token(instr, i, '\n');
- --i;
- --lines;
- }
- }
- return(incomplete);
+void QItem_Handle_retry(OneQueItem *Item, StrBuf *Line, const char **Pos)
+{
+ if (Item->Current == NULL)
+ NewMailQEntry(Item);
+ if (Item->Current->Attempts[Item->Current->nAttempts].retry != 0)
+ Item->Current->nAttempts++;
+ if (Item->Current->nAttempts > MaxAttempts) {
+ Item->FailNow = 1;
+ return;
+ }
+ Item->Current->Attempts[Item->Current->nAttempts].retry = StrBufExtractNext_int(Line, Pos, '|');
}
-void smtp_try(const char *key, const char *addr, int *status,
- char *dsn, size_t n, long msgnum, char *envelope_from)
+void QItem_Handle_Attempted(OneQueItem *Item, StrBuf *Line, const char **Pos)
{
- 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);
+ if (Item->Current == NULL)
+ NewMailQEntry(Item);
+ if (Item->Current->Attempts[Item->Current->nAttempts].when != 0)
+ Item->Current->nAttempts++;
+ if (Item->Current->nAttempts > MaxAttempts) {
+ Item->FailNow = 1;
+ return;
+ }
+
+ Item->Current->Attempts[Item->Current->nAttempts].when = StrBufExtractNext_int(Line, Pos, '|');
+ if (Item->Current->Attempts[Item->Current->nAttempts].when > Item->LastAttempt.when)
+ {
+ Item->LastAttempt.when = Item->Current->Attempts[Item->Current->nAttempts].when;
+ Item->LastAttempt.retry = Item->Current->Attempts[Item->Current->nAttempts].retry * 2;
+ if (Item->LastAttempt.retry > SMTP_RETRY_MAX)
+ Item->LastAttempt.retry = SMTP_RETRY_MAX;
+ }
}
+
+
+
/*
* smtp_do_procmsg()
*
*/
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, "");
+ char *instr = NULL;
+ StrBuf *PlainQItem;
+ OneQueItem *MyQItem;
+ char *pch;
+ HashPos *It;
+ void *vQE;
+ long len;
+ const char *Key;
+
+ CtdlLogPrintf(CTDL_DEBUG, "SMTP Queue: 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);
+ CtdlLogPrintf(CTDL_ERR, "SMTP Queue: tried %ld but no such message!\n", msgnum);
return;
}
- instr = strdup(msg->cm_fields['M']);
- CtdlFreeMessage(msg);
+ pch = instr = msg->cm_fields['M'];
- /* 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;
+ /* Strip out the headers (no not amd any other non-instruction) line */
+ while (pch != NULL) {
+ pch = strchr(pch, '\n');
+ if ((pch != NULL) && (*(pch + 1) == '\n')) {
+ instr = pch + 2;
+ pch = NULL;
}
}
+ PlainQItem = NewStrBufPlain(instr, -1);
+ CtdlFreeMessage(msg);
+ MyQItem = DeserializeQueueItem(PlainQItem, msgnum);
+ FreeStrBuf(&PlainQItem);
- /* 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;
- }
+ if (MyQItem == NULL) {
+ CtdlLogPrintf(CTDL_ERR, "SMTP Queue: Msg No %ld: already in progress!\n", msgnum);
+ return; /* s.b. else is already processing... */
}
/*
* Postpone delivery if we've already tried recently.
* /
- if (((time(NULL) - last_attempted) < retry) && (run_queue_now == 0)) {
+ if (((time(NULL) - MyQItem->LastAttempt.when) < MyQItem->LastAttempt.retry) && (run_queue_now == 0)) {
CtdlLogPrintf(CTDL_DEBUG, "SMTP client: Retry time not yet reached.\n");
- free(instr);
+
+ It = GetNewHashPos(MyQItem->MailQEntries, 0);
+ citthread_mutex_lock(&ActiveQItemsLock);
+ {
+ GetHashPosFromKey(ActiveQItems, IKEY(MyQItem->MessageID), It);
+ DeleteEntryFromHash(ActiveQItems, It);
+ }
+ citthread_mutex_unlock(&ActiveQItemsLock);
+ ////FreeQueItem(&MyQItem); TODO: DeleteEntryFromHash frees this?
+ DeleteHashPos(&It);
return;
- }
-TMP TODO */
+ }// TODO: reenable me.*/
/*
* 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);
+ if (MyQItem->MessageID < 0L) {
+ CtdlLogPrintf(CTDL_ERR, "SMTP Queue: no 'msgid' directive found!\n");
+ It = GetNewHashPos(MyQItem->MailQEntries, 0);
+ citthread_mutex_lock(&ActiveQItemsLock);
+ {
+ GetHashPosFromKey(ActiveQItems, IKEY(MyQItem->MessageID), It);
+ DeleteEntryFromHash(ActiveQItems, It);
+ }
+ citthread_mutex_unlock(&ActiveQItemsLock);
+ DeleteHashPos(&It);
+ ////FreeQueItem(&MyQItem); TODO: DeleteEntryFromHash frees this?
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");
- }
+ It = GetNewHashPos(MyQItem->MailQEntries, 0);
+ while (GetNextHashPos(MyQItem->MailQEntries, It, &len, &Key, &vQE))
+ {
+ MailQEntry *ThisItem = vQE;
+ CtdlLogPrintf(CTDL_DEBUG, "SMTP Queue: Task: <%s> %d\n", ChrPtr(ThisItem->Recipient), ThisItem->Active);
+ }
+ DeleteHashPos(&It);
- --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);
+ CountActiveQueueEntries(MyQItem);
+ if (MyQItem->ActiveDeliveries > 0)
+ {
+ int i = 1;
+ StrBuf *Msg = smtp_load_msg(MyQItem);
+ It = GetNewHashPos(MyQItem->MailQEntries, 0);
+ while ((i <= MyQItem->ActiveDeliveries) &&
+ (GetNextHashPos(MyQItem->MailQEntries, It, &len, &Key, &vQE)))
+ {
+ MailQEntry *ThisItem = vQE;
+ if (ThisItem->Active == 1) {
+ CtdlLogPrintf(CTDL_DEBUG, "SMTP Queue: Trying <%s>\n", ChrPtr(ThisItem->Recipient));
+ smtp_try(MyQItem, ThisItem, Msg, (i == MyQItem->ActiveDeliveries));
+ i++;
}
}
+ DeleteHashPos(&It);
}
+ else
+ {
+ It = GetNewHashPos(MyQItem->MailQEntries, 0);
+ citthread_mutex_lock(&ActiveQItemsLock);
+ {
+ GetHashPosFromKey(ActiveQItems, IKEY(MyQItem->MessageID), It);
+ DeleteEntryFromHash(ActiveQItems, It);
+ }
+ citthread_mutex_unlock(&ActiveQItemsLock);
+ DeleteHashPos(&It);
+ ////FreeQueItem(&MyQItem); TODO: DeleteEntryFromHash frees this?
- 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, "");
- }
+// TODO: bounce & delete?
- /*
- * 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);
}
int num_processed = 0;
struct CitContext smtp_queue_CC;
+ CtdlThreadSleep(10);
+
CtdlFillSystemContext(&smtp_queue_CC, "SMTP Send");
citthread_setspecific(MyConKey, (void *)&smtp_queue_CC);
CtdlLogPrintf(CTDL_DEBUG, "smtp_queue_thread() initializing\n");
SMTPC_send_QUIT
};
+eNextState SMTP_C_Terminate(void *Data)
+{
+ SmtpOutMsg *pMsg = Data;
+ FinalizeMessageSend(pMsg);
+ return 0;
+}
+
+eNextState SMTP_C_Timeout(void *Data)
+{
+ SmtpOutMsg *pMsg = Data;
+ FinalizeMessageSend(pMsg);
+ return 0;
+}
+
+eNextState SMTP_C_ConnFail(void *Data)
+{
+ SmtpOutMsg *pMsg = Data;
+ FinalizeMessageSend(pMsg);
+ return 0;
+}
+
eNextState SMTP_C_DispatchReadDone(void *Data)
{
SmtpOutMsg *pMsg = Data;
}
+void smtp_evc_cleanup(void)
+{
+ DeleteHash(&QItemHandlers);
+ DeleteHash(&ActiveQItems);
+}
#endif
CTDL_MODULE_INIT(smtp_eventclient)
#ifdef EXPERIMENTAL_SMTP_EVENT_CLIENT
if (!threading)
{
+ ActiveQItems = NewHash(1, Flathash);
+ citthread_mutex_init(&ActiveQItemsLock, NULL);
+
+ QItemHandlers = NewHash(0, NULL);
+
+ Put(QItemHandlers, HKEY("msgid"), QItem_Handle_MsgID, reference_free_handler);
+ Put(QItemHandlers, HKEY("envelope_from"), QItem_Handle_EnvelopeFrom, reference_free_handler);
+ Put(QItemHandlers, HKEY("retry"), QItem_Handle_retry, reference_free_handler);
+ Put(QItemHandlers, HKEY("attempted"), QItem_Handle_Attempted, reference_free_handler);
+ Put(QItemHandlers, HKEY("remote"), QItem_Handle_Recipient, reference_free_handler);
+ Put(QItemHandlers, HKEY("bounceto"), QItem_Handle_BounceTo, reference_free_handler);
+///submitted /TODO: flush qitemhandlers on exit
+
+
smtp_init_spoolout();
+
+ CtdlRegisterCleanupHook(smtp_evc_cleanup);
CtdlThreadCreate("SMTPEvent Send", CTDLTHREAD_BIGSTACK, smtp_queue_thread, NULL);
CtdlRegisterProtoHook(cmd_smtp, "SMTP", "SMTP utility commands");
projects / citadel.git / blobdiff