/[imapfilter]/imapfilter/request.c
ViewVC logotype

Contents of /imapfilter/request.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.44 - (show annotations)
Thu Mar 6 15:00:46 2003 UTC (21 years ago) by lefcha
Branch: MAIN
Changes since 1.43: +101 -5 lines
File MIME type: text/plain
Add support for date conversion specifiers for current and message time in mailbox names.

1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <string.h>
4 #include <errno.h>
5
6 #include "config.h"
7 #include "imapfilter.h"
8 #include "data.h"
9
10
11 extern int sockpri, sockaux;
12 extern unsigned int options;
13 extern char charset[CHARSET_LEN];
14 extern unsigned int capabilities;
15
16 namesp_t nsppri, nspaux; /* Primary and auxiliary namespace. */
17
18
19 #ifdef DEBUG
20 /*
21 * Test/ping server.
22 */
23 int
24 test(int *sock)
25 {
26 return server_response(sock, imap_noop(sock));
27 }
28
29 #endif
30
31
32 /*
33 * Check server's capabilities.
34 */
35 int
36 check_capabilities(int *sock)
37 {
38 capabilities = CAPABILITY_NONE;
39
40 return capability_response(sock, imap_capability(sock));
41 }
42
43
44 /*
45 * Get namespace of mail server's mailboxes.
46 */
47 int
48 check_namespace(int *sock, namesp_t * nsp)
49 {
50 nsp->prefix[0] = nsp->delim = '\0';
51
52 if (!(options & OPTION_NAMESPACE) ||
53 !(capabilities & CAPABILITY_NAMESPACE))
54 return 0;
55 else
56 return namespace_response(sock, imap_namespace(sock), nsp);
57 }
58
59
60 /*
61 * Login to server.
62 */
63 int
64 login(int *sock, char *user, char *pass)
65 {
66 return server_response(sock, imap_login(sock, user, pass));
67 }
68
69
70
71 /*
72 * Check if a mailbox exists.
73 */
74 int
75 check_mailbox(int *sock, char *mbox, namesp_t * nsp)
76 {
77 return server_response(sock, imap_examine(sock,
78 apply_namespace(mbox, nsp->prefix, nsp->delim)));
79 }
80
81
82 /*
83 * Open mailbox in read-write mode.
84 */
85 int
86 select_mailbox(int *sock, char *mbox, namesp_t * nsp)
87 {
88 int r;
89
90 if (mailbox_status(sock, mbox, nsp) == -2)
91 return -2; /* No messages exist. No filters need to be
92 * applied. */
93
94 r = select_response(sock, imap_select(sock,
95 apply_namespace(mbox, nsp->prefix,
96 nsp->delim)));
97
98 log_info(LOG_MAILBOX, mbox);
99
100 return r;
101 }
102
103
104 /*
105 * Get mailbox's status.
106 */
107 int
108 mailbox_status(int *sock, char *mbox, namesp_t * nsp)
109 {
110 return status_response(sock, imap_status(sock,
111 apply_namespace(mbox, nsp->prefix, nsp->delim),
112 "MESSAGES RECENT UNSEEN"), mbox);
113 }
114
115
116 /*
117 * Close examined/selected mailbox.
118 */
119 int
120 close_mailbox(int *sock)
121 {
122 return server_response(sock, imap_close(sock));
123 }
124
125
126 /*
127 * Logout from server.
128 */
129 int
130 logout(int *sock)
131 {
132 return logout_response(sock, imap_logout(sock));
133 }
134
135
136 /*
137 * Match and apply filters assigned to a mailbox.
138 */
139 int
140 apply_filters(filter_t ** filters)
141 {
142 int i;
143 char *mesgs;
144
145 for (i = 0; filters[i] != NULL; i++) {
146 mesgs = NULL;
147
148 if (match_filter(filters[i], &mesgs))
149 continue;
150
151 log_info(LOG_FILTER, filters[i]->key);
152
153 apply_action(mesgs, &(filters[i]->action.type),
154 filters[i]->action.raccount, filters[i]->action.destmbox,
155 &filters[i]->action.msgflags, filters[i]->action.args);
156
157 xfree(mesgs);
158 }
159
160 return 0;
161 }
162
163
164 /*
165 * Generate the search request by the masks of the filter and try to
166 * match the generated filter.
167 */
168 int
169 match_filter(filter_t * filter, char **mesgs)
170 {
171 char *search;
172
173 if (filter->mode == FILTER_MODE_OR)
174 search = generate_filter_or(filter->masks, filter->masknum,
175 filter->masklen);
176 else
177 search = generate_filter_and(filter->masks, filter->masknum,
178 filter->masklen);
179
180 search_response(&sockpri, imap_search(&sockpri, charset, search),
181 mesgs);
182
183 xfree(search);
184
185 if (*mesgs == '\0')
186 return 1;
187
188 return 0;
189 }
190
191
192 /*
193 * Empty the FIFO inventory.
194 */
195 void
196 empty_fifo(mask_t ** mfifo)
197 {
198 mfifo[0] = NULL;
199
200 queue_fifo(NULL, NULL);
201 dequeue_fifo(NULL);
202 }
203
204
205 /*
206 * Add item to FIFO inventory.
207 */
208 void
209 queue_fifo(mask_t ** mfifo, mask_t * mask)
210 {
211 static unsigned int i;
212
213 if (mfifo == NULL) {
214 i = 0;
215 return;
216 }
217 mfifo[i++] = mask;
218 mfifo[i] = NULL;
219 }
220
221
222 /*
223 * Get next item from FIFO inventory.
224 */
225 mask_t *
226 dequeue_fifo(mask_t ** mfifo)
227 {
228 static unsigned int j;
229
230 if (mfifo == NULL) {
231 j = 0;
232 return NULL;
233 }
234 return mfifo[j++];
235 }
236
237
238 /*
239 * Generate the filter search command from the masks, assuming that
240 * masks are AND-ed.
241 */
242 char *
243 generate_filter_and(mask_t * mask, unsigned int masknum,
244 unsigned int masklen)
245 {
246 const unsigned int searchbuf = masklen + masknum * 6 + 8;
247 unsigned int len;
248 char *search;
249 mask_t *tmp;
250
251 len = 0;
252
253 search = (char *)xmalloc(sizeof(char) * searchbuf);
254 search[0] = '\0';
255
256 tmp = mask;
257 if (tmp == NULL) {
258 strncat(search, "ALL ", searchbuf - len - 1);
259 len += 4;
260 } else
261 while ((tmp = tmp->next) != NULL) {
262 if (tmp->type != MASK_TYPE_OR) {
263 strncat(search, "ALL ", searchbuf - len - 1);
264 len += 4;
265 break;
266 }
267 }
268
269 tmp = NULL;
270 while (mask != NULL) {
271 tmp = mask;
272 mask = mask->next;
273
274 if (mask != NULL && mask->type == MASK_TYPE_OR) {
275 strncat(search, "OR (", searchbuf - len - 1);
276 len += 4;
277
278 strncat(search, tmp->body, searchbuf - len - 1);
279 len = strlen(search);
280 search[len] = ' ';
281 search[++len] = '\0';
282
283 search[len - 1] = ')';
284 search[len] = ' ';
285 search[++len] = '\0';
286
287 if (mask->next == NULL ||
288 mask->next->type != MASK_TYPE_OR) {
289 search[len] = '(';
290 search[++len] = '\0';
291 strncat(search, mask->body,
292 searchbuf - len - 1);
293 len = strlen(search);
294 search[len] = ')';
295 search[++len] = ' ';
296 search[++len] = '\0';
297 mask = mask->next;
298 }
299 } else {
300 strncat(search, tmp->body, searchbuf - len - 1);
301 len = strlen(search);
302 search[len] = ' ';
303 search[++len] = '\0';
304 }
305 }
306
307 search[len - 1] = '\0';
308
309 return search;
310 }
311
312
313 /*
314 * Generate the filter search command from the masks, assuming that
315 * masks are OR-ed.
316 */
317 char *
318 generate_filter_or(mask_t * mask, unsigned int masknum,
319 unsigned int masklen)
320 {
321 const unsigned int searchbuf = masklen + masknum * 6 + 8;
322 unsigned int len;
323 char *search;
324 mask_t **mfifo; /* Mailbox FIFO queue. */
325 mask_t *mf; /* Mask returned from FIFO. */
326
327 len = 0;
328
329 search = (char *)xmalloc(sizeof(char) * searchbuf);
330 mfifo = (mask_t **) xmalloc(sizeof(mask_t *) * (masknum + 1));
331
332 search[0] = '\0';
333 empty_fifo(mfifo);
334
335 strncat(search, "ALL ", searchbuf - len - 1);
336 len += 4;
337
338 while (mask != NULL) {
339 queue_fifo(mfifo, mask);
340 mask = mask->next;
341
342 while (mask != NULL && mask->type == MASK_TYPE_AND) {
343 queue_fifo(mfifo, mask);
344 mask = mask->next;
345 }
346
347 if (mask != NULL) {
348 if (len == 4 && search[0] == 'A') {
349 search[0] = '\0';
350 len = 0;
351 }
352 strncat(search, "OR ", searchbuf - len - 1);
353 len += 3;
354 }
355 if (search[0] != 'A') {
356 search[len] = '(';
357 search[++len] = '\0';
358 }
359 while ((mf = dequeue_fifo(mfifo)) != NULL) {
360 strncat(search, mf->body, searchbuf - len - 1);
361 len = strlen(search);
362 search[len] = ' ';
363 search[++len] = '\0';
364 }
365
366 if (strchr(search, '(')) {
367 search[len - 1] = ')';
368 search[len] = ' ';
369 search[++len] = '\0';
370 }
371 empty_fifo(mfifo);
372 }
373
374 search[len - 1] = '\0';
375
376 xfree(mfifo);
377
378 return search;
379 }
380
381
382 /*
383 * Apply the appropriate action.
384 */
385 int
386 apply_action(char *mesgs, unsigned int *type, account_t * raccount,
387 char *destmbox, unsigned int *msgflags, char *args)
388 {
389 unsigned int cnt;
390
391 if (*mesgs == '\0')
392 return 0;
393
394 log_info(LOG_ACTION, type);
395 log_info(LOG_DESTINATION_ACCOUNT, raccount->key);
396 log_info(LOG_DESTINATION_MAILBOX, destmbox);
397
398 cnt = count_messages(mesgs);
399
400 switch (*type) {
401 case FILTER_ACTION_DELETE:
402 info("%d message%s deleted.\n", cnt, plural(cnt));
403 action_delete(mesgs, args);
404 break;
405 case FILTER_ACTION_COPY:
406 info("%d message%s copied to mailbox \"%s\".\n", cnt,
407 plural(cnt), destmbox);
408 action_copy(mesgs, apply_namespace(destmbox, nsppri.prefix,
409 nsppri.delim), args);
410 break;
411 case FILTER_ACTION_MOVE:
412 info("%d message%s moved to mailbox \"%s\".\n", cnt,
413 plural(cnt), destmbox);
414 action_move(mesgs, apply_namespace(destmbox, nsppri.prefix,
415 nsppri.delim), args);
416 break;
417 case FILTER_ACTION_RCOPY:
418 info("%d message%s copied to mailbox \"%s\" at account %s.\n",
419 cnt, plural(cnt), destmbox, raccount->key);
420 action_rcopy(mesgs, raccount, destmbox, args);
421 break;
422 case FILTER_ACTION_RMOVE:
423 info("%d message%s moved to mailbox \"%s\" at account %s.\n",
424 cnt, plural(cnt), destmbox, raccount->key);
425 action_rmove(mesgs, raccount, destmbox, args);
426 break;
427 case FILTER_ACTION_FLAG_REPLACE:
428 case FILTER_ACTION_FLAG_ADD:
429 case FILTER_ACTION_FLAG_REMOVE:
430 info("%d message%s flagged.\n", cnt, plural(cnt));
431 action_flag(mesgs, type, msgflags, args);
432 break;
433 case FILTER_ACTION_LIST:
434 info("%d message%s listed.\n", cnt, plural(cnt));
435 action_list(mesgs, args);
436 break;
437 }
438
439 if (*args == '\0')
440 log_info(LOG_WRITE, NULL);
441
442 return 0;
443 }
444
445
446 /*
447 * Delete messages and optionally list some of their headers.
448 */
449 int
450 action_delete(char *mesgs, char *args)
451 {
452 char *tok, *m, *mcp;
453
454 action_list(mesgs, args);
455
456 m = mcp = convert_messages(mesgs);
457
458 tok = strtok_r(m, " ", &m);
459 while (tok) {
460 server_response(&sockpri, imap_store(&sockpri, tok,
461 STORE_FLAG_ADD, "\\Deleted"));
462
463 tok = strtok_r(NULL, " ", &m);
464 }
465
466 if (options & OPTION_EXPUNGE)
467 server_response(&sockpri, imap_expunge(&sockpri));
468
469 xfree(mcp);
470
471 return 0;
472 }
473
474
475 /*
476 * Copy messages to specified mailbox.
477 */
478 int
479 action_copy(char *mesgs, char *destmbox, char *args)
480 {
481 int r;
482 char *tok, *mcp, *m;
483 char dm[MBOX_NAME_LEN];
484
485 r = 0;
486 tok = NULL;
487
488 action_list(mesgs, args);
489
490 if (strchr(destmbox, '@'))
491 m = mcp = xstrdup(mesgs);
492 else
493 m = mcp = convert_messages(mesgs);
494
495 tok = strtok_r(m, " ", &m);
496 while (tok != NULL) {
497 xstrncpy(dm, destmbox, MBOX_NAME_LEN - 1);
498 current_date(dm);
499 message_date(tok, dm);
500
501 if ((r = copy_response(&sockpri, imap_copy(&sockpri, tok,
502 dm))) == RESPONSE_TRYCREATE)
503 if (!server_response(&sockpri, imap_create(&sockpri,
504 dm))) {
505 if ((options & OPTION_SUBSCRIBE))
506 server_response(&sockpri,
507 imap_subscribe(&sockpri, dm));
508 r = copy_response(&sockpri,
509 imap_copy(&sockpri, tok, dm));
510 }
511 tok = strtok_r(NULL, " ", &m);
512 }
513
514 xfree(mcp);
515
516 return r;
517 }
518
519
520 /*
521 * Move messages to specified mailbox.
522 */
523 int
524 action_move(char *mesgs, char *destmbox, char *args)
525 {
526 if (!action_copy(mesgs, destmbox, args))
527 action_delete(mesgs, "\0");
528
529 return 0;
530 }
531
532
533 /*
534 * Copy messages to the specified mailbox of another mail server.
535 */
536 int
537 action_rcopy(char *mesgs, account_t * destacc, char *destmbox, char *args)
538 {
539 int r, ta, tf;
540 char *tok, *m, *mcp, *ndm;
541 unsigned int n;
542 char buf[RESPONSE_BUF * 2];
543
544 if (init_connection(&sockaux, destacc->server, destacc->port,
545 destacc->ssl))
546 return ERROR_NETWORK;
547
548 r = greeting_response(&sockaux);
549
550 if (r == RESPONSE_BYE || check_capabilities(&sockaux))
551 return ERROR_NETWORK;
552
553 #ifdef DEBUG
554 test(&sockaux);
555 #endif
556
557 if (r != RESPONSE_PREAUTH) {
558 if (destacc->passwdattr == PASSWORD_NONE) {
559 printf("Enter password for %s@%s: ", destacc->username,
560 destacc->server);
561 get_password(destacc->password, PASSWORD_LEN);
562 destacc->passwdattr = PASSWORD_PLAIN;
563 }
564 if (login(&sockaux, destacc->username,
565 destacc->password) == RESPONSE_NO) {
566 error("username %s or password rejected at %s\n",
567 destacc->username, destacc->server);
568 return ERROR_NETWORK;
569 }
570 }
571 check_namespace(&sockaux, &nspaux);
572
573 /* apply_namespace() returns a pointer to a static buffer. */
574 ndm = apply_namespace(destmbox, nspaux.prefix, nspaux.delim);
575
576 r = check_mailbox(&sockaux, destmbox, &nspaux);
577
578 if (r == RESPONSE_OK)
579 close_mailbox(&sockaux);
580 else if (r == RESPONSE_NO) {
581 server_response(&sockaux, imap_create(&sockaux, ndm));
582 if ((options & OPTION_SUBSCRIBE))
583 server_response(&sockaux, imap_subscribe(&sockaux,
584 ndm));
585 }
586 m = mcp = xstrdup(mesgs);
587
588 tok = strtok_r(m, " ", &m);
589 while (tok != NULL) {
590 fetchsize_response(&sockpri, &n,
591 imap_fetch(&sockpri, tok, "RFC822.SIZE"));
592
593 ta = imap_append(&sockaux, ndm, n);
594
595 fetch_response(&sockpri, 0, 1, NULL);
596 tf = imap_fetch(&sockpri, tok, "RFC822.HEADER");
597 do {
598 r = fetch_response(&sockpri, tf, 0, buf);
599 socket_write(&sockaux, buf);
600 } while (r == RESPONSE_NONE);
601
602 socket_write(&sockaux, "\r\n");
603
604 fetch_response(&sockpri, 0, 1, NULL);
605 tf = imap_fetch(&sockpri, tok, "BODY[TEXT]");
606 do {
607 r = fetch_response(&sockpri, tf, 0, buf);
608 if (r != RESPONSE_NULLBODY)
609 socket_write(&sockaux, buf);
610 } while (r == RESPONSE_NONE);
611
612 if (r != RESPONSE_NULLBODY)
613 socket_write(&sockaux, "\r\n\r\n");
614 else
615 socket_write(&sockaux, "\r\n");
616
617 append_response(&sockaux, ta);
618
619 tok = strtok_r(NULL, " ", &m);
620 }
621
622 logout(&sockaux);
623
624 action_list(mesgs, args);
625
626 xfree(mcp);
627
628 return 0;
629 }
630
631
632 /*
633 * Move messages to the specified mailbox of another mail server.
634 */
635 int
636 action_rmove(char *mesgs, account_t * destacc, char *destmbox, char *args)
637 {
638 if (!action_rcopy(mesgs, destacc, destmbox, args))
639 action_delete(mesgs, "\0");
640
641 return 0;
642 }
643
644
645 /*
646 * Flag messages by replacing, adding or removing specified flags.
647 */
648 int
649 action_flag(char *mesgs, unsigned int *type, unsigned int *msgflags,
650 char *args)
651 {
652 unsigned int t;
653 char s[STORE_FLAGS_BUF];
654 char *tok, *m, *mcp;
655
656 *s = 0;
657
658 switch (*type) {
659 case FILTER_ACTION_FLAG_ADD:
660 t = STORE_FLAG_ADD;
661 break;
662 case FILTER_ACTION_FLAG_REMOVE:
663 t = STORE_FLAG_REMOVE;
664 break;
665 default:
666 t = STORE_FLAG_REPLACE;
667 }
668
669 if ((*msgflags != MESSAGE_FLAG_NONE)) {
670 if ((*msgflags & MESSAGE_FLAG_SEEN))
671 strncat(s, "\\Seen ", STORE_FLAGS_BUF - strlen(s) - 1);
672 if ((*msgflags & MESSAGE_FLAG_ANSWERED))
673 strncat(s, "\\Answered ",
674 STORE_FLAGS_BUF - strlen(s) - 1);
675 if ((*msgflags & MESSAGE_FLAG_FLAGGED))
676 strncat(s, "\\Flagged ",
677 STORE_FLAGS_BUF - strlen(s) - 1);
678 if ((*msgflags & MESSAGE_FLAG_DELETED))
679 strncat(s, "\\Deleted ",
680 STORE_FLAGS_BUF - strlen(s) - 1);
681 if ((*msgflags & MESSAGE_FLAG_DRAFT))
682 strncat(s, "\\Draft", STORE_FLAGS_BUF - strlen(s) - 1);
683 if ((s[strlen(s) - 1] == ' '))
684 s[strlen(s) - 1] = 0;
685 }
686 action_list(mesgs, args);
687
688 m = mcp = convert_messages(mesgs);
689
690 tok = strtok_r(m, " ", &m);
691 while (tok != NULL) {
692 server_response(&sockpri, imap_store(&sockpri, tok, t, s));
693
694 tok = strtok_r(NULL, " ", &m);
695 }
696
697 if (options & OPTION_EXPUNGE)
698 server_response(&sockpri, imap_expunge(&sockpri));
699
700 xfree(mcp);
701
702 return 0;
703 }
704
705 /*
706 * List user selected headers of messages.
707 */
708 int
709 action_list(char *mesgs, char *args)
710 {
711 int r, t;
712 char *tok, *mcp, *m;
713 char s[ARGS_LEN + 27];
714 char hdrs[RESPONSE_BUF];
715
716 if (*args == '\0')
717 return 0;
718
719 m = mcp = xstrdup(mesgs);
720
721 snprintf(s, ARGS_LEN + 27 - 1, "BODY.PEEK[HEADER.FIELDS (%s)]", args);
722
723 tok = strtok_r(m, " ", &m);
724 while (tok != NULL) {
725 /* Reset internal fetch counter. */
726 fetch_response(&sockpri, 0, 1, NULL);
727 t = imap_fetch(&sockpri, tok, s);
728 do {
729 r = fetch_response(&sockpri, t, 0, hdrs);
730 } while (r == RESPONSE_NONE);
731
732 if (*hdrs != '\0') {
733 if (options & OPTION_HEADERS)
734 info("%s\n", hdrs);
735 log_info(LOG_WRITE, hdrs);
736 } else {
737 log_info(LOG_WRITE, NULL);
738 }
739
740 tok = strtok_r(NULL, " ", &m);
741 }
742
743 xfree(mcp);
744
745 return 0;
746 }
747
748
749 /*
750 * Count how many messages matched the filter.
751 */
752 unsigned int
753 count_messages(char *mesgs)
754 {
755 unsigned int cnt;
756 char *c;
757
758 cnt = 0;
759 c = mesgs;
760
761 while ((c = strchr(c, ' '))) {
762 cnt++;
763 c++;
764 }
765
766 return ++cnt;
767 }
768
769
770 /*
771 * Convert messages with contiguous sequence number to the corresponding
772 * number range, eg. 1 2 3 5 7 8 --> 1:3 5 7:8 and return a newly allocated
773 * buffer with the results.
774 */
775 char *
776 convert_messages(char *mesgs)
777 {
778 int maxlen;
779 unsigned int start, end, tmp;
780 char *c, *cp, *tail;
781
782 start = end = tmp = 0;
783 maxlen = strlen(mesgs) + 1;
784 tail = NULL;
785
786 c = cp = xstrdup(mesgs);
787
788 start = (unsigned int)strtoul(mesgs, &tail, 10);
789 end = start;
790
791 do {
792 if (tail != NULL) {
793 tmp = (unsigned int)strtoul(tail, &tail, 10);
794 if (tmp == 0)
795 tail = NULL;
796 }
797 if (tmp == end + 1)
798 end++;
799 else {
800 if (start == end) {
801 xstrncpy(c, ultostr(start, 10), maxlen);
802 c += strlen(c);
803 } else {
804 xstrncpy(c, ultostr(start, 10), maxlen - 1);
805 c += strlen(c);
806 *c = ':';
807 *++c = 0;
808 xstrncpy(c, ultostr(end, 10), maxlen);
809 c += strlen(c);
810 }
811
812 if (tail != NULL && c - cp < maxlen) {
813 *c = ' ';
814 *++c = 0;
815 }
816 start = end = tmp;
817 }
818 } while (tmp != 0);
819
820 return cp;
821 }
822
823
824 /*
825 * Substitute all occurences of the '@' character with the '%' character,
826 * and any double '@' characters with a signle '@' character, returning the
827 * number of replacements.
828 */
829 int
830 substitute_date(char *str)
831 {
832 int n;
833 char *r, *w, *s;
834
835 n = 0;
836
837 s = xstrdup(str);
838
839 for (r = s, w = str; *r != '\0'; r++, w++) {
840 if (*r == '%') {
841 *w++ = '%';
842 *w = '%';
843 } else if (*r == '@') {
844 if (*(r + 1) == '@') {
845 *w = *r++;
846 } else {
847 *w = '%';
848 n++;
849 }
850 } else {
851 *w = *r;
852 }
853 }
854 *w = '\0';
855
856 free(s);
857
858 return n;
859 }
860
861
862 /*
863 * Format the destination mailbox according to the current date conversion
864 * specifiers.
865 */
866 void
867 current_date(char *destmbox)
868 {
869 char s[MBOX_NAME_LEN];
870 time_t te;
871 struct tm *tl;
872
873 if (!strchr(destmbox, '%'))
874 return;
875
876 te = time(NULL);
877 tl = localtime(&te);
878
879 if (strftime(s, MBOX_NAME_LEN - 1, destmbox, tl))
880 xstrncpy(destmbox, s, MBOX_NAME_LEN - 1);
881 }
882
883
884 /*
885 * Format the destination mailbox according to the message date conversion
886 * specifiers.
887 */
888 void
889 message_date(char *mesg, char *destmbox)
890 {
891 unsigned int t;
892 char s[MBOX_NAME_LEN];
893 struct tm tl;
894 char dbuf[RESPONSE_BUF];
895
896 if (!strchr(destmbox, '@'))
897 return;
898
899 substitute_date(destmbox);
900
901 fetch_response(&sockpri, 0, 1, NULL);
902 t = imap_fetch(&sockpri, mesg, "BODY.PEEK[HEADER.FIELDS (DATE)]");
903
904 while (fetch_response(&sockpri, t, 0, dbuf) == RESPONSE_NONE);
905
906 if (strptime(dbuf, "Date: %a, %d %b %Y %H:%M:%S %z", &tl) &&
907 strftime(s, MBOX_NAME_LEN - 1, destmbox, &tl))
908 xstrncpy(destmbox, s, MBOX_NAME_LEN - 1);
909 }

webmaster@linux.gr
ViewVC Help
Powered by ViewVC 1.1.26