X-Git-Url: https://code.citadel.org/?a=blobdiff_plain;f=citadel%2Fmodules%2Fsmtp%2Fserv_smtpqueue.c;h=2f7c3a5905cbe2a16596f17baeaf161ed26b65e2;hb=c153881665bf42b19c50f25554c099ff4ad7795a;hp=72b73bf1a27580410c0739ebcdc3a3d2cde3b8e0;hpb=f76f3c0605ef8837dbba97014c1381365f3a82ba;p=citadel.git diff --git a/citadel/modules/smtp/serv_smtpqueue.c b/citadel/modules/smtp/serv_smtpqueue.c index 72b73bf1a..2f7c3a590 100644 --- a/citadel/modules/smtp/serv_smtpqueue.c +++ b/citadel/modules/smtp/serv_smtpqueue.c @@ -20,21 +20,21 @@ * The VRFY and EXPN commands have been removed from this implementation * because nobody uses these commands anymore, except for spammers. * - * Copyright (c) 1998-2009 by the citadel.org team + * Copyright (c) 1998-2012 by the citadel.org team * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. + * This program is open source software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 3. + * + * * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * + * */ #include "sysdep.h" @@ -86,6 +86,7 @@ #include "ctdl_module.h" #include "smtpqueue.h" +#include "smtp_clienthandlers.h" #include "event_client.h" @@ -93,11 +94,23 @@ struct CitContext smtp_queue_CC; pthread_mutex_t ActiveQItemsLock; HashList *ActiveQItems = NULL; HashList *QItemHandlers = NULL; +int max_sessions_for_outbound_smtp = 500; /* how many sessions might be active till we stop adding more smtp jobs */ +int ndelay_count = 50; /* every n queued messages we will sleep... */ +int delay_msec = 5000; /* this many seconds. */ static const long MaxRetry = SMTP_RETRY_INTERVAL * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2; int MsgCount = 0; int run_queue_now = 0; /* Set to 1 to ignore SMTP send retry times */ +void RegisterQItemHandler(const char *Key, long Len, QItemHandler H) +{ + QItemHandlerStruct *HS = (QItemHandlerStruct*)malloc(sizeof(QItemHandlerStruct)); + HS->H = H; + Put(QItemHandlers, Key, Len, HS, NULL); +} + + + void smtp_try_one_queue_entry(OneQueItem *MyQItem, MailQEntry *MyQEntry, StrBuf *MsgText, @@ -129,6 +142,22 @@ int DecreaseQReference(OneQueItem *MyQItem) return IDestructQueItem; } +void DecreaseShutdownDeliveries(OneQueItem *MyQItem) +{ + pthread_mutex_lock(&ActiveQItemsLock); + MyQItem->NotYetShutdownDeliveries--; + pthread_mutex_unlock(&ActiveQItemsLock); +} + +int GetShutdownDeliveries(OneQueItem *MyQItem) +{ + int DestructNow; + + pthread_mutex_lock(&ActiveQItemsLock); + DestructNow = MyQItem->ActiveDeliveries == 0; + pthread_mutex_unlock(&ActiveQItemsLock); + return DestructNow; +} void RemoveQItem(OneQueItem *MyQItem) { long len; @@ -142,13 +171,13 @@ void RemoveQItem(OneQueItem *MyQItem) DeleteEntryFromHash(ActiveQItems, It); else { - syslog(LOG_WARNING, - "SMTP cleanup: unable to find QItem with ID[%ld]", - MyQItem->MessageID); + SMTPC_syslog(LOG_WARNING, + "unable to find QItem with ID[%ld]", + MyQItem->MessageID); while (GetNextHashPos(ActiveQItems, It, &len, &Key, &VData)) - syslog(LOG_WARNING, - "SMTP cleanup: have_: ID[%ld]", - ((OneQueItem *)VData)->MessageID); + SMTPC_syslog(LOG_WARNING, + "have_: ID[%ld]", + ((OneQueItem *)VData)->MessageID); } pthread_mutex_unlock(&ActiveQItemsLock); DeleteHashPos(&It); @@ -158,16 +187,28 @@ void RemoveQItem(OneQueItem *MyQItem) void FreeMailQEntry(void *qv) { MailQEntry *Q = qv; +/* + SMTPC_syslog(LOG_DEBUG, "---------------%s--------------", __FUNCTION__); + cit_backtrace(); +*/ FreeStrBuf(&Q->Recipient); FreeStrBuf(&Q->StatusMessage); + + memset(Q, 0, sizeof(MailQEntry)); free(Q); } void FreeQueItem(OneQueItem **Item) { +/* + SMTPC_syslog(LOG_DEBUG, "---------------%s--------------", __FUNCTION__); + cit_backtrace(); +*/ DeleteHash(&(*Item)->MailQEntries); FreeStrBuf(&(*Item)->EnvelopeFrom); FreeStrBuf(&(*Item)->BounceTo); + FreeStrBuf(&(*Item)->SenderRoom); FreeURL(&(*Item)->URL); + memset(*Item, 0, sizeof(OneQueItem)); free(*Item); Item = NULL; } @@ -181,6 +222,29 @@ void HFreeQueItem(void *Item) * - 3/4 (transient errors * were experienced and it's time to try again) */ +int CheckQEntryActive(MailQEntry *ThisItem) +{ + if ((ThisItem->Status == 0) || + (ThisItem->Status == 3) || + (ThisItem->Status == 4)) + { + return 1; + } + else + return 0; +} +int CheckQEntryIsBounce(MailQEntry *ThisItem) +{ + if ((ThisItem->Status == 3) || + (ThisItem->Status == 4) || + (ThisItem->Status == 5)) + { + return 1; + } + else + return 0; +} + int CountActiveQueueEntries(OneQueItem *MyQItem) { HashPos *It; @@ -194,9 +258,8 @@ int CountActiveQueueEntries(OneQueItem *MyQItem) while (GetNextHashPos(MyQItem->MailQEntries, It, &len, &Key, &vQE)) { MailQEntry *ThisItem = vQE; - if ((ThisItem->Status == 0) || - (ThisItem->Status == 3) || - (ThisItem->Status == 4)) + + if (CheckQEntryActive(ThisItem)) { ActiveDeliveries++; ThisItem->Active = 1; @@ -233,9 +296,9 @@ OneQueItem *DeserializeQueueItem(StrBuf *RawQItem, long QueMsgID) StrBufExtract_NextToken(Token, Line, &pItemPart, '|'); if (GetHash(QItemHandlers, SKEY(Token), &vHandler)) { - QItemHandler H; - H = (QItemHandler) vHandler; - H(Item, Line, &pItemPart); + QItemHandlerStruct *HS; + HS = (QItemHandlerStruct*) vHandler; + HS->H(Item, Line, &pItemPart); } } FreeStrBuf(&Line); @@ -293,24 +356,24 @@ StrBuf *SerializeQueueItem(OneQueItem *MyQItem) StrBufAppendBuf(QMessage, MyQItem->EnvelopeFrom, 0); } + if (StrLength(MyQItem->SenderRoom) > 0) { + StrBufAppendBufPlain(QMessage, HKEY("\nsource_room|"), 0); + StrBufAppendBuf(QMessage, MyQItem->SenderRoom, 0); + } + StrBufAppendBufPlain(QMessage, HKEY("\nretry|"), 0); StrBufAppendPrintf(QMessage, "%ld", MyQItem->Retry); StrBufAppendBufPlain(QMessage, HKEY("\nattempted|"), 0); StrBufAppendPrintf(QMessage, "%ld", - MyQItem->ReattemptWhen); + time(NULL) /*ctdl_ev_now()*/ + MyQItem->Retry); It = GetNewHashPos(MyQItem->MailQEntries, 0); while (GetNextHashPos(MyQItem->MailQEntries, It, &len, &Key, &vQE)) { MailQEntry *ThisItem = vQE; - if (!ThisItem->Active) - { - /* skip already sent ones from the spoolfile. */ - continue; - } StrBufAppendBufPlain(QMessage, HKEY("\nremote|"), 0); StrBufAppendBuf(QMessage, ThisItem->Recipient, 0); StrBufAppendBufPlain(QMessage, HKEY("|"), 0); @@ -334,7 +397,8 @@ void NewMailQEntry(OneQueItem *Item) if (Item->MailQEntries == NULL) Item->MailQEntries = NewHash(1, Flathash); - Item->Current->StatusMessage = NewStrBuf(); + /* alocate big buffer so we won't get problems reallocating later. */ + Item->Current->StatusMessage = NewStrBufPlain(NULL, SIZ); Item->Current->n = GetCount(Item->MailQEntries); Put(Item->MailQEntries, IKEY(Item->Current->n), @@ -361,6 +425,13 @@ void QItem_Handle_BounceTo(OneQueItem *Item, StrBuf *Line, const char **Pos) StrBufExtract_NextToken(Item->BounceTo, Line, Pos, '|'); } +void QItem_Handle_SenderRoom(OneQueItem *Item, StrBuf *Line, const char **Pos) +{ + if (Item->SenderRoom == NULL) + Item->SenderRoom = NewStrBufPlain(NULL, StrLength(Line)); + StrBufExtract_NextToken(Item->SenderRoom, Line, Pos, '|'); +} + void QItem_Handle_Recipient(OneQueItem *Item, StrBuf *Line, const char **Pos) { if (Item->Current == NULL) @@ -378,7 +449,10 @@ void QItem_Handle_retry(OneQueItem *Item, StrBuf *Line, const char **Pos) { Item->Retry = StrBufExtractNext_int(Line, Pos, '|'); - Item->Retry *= 2; + if (Item->Retry == 0) + Item->Retry = SMTP_RETRY_INTERVAL; + else + Item->Retry *= 2; } @@ -413,11 +487,11 @@ StrBuf *smtp_load_msg(OneQueItem *MyQItem, int n) CCC->redirect_buffer = NULL; if ((StrLength(SendMsg) > 0) && ChrPtr(SendMsg)[StrLength(SendMsg) - 1] != '\n') { - syslog(LOG_WARNING, - "SMTP client[%d]: Possible problem: message did not " - "correctly terminate. (expecting 0x10, got 0x%02x)\n", - MsgCount, //yes uncool, but best choice here... - ChrPtr(SendMsg)[StrLength(SendMsg) - 1] ); + SMTPC_syslog(LOG_WARNING, + "[%d] Possible problem: message did not " + "correctly terminate. (expecting 0x10, got 0x%02x)\n", + MsgCount, //yes uncool, but best choice here... + ChrPtr(SendMsg)[StrLength(SendMsg) - 1] ); StrBufAppendBufPlain(SendMsg, HKEY("\r\n"), 0); } return SendMsg; @@ -439,36 +513,46 @@ void smtpq_do_bounce(OneQueItem *MyQItem, StrBuf *OMsgTxt) StrBuf *Msg = NULL; StrBuf *BounceMB; struct recptypes *valid; + time_t now; HashPos *It; void *vQE; long len; const char *Key; + int first_attempt = 0; int successful_bounce = 0; int num_bounces = 0; int give_up = 0; - syslog(LOG_DEBUG, "smtp_do_bounce() called\n"); + SMTPCM_syslog(LOG_DEBUG, "smtp_do_bounce() called\n"); + + if (MyQItem->SendBounceMail == 0) + return; + + now = time (NULL); //ev_time(); + + if ( (now - MyQItem->Submitted) > SMTP_GIVE_UP ) { + give_up = 1; + } - if ( (ev_time() - MyQItem->Submitted) > SMTP_GIVE_UP ) { - give_up = 1;/// TODO: replace time by libevq timer get + if (MyQItem->Retry == SMTP_RETRY_INTERVAL) { + first_attempt = 1; } /* * Now go through the instructions checking for stuff. */ + Msg = NewStrBufPlain(NULL, 1024); It = GetNewHashPos(MyQItem->MailQEntries, 0); while (GetNextHashPos(MyQItem->MailQEntries, It, &len, &Key, &vQE)) { MailQEntry *ThisItem = vQE; - if ((ThisItem->Status == 5) || /* failed now? */ - ((give_up == 1) && - (ThisItem->Status != 2))) + if ((ThisItem->Active && (ThisItem->Status == 5)) || /* failed now? */ + ((give_up == 1) && (ThisItem->Status != 2)) || + ((first_attempt == 1) && (ThisItem->Status != 2))) /* giving up after failed attempts... */ { - if (num_bounces == 0) - Msg = NewStrBufPlain(NULL, 1024); ++num_bounces; StrBufAppendBuf(Msg, ThisItem->Recipient, 0); @@ -480,7 +564,7 @@ void smtpq_do_bounce(OneQueItem *MyQItem, StrBuf *OMsgTxt) DeleteHashPos(&It); /* Deliver the bounce if there's anything worth mentioning */ - syslog(LOG_DEBUG, "num_bounces = %d\n", num_bounces); + SMTPC_syslog(LOG_DEBUG, "num_bounces = %d\n", num_bounces); if (num_bounces == 0) { FreeStrBuf(&Msg); @@ -502,7 +586,7 @@ void smtpq_do_bounce(OneQueItem *MyQItem, StrBuf *OMsgTxt) StrLength(OMsgTxt)); /* the original message */ if (BounceMB == NULL) { FreeStrBuf(&boundary); - syslog(LOG_ERR, "Failed to alloc() bounce message.\n"); + SMTPCM_syslog(LOG_ERR, "Failed to alloc() bounce message.\n"); return; } @@ -511,7 +595,7 @@ void smtpq_do_bounce(OneQueItem *MyQItem, StrBuf *OMsgTxt) if (bmsg == NULL) { FreeStrBuf(&boundary); FreeStrBuf(&BounceMB); - syslog(LOG_ERR, "Failed to alloc() bounce message.\n"); + SMTPCM_syslog(LOG_ERR, "Failed to alloc() bounce message.\n"); return; } @@ -552,8 +636,19 @@ void smtpq_do_bounce(OneQueItem *MyQItem, StrBuf *OMsgTxt) StrBufAppendBuf(BounceMB, Msg, 0); FreeStrBuf(&Msg); + if (StrLength(MyQItem->SenderRoom) > 0) + { + StrBufAppendBufPlain( + BounceMB, + HKEY("The message was originaly posted in: "), 0); + StrBufAppendBuf(BounceMB, MyQItem->SenderRoom, 0); + StrBufAppendBufPlain( + BounceMB, + HKEY("\n"), 0); + } + /* Attach the original message */ - StrBufAppendBufPlain(BounceMB, HKEY("--"), 0); + StrBufAppendBufPlain(BounceMB, HKEY("\r\n--"), 0); StrBufAppendBuf(BounceMB, boundary, 0); StrBufAppendBufPlain(BounceMB, HKEY("\r\n"), 0); StrBufAppendBufPlain(BounceMB, @@ -581,11 +676,13 @@ void smtpq_do_bounce(OneQueItem *MyQItem, StrBuf *OMsgTxt) bmsg->cm_fields['M'] = SmashStrBuf(&BounceMB); /* First try the user who sent the message */ - if (StrLength(MyQItem->BounceTo) == 0) - syslog(LOG_ERR, "No bounce address specified\n"); - else - syslog(LOG_DEBUG, "bounce to user? <%s>\n", + if (StrLength(MyQItem->BounceTo) == 0) { + SMTPCM_syslog(LOG_ERR, "No bounce address specified\n"); + } + else { + SMTPC_syslog(LOG_DEBUG, "bounce to user? <%s>\n", ChrPtr(MyQItem->BounceTo)); + } /* Can we deliver the bounce to the original sender? */ valid = validate_recipients(ChrPtr(MyQItem->BounceTo), NULL, 0); @@ -603,7 +700,7 @@ void smtpq_do_bounce(OneQueItem *MyQItem, StrBuf *OMsgTxt) free_recipients(valid); FreeStrBuf(&boundary); CtdlFreeMessage(bmsg); - syslog(LOG_DEBUG, "Done processing bounces\n"); + SMTPCM_syslog(LOG_DEBUG, "Done processing bounces\n"); } /* @@ -612,6 +709,8 @@ void smtpq_do_bounce(OneQueItem *MyQItem, StrBuf *OMsgTxt) * Called by smtp_do_queue() to handle an individual message. */ void smtp_do_procmsg(long msgnum, void *userdata) { + time_t now; + int mynumsessions = num_sessions; struct CtdlMessage *msg = NULL; char *instr = NULL; StrBuf *PlainQItem; @@ -626,12 +725,19 @@ void smtp_do_procmsg(long msgnum, void *userdata) { int HaveBuffers = 0; StrBuf *Msg =NULL; - syslog(LOG_DEBUG, "SMTP Queue: smtp_do_procmsg(%ld)\n", msgnum); + if (mynumsessions > max_sessions_for_outbound_smtp) { + SMTPC_syslog(LOG_DEBUG, + "skipping because of num jobs %d > %d max_sessions_for_outbound_smtp", + mynumsessions, + max_sessions_for_outbound_smtp); + } + + SMTPC_syslog(LOG_DEBUG, "smtp_do_procmsg(%ld)\n", msgnum); ///strcpy(envelope_from, ""); msg = CtdlFetchMessage(msgnum, 1); if (msg == NULL) { - syslog(LOG_ERR, "SMTP Queue: tried %ld but no such message!\n", + SMTPC_syslog(LOG_ERR, "tried %ld but no such message!\n", msgnum); return; } @@ -652,19 +758,23 @@ void smtp_do_procmsg(long msgnum, void *userdata) { FreeStrBuf(&PlainQItem); if (MyQItem == NULL) { - syslog(LOG_ERR, - "SMTP Queue: Msg No %ld: already in progress!\n", - msgnum); + SMTPC_syslog(LOG_ERR, + "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) - MyQItem->ReattemptWhen) > 0) && + now = time(NULL); + if ((MyQItem->ReattemptWhen != 0) && + (now < MyQItem->ReattemptWhen) && (run_queue_now == 0)) { - syslog(LOG_DEBUG, "SMTP client: Retry time not yet reached.\n"); + SMTPC_syslog(LOG_DEBUG, + "Retry time not yet reached. %ld seconds left.", + MyQItem->ReattemptWhen - now); It = GetNewHashPos(MyQItem->MailQEntries, 0); pthread_mutex_lock(&ActiveQItemsLock); @@ -686,7 +796,7 @@ void smtp_do_procmsg(long msgnum, void *userdata) { * Bail out if there's no actual message associated with this */ if (MyQItem->MessageID < 0L) { - syslog(LOG_ERR, "SMTP Queue: no 'msgid' directive found!\n"); + SMTPCM_syslog(LOG_ERR, "no 'msgid' directive found!\n"); It = GetNewHashPos(MyQItem->MailQEntries, 0); pthread_mutex_lock(&ActiveQItemsLock); { @@ -719,10 +829,11 @@ void smtp_do_procmsg(long msgnum, void *userdata) { !IsEmptyStr(Pos))) { StrBufExtract_NextToken(One, All, &Pos, '|'); - if (!ParseURL(Url, One, 25)) - syslog(LOG_DEBUG, - "Failed to parse: %s\n", - ChrPtr(One)); + if (!ParseURL(Url, One, 25)) { + SMTPC_syslog(LOG_DEBUG, + "Failed to parse: %s\n", + ChrPtr(One)); + } else { ///if (!Url->IsIP)) // todo dupe me fork ipv6 Url = &(*Url)->Next; @@ -746,10 +857,11 @@ void smtp_do_procmsg(long msgnum, void *userdata) { !IsEmptyStr(Pos))) { StrBufExtract_NextToken(One, All, &Pos, '|'); - if (!ParseURL(Url, One, 25)) - syslog(LOG_DEBUG, - "Failed to parse: %s\n", - ChrPtr(One)); + if (!ParseURL(Url, One, 25)) { + SMTPC_syslog(LOG_DEBUG, + "Failed to parse: %s\n", + ChrPtr(One)); + } else Url = &(*Url)->Next; } @@ -762,15 +874,40 @@ void smtp_do_procmsg(long msgnum, void *userdata) { while (GetNextHashPos(MyQItem->MailQEntries, It, &len, &Key, &vQE)) { MailQEntry *ThisItem = vQE; - syslog(LOG_DEBUG, "SMTP Queue: Task: <%s> %d\n", - ChrPtr(ThisItem->Recipient), - ThisItem->Active); + SMTPC_syslog(LOG_DEBUG, "SMTP Queue: Task: <%s> %d\n", + ChrPtr(ThisItem->Recipient), + ThisItem->Active); } DeleteHashPos(&It); + MyQItem->NotYetShutdownDeliveries = MyQItem->ActiveDeliveries = CountActiveQueueEntries(MyQItem); + + /* failsafe against overload: + * will we exceed the limit set? + */ + if ((MyQItem->ActiveDeliveries + mynumsessions > max_sessions_for_outbound_smtp) && + /* if yes, did we reach more than half of the quota? */ + ((mynumsessions * 2) > max_sessions_for_outbound_smtp) && + /* if... would we ever fit into half of the quota?? */ + (((MyQItem->ActiveDeliveries * 2) < max_sessions_for_outbound_smtp))) + { + /* abort delivery for another time. */ + SMTPC_syslog(LOG_DEBUG, + "SMTP Queue: skipping because of num jobs %d + %ld > %d max_sessions_for_outbound_smtp", + mynumsessions, + MyQItem->ActiveDeliveries, + max_sessions_for_outbound_smtp); + + FreeQueItem(&MyQItem); + + return; + } + + if (MyQItem->ActiveDeliveries > 0) { + int nActivated = 0; int n = MsgCount++; int m = MyQItem->ActiveDeliveries; int i = 1; @@ -785,13 +922,19 @@ void smtp_do_procmsg(long msgnum, void *userdata) { if (ThisItem->Active == 1) { int KeepBuffers = (i == m); + + nActivated++; + if (nActivated % ndelay_count == 0) + usleep(delay_msec); + if (i > 1) n = MsgCount++; syslog(LOG_DEBUG, - "SMTPQ: Trying <%ld> <%s> %d / %d \n", + "SMTPC: Trying <%ld> <%s> %d / %d \n", MyQItem->MessageID, ChrPtr(ThisItem->Recipient), i, m); + (*((int*) userdata)) ++; smtp_try_one_queue_entry(MyQItem, ThisItem, Msg, @@ -823,19 +966,18 @@ void smtp_do_procmsg(long msgnum, void *userdata) { const char* Key; void *VData; - syslog(LOG_WARNING, - "SMTP cleanup: unable to find " - "QItem with ID[%ld]", - MyQItem->MessageID); + SMTPC_syslog(LOG_WARNING, + "unable to find QItem with ID[%ld]", + MyQItem->MessageID); while (GetNextHashPos(ActiveQItems, It, &len, &Key, &VData)) { - syslog(LOG_WARNING, - "SMTP cleanup: have: ID[%ld]", - ((OneQueItem *)VData)->MessageID); + SMTPC_syslog(LOG_WARNING, + "have: ID[%ld]", + ((OneQueItem *)VData)->MessageID); } } @@ -863,16 +1005,17 @@ void smtp_do_procmsg(long msgnum, void *userdata) { void smtp_do_queue(void) { static int is_running = 0; int num_processed = 0; + int num_activated = 0; if (is_running) return; /* Concurrency check - only one can run */ is_running = 1; pthread_setspecific(MyConKey, (void *)&smtp_queue_CC); - syslog(LOG_INFO, "SMTP client: processing outbound queue"); + SMTPCM_syslog(LOG_INFO, "processing outbound queue"); if (CtdlGetRoom(&CC->room, SMTP_SPOOLOUT_ROOM) != 0) { - syslog(LOG_ERR, "Cannot find room <%s>", SMTP_SPOOLOUT_ROOM); + SMTPC_syslog(LOG_ERR, "Cannot find room <%s>", SMTP_SPOOLOUT_ROOM); } else { num_processed = CtdlForEachMessage(MSGS_ALL, @@ -881,11 +1024,11 @@ void smtp_do_queue(void) { SPOOLMIME, NULL, smtp_do_procmsg, - NULL); + &num_activated); } - syslog(LOG_INFO, - "SMTP client: queue run completed; %d messages processed", - num_processed); + SMTPC_syslog(LOG_INFO, + "queue run completed; %d messages processed %d activated", + num_processed, num_activated); run_queue_now = 0; is_running = 0; @@ -903,7 +1046,7 @@ void smtp_init_spoolout(void) { * 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); + CtdlCreateRoom(SMTP_SPOOLOUT_ROOM, 3, "", 0, 1, 0, VIEW_QUEUE); /* * Make sure it's set to be a "system room" so it doesn't show up @@ -961,25 +1104,43 @@ void cmd_smtp(char *argbuf) { CTDL_MODULE_INIT(smtp_queu) { + char *pstr; + if (!threading) { + pstr = getenv("CITSERVER_n_session_max"); + if ((pstr != NULL) && (*pstr != '\0')) + max_sessions_for_outbound_smtp = atol(pstr); /* how many sessions might be active till we stop adding more smtp jobs */ + + pstr = getenv("CITSERVER_smtp_n_delay_count"); + if ((pstr != NULL) && (*pstr != '\0')) + ndelay_count = atol(pstr); /* every n queued messages we will sleep... */ + + pstr = getenv("CITSERVER_smtp_delay"); + if ((pstr != NULL) && (*pstr != '\0')) + delay_msec = atol(pstr) * 1000; /* this many seconds. */ + + + + CtdlFillSystemContext(&smtp_queue_CC, "SMTP_Send"); ActiveQItems = NewHash(1, lFlathash); pthread_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); - Put(QItemHandlers, HKEY("submitted"), QItem_Handle_Submitted, reference_free_handler); + RegisterQItemHandler(HKEY("msgid"), QItem_Handle_MsgID); + RegisterQItemHandler(HKEY("envelope_from"), QItem_Handle_EnvelopeFrom); + RegisterQItemHandler(HKEY("retry"), QItem_Handle_retry); + RegisterQItemHandler(HKEY("attempted"), QItem_Handle_Attempted); + RegisterQItemHandler(HKEY("remote"), QItem_Handle_Recipient); + RegisterQItemHandler(HKEY("bounceto"), QItem_Handle_BounceTo); + RegisterQItemHandler(HKEY("source_room"), QItem_Handle_SenderRoom); + RegisterQItemHandler(HKEY("submitted"), QItem_Handle_Submitted); smtp_init_spoolout(); - CtdlRegisterCleanupHook(smtp_evq_cleanup); + CtdlRegisterEVCleanupHook(smtp_evq_cleanup); CtdlRegisterProtoHook(cmd_smtp, "SMTP", "SMTP utility commands"); CtdlRegisterSessionHook(smtp_do_queue, EVT_TIMER);