#include "ctdl_module.h"
#include "smtpqueue.h"
+#include "smtp_clienthandlers.h"
#include "event_client.h"
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,
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;
void FreeMailQEntry(void *qv)
{
MailQEntry *Q = qv;
+/*
+ syslog(LOG_DEBUG, "---------------%s--------------", __FUNCTION__);
+ cit_backtrace();
+*/
FreeStrBuf(&Q->Recipient);
FreeStrBuf(&Q->StatusMessage);
+
+ memset(Q, 0, sizeof(MailQEntry));
free(Q);
}
void FreeQueItem(OneQueItem **Item)
{
+/*
+ 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;
}
* - 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;
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;
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);
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);
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)
{
Item->Retry =
StrBufExtractNext_int(Line, Pos, '|');
- Item->Retry *= 2;
+ if (Item->Retry == 0)
+ Item->Retry = SMTP_RETRY_INTERVAL;
+ else
+ Item->Retry *= 2;
}
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");
- if ( (ev_time() - MyQItem->Submitted) > SMTP_GIVE_UP ) {
- give_up = 1;/// TODO: replace time by libevq timer get
+ if (MyQItem->SendBounceMail == 0)
+ return;
+
+ now = time (NULL); //ev_time();
+
+ if ( (now - MyQItem->Submitted) > SMTP_GIVE_UP ) {
+ give_up = 1;
+ }
+
+ 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);
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,
* 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;
/*
* Postpone delivery if we've already tried recently.
*/
+ now = time(NULL);
if ((MyQItem->ReattemptWhen != 0) &&
- (time(NULL) < MyQItem->ReattemptWhen) &&
+ (now < MyQItem->ReattemptWhen) &&
(run_queue_now == 0))
{
- syslog(LOG_DEBUG, "SMTP client: Retry time not yet reached.\n");
+ syslog(LOG_DEBUG, "SMTP client: Retry time not yet reached. %ld seconds left.", MyQItem->ReattemptWhen - now);
It = GetNewHashPos(MyQItem->MailQEntries, 0);
pthread_mutex_lock(&ActiveQItemsLock);
}
DeleteHashPos(&It);
+ MyQItem->NotYetShutdownDeliveries =
MyQItem->ActiveDeliveries = CountActiveQueueEntries(MyQItem);
/* failsafe against overload:
ChrPtr(ThisItem->Recipient),
i,
m);
+ (*((int*) userdata)) ++;
smtp_try_one_queue_entry(MyQItem,
ThisItem,
Msg,
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,
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;
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);