webcit/smtpqueue.c

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