webcit/smtpqueue.c

   1
   2 /*
   3  * Display the outbound SMTP queue
   4  */
   5
   6 #include "webcit.h"
   7 CtxType CTX_MAILQITEM = CTX_NONE;
   8 CtxType CTX_MAILQ_RCPT = CTX_NONE;
   9 HashList *QItemHandlers = NULL;
  10
  11
  12
  13 typedef struct _mailq_entry {
  14         StrBuf *Recipient;
  15         StrBuf *StatusMessage;
  16         int Status;
  17
  18         /**<
  19          * 0 = No delivery has yet been attempted
  20          * 2 = Delivery was successful
  21          * 3 = Transient error like connection problem. Try next remote if available.
  22          * 4 = A transient error was experienced ... try again later
  23          * 5 = Delivery to this address failed permanently.  The error message
  24          *     should be placed in the fourth field so that a bounce message may
  25          *     be generated.
  26          */
  27
  28         int n;
  29         int Active;
  30 } MailQEntry;
  31
  32 typedef struct queueitem {
  33         long MessageID;
  34         long QueMsgID;
  35         long Submitted;
  36         int FailNow;
  37         HashList *MailQEntries;
  38
  39 /* copy of the currently parsed item in the MailQEntries list;
  40  * if null add a new one.
  41  */
  42         MailQEntry *Current;
  43         time_t ReattemptWhen;
  44         time_t Retry;
  45
  46         long ActiveDeliveries;
  47         StrBuf *EnvelopeFrom;
  48         StrBuf *BounceTo;
  49         StrBuf *SenderRoom;
  50         ParsedURL *URL;
  51         ParsedURL *FallBackHost;
  52 } OneQueItem;
  53
  54
  55 typedef void (*QItemHandler)(OneQueItem * Item, StrBuf * Line, const char **Pos);
  56
  57 typedef struct __QItemHandlerStruct {
  58         QItemHandler H;
  59 } QItemHandlerStruct;
  60
  61 void RegisterQItemHandler(const char *Key, long Len, QItemHandler H) {
  62         QItemHandlerStruct *HS = (QItemHandlerStruct *) malloc(sizeof(QItemHandlerStruct));
  63         HS->H = H;
  64         Put(QItemHandlers, Key, Len, HS, NULL);
  65 }
  66
  67 void FreeMailQEntry(void *qv) {
  68         MailQEntry *Q = qv;
  69         FreeStrBuf(&Q->Recipient);
  70         FreeStrBuf(&Q->StatusMessage);
  71         free(Q);
  72 }
  73 void FreeQueItem(OneQueItem ** Item) {
  74         DeleteHash(&(*Item)->MailQEntries);
  75         FreeStrBuf(&(*Item)->EnvelopeFrom);
  76         FreeStrBuf(&(*Item)->BounceTo);
  77         FreeStrBuf(&(*Item)->SenderRoom);
  78         FreeURL(&(*Item)->URL);
  79         free(*Item);
  80         Item = NULL;
  81 }
  82 void HFreeQueItem(void *Item) {
  83         FreeQueItem((OneQueItem **) & Item);
  84 }
  85
  86
  87 OneQueItem *DeserializeQueueItem(StrBuf * RawQItem, long QueMsgID) {
  88         OneQueItem *Item;
  89         const char *pLine = NULL;
  90         StrBuf *Line;
  91         StrBuf *Token;
  92
  93         Item = (OneQueItem *) malloc(sizeof(OneQueItem));
  94         memset(Item, 0, sizeof(OneQueItem));
  95         Item->Retry = 0;
  96         Item->MessageID = -1;
  97         Item->QueMsgID = QueMsgID;
  98
  99         Token = NewStrBuf();
 100         Line = NewStrBufPlain(NULL, 128);
 101         while (pLine != StrBufNOTNULL) {
 102                 const char *pItemPart = NULL;
 103                 void *vHandler;
 104
 105                 StrBufExtract_NextToken(Line, RawQItem, &pLine, '\n');
 106                 if (StrLength(Line) == 0)
 107                         continue;
 108                 StrBufExtract_NextToken(Token, Line, &pItemPart, '|');
 109                 if (GetHash(QItemHandlers, SKEY(Token), &vHandler)) {
 110                         QItemHandlerStruct *HS;
 111                         HS = (QItemHandlerStruct *) vHandler;
 112                         HS->H(Item, Line, &pItemPart);
 113                 }
 114         }
 115         FreeStrBuf(&Line);
 116         FreeStrBuf(&Token);
 117
 118 /*
 119         Put(ActiveQItems,
 120             LKEY(Item->MessageID),
 121             Item,
 122             HFreeQueItem);
 123 */
 124
 125         return Item;
 126 }
 127
 128 void tmplput_MailQID(StrBuf * Target, WCTemplputParams * TP) {
 129         OneQueItem *Item = (OneQueItem *) CTX(CTX_MAILQITEM);
 130         StrBufAppendPrintf(Target, "%ld", Item->QueMsgID);;
 131 }
 132 void tmplput_MailQPayloadID(StrBuf * Target, WCTemplputParams * TP) {
 133         OneQueItem *Item = (OneQueItem *) CTX(CTX_MAILQITEM);
 134         StrBufAppendPrintf(Target, "%ld", Item->MessageID);
 135 }
 136 void tmplput_MailQBounceTo(StrBuf * Target, WCTemplputParams * TP) {
 137         OneQueItem *Item = (OneQueItem *) CTX(CTX_MAILQITEM);
 138         StrBufAppendTemplate(Target, TP, Item->BounceTo, 0);
 139 }
 140 void tmplput_MailQAttempted(StrBuf * Target, WCTemplputParams * TP) {
 141         char datebuf[64];
 142         OneQueItem *Item = (OneQueItem *) CTX(CTX_MAILQITEM);
 143         webcit_fmt_date(datebuf, 64, Item->ReattemptWhen, DATEFMT_BRIEF);
 144         StrBufAppendBufPlain(Target, datebuf, -1, 0);
 145 }
 146 void tmplput_MailQSubmitted(StrBuf * Target, WCTemplputParams * TP) {
 147         char datebuf[64];
 148         OneQueItem *Item = (OneQueItem *) CTX(CTX_MAILQITEM);
 149         webcit_fmt_date(datebuf, 64, Item->Submitted, DATEFMT_BRIEF);
 150         StrBufAppendBufPlain(Target, datebuf, -1, 0);
 151 }
 152 void tmplput_MailQEnvelopeFrom(StrBuf * Target, WCTemplputParams * TP) {
 153         OneQueItem *Item = (OneQueItem *) CTX(CTX_MAILQITEM);
 154         StrBufAppendTemplate(Target, TP, Item->EnvelopeFrom, 0);
 155 }
 156 void tmplput_MailQSourceRoom(StrBuf * Target, WCTemplputParams * TP) {
 157         OneQueItem *Item = (OneQueItem *) CTX(CTX_MAILQITEM);
 158         StrBufAppendTemplate(Target, TP, Item->SenderRoom, 0);
 159 }
 160
 161 int Conditional_MailQ_HaveSourceRoom(StrBuf * Target, WCTemplputParams * TP) {
 162         OneQueItem *Item = (OneQueItem *) CTX(CTX_MAILQITEM);
 163         return StrLength(Item->SenderRoom) > 0;
 164 }
 165
 166 void tmplput_MailQRetry(StrBuf * Target, WCTemplputParams * TP) {
 167         char datebuf[64];
 168         OneQueItem *Item = (OneQueItem *) CTX(CTX_MAILQITEM);
 169
 170         if (Item->Retry == 0) {
 171                 StrBufAppendBufPlain(Target, _("First Attempt pending"), -1, 0);
 172         }
 173         else {
 174                 webcit_fmt_date(datebuf, sizeof(datebuf), Item->Retry, DATEFMT_BRIEF);
 175                 StrBufAppendBufPlain(Target, datebuf, -1, 0);
 176         }
 177 }
 178
 179 void tmplput_MailQRCPT(StrBuf * Target, WCTemplputParams * TP) {
 180         MailQEntry *Entry = (MailQEntry *) CTX(CTX_MAILQ_RCPT);
 181         StrBufAppendTemplate(Target, TP, Entry->Recipient, 0);
 182 }
 183 void tmplput_MailQRCPTStatus(StrBuf * Target, WCTemplputParams * TP) {
 184         MailQEntry *Entry = (MailQEntry *) CTX(CTX_MAILQ_RCPT);
 185         StrBufAppendPrintf(Target, "%ld", Entry->Status);
 186 }
 187 void tmplput_MailQStatusMsg(StrBuf * Target, WCTemplputParams * TP) {
 188         MailQEntry *Entry = (MailQEntry *) CTX(CTX_MAILQ_RCPT);
 189         StrBufAppendTemplate(Target, TP, Entry->StatusMessage, 0);
 190 }
 191
 192 HashList *iterate_get_Recipients(StrBuf * Target, WCTemplputParams * TP) {
 193         OneQueItem *Item = (OneQueItem *) CTX(CTX_MAILQITEM);
 194         return Item->MailQEntries;
 195 }
 196
 197
 198 void NewMailQEntry(OneQueItem * Item) {
 199         Item->Current = (MailQEntry *) malloc(sizeof(MailQEntry));
 200         memset(Item->Current, 0, sizeof(MailQEntry));
 201
 202         if (Item->MailQEntries == NULL)
 203                 Item->MailQEntries = NewHash(1, Flathash);
 204         Item->Current->StatusMessage = NewStrBuf();
 205         Item->Current->n = GetCount(Item->MailQEntries);
 206         Put(Item->MailQEntries, IKEY(Item->Current->n), Item->Current, FreeMailQEntry);
 207 }
 208
 209 void QItem_Handle_MsgID(OneQueItem * Item, StrBuf * Line, const char **Pos) {
 210         Item->MessageID = StrBufExtractNext_long(Line, Pos, '|');
 211 }
 212
 213 void QItem_Handle_EnvelopeFrom(OneQueItem * Item, StrBuf * Line, const char **Pos) {
 214         if (Item->EnvelopeFrom == NULL)
 215                 Item->EnvelopeFrom = NewStrBufPlain(NULL, StrLength(Line));
 216         StrBufExtract_NextToken(Item->EnvelopeFrom, Line, Pos, '|');
 217 }
 218
 219 void QItem_Handle_BounceTo(OneQueItem * Item, StrBuf * Line, const char **Pos) {
 220         if (Item->BounceTo == NULL)
 221                 Item->BounceTo = NewStrBufPlain(NULL, StrLength(Line));
 222         StrBufExtract_NextToken(Item->BounceTo, Line, Pos, '|');
 223 }
 224
 225 void QItem_Handle_SenderRoom(OneQueItem * Item, StrBuf * Line, const char **Pos) {
 226         if (Item->SenderRoom == NULL)
 227                 Item->SenderRoom = NewStrBufPlain(NULL, StrLength(Line));
 228         StrBufExtract_NextToken(Item->SenderRoom, Line, Pos, '|');
 229 }
 230
 231 void QItem_Handle_Recipient(OneQueItem * Item, StrBuf * Line, const char **Pos) {
 232         const char *pch;
 233         if (Item->Current == NULL)
 234                 NewMailQEntry(Item);
 235         if (Item->Current->Recipient == NULL)
 236                 Item->Current->Recipient = NewStrBufPlain(NULL, StrLength(Line));
 237         StrBufExtract_NextToken(Item->Current->Recipient, Line, Pos, '|');
 238         Item->Current->Status = StrBufExtractNext_int(Line, Pos, '|');
 239         StrBufExtract_NextToken(Item->Current->StatusMessage, Line, Pos, '|');
 240
 241         pch = ChrPtr(Item->Current->StatusMessage);
 242         while ((pch != NULL) && (*pch != '\0')) {
 243                 pch = strchr(pch, ';');
 244                 if (pch != NULL) {
 245                         pch++;
 246                         if (*pch == ' ') {
 247                                 StrBufPeek(Item->Current->StatusMessage, pch, -1, '\n');
 248                         }
 249                 }
 250         }
 251         Item->Current = NULL;   // TODO: is this always right?
 252 }
 253
 254
 255 void QItem_Handle_retry(OneQueItem * Item, StrBuf * Line, const char **Pos) {
 256         Item->Retry = StrBufExtractNext_int(Line, Pos, '|');
 257 }
 258
 259
 260 void QItem_Handle_Submitted(OneQueItem * Item, StrBuf * Line, const char **Pos) {
 261         Item->Submitted = atol(*Pos);
 262
 263 }
 264
 265 void QItem_Handle_Attempted(OneQueItem * Item, StrBuf * Line, const char **Pos) {
 266         Item->ReattemptWhen = StrBufExtractNext_int(Line, Pos, '|');
 267 }
 268
 269
 270
 271
 272 void render_QUEUE(StrBuf * Target, WCTemplputParams * TP, StrBuf * FoundCharset) {
 273         wc_mime_attachment *Mime = CTX(CTX_MIME_ATACH);
 274         WCTemplputParams SubTP;
 275         OneQueItem *Context;
 276
 277         Context = DeserializeQueueItem(Mime->Data, Mime->msgnum);
 278         StackContext(TP, &SubTP, Context, CTX_MAILQITEM, 0, TP->Tokens);
 279         {
 280                 DoTemplate(HKEY("view_mailq_message"), NULL, &SubTP);
 281         }
 282         UnStackContext(&SubTP);
 283
 284         FreeQueItem(&Context);
 285 }
 286
 287 void ServerShutdownModule_SMTP_QUEUE(void) {
 288         DeleteHash(&QItemHandlers);
 289 }
 290
 291 void ServerStartModule_SMTP_QUEUE(void) {
 292         QItemHandlers = NewHash(0, NULL);
 293 }
 294
 295 int qview_PrintPageHeader(SharedMessageStatus * Stat, void **ViewSpecific) {
 296         if (yesbstr("ListOnly"))
 297                 output_headers(1, 0, 0, 0, 0, 0);
 298         else
 299                 output_headers(1, 1, 1, 0, 0, 0);
 300         return 0;
 301 }
 302
 303 int qview_GetParamsGetServerCall(SharedMessageStatus * Stat,
 304                                  void **ViewSpecific, long oper, char *cmd, long len, char *filter, long flen) {
 305         if (!WC->is_aide) {
 306                 DoTemplate(HKEY("aide_required"), NULL, NULL);
 307                 end_burst();
 308
 309                 return 300;
 310         }
 311         else {
 312                 snprintf(cmd, len, "MSGS ALL|0|1");
 313                 snprintf(filter, flen, "SUBJ|QMSG");
 314                 if (yesbstr("ListOnly"))
 315                         DoTemplate(HKEY("view_mailq_table"), NULL, NULL);
 316                 else
 317                         DoTemplate(HKEY("view_mailq_header"), NULL, NULL);
 318                 return 200;
 319         }
 320 }
 321
 322 /*
 323  * Display task view
 324  */
 325 int qview_LoadMsgFromServer(SharedMessageStatus * Stat, void **ViewSpecific, message_summary * Msg, int is_new, int i) {
 326         wcsession *WCC = WC;
 327         const StrBuf *Mime;
 328
 329         /* Not (yet?) needed here? calview *c = (calview *) *ViewSpecific; */
 330         read_message(WCC->WBuf, HKEY("view_mailq_message_bearer"), Msg->msgnum, NULL, &Mime, NULL);
 331
 332         return 0;
 333 }
 334
 335
 336 int qview_RenderView_or_Tail(SharedMessageStatus * Stat, void **ViewSpecific, long oper) {
 337         wcsession *WCC = WC;
 338         WCTemplputParams SubTP;
 339
 340         memset(&SubTP, 0, sizeof(WCTemplputParams));
 341         if (yesbstr("ListOnly"))
 342                 DoTemplate(HKEY("view_mailq_footer_listonly"), NULL, &SubTP);
 343         else {
 344                 if (GetCount(WCC->summ) == 0)
 345                         DoTemplate(HKEY("view_mailq_footer_empty"), NULL, &SubTP);
 346                 else
 347                         DoTemplate(HKEY("view_mailq_footer"), NULL, &SubTP);
 348         }
 349
 350         return 0;
 351 }
 352 int qview_Cleanup(void **ViewSpecific) {
 353
 354         wDumpContent(yesbstr("ListOnly") ? 0 : 1);
 355         return 0;
 356 }
 357
 358 void InitModule_SMTP_QUEUE(void) {
 359         RegisterCTX(CTX_MAILQITEM);
 360         RegisterCTX(CTX_MAILQ_RCPT);
 361
 362         RegisterQItemHandler(HKEY("msgid"), QItem_Handle_MsgID);
 363         RegisterQItemHandler(HKEY("envelope_from"), QItem_Handle_EnvelopeFrom);
 364         RegisterQItemHandler(HKEY("retry"), QItem_Handle_retry);
 365         RegisterQItemHandler(HKEY("attempted"), QItem_Handle_Attempted);
 366         RegisterQItemHandler(HKEY("remote"), QItem_Handle_Recipient);
 367         RegisterQItemHandler(HKEY("bounceto"), QItem_Handle_BounceTo);
 368         RegisterQItemHandler(HKEY("source_room"), QItem_Handle_SenderRoom);
 369         RegisterQItemHandler(HKEY("submitted"), QItem_Handle_Submitted);
 370         RegisterMimeRenderer(HKEY("application/x-citadel-delivery-list"), render_QUEUE, 1, 9000);
 371         RegisterNamespace("MAILQ:ID", 0, 0, tmplput_MailQID, NULL, CTX_MAILQITEM);
 372         RegisterNamespace("MAILQ:PAYLOAD:ID", 0, 0, tmplput_MailQPayloadID, NULL, CTX_MAILQITEM);
 373         RegisterNamespace("MAILQ:BOUNCETO", 0, 1, tmplput_MailQBounceTo, NULL, CTX_MAILQITEM);
 374         RegisterNamespace("MAILQ:ATTEMPTED", 0, 0, tmplput_MailQAttempted, NULL, CTX_MAILQITEM);
 375         RegisterNamespace("MAILQ:SUBMITTED", 0, 0, tmplput_MailQSubmitted, NULL, CTX_MAILQITEM);
 376         RegisterNamespace("MAILQ:ENVELOPEFROM", 0, 1, tmplput_MailQEnvelopeFrom, NULL, CTX_MAILQITEM);
 377         RegisterNamespace("MAILQ:SRCROOM", 0, 1, tmplput_MailQSourceRoom, NULL, CTX_MAILQITEM);
 378         RegisterConditional("COND:MAILQ:HAVESRCROOM", 0, Conditional_MailQ_HaveSourceRoom, CTX_MAILQITEM);
 379         RegisterNamespace("MAILQ:RETRY", 0, 0, tmplput_MailQRetry, NULL, CTX_MAILQITEM);
 380
 381         RegisterNamespace("MAILQ:RCPT:ADDR", 0, 1, tmplput_MailQRCPT, NULL, CTX_MAILQ_RCPT);
 382         RegisterNamespace("MAILQ:RCPT:STATUS", 0, 0, tmplput_MailQRCPTStatus, NULL, CTX_MAILQ_RCPT);
 383         RegisterNamespace("MAILQ:RCPT:STATUSMSG", 0, 1, tmplput_MailQStatusMsg, NULL, CTX_MAILQ_RCPT);
 384
 385         RegisterIterator("MAILQ:RCPT", 0, NULL, iterate_get_Recipients, NULL, NULL, CTX_MAILQ_RCPT, CTX_MAILQITEM, IT_NOFLAG);
 386
 387
 388         RegisterReadLoopHandlerset(VIEW_QUEUE, qview_GetParamsGetServerCall, qview_PrintPageHeader, NULL,       /* TODO: is this right? */
 389                                    NULL, qview_LoadMsgFromServer, qview_RenderView_or_Tail, qview_Cleanup, NULL);
 390
 391 }