?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
.mailmap: (sigh..)
[s-mailx.git] / imap.c
blob4e0894147cf9d4a3e44139437b02555a31b8635e
1 /*@ S-nail - a mail user agent derived from Berkeley Mail.
2 *@ IMAP v4r1 client following RFC 2060.
3 *
4 * Copyright (c) 2000-2004 Gunnar Ritter, Freiburg i. Br., Germany.
5 * Copyright (c) 2012 - 2014 Steffen (Daode) Nurpmeso <sdaoden@users.sf.net>.
6 */
7 /*
8 * Copyright (c) 2004
9 * Gunnar Ritter. All rights reserved.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 * 3. All advertising materials mentioning features or use of this software
20 * must display the following acknowledgement:
21 * This product includes software developed by Gunnar Ritter
22 * and his contributors.
23 * 4. Neither the name of Gunnar Ritter nor the names of his contributors
24 * may be used to endorse or promote products derived from this software
25 * without specific prior written permission.
26 *
27 * THIS SOFTWARE IS PROVIDED BY GUNNAR RITTER AND CONTRIBUTORS ``AS IS'' AND
28 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
29 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
30 * ARE DISCLAIMED. IN NO EVENT SHALL GUNNAR RITTER OR CONTRIBUTORS BE LIABLE
31 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
32 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
33 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
34 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
35 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
36 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
37 * SUCH DAMAGE.
38 */
39
40 #ifndef HAVE_AMALGAMATION
41 # include "nail.h"
42 #endif
43
44 #ifdef HAVE_IMAP
45 # include <sys/socket.h>
46
47 # include <netdb.h>
48
49 # include <netinet/in.h>
50
51 # ifdef HAVE_ARPA_INET_H
52 # include <arpa/inet.h>
53 # endif
54 #endif
55
56 #ifdef HAVE_IMAP
57 #define IMAP_ANSWER() \
58 {\
59 if (mp->mb_type != MB_CACHE) {\
60 enum okay ok = OKAY;\
61 while (mp->mb_active & MB_COMD)\
62 ok = imap_answer(mp, 1);\
63 if (ok == STOP)\
64 return STOP;\
65 }\
66 }
67
68 /* TODO IMAP_OUT() simply returns instead of doing "actioN" if imap_finish()
69 * TODO fails, which leaves behind leaks in, e.g., imap_append1()!
70 * TODO IMAP_XOUT() was added due to this, but (1) needs to be used everywhere
71 * TODO and (2) doesn't handle all I/O errors itself, yet, too.
72 * TODO I.e., that should be a function, not a macro ... or so.
73 * TODO This entire module needs MASSIVE work! */
74 #define IMAP_OUT(X,Y,ACTION) IMAP_XOUT(X, Y, ACTION, return STOP)
75 #define IMAP_XOUT(X,Y,ACTIONERR,ACTIONBAIL) \
76 do {\
77 if (mp->mb_type != MB_CACHE) {\
78 if (imap_finish(mp) == STOP) {\
79 ACTIONBAIL;\
80 }\
81 if (options & OPT_VERBOSE)\
82 fprintf(stderr, ">>> %s", X);\
83 mp->mb_active |= Y;\
84 if (swrite(&mp->mb_sock, X) == STOP) {\
85 ACTIONERR;\
86 }\
87 } else {\
88 if (queuefp != NULL)\
89 fputs(X, queuefp);\
90 }\
91 } while (0);
92
93 static struct record {
94 struct record *rec_next;
95 unsigned long rec_count;
96 enum rec_type {
97 REC_EXISTS,
98 REC_EXPUNGE
99 } rec_type;
100 } *record, *recend;
101
102 static enum {
103 RESPONSE_TAGGED,
104 RESPONSE_DATA,
105 RESPONSE_FATAL,
106 RESPONSE_CONT,
107 RESPONSE_ILLEGAL
108 } response_type;
109
110 static enum {
111 RESPONSE_OK,
112 RESPONSE_NO,
113 RESPONSE_BAD,
114 RESPONSE_PREAUTH,
115 RESPONSE_BYE,
116 RESPONSE_OTHER,
117 RESPONSE_UNKNOWN
118 } response_status;
119
120 static char *responded_tag;
121 static char *responded_text;
122 static char *responded_other_text;
123 static long responded_other_number;
124
125 static enum {
126 MAILBOX_DATA_FLAGS,
127 MAILBOX_DATA_LIST,
128 MAILBOX_DATA_LSUB,
129 MAILBOX_DATA_MAILBOX,
130 MAILBOX_DATA_SEARCH,
131 MAILBOX_DATA_STATUS,
132 MAILBOX_DATA_EXISTS,
133 MAILBOX_DATA_RECENT,
134 MESSAGE_DATA_EXPUNGE,
135 MESSAGE_DATA_FETCH,
136 CAPABILITY_DATA,
137 RESPONSE_OTHER_UNKNOWN
138 } response_other;
139
140 static enum list_attributes {
141 LIST_NONE = 000,
142 LIST_NOINFERIORS = 001,
143 LIST_NOSELECT = 002,
144 LIST_MARKED = 004,
145 LIST_UNMARKED = 010
146 } list_attributes;
147
148 static int list_hierarchy_delimiter;
149 static char *list_name;
150
151 struct list_item {
152 struct list_item *l_next;
153 char *l_name;
154 char *l_base;
155 enum list_attributes l_attr;
156 int l_delim;
157 int l_level;
158 int l_has_children;
159 };
160
161 static char *imapbuf; /* TODO not static, use pool */
162 static size_t imapbufsize;
163 static sigjmp_buf imapjmp;
164 static sighandler_type savealrm;
165 static int imapkeepalive;
166 static long had_exists = -1;
167 static long had_expunge = -1;
168 static long expunged_messages;
169 static int volatile imaplock;
170 static int same_imap_account;
171
172 static void imap_other_get(char *pp);
173 static void imap_response_get(const char **cp);
174 static void imap_response_parse(void);
175 static enum okay imap_answer(struct mailbox *mp, int errprnt);
176 static enum okay imap_parse_list(void);
177 static enum okay imap_finish(struct mailbox *mp);
178 static void imap_timer_off(void);
179 static void imapcatch(int s);
180 static void _imap_maincatch(int s);
181 static enum okay imap_noop1(struct mailbox *mp);
182 static void rec_queue(enum rec_type type, unsigned long cnt);
183 static enum okay rec_dequeue(void);
184 static void rec_rmqueue(void);
185 static void imapalarm(int s);
186 static int imap_use_starttls(const char *uhp);
187 static enum okay imap_preauth(struct mailbox *mp, const char *xserver,
188 const char *uhp);
189 static enum okay imap_capability(struct mailbox *mp);
190 static enum okay imap_auth(struct mailbox *mp, const char *uhp,
191 char *xuser, char *pass);
192 #ifdef HAVE_MD5
193 static enum okay imap_cram_md5(struct mailbox *mp, char *xuser, char *xpass);
194 #endif
195 static enum okay imap_login(struct mailbox *mp, char *xuser, char *xpass);
196 #ifdef HAVE_GSSAPI
197 static enum okay imap_gss(struct mailbox *mp, char *user);
198 #endif
199 static enum okay imap_flags(struct mailbox *mp, unsigned X, unsigned Y);
200 static void imap_init(struct mailbox *mp, int n);
201 static void imap_setptr(struct mailbox *mp, int nmail, int transparent,
202 int *prevcount);
203 static void imap_split(char **server, const char **sp, int *use_ssl,
204 const char **cp, char const **uhp, char const **mbx,
205 char **pass, char **user);
206 static int imap_setfile1(const char *xserver, int nmail, int isedit,
207 int transparent);
208 static int imap_fetchdata(struct mailbox *mp, struct message *m,
209 size_t expected, int need, const char *head,
210 size_t headsize, long headlines);
211 static void imap_putstr(struct mailbox *mp, struct message *m,
212 const char *str, const char *head, size_t headsize,
213 long headlines);
214 static enum okay imap_get(struct mailbox *mp, struct message *m,
215 enum needspec need);
216 static void commitmsg(struct mailbox *mp, struct message *to,
217 struct message *from, enum havespec have);
218 static enum okay imap_fetchheaders(struct mailbox *mp, struct message *m,
219 int bot, int top);
220 static enum okay imap_exit(struct mailbox *mp);
221 static enum okay imap_delete(struct mailbox *mp, int n, struct message *m,
222 int needstat);
223 static enum okay imap_close(struct mailbox *mp);
224 static enum okay imap_update(struct mailbox *mp);
225 static enum okay imap_store(struct mailbox *mp, struct message *m, int n,
226 int c, const char *sp, int needstat);
227 static enum okay imap_unstore(struct message *m, int n, const char *flag);
228 static const char *tag(int new);
229 static char * imap_putflags(int f);
230 static void imap_getflags(const char *cp, char const **xp, enum mflag *f);
231 static enum okay imap_append1(struct mailbox *mp, const char *name, FILE *fp,
232 off_t off1, long xsize, enum mflag flag, time_t t);
233 static enum okay imap_append0(struct mailbox *mp, const char *name, FILE *fp);
234 static enum okay imap_list1(struct mailbox *mp, const char *base,
235 struct list_item **list, struct list_item **lend,
236 int level);
237 static enum okay imap_list(struct mailbox *mp, const char *base, int strip,
238 FILE *fp);
239 static void dopr(FILE *fp);
240 static enum okay imap_copy1(struct mailbox *mp, struct message *m, int n,
241 const char *name);
242 static enum okay imap_copyuid_parse(const char *cp,
243 unsigned long *uidvalidity, unsigned long *olduid,
244 unsigned long *newuid);
245 static enum okay imap_appenduid_parse(const char *cp,
246 unsigned long *uidvalidity, unsigned long *uid);
247 static enum okay imap_copyuid(struct mailbox *mp, struct message *m,
248 const char *name);
249 static enum okay imap_appenduid(struct mailbox *mp, FILE *fp, time_t t,
250 long off1, long xsize, long size, long lines, int flag,
251 const char *name);
252 static enum okay imap_appenduid_cached(struct mailbox *mp, FILE *fp);
253 #ifdef HAVE_IMAP_SEARCH
254 static enum okay imap_search2(struct mailbox *mp, struct message *m, int cnt,
255 const char *spec, int f);
256 #endif
257 static enum okay imap_remove1(struct mailbox *mp, const char *name);
258 static enum okay imap_rename1(struct mailbox *mp, const char *old,
259 const char *new);
260 static char * imap_strex(char const *cp, char const **xp);
261 static enum okay check_expunged(void);
262
263 static void
264 imap_other_get(char *pp)
265 {
266 char *xp;
267 NYD_ENTER;
268
269 if (ascncasecmp(pp, "FLAGS ", 6) == 0) {
270 pp += 6;
271 response_other = MAILBOX_DATA_FLAGS;
272 } else if (ascncasecmp(pp, "LIST ", 5) == 0) {
273 pp += 5;
274 response_other = MAILBOX_DATA_LIST;
275 } else if (ascncasecmp(pp, "LSUB ", 5) == 0) {
276 pp += 5;
277 response_other = MAILBOX_DATA_LSUB;
278 } else if (ascncasecmp(pp, "MAILBOX ", 8) == 0) {
279 pp += 8;
280 response_other = MAILBOX_DATA_MAILBOX;
281 } else if (ascncasecmp(pp, "SEARCH ", 7) == 0) {
282 pp += 7;
283 response_other = MAILBOX_DATA_SEARCH;
284 } else if (ascncasecmp(pp, "STATUS ", 7) == 0) {
285 pp += 7;
286 response_other = MAILBOX_DATA_STATUS;
287 } else if (ascncasecmp(pp, "CAPABILITY ", 11) == 0) {
288 pp += 11;
289 response_other = CAPABILITY_DATA;
290 } else {
291 responded_other_number = strtol(pp, &xp, 10);
292 while (*xp == ' ')
293 ++xp;
294 if (ascncasecmp(xp, "EXISTS\r\n", 8) == 0) {
295 response_other = MAILBOX_DATA_EXISTS;
296 } else if (ascncasecmp(xp, "RECENT\r\n", 8) == 0) {
297 response_other = MAILBOX_DATA_RECENT;
298 } else if (ascncasecmp(xp, "EXPUNGE\r\n", 9) == 0) {
299 response_other = MESSAGE_DATA_EXPUNGE;
300 } else if (ascncasecmp(xp, "FETCH ", 6) == 0) {
301 pp = &xp[6];
302 response_other = MESSAGE_DATA_FETCH;
303 } else
304 response_other = RESPONSE_OTHER_UNKNOWN;
305 }
306 responded_other_text = pp;
307 NYD_LEAVE;
308 }
309
310 static void
311 imap_response_get(const char **cp)
312 {
313 NYD_ENTER;
314 if (ascncasecmp(*cp, "OK ", 3) == 0) {
315 *cp += 3;
316 response_status = RESPONSE_OK;
317 } else if (ascncasecmp(*cp, "NO ", 3) == 0) {
318 *cp += 3;
319 response_status = RESPONSE_NO;
320 } else if (ascncasecmp(*cp, "BAD ", 4) == 0) {
321 *cp += 4;
322 response_status = RESPONSE_BAD;
323 } else if (ascncasecmp(*cp, "PREAUTH ", 8) == 0) {
324 *cp += 8;
325 response_status = RESPONSE_PREAUTH;
326 } else if (ascncasecmp(*cp, "BYE ", 4) == 0) {
327 *cp += 4;
328 response_status = RESPONSE_BYE;
329 } else
330 response_status = RESPONSE_OTHER;
331 NYD_LEAVE;
332 }
333
334 static void
335 imap_response_parse(void)
336 {
337 static char *parsebuf; /* TODO Use pool */
338 static size_t parsebufsize;
339
340 const char *ip = imapbuf;
341 char *pp;
342 NYD_ENTER;
343
344 if (parsebufsize < imapbufsize)
345 parsebuf = srealloc(parsebuf, parsebufsize = imapbufsize);
346 memcpy(parsebuf, imapbuf, strlen(imapbuf) + 1);
347 pp = parsebuf;
348 switch (*ip) {
349 case '+':
350 response_type = RESPONSE_CONT;
351 ip++;
352 pp++;
353 while (*ip == ' ') {
354 ip++;
355 pp++;
356 }
357 break;
358 case '*':
359 ip++;
360 pp++;
361 while (*ip == ' ') {
362 ip++;
363 pp++;
364 }
365 imap_response_get(&ip);
366 pp = &parsebuf[ip - imapbuf];
367 switch (response_status) {
368 case RESPONSE_BYE:
369 response_type = RESPONSE_FATAL;
370 break;
371 default:
372 response_type = RESPONSE_DATA;
373 }
374 break;
375 default:
376 responded_tag = parsebuf;
377 while (*pp && *pp != ' ')
378 pp++;
379 if (*pp == '\0') {
380 response_type = RESPONSE_ILLEGAL;
381 break;
382 }
383 *pp++ = '\0';
384 while (*pp && *pp == ' ')
385 pp++;
386 if (*pp == '\0') {
387 response_type = RESPONSE_ILLEGAL;
388 break;
389 }
390 ip = &imapbuf[pp - parsebuf];
391 response_type = RESPONSE_TAGGED;
392 imap_response_get(&ip);
393 pp = &parsebuf[ip - imapbuf];
394 }
395 responded_text = pp;
396 if (response_type != RESPONSE_CONT && response_type != RESPONSE_ILLEGAL &&
397 response_status == RESPONSE_OTHER)
398 imap_other_get(pp);
399 NYD_LEAVE;
400 }
401
402 static enum okay
403 imap_answer(struct mailbox *mp, int errprnt)
404 {
405 int i, complete;
406 enum okay rv;
407 NYD_ENTER;
408
409 rv = OKAY;
410 if (mp->mb_type == MB_CACHE)
411 goto jleave;
412 rv = STOP;
413 jagain:
414 if (sgetline(&imapbuf, &imapbufsize, NULL, &mp->mb_sock) > 0) {
415 if (options & OPT_VERBOSE)
416 fputs(imapbuf, stderr);
417 imap_response_parse();
418 if (response_type == RESPONSE_ILLEGAL)
419 goto jagain;
420 if (response_type == RESPONSE_CONT) {
421 rv = OKAY;
422 goto jleave;
423 }
424 if (response_status == RESPONSE_OTHER) {
425 if (response_other == MAILBOX_DATA_EXISTS) {
426 had_exists = responded_other_number;
427 rec_queue(REC_EXISTS, responded_other_number);
428 if (had_expunge > 0)
429 had_expunge = 0;
430 } else if (response_other == MESSAGE_DATA_EXPUNGE) {
431 rec_queue(REC_EXPUNGE, responded_other_number);
432 if (had_expunge < 0)
433 had_expunge = 0;
434 had_expunge++;
435 expunged_messages++;
436 }
437 }
438 complete = 0;
439 if (response_type == RESPONSE_TAGGED) {
440 if (asccasecmp(responded_tag, tag(0)) == 0)
441 complete |= 1;
442 else
443 goto jagain;
444 }
445 switch (response_status) {
446 case RESPONSE_PREAUTH:
447 mp->mb_active &= ~MB_PREAUTH;
448 /*FALLTHRU*/
449 case RESPONSE_OK:
450 jokay:
451 rv = OKAY;
452 complete |= 2;
453 break;
454 case RESPONSE_NO:
455 case RESPONSE_BAD:
456 jstop:
457 rv = STOP;
458 complete |= 2;
459 if (errprnt)
460 fprintf(stderr, tr(270, "IMAP error: %s"), responded_text);
461 break;
462 case RESPONSE_UNKNOWN: /* does not happen */
463 case RESPONSE_BYE:
464 i = mp->mb_active;
465 mp->mb_active = MB_NONE;
466 if (i & MB_BYE)
467 goto jokay;
468 goto jstop;
469 case RESPONSE_OTHER:
470 rv = OKAY;
471 break;
472 }
473 if (response_status != RESPONSE_OTHER &&
474 ascncasecmp(responded_text, "[ALERT] ", 8) == 0)
475 fprintf(stderr, "IMAP alert: %s", &responded_text[8]);
476 if (complete == 3)
477 mp->mb_active &= ~MB_COMD;
478 } else {
479 rv = STOP;
480 mp->mb_active = MB_NONE;
481 }
482 jleave:
483 NYD_LEAVE;
484 return rv;
485 }
486
487 static enum okay
488 imap_parse_list(void)
489 {
490 char *cp;
491 enum okay rv;
492 NYD_ENTER;
493
494 rv = STOP;
495
496 cp = responded_other_text;
497 list_attributes = LIST_NONE;
498 if (*cp == '(') {
499 while (*cp && *cp != ')') {
500 if (*cp == '\\') {
501 if (ascncasecmp(&cp[1], "Noinferiors ", 12) == 0) {
502 list_attributes |= LIST_NOINFERIORS;
503 cp += 12;
504 } else if (ascncasecmp(&cp[1], "Noselect ", 9) == 0) {
505 list_attributes |= LIST_NOSELECT;
506 cp += 9;
507 } else if (ascncasecmp(&cp[1], "Marked ", 7) == 0) {
508 list_attributes |= LIST_MARKED;
509 cp += 7;
510 } else if (ascncasecmp(&cp[1], "Unmarked ", 9) == 0) {
511 list_attributes |= LIST_UNMARKED;
512 cp += 9;
513 }
514 }
515 cp++;
516 }
517 if (*++cp != ' ')
518 goto jleave;
519 while (*cp == ' ')
520 cp++;
521 }
522
523 list_hierarchy_delimiter = EOF;
524 if (*cp == '"') {
525 if (*++cp == '\\')
526 cp++;
527 list_hierarchy_delimiter = *cp++ & 0377;
528 if (cp[0] != '"' || cp[1] != ' ')
529 goto jleave;
530 cp++;
531 } else if (cp[0] == 'N' && cp[1] == 'I' && cp[2] == 'L' && cp[3] == ' ') {
532 list_hierarchy_delimiter = EOF;
533 cp += 3;
534 }
535
536 while (*cp == ' ')
537 cp++;
538 list_name = cp;
539 while (*cp && *cp != '\r')
540 cp++;
541 *cp = '\0';
542 rv = OKAY;
543 jleave:
544 NYD_LEAVE;
545 return rv;
546 }
547
548 static enum okay
549 imap_finish(struct mailbox *mp)
550 {
551 NYD_ENTER;
552 while (mp->mb_sock.s_fd > 0 && mp->mb_active & MB_COMD)
553 imap_answer(mp, 1);
554 NYD_LEAVE;
555 return OKAY;
556 }
557
558 static void
559 imap_timer_off(void)
560 {
561 NYD_ENTER;
562 if (imapkeepalive > 0) {
563 alarm(0);
564 safe_signal(SIGALRM, savealrm);
565 }
566 NYD_LEAVE;
567 }
568
569 static void
570 imapcatch(int s)
571 {
572 NYD_X; /* Signal handler */
573 termios_state_reset();
574 switch (s) {
575 case SIGINT:
576 fprintf(stderr, tr(102, "Interrupt\n"));
577 siglongjmp(imapjmp, 1);
578 /*NOTREACHED*/
579 case SIGPIPE:
580 fprintf(stderr, tr(98, "Received SIGPIPE during IMAP operation\n"));
581 break;
582 }
583 }
584
585 static void
586 _imap_maincatch(int s)
587 {
588 NYD_X; /* Signal handler */
589 UNUSED(s);
590 if (interrupts++ == 0) {
591 fprintf(stderr, tr(102, "Interrupt\n"));
592 return;
593 }
594 onintr(0);
595 }
596
597 static enum okay
598 imap_noop1(struct mailbox *mp)
599 {
600 char o[LINESIZE];
601 FILE *queuefp = NULL;
602 NYD_X;
603
604 snprintf(o, sizeof o, "%s NOOP\r\n", tag(1));
605 IMAP_OUT(o, MB_COMD, return STOP)
606 IMAP_ANSWER()
607 return OKAY;
608 }
609
610 FL char const *
611 imap_fileof(char const *xcp)
612 {
613 char const *cp = xcp;
614 int state = 0;
615 NYD_ENTER;
616
617 while (*cp) {
618 if (cp[0] == ':' && cp[1] == '/' && cp[2] == '/') {
619 cp += 3;
620 state = 1;
621 }
622 if (cp[0] == '/' && state == 1) {
623 ++cp;
624 goto jleave;
625 }
626 if (cp[0] == '/') {
627 cp = xcp;
628 goto jleave;
629 }
630 ++cp;
631 }
632 jleave:
633 NYD_LEAVE;
634 return cp;
635 }
636
637 FL enum okay
638 imap_noop(void)
639 {
640 sighandler_type volatile oldint, oldpipe;
641 enum okay rv = STOP;
642 NYD_ENTER;
643
644 if (mb.mb_type != MB_IMAP)
645 goto jleave;
646
647 imaplock = 1;
648 if ((oldint = safe_signal(SIGINT, SIG_IGN)) != SIG_IGN)
649 safe_signal(SIGINT, &_imap_maincatch);
650 oldpipe = safe_signal(SIGPIPE, SIG_IGN);
651 if (sigsetjmp(imapjmp, 1) == 0) {
652 if (oldpipe != SIG_IGN)
653 safe_signal(SIGPIPE, imapcatch);
654
655 rv = imap_noop1(&mb);
656 }
657 safe_signal(SIGINT, oldint);
658 safe_signal(SIGPIPE, oldpipe);
659 imaplock = 0;
660 jleave:
661 NYD_LEAVE;
662 if (interrupts)
663 onintr(0);
664 return rv;
665 }
666
667 static void
668 rec_queue(enum rec_type rt, unsigned long cnt)
669 {
670 struct record *rp;
671 NYD_ENTER;
672
673 rp = scalloc(1, sizeof *rp);
674 rp->rec_type = rt;
675 rp->rec_count = cnt;
676 if (record && recend) {
677 recend->rec_next = rp;
678 recend = rp;
679 } else
680 record = recend = rp;
681 NYD_LEAVE;
682 }
683
684 static enum okay
685 rec_dequeue(void)
686 {
687 struct message *omessage;
688 struct record *rp, *rq;
689 uiz_t exists = 0, i;
690 enum okay rv = STOP;
691 NYD_ENTER;
692
693 if (record == NULL)
694 goto jleave;
695
696 omessage = message;
697 message = smalloc((msgCount+1) * sizeof *message);
698 if (msgCount)
699 memcpy(message, omessage, msgCount * sizeof *message);
700 memset(&message[msgCount], 0, sizeof *message);
701
702 rp = record, rq = NULL;
703 rv = OKAY;
704 while (rp != NULL) {
705 switch (rp->rec_type) {
706 case REC_EXISTS:
707 exists = rp->rec_count;
708 break;
709 case REC_EXPUNGE:
710 if (rp->rec_count == 0) {
711 rv = STOP;
712 break;
713 }
714 if (rp->rec_count > (unsigned long)msgCount) {
715 if (exists == 0 || rp->rec_count > exists--)
716 rv = STOP;
717 break;
718 }
719 if (exists > 0)
720 exists--;
721 delcache(&mb, &message[rp->rec_count-1]);
722 memmove(&message[rp->rec_count-1], &message[rp->rec_count],
723 ((msgCount - rp->rec_count + 1) * sizeof *message));
724 --msgCount;
725 /* If the message was part of a collapsed thread,
726 * the m_collapsed field of one of its ancestors
727 * should be incremented. It seems hardly possible
728 * to do this with the current message structure,
729 * though. The result is that a '+' may be shown
730 * in the header summary even if no collapsed
731 * children exists */
732 break;
733 }
734 if (rq != NULL)
735 free(rq);
736 rq = rp;
737 rp = rp->rec_next;
738 }
739 if (rq != NULL)
740 free(rq);
741
742 record = recend = NULL;
743 if (rv == OKAY && UICMP(z, exists, >, msgCount)) {
744 message = srealloc(message, (exists + 1) * sizeof *message);
745 memset(&message[msgCount], 0, (exists - msgCount + 1) * sizeof *message);
746 for (i = msgCount; i < exists; ++i)
747 imap_init(&mb, i);
748 imap_flags(&mb, msgCount+1, exists);
749 msgCount = exists;
750 }
751
752 if (rv == STOP) {
753 free(message);
754 message = omessage;
755 }
756 jleave:
757 NYD_LEAVE;
758 return rv;
759 }
760
761 static void
762 rec_rmqueue(void)
763 {
764 struct record *rp;
765 NYD_ENTER;
766
767 for (rp = record; rp != NULL;) {
768 struct record *tmp = rp;
769 rp = rp->rec_next;
770 free(tmp);
771 }
772 record = recend = NULL;
773 NYD_LEAVE;
774 }
775
776 /*ARGSUSED*/
777 static void
778 imapalarm(int s)
779 {
780 sighandler_type volatile saveint, savepipe;
781 NYD_X; /* Signal handler */
782 UNUSED(s);
783
784 if (imaplock++ == 0) {
785 if ((saveint = safe_signal(SIGINT, SIG_IGN)) != SIG_IGN)
786 safe_signal(SIGINT, &_imap_maincatch);
787 savepipe = safe_signal(SIGPIPE, SIG_IGN);
788 if (sigsetjmp(imapjmp, 1)) {
789 safe_signal(SIGINT, saveint);
790 safe_signal(SIGPIPE, savepipe);
791 goto jbrk;
792 }
793 if (savepipe != SIG_IGN)
794 safe_signal(SIGPIPE, imapcatch);
795 if (imap_noop1(&mb) != OKAY) {
796 safe_signal(SIGINT, saveint);
797 safe_signal(SIGPIPE, savepipe);
798 goto jleave;
799 }
800 safe_signal(SIGINT, saveint);
801 safe_signal(SIGPIPE, savepipe);
802 }
803 jbrk:
804 alarm(imapkeepalive);
805 jleave:
806 --imaplock;
807 }
808
809 static int
810 imap_use_starttls(const char *uhp)
811 {
812 int rv;
813 NYD_ENTER;
814
815 if (ok_blook(imap_use_starttls))
816 rv = 1;
817 else {
818 char *var = savecat("imap-use-starttls-", uhp);
819 rv = vok_blook(var);
820 }
821 NYD_LEAVE;
822 return rv;
823 }
824
825 static enum okay
826 imap_preauth(struct mailbox *mp, const char *xserver, const char *uhp)
827 {
828 char *cp;
829 NYD_X;
830
831 mp->mb_active |= MB_PREAUTH;
832 imap_answer(mp, 1);
833 if ((cp = strchr(xserver, ':')) != NULL) {
834 char *x = salloc(cp - xserver + 1);
835 memcpy(x, xserver, cp - xserver);
836 x[cp - xserver] = '\0';
837 xserver = x;
838 }
839 #ifdef HAVE_SSL
840 if (mp->mb_sock.s_use_ssl == 0 && imap_use_starttls(uhp)) {
841 FILE *queuefp = NULL;
842 char o[LINESIZE];
843
844 snprintf(o, sizeof o, "%s STARTTLS\r\n", tag(1));
845 IMAP_OUT(o, MB_COMD, return STOP)
846 IMAP_ANSWER()
847 if (ssl_open(xserver, &mp->mb_sock, uhp) != OKAY)
848 return STOP;
849 }
850 #else
851 if (imap_use_starttls(uhp)) {
852 fprintf(stderr, "No SSL support compiled in.\n");
853 return STOP;
854 }
855 #endif
856 imap_capability(mp);
857 return OKAY;
858 }
859
860 static enum okay
861 imap_capability(struct mailbox *mp)
862 {
863 char o[LINESIZE];
864 FILE *queuefp = NULL;
865 enum okay ok = STOP;
866 const char *cp;
867 NYD_X;
868
869 snprintf(o, sizeof o, "%s CAPABILITY\r\n", tag(1));
870 IMAP_OUT(o, MB_COMD, return STOP)
871 while (mp->mb_active & MB_COMD) {
872 ok = imap_answer(mp, 0);
873 if (response_status == RESPONSE_OTHER &&
874 response_other == CAPABILITY_DATA) {
875 cp = responded_other_text;
876 while (*cp) {
877 while (spacechar(*cp))
878 ++cp;
879 if (strncmp(cp, "UIDPLUS", 7) == 0 && spacechar(cp[7]))
880 /* RFC 2359 */
881 mp->mb_flags |= MB_UIDPLUS;
882 while (*cp && !spacechar(*cp))
883 ++cp;
884 }
885 }
886 }
887 return ok;
888 }
889
890 static enum okay
891 imap_auth(struct mailbox *mp, const char *uhp, char *xuser, char *pass)
892 {
893 char *var, *auth;
894 enum okay rv;
895 NYD_ENTER;
896
897 if (!(mp->mb_active & MB_PREAUTH)) {
898 rv = OKAY;
899 goto jleave;
900 }
901
902 if ((auth = ok_vlook(imap_auth)) == NULL) {
903 size_t i = strlen(uhp) + 1;
904 var = ac_alloc(i + 10);
905 memcpy(var, "imap-auth-", 10);
906 memcpy(var + 10, uhp, i);
907 auth = vok_vlook(var);
908 ac_free(var);
909 }
910
911 if (auth == NULL || !strcmp(auth, "login"))
912 rv = imap_login(mp, xuser, pass);
913 else if (!strcmp(auth, "cram-md5")) {
914 #ifdef HAVE_MD5
915 rv = imap_cram_md5(mp, xuser, pass);
916 #else
917 fprintf(stderr, tr(277, "No CRAM-MD5 support compiled in.\n"));
918 rv = STOP;
919 #endif
920 } else if (!strcmp(auth, "gssapi")) {
921 #ifdef HAVE_GSSAPI
922 rv = imap_gss(mp, xuser);
923 #else
924 fprintf(stderr, tr(272, "No GSSAPI support compiled in.\n"));
925 rv = STOP;
926 #endif
927 } else {
928 fprintf(stderr, tr(273,
929 "Unknown IMAP authentication method: %s\n"), auth);
930 rv = STOP;
931 }
932 jleave:
933 NYD_LEAVE;
934 return rv;
935 }
936
937 /* Implementation of RFC 2194 */
938 #ifdef HAVE_MD5
939 static enum okay
940 imap_cram_md5(struct mailbox *mp, char *xuser, char *xpass)
941 {
942 char o[LINESIZE], *user, *pass, *cp;
943 FILE *queuefp = NULL;
944 enum okay rv = STOP;
945 NYD_ENTER;
946
947 jretry:
948 user = xuser;
949 pass = xpass;
950 if (!getcredentials(&user, &pass))
951 goto jleave;
952
953 snprintf(o, sizeof o, "%s AUTHENTICATE CRAM-MD5\r\n", tag(1));
954 IMAP_XOUT(o, 0, goto jleave, goto jleave);
955 imap_answer(mp, 1);
956 if (response_type != RESPONSE_CONT)
957 goto jleave;
958
959 cp = cram_md5_string(user, pass, responded_text);
960 IMAP_XOUT(cp, MB_COMD, goto jleave, goto jleave);
961 while (mp->mb_active & MB_COMD)
962 rv = imap_answer(mp, 1);
963 if (rv == STOP) {
964 xpass = NULL;
965 goto jretry;
966 }
967 jleave:
968 NYD_LEAVE;
969 return rv;
970 }
971 #endif /* HAVE_MD5 */
972
973 static enum okay
974 imap_login(struct mailbox *mp, char *xuser, char *xpass)
975 {
976 char o[LINESIZE];
977 char *user, *pass;
978 FILE *queuefp = NULL;
979 enum okay rv = STOP;
980 NYD_ENTER;
981
982 jretry:
983 user = xuser;
984 pass = xpass;
985 if (!getcredentials(&user, &pass))
986 goto jleave;
987
988 snprintf(o, sizeof o, "%s LOGIN %s %s\r\n",
989 tag(1), imap_quotestr(user), imap_quotestr(pass));
990 IMAP_XOUT(o, MB_COMD, goto jleave, goto jleave);
991 while (mp->mb_active & MB_COMD)
992 rv = imap_answer(mp, 1);
993 if (rv == STOP) {
994 xpass = NULL;
995 goto jretry;
996 }
997 jleave:
998 NYD_LEAVE;
999 return rv;
1000 }
1001
1002 #ifdef HAVE_GSSAPI
1003 # include "imap_gssapi.h"
1004 #endif
1005
1006 FL enum okay
1007 imap_select(struct mailbox *mp, off_t *size, int *cnt, const char *mbx)
1008 {
1009 enum okay ok = OKAY;
1010 char const *cp;
1011 char o[LINESIZE];
1012 FILE *queuefp = NULL;
1013 NYD_X;
1014 UNUSED(size);
1015
1016 mp->mb_uidvalidity = 0;
1017 snprintf(o, sizeof o, "%s SELECT %s\r\n", tag(1), imap_quotestr(mbx));
1018 IMAP_OUT(o, MB_COMD, return STOP)
1019 while (mp->mb_active & MB_COMD) {
1020 ok = imap_answer(mp, 1);
1021 if (response_status != RESPONSE_OTHER &&
1022 (cp = asccasestr(responded_text, "[UIDVALIDITY ")) != NULL)
1023 mp->mb_uidvalidity = atol(&cp[13]);
1024 }
1025 *cnt = (had_exists > 0) ? had_exists : 0;
1026 if (response_status != RESPONSE_OTHER &&
1027 ascncasecmp(responded_text, "[READ-ONLY] ", 12) == 0)
1028 mp->mb_perm = 0;
1029 return ok;
1030 }
1031
1032 static enum okay
1033 imap_flags(struct mailbox *mp, unsigned X, unsigned Y)
1034 {
1035 char o[LINESIZE];
1036 FILE *queuefp = NULL;
1037 char const *cp;
1038 struct message *m;
1039 unsigned x = X, y = Y, n;
1040 NYD_X;
1041
1042 snprintf(o, sizeof o, "%s FETCH %u:%u (FLAGS UID)\r\n", tag(1), x, y);
1043 IMAP_OUT(o, MB_COMD, return STOP)
1044 while (mp->mb_active & MB_COMD) {
1045 imap_answer(mp, 1);
1046 if (response_status == RESPONSE_OTHER &&
1047 response_other == MESSAGE_DATA_FETCH) {
1048 n = responded_other_number;
1049 if (n < x || n > y)
1050 continue;
1051 m = &message[n-1];
1052 m->m_xsize = 0;
1053 } else
1054 continue;
1055
1056 if ((cp = asccasestr(responded_other_text, "FLAGS ")) != NULL) {
1057 cp += 5;
1058 while (*cp == ' ')
1059 cp++;
1060 if (*cp == '(')
1061 imap_getflags(cp, &cp, &m->m_flag);
1062 }
1063
1064 if ((cp = asccasestr(responded_other_text, "UID ")) != NULL)
1065 m->m_uid = strtoul(&cp[4], NULL, 10);
1066 getcache1(mp, m, NEED_UNSPEC, 1);
1067 m->m_flag &= ~MHIDDEN;
1068 }
1069
1070 while (x <= y && message[x-1].m_xsize && message[x-1].m_time)
1071 x++;
1072 while (y > x && message[y-1].m_xsize && message[y-1].m_time)
1073 y--;
1074 if (x <= y) {
1075 snprintf(o, sizeof o, "%s FETCH %u:%u (RFC822.SIZE INTERNALDATE)\r\n",
1076 tag(1), x, y);
1077 IMAP_OUT(o, MB_COMD, return STOP)
1078 while (mp->mb_active & MB_COMD) {
1079 imap_answer(mp, 1);
1080 if (response_status == RESPONSE_OTHER &&
1081 response_other == MESSAGE_DATA_FETCH) {
1082 n = responded_other_number;
1083 if (n < x || n > y)
1084 continue;
1085 m = &message[n-1];
1086 } else
1087 continue;
1088 if ((cp = asccasestr(responded_other_text, "RFC822.SIZE ")) != NULL)
1089 m->m_xsize = strtol(&cp[12], NULL, 10);
1090 if ((cp = asccasestr(responded_other_text, "INTERNALDATE ")) != NULL)
1091 m->m_time = imap_read_date_time(&cp[13]);
1092 }
1093 }
1094
1095 for (n = X; n <= Y; n++)
1096 putcache(mp, &message[n-1]);
1097 return OKAY;
1098 }
1099
1100 static void
1101 imap_init(struct mailbox *mp, int n)
1102 {
1103 struct message *m;
1104 NYD_ENTER;
1105 UNUSED(mp);
1106
1107 m = message + n;
1108 m->m_flag = MUSED | MNOFROM;
1109 m->m_block = 0;
1110 m->m_offset = 0;
1111 NYD_LEAVE;
1112 }
1113
1114 static void
1115 imap_setptr(struct mailbox *mp, int nmail, int transparent, int *prevcount)
1116 {
1117 struct message *omessage = 0;
1118 int i, omsgCount = 0;
1119 enum okay dequeued = STOP;
1120 NYD_ENTER;
1121
1122 if (nmail || transparent) {
1123 omessage = message;
1124 omsgCount = msgCount;
1125 }
1126 if (nmail)
1127 dequeued = rec_dequeue();
1128
1129 if (had_exists >= 0) {
1130 if (dequeued != OKAY)
1131 msgCount = had_exists;
1132 had_exists = -1;
1133 }
1134 if (had_expunge >= 0) {
1135 if (dequeued != OKAY)
1136 msgCount -= had_expunge;
1137 had_expunge = -1;
1138 }
1139
1140 if (nmail && expunged_messages)
1141 printf("Expunged %ld message%s.\n", expunged_messages,
1142 (expunged_messages != 1 ? "s" : ""));
1143 *prevcount = omsgCount - expunged_messages;
1144 expunged_messages = 0;
1145 if (msgCount < 0) {
1146 fputs("IMAP error: Negative message count\n", stderr);
1147 msgCount = 0;
1148 }
1149
1150 if (dequeued != OKAY) {
1151 message = scalloc(msgCount + 1, sizeof *message);
1152 for (i = 0; i < msgCount; i++)
1153 imap_init(mp, i);
1154 if (!nmail && mp->mb_type == MB_IMAP)
1155 initcache(mp);
1156 if (msgCount > 0)
1157 imap_flags(mp, 1, msgCount);
1158 message[msgCount].m_size = 0;
1159 message[msgCount].m_lines = 0;
1160 rec_rmqueue();
1161 }
1162 if (nmail || transparent)
1163 transflags(omessage, omsgCount, transparent);
1164 else
1165 setdot(message);
1166 NYD_LEAVE;
1167 }
1168
1169 static void
1170 imap_split(char **server, const char **sp, int *use_ssl, const char **cp,
1171 char const **uhp, char const **mbx, char **pass, char **user)
1172 {
1173 NYD_ENTER;
1174 *sp = *server;
1175 if (strncmp(*sp, "imap://", 7) == 0) {
1176 *sp = &(*sp)[7];
1177 *use_ssl = 0;
1178 #ifdef HAVE_SSL
1179 } else if (strncmp(*sp, "imaps://", 8) == 0) {
1180 *sp = &(*sp)[8];
1181 *use_ssl = 1;
1182 #endif
1183 } else
1184 *use_ssl = 0; /* (silence CC) */
1185
1186 if ((*cp = strchr(*sp, '/')) != NULL && (*cp)[1] != '\0') {
1187 char *x = savestr(*sp);
1188 x[*cp - *sp] = '\0';
1189 *uhp = x;
1190 *mbx = &(*cp)[1];
1191 } else {
1192 if (*cp)
1193 (*server)[*cp - *server] = '\0';
1194 *uhp = *sp;
1195 *mbx = "INBOX";
1196 }
1197
1198 *pass = lookup_password_for_token(*uhp);
1199 if ((*cp = last_at_before_slash(*uhp)) != NULL) {
1200 *user = salloc(*cp - *uhp + 1);
1201 memcpy(*user, *uhp, *cp - *uhp);
1202 (*user)[*cp - *uhp] = '\0';
1203 *sp = &(*cp)[1];
1204 *user = urlxdec(*user);
1205 } else {
1206 *user = NULL;
1207 *sp = *uhp;
1208 }
1209 NYD_LEAVE;
1210 }
1211
1212 FL int
1213 imap_setfile(const char *xserver, int nmail, int isedit)
1214 {
1215 int rv;
1216 NYD_ENTER;
1217
1218 rv = imap_setfile1(xserver, nmail, isedit, 0);
1219 NYD_LEAVE;
1220 return rv;
1221 }
1222
1223 static int
1224 imap_setfile1(const char *xserver, int nmail, int isedit,
1225 int volatile transparent)
1226 {
1227 struct sock so;
1228 sighandler_type volatile saveint, savepipe;
1229 char *server, *user, *pass, *acc;
1230 char const *cp, *sp, * volatile mbx, *uhp;
1231 int rv, use_ssl = 0, prevcount = 0;
1232 enum mbflags same_flags;
1233 NYD_ENTER;
1234
1235 server = savestr(xserver);
1236 if (nmail) {
1237 saveint = safe_signal(SIGINT, SIG_IGN);
1238 savepipe = safe_signal(SIGPIPE, SIG_IGN);
1239 if (saveint != SIG_IGN)
1240 safe_signal(SIGINT, imapcatch);
1241 if (savepipe != SIG_IGN)
1242 safe_signal(SIGPIPE, imapcatch);
1243 imaplock = 1;
1244 goto jnmail;
1245 }
1246
1247 same_flags = mb.mb_flags;
1248 same_imap_account = 0;
1249 sp = protbase(server);
1250 if (mb.mb_imap_account && mb.mb_type == MB_IMAP) {
1251 if (mb.mb_sock.s_fd > 0 && strcmp(mb.mb_imap_account, sp) == 0 &&
1252 disconnected(mb.mb_imap_account) == 0)
1253 same_imap_account = 1;
1254 }
1255 acc = sstrdup(sp);
1256
1257 {
1258 char const *xmbx;
1259 imap_split(&server, &sp, &use_ssl, &cp, &uhp, &xmbx, &pass, &user);
1260 mbx = xmbx;
1261 }
1262 so.s_fd = -1;
1263 if (!same_imap_account) {
1264 if (!disconnected(acc) &&
1265 sopen(sp, &so, use_ssl, uhp, (use_ssl ? "imaps" : "imap")
1266 ) != OKAY) {
1267 free(acc);
1268 rv = -1;
1269 goto jleave;
1270 }
1271 } else
1272 so = mb.mb_sock;
1273 if (!transparent)
1274 quit();
1275
1276 edit = (isedit != 0);
1277 if (mb.mb_imap_account != NULL)
1278 free(mb.mb_imap_account);
1279 mb.mb_imap_account = acc;
1280 if (!same_imap_account) {
1281 if (mb.mb_sock.s_fd >= 0)
1282 sclose(&mb.mb_sock);
1283 }
1284 same_imap_account = 0;
1285
1286 if (!transparent) {
1287 if (mb.mb_itf) {
1288 fclose(mb.mb_itf);
1289 mb.mb_itf = NULL;
1290 }
1291 if (mb.mb_otf) {
1292 fclose(mb.mb_otf);
1293 mb.mb_otf = NULL;
1294 }
1295 if (mb.mb_imap_mailbox != NULL)
1296 free(mb.mb_imap_mailbox);
1297 mb.mb_imap_mailbox = sstrdup(mbx);
1298 initbox(server);
1299 }
1300 mb.mb_type = MB_VOID;
1301 mb.mb_active = MB_NONE;
1302
1303 imaplock = 1;
1304 saveint = safe_signal(SIGINT, SIG_IGN);
1305 savepipe = safe_signal(SIGPIPE, SIG_IGN);
1306 if (sigsetjmp(imapjmp, 1)) {
1307 /* Not safe to use &so; save to use mb.mb_sock?? :-( TODO */
1308 sclose(&mb.mb_sock);
1309 safe_signal(SIGINT, saveint);
1310 safe_signal(SIGPIPE, savepipe);
1311 imaplock = 0;
1312
1313 mb.mb_type = MB_VOID;
1314 mb.mb_active = MB_NONE;
1315 rv = -1;
1316 goto jleave;
1317 }
1318 if (saveint != SIG_IGN)
1319 safe_signal(SIGINT, imapcatch);
1320 if (savepipe != SIG_IGN)
1321 safe_signal(SIGPIPE, imapcatch);
1322
1323 if (mb.mb_sock.s_fd < 0) {
1324 if (disconnected(mb.mb_imap_account)) {
1325 if (cache_setptr(transparent) == STOP)
1326 fprintf(stderr,
1327 "Mailbox \"%s\" is not cached.\n",
1328 server);
1329 goto jdone;
1330 }
1331 if ((cp = ok_vlook(imap_keepalive)) != NULL) {
1332 if ((imapkeepalive = strtol(cp, NULL, 10)) > 0) {
1333 savealrm = safe_signal(SIGALRM, imapalarm);
1334 alarm(imapkeepalive);
1335 }
1336 }
1337
1338 mb.mb_sock = so;
1339 mb.mb_sock.s_desc = "IMAP";
1340 mb.mb_sock.s_onclose = imap_timer_off;
1341 if (imap_preauth(&mb, sp, uhp) != OKAY ||
1342 imap_auth(&mb, uhp, user, pass) != OKAY) {
1343 sclose(&mb.mb_sock);
1344 imap_timer_off();
1345 safe_signal(SIGINT, saveint);
1346 safe_signal(SIGPIPE, savepipe);
1347 imaplock = 0;
1348 rv = -1;
1349 goto jleave;
1350 }
1351 } else /* same account */
1352 mb.mb_flags |= same_flags;
1353
1354 mb.mb_perm = (options & OPT_R_FLAG) ? 0 : MB_DELE;
1355 mb.mb_type = MB_IMAP;
1356 cache_dequeue(&mb);
1357 if (imap_select(&mb, &mailsize, &msgCount, mbx) != OKAY) {
1358 /*sclose(&mb.mb_sock);
1359 imap_timer_off();*/
1360 safe_signal(SIGINT, saveint);
1361 safe_signal(SIGPIPE, savepipe);
1362 imaplock = 0;
1363 mb.mb_type = MB_VOID;
1364 rv = -1;
1365 goto jleave;
1366 }
1367
1368 jnmail:
1369 imap_setptr(&mb, nmail, transparent, &prevcount);
1370 jdone:
1371 setmsize(msgCount);
1372 if (!nmail && !transparent)
1373 sawcom = FAL0;
1374 safe_signal(SIGINT, saveint);
1375 safe_signal(SIGPIPE, savepipe);
1376 imaplock = 0;
1377
1378 if (!nmail && mb.mb_type == MB_IMAP)
1379 purgecache(&mb, message, msgCount);
1380 if ((nmail || transparent) && mb.mb_sorted) {
1381 mb.mb_threaded = 0;
1382 c_sort((void*)-1);
1383 }
1384
1385 if (!nmail && !edit && msgCount == 0) {
1386 if ((mb.mb_type == MB_IMAP || mb.mb_type == MB_CACHE) &&
1387 !ok_blook(emptystart))
1388 fprintf(stderr, tr(258, "No mail at %s\n"), server);
1389 rv = 1;
1390 goto jleave;
1391 }
1392 if (nmail)
1393 newmailinfo(prevcount);
1394 rv = 0;
1395 jleave:
1396 NYD_LEAVE;
1397 return rv;
1398 }
1399
1400 static int
1401 imap_fetchdata(struct mailbox *mp, struct message *m, size_t expected,
1402 int need, const char *head, size_t headsize, long headlines)
1403 {
1404 char *line = NULL, *lp;
1405 size_t linesize = 0, linelen, size = 0;
1406 int emptyline = 0, lines = 0, excess = 0;
1407 off_t offset;
1408 NYD_ENTER;
1409
1410 fseek(mp->mb_otf, 0L, SEEK_END);
1411 offset = ftell(mp->mb_otf);
1412
1413 if (head)
1414 fwrite(head, 1, headsize, mp->mb_otf);
1415
1416 while (sgetline(&line, &linesize, &linelen, &mp->mb_sock) > 0) {
1417 lp = line;
1418 if (linelen > expected) {
1419 excess = linelen - expected;
1420 linelen = expected;
1421 }
1422 /* TODO >>
1423 * Need to mask 'From ' lines. This cannot be done properly
1424 * since some servers pass them as 'From ' and others as
1425 * '>From '. Although one could identify the first kind of
1426 * server in principle, it is not possible to identify the
1427 * second as '>From ' may also come from a server of the
1428 * first type as actual data. So do what is absolutely
1429 * necessary only - mask 'From '.
1430 *
1431 * If the line is the first line of the message header, it
1432 * is likely a real 'From ' line. In this case, it is just
1433 * ignored since it violates all standards.
1434 * TODO can the latter *really* happen??
1435 * TODO <<
1436 */
1437 /* Since we simply copy over data without doing any transfer
1438 * encoding reclassification/adjustment we *have* to perform
1439 * RFC 4155 compliant From_ quoting here */
1440 if (is_head(lp, linelen)) {
1441 if (lines + headlines == 0)
1442 goto jskip;
1443 fputc('>', mp->mb_otf);
1444 ++size;
1445 }
1446 if (lp[linelen-1] == '\n' && (linelen == 1 || lp[linelen-2] == '\r')) {
1447 emptyline = linelen <= 2;
1448 if (linelen > 2) {
1449 fwrite(lp, 1, linelen - 2, mp->mb_otf);
1450 size += linelen - 1;
1451 } else
1452 ++size;
1453 fputc('\n', mp->mb_otf);
1454 } else {
1455 emptyline = 0;
1456 fwrite(lp, 1, linelen, mp->mb_otf);
1457 size += linelen;
1458 }
1459 ++lines;
1460 jskip:
1461 if ((expected -= linelen) <= 0)
1462 break;
1463 }
1464 if (!emptyline) {
1465 /* This is very ugly; but some IMAP daemons don't end a
1466 * message with \r\n\r\n, and we need \n\n for mbox format */
1467 fputc('\n', mp->mb_otf);
1468 ++lines;
1469 ++size;
1470 }
1471 fflush(mp->mb_otf);
1472
1473 if (m != NULL) {
1474 m->m_size = size + headsize;
1475 m->m_lines = lines + headlines;
1476 m->m_block = mailx_blockof(offset);
1477 m->m_offset = mailx_offsetof(offset);
1478 switch (need) {
1479 case NEED_HEADER:
1480 m->m_have |= HAVE_HEADER;
1481 break;
1482 case NEED_BODY:
1483 m->m_have |= HAVE_HEADER | HAVE_BODY;
1484 m->m_xlines = m->m_lines;
1485 m->m_xsize = m->m_size;
1486 break;
1487 }
1488 }
1489 free(line);
1490 NYD_LEAVE;
1491 return excess;
1492 }
1493
1494 static void
1495 imap_putstr(struct mailbox *mp, struct message *m, const char *str,
1496 const char *head, size_t headsize, long headlines)
1497 {
1498 off_t offset;
1499 size_t len;
1500 NYD_ENTER;
1501
1502 len = strlen(str);
1503 fseek(mp->mb_otf, 0L, SEEK_END);
1504 offset = ftell(mp->mb_otf);
1505 if (head)
1506 fwrite(head, 1, headsize, mp->mb_otf);
1507 if (len > 0) {
1508 fwrite(str, 1, len, mp->mb_otf);
1509 fputc('\n', mp->mb_otf);
1510 ++len;
1511 }
1512 fflush(mp->mb_otf);
1513
1514 if (m != NULL) {
1515 m->m_size = headsize + len;
1516 m->m_lines = headlines + 1;
1517 m->m_block = mailx_blockof(offset);
1518 m->m_offset = mailx_offsetof(offset);
1519 m->m_have |= HAVE_HEADER | HAVE_BODY;
1520 m->m_xlines = m->m_lines;
1521 m->m_xsize = m->m_size;
1522 }
1523 NYD_LEAVE;
1524 }
1525
1526 static enum okay
1527 imap_get(struct mailbox *mp, struct message *m, enum needspec need)
1528 {
1529 char o[LINESIZE];
1530 struct message mt;
1531 sighandler_type volatile saveint, savepipe;
1532 char * volatile head;
1533 char const *cp, *loc, * volatile item, * volatile resp;
1534 size_t expected;
1535 size_t volatile headsize;
1536 int number;
1537 FILE *queuefp;
1538 long volatile headlines;
1539 long n;
1540 unsigned long u;
1541 enum okay ok;
1542 NYD_X;
1543
1544 saveint = savepipe = SIG_IGN;
1545 head = NULL;
1546 cp = loc = item = resp = NULL;
1547 headsize = 0;
1548 number = (int)PTR2SIZE(m - message + 1);
1549 queuefp = NULL;
1550 headlines = 0;
1551 n = -1;
1552 u = 0;
1553 ok = STOP;
1554
1555 if (getcache(mp, m, need) == OKAY)
1556 return OKAY;
1557 if (mp->mb_type == MB_CACHE) {
1558 fprintf(stderr, "Message %u not available.\n", number);
1559 return STOP;
1560 }
1561
1562 if (mp->mb_sock.s_fd < 0) {
1563 fprintf(stderr, "IMAP connection closed.\n");
1564 return STOP;
1565 }
1566
1567 switch (need) {
1568 case NEED_HEADER:
1569 resp = item = "RFC822.HEADER";
1570 break;
1571 case NEED_BODY:
1572 item = "BODY.PEEK[]";
1573 resp = "BODY[]";
1574 if (m->m_flag & HAVE_HEADER && m->m_size) {
1575 char *hdr = smalloc(m->m_size);
1576 fflush(mp->mb_otf);
1577 if (fseek(mp->mb_itf, (long)mailx_positionof(m->m_block, m->m_offset),
1578 SEEK_SET) < 0 ||
1579 fread(hdr, 1, m->m_size, mp->mb_itf) != m->m_size) {
1580 free(hdr);
1581 break;
1582 }
1583 head = hdr;
1584 headsize = m->m_size;
1585 headlines = m->m_lines;
1586 item = "BODY.PEEK[TEXT]";
1587 resp = "BODY[TEXT]";
1588 }
1589 break;
1590 case NEED_UNSPEC:
1591 return STOP;
1592 }
1593
1594 imaplock = 1;
1595 savepipe = safe_signal(SIGPIPE, SIG_IGN);
1596 if (sigsetjmp(imapjmp, 1)) {
1597 safe_signal(SIGINT, saveint);
1598 safe_signal(SIGPIPE, savepipe);
1599 imaplock = 0;
1600 return STOP;
1601 }
1602 if ((saveint = safe_signal(SIGINT, SIG_IGN)) != SIG_IGN)
1603 safe_signal(SIGINT, &_imap_maincatch);
1604 if (savepipe != SIG_IGN)
1605 safe_signal(SIGPIPE, imapcatch);
1606
1607 if (m->m_uid)
1608 snprintf(o, sizeof o, "%s UID FETCH %lu (%s)\r\n",
1609 tag(1), m->m_uid, item);
1610 else {
1611 if (check_expunged() == STOP)
1612 goto out;
1613 snprintf(o, sizeof o, "%s FETCH %u (%s)\r\n", tag(1), number, item);
1614 }
1615 IMAP_OUT(o, MB_COMD, goto out)
1616 for (;;) {
1617 ok = imap_answer(mp, 1);
1618 if (ok == STOP)
1619 break;
1620 if (response_status != RESPONSE_OTHER ||
1621 response_other != MESSAGE_DATA_FETCH)
1622 continue;
1623 if ((loc = asccasestr(responded_other_text, resp)) == NULL)
1624 continue;
1625 if (m->m_uid) {
1626 if ((cp = asccasestr(responded_other_text, "UID "))) {
1627 u = atol(&cp[4]);
1628 n = 0;
1629 } else {
1630 n = -1;
1631 u = 0;
1632 }
1633 } else
1634 n = responded_other_number;
1635 if ((cp = strrchr(responded_other_text, '{')) == NULL) {
1636 if (m->m_uid ? m->m_uid != u : n != number)
1637 continue;
1638 if ((cp = strchr(loc, '"')) != NULL) {
1639 cp = imap_unquotestr(cp);
1640 imap_putstr(mp, m, cp, head, headsize, headlines);
1641 } else {
1642 m->m_have |= HAVE_HEADER|HAVE_BODY;
1643 m->m_xlines = m->m_lines;
1644 m->m_xsize = m->m_size;
1645 }
1646 goto out;
1647 }
1648 expected = atol(&cp[1]);
1649 if (m->m_uid ? n == 0 && m->m_uid != u : n != number) {
1650 imap_fetchdata(mp, NULL, expected, need, NULL, 0, 0);
1651 continue;
1652 }
1653 mt = *m;
1654 imap_fetchdata(mp, &mt, expected, need, head, headsize, headlines);
1655 if (n >= 0) {
1656 commitmsg(mp, m, &mt, mt.m_have);
1657 break;
1658 }
1659 if (n == -1 && sgetline(&imapbuf, &imapbufsize, NULL, &mp->mb_sock) > 0) {
1660 if (options & OPT_VERBOSE)
1661 fputs(imapbuf, stderr);
1662 if ((cp = asccasestr(imapbuf, "UID ")) != NULL) {
1663 u = atol(&cp[4]);
1664 if (u == m->m_uid) {
1665 commitmsg(mp, m, &mt, mt.m_have);
1666 break;
1667 }
1668 }
1669 }
1670 }
1671 out:
1672 while (mp->mb_active & MB_COMD)
1673 ok = imap_answer(mp, 1);
1674
1675 if (saveint != SIG_IGN)
1676 safe_signal(SIGINT, saveint);
1677 if (savepipe != SIG_IGN)
1678 safe_signal(SIGPIPE, savepipe);
1679 imaplock--;
1680
1681 if (ok == OKAY)
1682 putcache(mp, m);
1683 if (head != NULL)
1684 free(head);
1685 if (interrupts)
1686 onintr(0);
1687 return ok;
1688 }
1689
1690 FL enum okay
1691 imap_header(struct message *m)
1692 {
1693 enum okay rv;
1694 NYD_ENTER;
1695
1696 rv = imap_get(&mb, m, NEED_HEADER);
1697 NYD_LEAVE;
1698 return rv;
1699 }
1700
1701
1702 FL enum okay
1703 imap_body(struct message *m)
1704 {
1705 enum okay rv;
1706 NYD_ENTER;
1707
1708 rv = imap_get(&mb, m, NEED_BODY);
1709 NYD_LEAVE;
1710 return rv;
1711 }
1712
1713 static void
1714 commitmsg(struct mailbox *mp, struct message *tomp, struct message *frommp,
1715 enum havespec have)
1716 {
1717 NYD_ENTER;
1718 tomp->m_size = frommp->m_size;
1719 tomp->m_lines = frommp->m_lines;
1720 tomp->m_block = frommp->m_block;
1721 tomp->m_offset = frommp->m_offset;
1722 tomp->m_have = have;
1723 if (have & HAVE_BODY) {
1724 tomp->m_xlines = frommp->m_lines;
1725 tomp->m_xsize = frommp->m_size;
1726 }
1727 putcache(mp, tomp);
1728 NYD_LEAVE;
1729 }
1730
1731 static enum okay
1732 imap_fetchheaders(struct mailbox *mp, struct message *m, int bot, int topp)
1733 {
1734 /* bot > topp */
1735 char o[LINESIZE];
1736 char const *cp;
1737 struct message mt;
1738 size_t expected;
1739 int n = 0, u;
1740 FILE *queuefp = NULL;
1741 enum okay ok;
1742 NYD_X;
1743
1744 if (m[bot].m_uid)
1745 snprintf(o, sizeof o, "%s UID FETCH %lu:%lu (RFC822.HEADER)\r\n",
1746 tag(1), m[bot-1].m_uid, m[topp-1].m_uid);
1747 else {
1748 if (check_expunged() == STOP)
1749 return STOP;
1750 snprintf(o, sizeof o, "%s FETCH %u:%u (RFC822.HEADER)\r\n",
1751 tag(1), bot, topp);
1752 }
1753 IMAP_OUT(o, MB_COMD, return STOP)
1754 for (;;) {
1755 ok = imap_answer(mp, 1);
1756 if (response_status != RESPONSE_OTHER)
1757 break;
1758 if (response_other != MESSAGE_DATA_FETCH)
1759 continue;
1760 if (ok == STOP || (cp=strrchr(responded_other_text, '{')) == 0)
1761 return STOP;
1762 if (asccasestr(responded_other_text, "RFC822.HEADER") == NULL)
1763 continue;
1764 expected = atol(&cp[1]);
1765 if (m[bot-1].m_uid) {
1766 if ((cp = asccasestr(responded_other_text, "UID ")) != NULL) {
1767 u = atoi(&cp[4]);
1768 for (n = bot; n <= topp; n++)
1769 if ((unsigned long)u == m[n-1].m_uid)
1770 break;
1771 if (n > topp) {
1772 imap_fetchdata(mp, NULL, expected, NEED_HEADER, NULL, 0, 0);
1773 continue;
1774 }
1775 } else
1776 n = -1;
1777 } else {
1778 n = responded_other_number;
1779 if (n <= 0 || n > msgCount) {
1780 imap_fetchdata(mp, NULL, expected, NEED_HEADER, NULL, 0, 0);
1781 continue;
1782 }
1783 }
1784 imap_fetchdata(mp, &mt, expected, NEED_HEADER, NULL, 0, 0);
1785 if (n >= 0 && !(m[n-1].m_have & HAVE_HEADER))
1786 commitmsg(mp, &m[n-1], &mt, HAVE_HEADER);
1787 if (n == -1 && sgetline(&imapbuf, &imapbufsize, NULL, &mp->mb_sock) > 0) {
1788 if (options & OPT_VERBOSE)
1789 fputs(imapbuf, stderr);
1790 if ((cp = asccasestr(imapbuf, "UID ")) != NULL) {
1791 u = atoi(&cp[4]);
1792 for (n = bot; n <= topp; n++)
1793 if ((unsigned long)u == m[n-1].m_uid)
1794 break;
1795 if (n <= topp && !(m[n-1].m_have & HAVE_HEADER))
1796 commitmsg(mp, &m[n-1], &mt,HAVE_HEADER);
1797 n = 0;
1798 }
1799 }
1800 }
1801 while (mp->mb_active & MB_COMD)
1802 ok = imap_answer(mp, 1);
1803 return ok;
1804 }
1805
1806 FL void
1807 imap_getheaders(int volatile bot, int topp) /* TODO should take iterator!! */
1808 {
1809 sighandler_type saveint, savepipe;
1810 /* enum okay ok = STOP;*/
1811 int i, chunk = 256;
1812 NYD_X;
1813
1814 if (mb.mb_type == MB_CACHE)
1815 return;
1816 if (bot < 1)
1817 bot = 1;
1818 if (topp > msgCount)
1819 topp = msgCount;
1820 for (i = bot; i < topp; i++) {
1821 if (message[i-1].m_have & HAVE_HEADER ||
1822 getcache(&mb, &message[i-1], NEED_HEADER) == OKAY)
1823 bot = i+1;
1824 else
1825 break;
1826 }
1827 for (i = topp; i > bot; i--) {
1828 if (message[i-1].m_have & HAVE_HEADER ||
1829 getcache(&mb, &message[i-1], NEED_HEADER) == OKAY)
1830 topp = i-1;
1831 else
1832 break;
1833 }
1834 if (bot >= topp)
1835 return;
1836
1837 imaplock = 1;
1838 if ((saveint = safe_signal(SIGINT, SIG_IGN)) != SIG_IGN)
1839 safe_signal(SIGINT, &_imap_maincatch);
1840 savepipe = safe_signal(SIGPIPE, SIG_IGN);
1841 if (sigsetjmp(imapjmp, 1) == 0) {
1842 if (savepipe != SIG_IGN)
1843 safe_signal(SIGPIPE, imapcatch);
1844
1845 for (i = bot; i <= topp; i += chunk) {
1846 int j = i + chunk - 1;
1847 /*ok = */imap_fetchheaders(&mb, message, i, (j < topp ? j : topp));
1848 if (interrupts)
1849 onintr(0); /* XXX imaplock? */
1850 }
1851 }
1852 safe_signal(SIGINT, saveint);
1853 safe_signal(SIGPIPE, savepipe);
1854 imaplock = 0;
1855 }
1856
1857 static enum okay
1858 __imap_exit(struct mailbox *mp)
1859 {
1860 char o[LINESIZE];
1861 FILE *queuefp = NULL;
1862 NYD_X;
1863
1864 mp->mb_active |= MB_BYE;
1865 snprintf(o, sizeof o, "%s LOGOUT\r\n", tag(1));
1866 IMAP_OUT(o, MB_COMD, return STOP)
1867 IMAP_ANSWER()
1868 return OKAY;
1869 }
1870
1871 static enum okay
1872 imap_exit(struct mailbox *mp)
1873 {
1874 enum okay rv;
1875 NYD_ENTER;
1876
1877 rv = __imap_exit(mp);
1878 #if 0 /* TODO the option today: memory leak(s) and halfway reuse or nottin */
1879 free(mp->mb_imap_account);
1880 free(mp->mb_imap_mailbox);
1881 if (mp->mb_cache_directory != NULL)
1882 free(mp->mb_cache_directory);
1883 #ifndef HAVE_DEBUG /* TODO ASSERT LEGACY */
1884 mp->mb_imap_account =
1885 mp->mb_imap_mailbox =
1886 mp->mb_cache_directory = "";
1887 #else
1888 mp->mb_imap_account = NULL; /* for assert legacy time.. */
1889 mp->mb_imap_mailbox = NULL;
1890 mp->mb_cache_directory = NULL;
1891 #endif
1892 #endif
1893 sclose(&mp->mb_sock);
1894 NYD_LEAVE;
1895 return rv;
1896 }
1897
1898 static enum okay
1899 imap_delete(struct mailbox *mp, int n, struct message *m, int needstat)
1900 {
1901 NYD_ENTER;
1902 imap_store(mp, m, n, '+', "\\Deleted", needstat);
1903 if (mp->mb_type == MB_IMAP)
1904 delcache(mp, m);
1905 NYD_LEAVE;
1906 return OKAY;
1907 }
1908
1909 static enum okay
1910 imap_close(struct mailbox *mp)
1911 {
1912 char o[LINESIZE];
1913 FILE *queuefp = NULL;
1914 NYD_X;
1915
1916 snprintf(o, sizeof o, "%s CLOSE\r\n", tag(1));
1917 IMAP_OUT(o, MB_COMD, return STOP)
1918 IMAP_ANSWER()
1919 return OKAY;
1920 }
1921
1922 static enum okay
1923 imap_update(struct mailbox *mp)
1924 {
1925 struct message *m;
1926 int dodel, c, gotcha = 0, held = 0, modflags = 0, needstat, stored = 0;
1927 NYD_ENTER;
1928
1929 if (!edit && mp->mb_perm != 0) {
1930 holdbits();
1931 c = 0;
1932 for (m = message; PTRCMP(m, <, message + msgCount); ++m)
1933 if (m->m_flag & MBOX)
1934 ++c;
1935 if (c > 0)
1936 if (makembox() == STOP)
1937 goto jbypass;
1938 }
1939
1940 gotcha = held = 0;
1941 for (m = message; PTRCMP(m, <, message + msgCount); ++m) {
1942 if (mp->mb_perm == 0)
1943 dodel = 0;
1944 else if (edit)
1945 dodel = ((m->m_flag & MDELETED) != 0);
1946 else
1947 dodel = !((m->m_flag & MPRESERVE) || !(m->m_flag & MTOUCH));
1948
1949 /* Fetch the result after around each 800 STORE commands
1950 * sent (approx. 32k data sent). Otherwise, servers will
1951 * try to flush the return queue at some point, leading
1952 * to a deadlock if we are still writing commands but not
1953 * reading their results */
1954 needstat = stored > 0 && stored % 800 == 0;
1955 /* Even if this message has been deleted, continue
1956 * to set further flags. This is necessary to support
1957 * Gmail semantics, where "delete" actually means
1958 * "archive", and the flags are applied to the copy
1959 * in "All Mail" */
1960 if ((m->m_flag & (MREAD | MSTATUS)) == (MREAD | MSTATUS)) {
1961 imap_store(mp, m, m-message+1, '+', "\\Seen", needstat);
1962 stored++;
1963 }
1964 if (m->m_flag & MFLAG) {
1965 imap_store(mp, m, m-message+1, '+', "\\Flagged", needstat);
1966 stored++;
1967 }
1968 if (m->m_flag & MUNFLAG) {
1969 imap_store(mp, m, m-message+1, '-', "\\Flagged", needstat);
1970 stored++;
1971 }
1972 if (m->m_flag & MANSWER) {
1973 imap_store(mp, m, m-message+1, '+', "\\Answered", needstat);
1974 stored++;
1975 }
1976 if (m->m_flag & MUNANSWER) {
1977 imap_store(mp, m, m-message+1, '-', "\\Answered", needstat);
1978 stored++;
1979 }
1980 if (m->m_flag & MDRAFT) {
1981 imap_store(mp, m, m-message+1, '+', "\\Draft", needstat);
1982 stored++;
1983 }
1984 if (m->m_flag & MUNDRAFT) {
1985 imap_store(mp, m, m-message+1, '-', "\\Draft", needstat);
1986 stored++;
1987 }
1988
1989 if (dodel) {
1990 imap_delete(mp, m-message+1, m, needstat);
1991 stored++;
1992 gotcha++;
1993 } else if (mp->mb_type != MB_CACHE ||
1994 (!edit && !(m->m_flag & (MBOXED | MSAVED | MDELETED))) ||
1995 (m->m_flag & (MBOXED | MPRESERVE | MTOUCH)) ==
1996 (MPRESERVE | MTOUCH) || (edit && !(m->m_flag & MDELETED)))
1997 held++;
1998 if (m->m_flag & MNEW) {
1999 m->m_flag &= ~MNEW;
2000 m->m_flag |= MSTATUS;
2001 }
2002 }
2003 jbypass:
2004 if (gotcha)
2005 imap_close(mp);
2006
2007 for (m = &message[0]; PTRCMP(m, <, message + msgCount); ++m)
2008 if (!(m->m_flag & MUNLINKED) &&
2009 m->m_flag & (MBOXED | MDELETED | MSAVED | MSTATUS | MFLAG |
2010 MUNFLAG | MANSWER | MUNANSWER | MDRAFT | MUNDRAFT)) {
2011 putcache(mp, m);
2012 modflags++;
2013 }
2014 if ((gotcha || modflags) && edit) {
2015 printf(tr(168, "\"%s\" "), displayname);
2016 printf((ok_blook(bsdcompat) || ok_blook(bsdmsgs))
2017 ? tr(170, "complete\n") : tr(212, "updated.\n"));
2018 } else if (held && !edit && mp->mb_perm != 0) {
2019 if (held == 1)
2020 printf(tr(155, "Held 1 message in %s\n"), displayname);
2021 else
2022 printf(tr(156, "Held %d messages in %s\n"), held, displayname);
2023 }
2024 fflush(stdout);
2025 NYD_LEAVE;
2026 return OKAY;
2027 }
2028
2029 FL void
2030 imap_quit(void)
2031 {
2032 sighandler_type volatile saveint, savepipe;
2033 NYD_ENTER;
2034
2035 if (mb.mb_type == MB_CACHE) {
2036 imap_update(&mb);
2037 goto jleave;
2038 }
2039
2040 if (mb.mb_sock.s_fd < 0) {
2041 fprintf(stderr, "IMAP connection closed.\n");
2042 goto jleave;
2043 }
2044
2045 imaplock = 1;
2046 saveint = safe_signal(SIGINT, SIG_IGN);
2047 savepipe = safe_signal(SIGPIPE, SIG_IGN);
2048 if (sigsetjmp(imapjmp, 1)) {
2049 safe_signal(SIGINT, saveint);
2050 safe_signal(SIGPIPE, saveint);
2051 imaplock = 0;
2052 goto jleave;
2053 }
2054 if (saveint != SIG_IGN)
2055 safe_signal(SIGINT, imapcatch);
2056 if (savepipe != SIG_IGN)
2057 safe_signal(SIGPIPE, imapcatch);
2058
2059 imap_update(&mb);
2060 if (!same_imap_account)
2061 imap_exit(&mb);
2062
2063 safe_signal(SIGINT, saveint);
2064 safe_signal(SIGPIPE, savepipe);
2065 imaplock = 0;
2066 jleave:
2067 NYD_LEAVE;
2068 }
2069
2070 static enum okay
2071 imap_store(struct mailbox *mp, struct message *m, int n, int c, const char *sp,
2072 int needstat)
2073 {
2074 char o[LINESIZE];
2075 FILE *queuefp = NULL;
2076 NYD_X;
2077
2078 if (mp->mb_type == MB_CACHE && (queuefp = cache_queue(mp)) == NULL)
2079 return STOP;
2080 if (m->m_uid)
2081 snprintf(o, sizeof o, "%s UID STORE %lu %cFLAGS (%s)\r\n",
2082 tag(1), m->m_uid, c, sp);
2083 else {
2084 if (check_expunged() == STOP)
2085 return STOP;
2086 snprintf(o, sizeof o, "%s STORE %u %cFLAGS (%s)\r\n", tag(1), n, c, sp);
2087 }
2088 IMAP_OUT(o, MB_COMD, return STOP)
2089 if (needstat)
2090 IMAP_ANSWER()
2091 else
2092 mb.mb_active &= ~MB_COMD;
2093 if (queuefp != NULL)
2094 Fclose(queuefp);
2095 return OKAY;
2096 }
2097
2098 FL enum okay
2099 imap_undelete(struct message *m, int n)
2100 {
2101 enum okay rv;
2102 NYD_ENTER;
2103
2104 rv = imap_unstore(m, n, "\\Deleted");
2105 NYD_LEAVE;
2106 return rv;
2107 }
2108
2109 FL enum okay
2110 imap_unread(struct message *m, int n)
2111 {
2112 enum okay rv;
2113 NYD_ENTER;
2114
2115 rv = imap_unstore(m, n, "\\Seen");
2116 NYD_LEAVE;
2117 return rv;
2118 }
2119
2120 static enum okay
2121 imap_unstore(struct message *m, int n, const char *flag)
2122 {
2123 sighandler_type saveint, savepipe;
2124 enum okay rv = STOP;
2125 NYD_ENTER;
2126
2127 imaplock = 1;
2128 if ((saveint = safe_signal(SIGINT, SIG_IGN)) != SIG_IGN)
2129 safe_signal(SIGINT, &_imap_maincatch);
2130 savepipe = safe_signal(SIGPIPE, SIG_IGN);
2131 if (sigsetjmp(imapjmp, 1) == 0) {
2132 if (savepipe != SIG_IGN)
2133 safe_signal(SIGPIPE, imapcatch);
2134
2135 rv = imap_store(&mb, m, n, '-', flag, 1);
2136 }
2137 safe_signal(SIGINT, saveint);
2138 safe_signal(SIGPIPE, savepipe);
2139 imaplock = 0;
2140
2141 NYD_LEAVE;
2142 if (interrupts)
2143 onintr(0);
2144 return rv;
2145 }
2146
2147 static const char *
2148 tag(int new)
2149 {
2150 static char ts[20];
2151 static long n;
2152 NYD_ENTER;
2153
2154 if (new)
2155 ++n;
2156 snprintf(ts, sizeof ts, "T%lu", n);
2157 NYD_LEAVE;
2158 return ts;
2159 }
2160
2161 FL int
2162 c_imap_imap(void *vp)
2163 {
2164 char o[LINESIZE];
2165 sighandler_type saveint, savepipe;
2166 struct mailbox *mp = &mb;
2167 FILE *queuefp = NULL;
2168 enum okay ok = STOP;
2169 NYD_X;
2170
2171 if (mp->mb_type != MB_IMAP) {
2172 printf("Not operating on an IMAP mailbox.\n");
2173 return 1;
2174 }
2175 imaplock = 1;
2176 if ((saveint = safe_signal(SIGINT, SIG_IGN)) != SIG_IGN)
2177 safe_signal(SIGINT, &_imap_maincatch);
2178 savepipe = safe_signal(SIGPIPE, SIG_IGN);
2179 if (sigsetjmp(imapjmp, 1) == 0) {
2180 if (savepipe != SIG_IGN)
2181 safe_signal(SIGPIPE, imapcatch);
2182
2183 snprintf(o, sizeof o, "%s %s\r\n", tag(1), (char *)vp);
2184 IMAP_OUT(o, MB_COMD, goto out)
2185 while (mp->mb_active & MB_COMD) {
2186 ok = imap_answer(mp, 0);
2187 fputs(responded_text, stdout);
2188 }
2189 }
2190 out:
2191 safe_signal(SIGINT, saveint);
2192 safe_signal(SIGPIPE, savepipe);
2193 imaplock = 0;
2194
2195 if (interrupts)
2196 onintr(0);
2197 return ok != OKAY;
2198 }
2199
2200 FL int
2201 imap_newmail(int nmail)
2202 {
2203 NYD_ENTER;
2204
2205 if (nmail && had_exists < 0 && had_expunge < 0) {
2206 imaplock = 1;
2207 imap_noop();
2208 imaplock = 0;
2209 }
2210
2211 if (had_exists == msgCount && had_expunge < 0)
2212 /* Some servers always respond with EXISTS to NOOP. If
2213 * the mailbox has been changed but the number of messages
2214 * has not, an EXPUNGE must also had been sent; otherwise,
2215 * nothing has changed */
2216 had_exists = -1;
2217 NYD_LEAVE;
2218 return (had_expunge >= 0 ? 2 : (had_exists >= 0 ? 1 : 0));
2219 }
2220
2221 static char *
2222 imap_putflags(int f)
2223 {
2224 const char *cp;
2225 char *buf, *bp;
2226 NYD_ENTER;
2227
2228 bp = buf = salloc(100);
2229 if (f & (MREAD | MFLAGGED | MANSWERED | MDRAFTED)) {
2230 *bp++ = '(';
2231 if (f & MREAD) {
2232 if (bp[-1] != '(')
2233 *bp++ = ' ';
2234 for (cp = "\\Seen"; *cp; cp++)
2235 *bp++ = *cp;
2236 }
2237 if (f & MFLAGGED) {
2238 if (bp[-1] != '(')
2239 *bp++ = ' ';
2240 for (cp = "\\Flagged"; *cp; cp++)
2241 *bp++ = *cp;
2242 }
2243 if (f & MANSWERED) {
2244 if (bp[-1] != '(')
2245 *bp++ = ' ';
2246 for (cp = "\\Answered"; *cp; cp++)
2247 *bp++ = *cp;
2248 }
2249 if (f & MDRAFT) {
2250 if (bp[-1] != '(')
2251 *bp++ = ' ';
2252 for (cp = "\\Draft"; *cp; cp++)
2253 *bp++ = *cp;
2254 }
2255 *bp++ = ')';
2256 *bp++ = ' ';
2257 }
2258 *bp = '\0';
2259 NYD_LEAVE;
2260 return buf;
2261 }
2262
2263 static void
2264 imap_getflags(const char *cp, char const **xp, enum mflag *f)
2265 {
2266 NYD_ENTER;
2267 while (*cp != ')') {
2268 if (*cp == '\\') {
2269 if (ascncasecmp(cp, "\\Seen", 5) == 0)
2270 *f |= MREAD;
2271 else if (ascncasecmp(cp, "\\Recent", 7) == 0)
2272 *f |= MNEW;
2273 else if (ascncasecmp(cp, "\\Deleted", 8) == 0)
2274 *f |= MDELETED;
2275 else if (ascncasecmp(cp, "\\Flagged", 8) == 0)
2276 *f |= MFLAGGED;
2277 else if (ascncasecmp(cp, "\\Answered", 9) == 0)
2278 *f |= MANSWERED;
2279 else if (ascncasecmp(cp, "\\Draft", 6) == 0)
2280 *f |= MDRAFTED;
2281 }
2282 cp++;
2283 }
2284
2285 if (xp != NULL)
2286 *xp = cp;
2287 NYD_LEAVE;
2288 }
2289
2290 static enum okay
2291 imap_append1(struct mailbox *mp, const char *name, FILE *fp, off_t off1,
2292 long xsize, enum mflag flag, time_t t)
2293 {
2294 char o[LINESIZE], *buf;
2295 size_t bufsize, buflen, cnt;
2296 long size, lines, ysize;
2297 int twice = 0;
2298 FILE *queuefp = NULL;
2299 enum okay rv;
2300 NYD_ENTER;
2301
2302 if (mp->mb_type == MB_CACHE) {
2303 queuefp = cache_queue(mp);
2304 if (queuefp == NULL) {
2305 rv = STOP;
2306 buf = NULL;
2307 goto jleave;
2308 }
2309 rv = OKAY;
2310 } else
2311 rv = STOP;
2312
2313 buf = smalloc(bufsize = LINESIZE);
2314 buflen = 0;
2315 jagain:
2316 size = xsize;
2317 cnt = fsize(fp);
2318 if (fseek(fp, off1, SEEK_SET) < 0) {
2319 rv = STOP;
2320 goto jleave;
2321 }
2322
2323 snprintf(o, sizeof o, "%s APPEND %s %s%s {%ld}\r\n",
2324 tag(1), imap_quotestr(name), imap_putflags(flag),
2325 imap_make_date_time(t), size);
2326 IMAP_XOUT(o, MB_COMD, goto jleave, rv=STOP;goto jleave)
2327 while (mp->mb_active & MB_COMD) {
2328 rv = imap_answer(mp, twice);
2329 if (response_type == RESPONSE_CONT)
2330 break;
2331 }
2332
2333 if (mp->mb_type != MB_CACHE && rv == STOP) {
2334 if (twice == 0)
2335 goto jtrycreate;
2336 else
2337 goto jleave;
2338 }
2339
2340 lines = ysize = 0;
2341 while (size > 0) {
2342 fgetline(&buf, &bufsize, &cnt, &buflen, fp, 1);
2343 lines++;
2344 ysize += buflen;
2345 buf[buflen - 1] = '\r';
2346 buf[buflen] = '\n';
2347 if (mp->mb_type != MB_CACHE)
2348 swrite1(&mp->mb_sock, buf, buflen+1, 1);
2349 else if (queuefp)
2350 fwrite(buf, 1, buflen+1, queuefp);
2351 size -= buflen + 1;
2352 }
2353 if (mp->mb_type != MB_CACHE)
2354 swrite(&mp->mb_sock, "\r\n");
2355 else if (queuefp)
2356 fputs("\r\n", queuefp);
2357 while (mp->mb_active & MB_COMD) {
2358 rv = imap_answer(mp, 0);
2359 if (response_status == RESPONSE_NO /*&&
2360 ascncasecmp(responded_text,
2361 "[TRYCREATE] ", 12) == 0*/) {
2362 jtrycreate:
2363 if (twice++) {
2364 rv = STOP;
2365 goto jleave;
2366 }
2367 snprintf(o, sizeof o, "%s CREATE %s\r\n", tag(1), imap_quotestr(name));
2368 IMAP_XOUT(o, MB_COMD, goto jleave, rv=STOP;goto jleave)
2369 while (mp->mb_active & MB_COMD)
2370 rv = imap_answer(mp, 1);
2371 if (rv == STOP)
2372 goto jleave;
2373 imap_created_mailbox++;
2374 goto jagain;
2375 } else if (rv != OKAY)
2376 fprintf(stderr, tr(270, "IMAP error: %s"), responded_text);
2377 else if (response_status == RESPONSE_OK && (mp->mb_flags & MB_UIDPLUS))
2378 imap_appenduid(mp, fp, t, off1, xsize, ysize, lines, flag, name);
2379 }
2380 jleave:
2381 if (queuefp != NULL)
2382 Fclose(queuefp);
2383 if (buf != NULL)
2384 free(buf);
2385 NYD_LEAVE;
2386 return rv;
2387 }
2388
2389 static enum okay
2390 imap_append0(struct mailbox *mp, const char *name, FILE *fp)
2391 {
2392 char *buf, *bp, *lp;
2393 size_t bufsize, buflen, cnt;
2394 off_t off1 = -1, offs;
2395 int inhead = 1, flag = MNEW | MNEWEST;
2396 long size = 0;
2397 time_t tim;
2398 enum okay rv;
2399 NYD_ENTER;
2400
2401 buf = smalloc(bufsize = LINESIZE);
2402 buflen = 0;
2403 cnt = fsize(fp);
2404 offs = ftell(fp);
2405 time(&tim);
2406
2407 do {
2408 bp = fgetline(&buf, &bufsize, &cnt, &buflen, fp, 1);
2409 if (bp == NULL || strncmp(buf, "From ", 5) == 0) {
2410 if (off1 != (off_t)-1) {
2411 rv = imap_append1(mp, name, fp, off1, size, flag, tim);
2412 if (rv == STOP)
2413 goto jleave;
2414 fseek(fp, offs+buflen, SEEK_SET);
2415 }
2416 off1 = offs + buflen;
2417 size = 0;
2418 inhead = 1;
2419 flag = MNEW;
2420 if (bp != NULL)
2421 tim = unixtime(buf);
2422 } else
2423 size += buflen+1;
2424 offs += buflen;
2425
2426 if (bp && buf[0] == '\n')
2427 inhead = 0;
2428 else if (bp && inhead && ascncasecmp(buf, "status", 6) == 0) {
2429 lp = &buf[6];
2430 while (whitechar(*lp))
2431 lp++;
2432 if (*lp == ':')
2433 while (*++lp != '\0')
2434 switch (*lp) {
2435 case 'R':
2436 flag |= MREAD;
2437 break;
2438 case 'O':
2439 flag &= ~MNEW;
2440 break;
2441 }
2442 } else if (bp && inhead && ascncasecmp(buf, "x-status", 8) == 0) {
2443 lp = &buf[8];
2444 while (whitechar(*lp))
2445 lp++;
2446 if (*lp == ':')
2447 while (*++lp != '\0')
2448 switch (*lp) {
2449 case 'F':
2450 flag |= MFLAGGED;
2451 break;
2452 case 'A':
2453 flag |= MANSWERED;
2454 break;
2455 case 'T':
2456 flag |= MDRAFTED;
2457 break;
2458 }
2459 }
2460 } while (bp != NULL);
2461 rv = OKAY;
2462 jleave:
2463 free(buf);
2464 NYD_LEAVE;
2465 return rv;
2466 }
2467
2468 FL enum okay
2469 imap_append(const char *xserver, FILE *fp)
2470 {
2471 sighandler_type volatile saveint, savepipe;
2472 char *server, *user, *pass;
2473 char const *sp, *cp, * volatile mbx, *uhp;
2474 int volatile use_ssl;
2475 enum okay rv = STOP;
2476 NYD_ENTER;
2477
2478 server = savestr(xserver);
2479 {
2480 int xus;
2481 char const *xmbx;
2482 imap_split(&server, &sp, &xus, &cp, &uhp, &xmbx, &pass, &user);
2483 use_ssl = xus;
2484 mbx = xmbx;
2485 }
2486
2487 imaplock = 1;
2488 if ((saveint = safe_signal(SIGINT, SIG_IGN)) != SIG_IGN)
2489 safe_signal(SIGINT, &_imap_maincatch);
2490 savepipe = safe_signal(SIGPIPE, SIG_IGN);
2491 if (sigsetjmp(imapjmp, 1))
2492 goto jleave;
2493 if (savepipe != SIG_IGN)
2494 safe_signal(SIGPIPE, imapcatch);
2495
2496 if ((mb.mb_type == MB_CACHE || mb.mb_sock.s_fd > 0) && mb.mb_imap_account &&
2497 strcmp(protbase(server), mb.mb_imap_account) == 0) {
2498 rv = imap_append0(&mb, mbx, fp);
2499 } else {
2500 struct mailbox mx;
2501
2502 memset(&mx, 0, sizeof mx);
2503 if (disconnected(server) == 0) {
2504 if (sopen(sp, &mx.mb_sock, use_ssl, uhp,
2505 (use_ssl ? "imaps" : "imap")) != OKAY)
2506 goto jfail;
2507 mx.mb_sock.s_desc = "IMAP";
2508 mx.mb_type = MB_IMAP;
2509 mx.mb_imap_account = (char *)protbase(server);
2510 /* TODO the code now did
2511 * TODO mx.mb_imap_mailbox = mbx;
2512 * TODO though imap_mailbox is sfree()d and mbx
2513 * TODO is possibly even a constant
2514 * TODO i changed this to sstrdup() sofar, as is used
2515 * TODO somewhere else in this file for this! */
2516 mx.mb_imap_mailbox = sstrdup(mbx);
2517 if (imap_preauth(&mx, sp, uhp) != OKAY ||
2518 imap_auth(&mx, uhp, user, pass)!=OKAY) {
2519 sclose(&mx.mb_sock);
2520 goto jfail;
2521 }
2522 rv = imap_append0(&mx, mbx, fp);
2523 imap_exit(&mx);
2524 } else {
2525 mx.mb_imap_account = (char*)protbase(server);
2526 mx.mb_imap_mailbox = sstrdup(mbx); /* TODO as above */
2527 mx.mb_type = MB_CACHE;
2528 rv = imap_append0(&mx, mbx, fp);
2529 }
2530 jfail:
2531 ;
2532 }
2533 jleave:
2534 safe_signal(SIGINT, saveint);
2535 safe_signal(SIGPIPE, savepipe);
2536 imaplock = 0;
2537
2538 NYD_LEAVE;
2539 if (interrupts)
2540 onintr(0);
2541 return rv;
2542 }
2543
2544 static enum okay
2545 imap_list1(struct mailbox *mp, const char *base, struct list_item **list,
2546 struct list_item **lend, int level)
2547 {
2548 char o[LINESIZE], *cp;
2549 const char *bp;
2550 FILE *queuefp = NULL;
2551 struct list_item *lp;
2552 enum okay ok = STOP;
2553 NYD_X;
2554
2555 *list = *lend = NULL;
2556 snprintf(o, sizeof o, "%s LIST %s %%\r\n", tag(1), imap_quotestr(base));
2557 IMAP_OUT(o, MB_COMD, return STOP)
2558 while (mp->mb_active & MB_COMD) {
2559 ok = imap_answer(mp, 1);
2560 if (response_status == RESPONSE_OTHER &&
2561 response_other == MAILBOX_DATA_LIST && imap_parse_list() == OKAY) {
2562 cp = imap_unquotestr(list_name);
2563 lp = csalloc(1, sizeof *lp);
2564 lp->l_name = cp;
2565 for (bp = base; *bp != '\0' && *bp == *cp; ++bp)
2566 ++cp;
2567 lp->l_base = *cp ? cp : savestr(base);
2568 lp->l_attr = list_attributes;
2569 lp->l_level = level+1;
2570 lp->l_delim = list_hierarchy_delimiter;
2571 if (*list && *lend) {
2572 (*lend)->l_next = lp;
2573 *lend = lp;
2574 } else
2575 *list = *lend = lp;
2576 }
2577 }
2578 return ok;
2579 }
2580
2581 static enum okay
2582 imap_list(struct mailbox *mp, const char *base, int strip, FILE *fp)
2583 {
2584 struct list_item *list, *lend, *lp, *lx, *ly;
2585 int n, depth;
2586 const char *bp;
2587 char *cp;
2588 enum okay rv;
2589 NYD_ENTER;
2590
2591 depth = (cp = ok_vlook(imap_list_depth)) != NULL ? atoi(cp) : 2;
2592 if ((rv = imap_list1(mp, base, &list, &lend, 0)) == STOP)
2593 goto jleave;
2594 rv = OKAY;
2595 if (list == NULL || lend == NULL)
2596 goto jleave;
2597
2598 for (lp = list; lp; lp = lp->l_next)
2599 if (lp->l_delim != '/' && lp->l_delim != EOF && lp->l_level < depth &&
2600 !(lp->l_attr & LIST_NOINFERIORS)) {
2601 cp = salloc((n = strlen(lp->l_name)) + 2);
2602 memcpy(cp, lp->l_name, n);
2603 cp[n] = lp->l_delim;
2604 cp[n+1] = '\0';
2605 if (imap_list1(mp, cp, &lx, &ly, lp->l_level) == OKAY && lx && ly) {
2606 lp->l_has_children = 1;
2607 if (strcmp(cp, lx->l_name) == 0)
2608 lx = lx->l_next;
2609 if (lx) {
2610 lend->l_next = lx;
2611 lend = ly;
2612 }
2613 }
2614 }
2615
2616 for (lp = list; lp; lp = lp->l_next) {
2617 if (strip) {
2618 cp = lp->l_name;
2619 for (bp = base; *bp && *bp == *cp; bp++)
2620 cp++;
2621 } else
2622 cp = lp->l_name;
2623 if (!(lp->l_attr & LIST_NOSELECT))
2624 fprintf(fp, "%s\n", *cp ? cp : base);
2625 else if (lp->l_has_children == 0)
2626 fprintf(fp, "%s%c\n", *cp ? cp : base,
2627 (lp->l_delim != EOF ? lp->l_delim : '\n'));
2628 }
2629 jleave:
2630 NYD_LEAVE;
2631 return rv;
2632 }
2633
2634 FL void
2635 imap_folders(const char * volatile name, int strip)
2636 {
2637 sighandler_type saveint, savepipe;
2638 const char *fold, *cp, *sp;
2639 FILE * volatile fp;
2640 NYD_ENTER;
2641
2642 cp = protbase(name);
2643 sp = mb.mb_imap_account;
2644 if (sp == NULL || strcmp(cp, sp)) {
2645 fprintf(stderr, tr(502,
2646 "Cannot perform `folders' but when on the very IMAP "
2647 "account; the current one is\n `%s' -- "
2648 "try `folders @'.\n"),
2649 (sp != NULL ? sp : tr(503, "[NONE]")));
2650 goto jleave;
2651 }
2652
2653 fold = imap_fileof(name);
2654 if (options & OPT_TTYOUT) {
2655 if ((fp = Ftmp(NULL, "imapfold", OF_RDWR | OF_UNLINK | OF_REGISTER,
2656 0600)) == NULL) {
2657 perror("tmpfile");
2658 goto jleave;
2659 }
2660 } else
2661 fp = stdout;
2662
2663 imaplock = 1;
2664 if ((saveint = safe_signal(SIGINT, SIG_IGN)) != SIG_IGN)
2665 safe_signal(SIGINT, &_imap_maincatch);
2666 savepipe = safe_signal(SIGPIPE, SIG_IGN);
2667 if (sigsetjmp(imapjmp, 1)) /* TODO imaplock? */
2668 goto junroll;
2669 if (savepipe != SIG_IGN)
2670 safe_signal(SIGPIPE, imapcatch);
2671
2672 if (mb.mb_type == MB_CACHE)
2673 cache_list(&mb, fold, strip, fp);
2674 else
2675 imap_list(&mb, fold, strip, fp);
2676
2677 imaplock = 0;
2678 if (interrupts) {
2679 if (options & OPT_TTYOUT)
2680 Fclose(fp);
2681 goto jleave;
2682 }
2683 fflush(fp);
2684
2685 if (options & OPT_TTYOUT) {
2686 rewind(fp);
2687 if (fsize(fp) > 0)
2688 dopr(fp);
2689 else
2690 fprintf(stderr, "Folder not found.\n");
2691 }
2692 junroll:
2693 safe_signal(SIGINT, saveint);
2694 safe_signal(SIGPIPE, savepipe);
2695 if (options & OPT_TTYOUT)
2696 Fclose(fp);
2697 jleave:
2698 NYD_LEAVE;
2699 if (interrupts)
2700 onintr(0);
2701 }
2702
2703 static void
2704 dopr(FILE *fp)
2705 {
2706 char o[LINESIZE];
2707 int c;
2708 long n = 0, mx = 0, columns, width;
2709 FILE *out;
2710 NYD_ENTER;
2711
2712 if ((out = Ftmp(NULL, "imapdopr", OF_RDWR | OF_UNLINK | OF_REGISTER, 0600))
2713 == NULL) {
2714 perror("tmpfile");
2715 goto jleave;
2716 }
2717
2718 while ((c = getc(fp)) != EOF) {
2719 if (c == '\n') {
2720 if (n > mx)
2721 mx = n;
2722 n = 0;
2723 } else
2724 ++n;
2725 }
2726 rewind(fp);
2727
2728 width = scrnwidth;
2729 if (mx < width / 2) {
2730 columns = width / (mx+2);
2731 snprintf(o, sizeof o, "sort | pr -%lu -w%lu -t", columns, width);
2732 } else
2733 strncpy(o, "sort", sizeof o)[sizeof o - 1] = '\0';
2734 run_command(XSHELL, 0, fileno(fp), fileno(out), "-c", o, NULL);
2735 try_pager(out);
2736 Fclose(out);
2737 jleave:
2738 NYD_LEAVE;
2739 }
2740
2741 static enum okay
2742 imap_copy1(struct mailbox *mp, struct message *m, int n, const char *name)
2743 {
2744 char o[LINESIZE];
2745 const char *qname;
2746 int twice = 0, stored = 0;
2747 FILE *queuefp = NULL;
2748 enum okay ok = STOP;
2749 NYD_X;
2750
2751 if (mp->mb_type == MB_CACHE) {
2752 if ((queuefp = cache_queue(mp)) == NULL)
2753 return STOP;
2754 ok = OKAY;
2755 }
2756 qname = imap_quotestr(name = imap_fileof(name));
2757 /* Since it is not possible to set flags on the copy, recently
2758 * set flags must be set on the original to include it in the copy */
2759 if ((m->m_flag & (MREAD | MSTATUS)) == (MREAD | MSTATUS))
2760 imap_store(mp, m, n, '+', "\\Seen", 0);
2761 if (m->m_flag&MFLAG)
2762 imap_store(mp, m, n, '+', "\\Flagged", 0);
2763 if (m->m_flag&MUNFLAG)
2764 imap_store(mp, m, n, '-', "\\Flagged", 0);
2765 if (m->m_flag&MANSWER)
2766 imap_store(mp, m, n, '+', "\\Answered", 0);
2767 if (m->m_flag&MUNANSWER)
2768 imap_store(mp, m, n, '-', "\\Flagged", 0);
2769 if (m->m_flag&MDRAFT)
2770 imap_store(mp, m, n, '+', "\\Draft", 0);
2771 if (m->m_flag&MUNDRAFT)
2772 imap_store(mp, m, n, '-', "\\Draft", 0);
2773 again:
2774 if (m->m_uid)
2775 snprintf(o, sizeof o, "%s UID COPY %lu %s\r\n", tag(1), m->m_uid, qname);
2776 else {
2777 if (check_expunged() == STOP)
2778 goto out;
2779 snprintf(o, sizeof o, "%s COPY %u %s\r\n", tag(1), n, qname);
2780 }
2781 IMAP_OUT(o, MB_COMD, goto out)
2782 while (mp->mb_active & MB_COMD)
2783 ok = imap_answer(mp, twice);
2784
2785 if (mp->mb_type == MB_IMAP && mp->mb_flags & MB_UIDPLUS &&
2786 response_status == RESPONSE_OK)
2787 imap_copyuid(mp, m, name);
2788
2789 if (response_status == RESPONSE_NO && twice++ == 0) {
2790 snprintf(o, sizeof o, "%s CREATE %s\r\n", tag(1), qname);
2791 IMAP_OUT(o, MB_COMD, goto out)
2792 while (mp->mb_active & MB_COMD)
2793 ok = imap_answer(mp, 1);
2794 if (ok == OKAY) {
2795 imap_created_mailbox++;
2796 goto again;
2797 }
2798 }
2799
2800 if (queuefp != NULL)
2801 Fclose(queuefp);
2802
2803 /* ... and reset the flag to its initial value so that the 'exit'
2804 * command still leaves the message unread */
2805 out:
2806 if ((m->m_flag & (MREAD | MSTATUS)) == (MREAD | MSTATUS)) {
2807 imap_store(mp, m, n, '-', "\\Seen", 0);
2808 stored++;
2809 }
2810 if (m->m_flag & MFLAG) {
2811 imap_store(mp, m, n, '-', "\\Flagged", 0);
2812 stored++;
2813 }
2814 if (m->m_flag & MUNFLAG) {
2815 imap_store(mp, m, n, '+', "\\Flagged", 0);
2816 stored++;
2817 }
2818 if (m->m_flag & MANSWER) {
2819 imap_store(mp, m, n, '-', "\\Answered", 0);
2820 stored++;
2821 }
2822 if (m->m_flag & MUNANSWER) {
2823 imap_store(mp, m, n, '+', "\\Answered", 0);
2824 stored++;
2825 }
2826 if (m->m_flag & MDRAFT) {
2827 imap_store(mp, m, n, '-', "\\Draft", 0);
2828 stored++;
2829 }
2830 if (m->m_flag & MUNDRAFT) {
2831 imap_store(mp, m, n, '+', "\\Draft", 0);
2832 stored++;
2833 }
2834 if (stored) {
2835 mp->mb_active |= MB_COMD;
2836 (void)imap_finish(mp);
2837 }
2838 return ok;
2839 }
2840
2841 FL enum okay
2842 imap_copy(struct message *m, int n, const char *name)
2843 {
2844 sighandler_type saveint, savepipe;
2845 enum okay rv = STOP;
2846 NYD_ENTER;
2847
2848 imaplock = 1;
2849 if ((saveint = safe_signal(SIGINT, SIG_IGN)) != SIG_IGN)
2850 safe_signal(SIGINT, &_imap_maincatch);
2851 savepipe = safe_signal(SIGPIPE, SIG_IGN);
2852 if (sigsetjmp(imapjmp, 1) == 0) {
2853 if (savepipe != SIG_IGN)
2854 safe_signal(SIGPIPE, imapcatch);
2855
2856 rv = imap_copy1(&mb, m, n, name);
2857 }
2858 safe_signal(SIGINT, saveint);
2859 safe_signal(SIGPIPE, savepipe);
2860 imaplock = 0;
2861
2862 NYD_LEAVE;
2863 if (interrupts)
2864 onintr(0);
2865 return rv;
2866 }
2867
2868 static enum okay
2869 imap_copyuid_parse(const char *cp, unsigned long *uidvalidity,
2870 unsigned long *olduid, unsigned long *newuid)
2871 {
2872 char *xp, *yp, *zp;
2873 enum okay rv;
2874 NYD_ENTER;
2875
2876 *uidvalidity = strtoul(cp, &xp, 10);
2877 *olduid = strtoul(xp, &yp, 10);
2878 *newuid = strtoul(yp, &zp, 10);
2879 rv = (*uidvalidity && *olduid && *newuid && xp > cp && *xp == ' ' &&
2880 yp > xp && *yp == ' ' && zp > yp && *zp == ']');
2881 NYD_LEAVE;
2882 return rv;
2883 }
2884
2885 static enum okay
2886 imap_appenduid_parse(const char *cp, unsigned long *uidvalidity,
2887 unsigned long *uid)
2888 {
2889 char *xp, *yp;
2890 enum okay rv;
2891 NYD_ENTER;
2892
2893 *uidvalidity = strtoul(cp, &xp, 10);
2894 *uid = strtoul(xp, &yp, 10);
2895 rv = (*uidvalidity && *uid && xp > cp && *xp == ' ' && yp > xp &&
2896 *yp == ']');
2897 NYD_LEAVE;
2898 return rv;
2899 }
2900
2901 static enum okay
2902 imap_copyuid(struct mailbox *mp, struct message *m, const char *name)
2903 {
2904 struct mailbox xmb;
2905 struct message xm;
2906 const char *cp;
2907 unsigned long uidvalidity, olduid, newuid;
2908 enum okay rv;
2909 NYD_ENTER;
2910
2911 rv = STOP;
2912 if ((cp = asccasestr(responded_text, "[COPYUID ")) == NULL ||
2913 imap_copyuid_parse(&cp[9], &uidvalidity, &olduid, &newuid) == STOP)
2914 goto jleave;
2915 rv = OKAY;
2916
2917 xmb = *mp;
2918 xmb.mb_cache_directory = NULL;
2919 xmb.mb_imap_mailbox = savestr(name);
2920 xmb.mb_uidvalidity = uidvalidity;
2921 initcache(&xmb);
2922 if (m == NULL) {
2923 memset(&xm, 0, sizeof xm);
2924 xm.m_uid = olduid;
2925 if ((rv = getcache1(mp, &xm, NEED_UNSPEC, 3)) != OKAY)
2926 goto jleave;
2927 getcache(mp, &xm, NEED_HEADER);
2928 getcache(mp, &xm, NEED_BODY);
2929 } else {
2930 if ((m->m_flag & HAVE_HEADER) == 0)
2931 getcache(mp, m, NEED_HEADER);
2932 if ((m->m_flag & HAVE_BODY) == 0)
2933 getcache(mp, m, NEED_BODY);
2934 xm = *m;
2935 }
2936 xm.m_uid = newuid;
2937 xm.m_flag &= ~MFULLYCACHED;
2938 putcache(&xmb, &xm);
2939 jleave:
2940 NYD_LEAVE;
2941 return rv;
2942 }
2943
2944 static enum okay
2945 imap_appenduid(struct mailbox *mp, FILE *fp, time_t t, long off1, long xsize,
2946 long size, long lines, int flag, const char *name)
2947 {
2948 struct mailbox xmb;
2949 struct message xm;
2950 const char *cp;
2951 unsigned long uidvalidity, uid;
2952 enum okay rv;
2953 NYD_ENTER;
2954
2955 rv = STOP;
2956 if ((cp = asccasestr(responded_text, "[APPENDUID ")) == NULL ||
2957 imap_appenduid_parse(&cp[11], &uidvalidity, &uid) == STOP)
2958 goto jleave;
2959 rv = OKAY;
2960
2961 xmb = *mp;
2962 xmb.mb_cache_directory = NULL;
2963 xmb.mb_imap_mailbox = savestr(name);
2964 xmb.mb_uidvalidity = uidvalidity;
2965 xmb.mb_otf = xmb.mb_itf = fp;
2966 initcache(&xmb);
2967 memset(&xm, 0, sizeof xm);
2968 xm.m_flag = (flag & MREAD) | MNEW;
2969 xm.m_time = t;
2970 xm.m_block = mailx_blockof(off1);
2971 xm.m_offset = mailx_offsetof(off1);
2972 xm.m_size = size;
2973 xm.m_xsize = xsize;
2974 xm.m_lines = xm.m_xlines = lines;
2975 xm.m_uid = uid;
2976 xm.m_have = HAVE_HEADER | HAVE_BODY;
2977 putcache(&xmb, &xm);
2978 jleave:
2979 NYD_LEAVE;
2980 return rv;
2981 }
2982
2983 static enum okay
2984 imap_appenduid_cached(struct mailbox *mp, FILE *fp)
2985 {
2986 FILE *tp = NULL;
2987 time_t t;
2988 long size, xsize, ysize, lines;
2989 enum mflag flag = MNEW;
2990 char *name, *buf, *bp;
2991 char const *cp;
2992 size_t bufsize, buflen, cnt;
2993 enum okay rv = STOP;
2994 NYD_ENTER;
2995
2996 buf = smalloc(bufsize = LINESIZE);
2997 buflen = 0;
2998 cnt = fsize(fp);
2999 if (fgetline(&buf, &bufsize, &cnt, &buflen, fp, 0) == NULL)
3000 goto jstop;
3001
3002 for (bp = buf; *bp != ' '; ++bp) /* strip old tag */
3003 ;
3004 while (*bp == ' ')
3005 ++bp;
3006
3007 if ((cp = strrchr(bp, '{')) == NULL)
3008 goto jstop;
3009
3010 xsize = atol(&cp[1]) + 2;
3011 if ((name = imap_strex(&bp[7], &cp)) == NULL)
3012 goto jstop;
3013 while (*cp == ' ')
3014 cp++;
3015
3016 if (*cp == '(') {
3017 imap_getflags(cp, &cp, &flag);
3018 while (*++cp == ' ')
3019 ;
3020 }
3021 t = imap_read_date_time(cp);
3022
3023 if ((tp = Ftmp(NULL, "imapapui", OF_RDWR | OF_UNLINK | OF_REGISTER, 0600)) ==
3024 NULL)
3025 goto jstop;
3026
3027 size = xsize;
3028 ysize = lines = 0;
3029 while (size > 0) {
3030 if (fgetline(&buf, &bufsize, &cnt, &buflen, fp, 0) == NULL)
3031 goto jstop;
3032 size -= buflen;
3033 buf[--buflen] = '\0';
3034 buf[buflen-1] = '\n';
3035 fwrite(buf, 1, buflen, tp);
3036 ysize += buflen;
3037 ++lines;
3038 }
3039 fflush(tp);
3040 rewind(tp);
3041
3042 imap_appenduid(mp, tp, t, 0, xsize-2, ysize-1, lines-1, flag,
3043 imap_unquotestr(name));
3044 rv = OKAY;
3045 jstop:
3046 free(buf);
3047 if (tp)
3048 Fclose(tp);
3049 NYD_LEAVE;
3050 return rv;
3051 }
3052
3053 #ifdef HAVE_IMAP_SEARCH
3054 static enum okay
3055 imap_search2(struct mailbox *mp, struct message *m, int cnt, const char *spec,
3056 int f)
3057 {
3058 char *o, *xp, *cs, c;
3059 size_t osize;
3060 FILE *queuefp = NULL;
3061 int i;
3062 unsigned long n;
3063 const char *cp;
3064 enum okay ok = STOP;
3065 NYD_X;
3066
3067 c = 0;
3068 for (cp = spec; *cp; cp++)
3069 c |= *cp;
3070 if (c & 0200) {
3071 cp = charset_get_lc();
3072 # ifdef HAVE_ICONV
3073 if (asccasecmp(cp, "utf-8") && asccasecmp(cp, "utf8")) {
3074 iconv_t it;
3075 char *nsp, *nspec;
3076 size_t sz, nsz;
3077
3078 if ((it = n_iconv_open("utf-8", cp)) != (iconv_t)-1) {
3079 sz = strlen(spec) + 1;
3080 nsp = nspec = salloc(nsz = 6*strlen(spec) + 1);
3081 if (n_iconv_buf(it, &spec, &sz, &nsp, &nsz, FAL0) == 0 &&
3082 sz == 0) {
3083 spec = nspec;
3084 cp = "utf-8";
3085 }
3086 n_iconv_close(it);
3087 }
3088 }
3089 # endif
3090 cp = imap_quotestr(cp);
3091 cs = salloc(n = strlen(cp) + 10);
3092 snprintf(cs, n, "CHARSET %s ", cp);
3093 } else
3094 cs = UNCONST("");
3095
3096 o = ac_alloc(osize = strlen(spec) + 60);
3097 snprintf(o, osize, "%s UID SEARCH %s%s\r\n", tag(1), cs, spec);
3098 IMAP_OUT(o, MB_COMD, goto out)
3099 while (mp->mb_active & MB_COMD) {
3100 ok = imap_answer(mp, 0);
3101 if (response_status == RESPONSE_OTHER &&
3102 response_other == MAILBOX_DATA_SEARCH) {
3103 xp = responded_other_text;
3104 while (*xp && *xp != '\r') {
3105 n = strtoul(xp, &xp, 10);
3106 for (i = 0; i < cnt; i++)
3107 if (m[i].m_uid == n && !(m[i].m_flag & MHIDDEN) &&
3108 (f == MDELETED || !(m[i].m_flag & MDELETED)))
3109 mark(i+1, f);
3110 }
3111 }
3112 }
3113 out:
3114 ac_free(o);
3115 return ok;
3116 }
3117
3118 FL enum okay
3119 imap_search1(const char * volatile spec, int f)
3120 {
3121 sighandler_type saveint, savepipe;
3122 enum okay rv = STOP;
3123 NYD_ENTER;
3124
3125 if (mb.mb_type != MB_IMAP)
3126 goto jleave;
3127
3128 imaplock = 1;
3129 if ((saveint = safe_signal(SIGINT, SIG_IGN)) != SIG_IGN)
3130 safe_signal(SIGINT, &_imap_maincatch);
3131 savepipe = safe_signal(SIGPIPE, SIG_IGN);
3132 if (sigsetjmp(imapjmp, 1) == 0) {
3133 if (savepipe != SIG_IGN)
3134 safe_signal(SIGPIPE, imapcatch);
3135
3136 rv = imap_search2(&mb, message, msgCount, spec, f);
3137 }
3138 safe_signal(SIGINT, saveint);
3139 safe_signal(SIGPIPE, savepipe);
3140 imaplock = 0;
3141 jleave:
3142 NYD_LEAVE;
3143 if (interrupts)
3144 onintr(0);
3145 return rv;
3146 }
3147 #endif /* HAVE_IMAP_SEARCH */
3148
3149 FL int
3150 imap_thisaccount(const char *cp)
3151 {
3152 int rv;
3153 NYD_ENTER;
3154
3155 if (mb.mb_type != MB_CACHE && mb.mb_type != MB_IMAP)
3156 rv = 0;
3157 else if ((mb.mb_type != MB_CACHE && mb.mb_sock.s_fd < 0) ||
3158 mb.mb_imap_account == NULL)
3159 rv = 0;
3160 else
3161 rv = !strcmp(protbase(cp), mb.mb_imap_account);
3162 NYD_LEAVE;
3163 return rv;
3164 }
3165
3166 FL enum okay
3167 imap_remove(const char * volatile name)
3168 {
3169 sighandler_type volatile saveint, savepipe;
3170 enum okay rv = STOP;
3171 NYD_ENTER;
3172
3173 if (mb.mb_type != MB_IMAP) {
3174 fprintf(stderr, "Refusing to remove \"%s\" in disconnected mode.\n",
3175 name);
3176 goto jleave;
3177 }
3178
3179 if (!imap_thisaccount(name)) {
3180 fprintf(stderr, "Can only remove mailboxes on current IMAP "
3181 "server: \"%s\" not removed.\n", name);
3182 goto jleave;
3183 }
3184
3185 imaplock = 1;
3186 if ((saveint = safe_signal(SIGINT, SIG_IGN)) != SIG_IGN)
3187 safe_signal(SIGINT, &_imap_maincatch);
3188 savepipe = safe_signal(SIGPIPE, SIG_IGN);
3189 if (sigsetjmp(imapjmp, 1) == 0) {
3190 if (savepipe != SIG_IGN)
3191 safe_signal(SIGPIPE, imapcatch);
3192
3193 rv = imap_remove1(&mb, imap_fileof(name));
3194 }
3195 safe_signal(SIGINT, saveint);
3196 safe_signal(SIGPIPE, savepipe);
3197 imaplock = 0;
3198
3199 if (rv == OKAY)
3200 rv = cache_remove(name);
3201 jleave:
3202 NYD_LEAVE;
3203 if (interrupts)
3204 onintr(0);
3205 return rv;
3206 }
3207
3208 static enum okay
3209 imap_remove1(struct mailbox *mp, const char *name)
3210 {
3211 FILE *queuefp = NULL;
3212 char *o;
3213 int os;
3214 enum okay ok = STOP;
3215 NYD_X;
3216
3217 o = ac_alloc(os = 2*strlen(name) + 100);
3218 snprintf(o, os, "%s DELETE %s\r\n", tag(1), imap_quotestr(name));
3219 IMAP_OUT(o, MB_COMD, goto out)
3220 while (mp->mb_active & MB_COMD)
3221 ok = imap_answer(mp, 1);
3222 out:
3223 ac_free(o);
3224 return ok;
3225 }
3226
3227 FL enum okay
3228 imap_rename(const char *old, const char *new)
3229 {
3230 sighandler_type saveint, savepipe;
3231 enum okay rv = STOP;
3232 NYD_ENTER;
3233
3234 if (mb.mb_type != MB_IMAP) {
3235 fprintf(stderr, "Refusing to rename mailboxes in disconnected mode.\n");
3236 goto jleave;
3237 }
3238
3239 if (!imap_thisaccount(old) || !imap_thisaccount(new)) {
3240 fprintf(stderr, "Can only rename mailboxes on current IMAP "
3241 "server: \"%s\" not renamed to \"%s\".\n", old, new);
3242 goto jleave;
3243 }
3244
3245 imaplock = 1;
3246 if ((saveint = safe_signal(SIGINT, SIG_IGN)) != SIG_IGN)
3247 safe_signal(SIGINT, &_imap_maincatch);
3248 savepipe = safe_signal(SIGPIPE, SIG_IGN);
3249 if (sigsetjmp(imapjmp, 1) == 0) {
3250 if (savepipe != SIG_IGN)
3251 safe_signal(SIGPIPE, imapcatch);
3252
3253 rv = imap_rename1(&mb, imap_fileof(old), imap_fileof(new));
3254 }
3255 safe_signal(SIGINT, saveint);
3256 safe_signal(SIGPIPE, savepipe);
3257 imaplock = 0;
3258
3259 if (rv == OKAY)
3260 rv = cache_rename(old, new);
3261 jleave:
3262 NYD_LEAVE;
3263 if (interrupts)
3264 onintr(0);
3265 return rv;
3266 }
3267
3268 static enum okay
3269 imap_rename1(struct mailbox *mp, const char *old, const char *new)
3270 {
3271 FILE *queuefp = NULL;
3272 char *o;
3273 int os;
3274 enum okay ok = STOP;
3275 NYD_X;
3276
3277 o = ac_alloc(os = 2*strlen(old) + 2*strlen(new) + 100);
3278 snprintf(o, os, "%s RENAME %s %s\r\n", tag(1), imap_quotestr(old),
3279 imap_quotestr(new));
3280 IMAP_OUT(o, MB_COMD, goto out)
3281 while (mp->mb_active & MB_COMD)
3282 ok = imap_answer(mp, 1);
3283 out:
3284 ac_free(o);
3285 return ok;
3286 }
3287
3288 FL enum okay
3289 imap_dequeue(struct mailbox *mp, FILE *fp)
3290 {
3291 char o[LINESIZE], *newname, *buf, *bp, *cp, iob[4096];
3292 size_t bufsize, buflen, cnt;
3293 long offs, offs1, offs2, octets;
3294 int twice, gotcha = 0;
3295 FILE *queuefp = NULL;
3296 enum okay ok = OKAY, rok = OKAY;
3297 NYD_X;
3298
3299 buf = smalloc(bufsize = LINESIZE);
3300 buflen = 0;
3301 cnt = fsize(fp);
3302 while ((offs1 = ftell(fp)) >= 0 &&
3303 fgetline(&buf, &bufsize, &cnt, &buflen, fp, 0) != NULL) {
3304 for (bp = buf; *bp != ' '; ++bp) /* strip old tag */
3305 ;
3306 while (*bp == ' ')
3307 ++bp;
3308 twice = 0;
3309 if ((offs = ftell(fp)) < 0)
3310 goto fail;
3311 again:
3312 snprintf(o, sizeof o, "%s %s", tag(1), bp);
3313 if (ascncasecmp(bp, "UID COPY ", 9) == 0) {
3314 cp = &bp[9];
3315 while (digitchar(*cp))
3316 cp++;
3317 if (*cp != ' ')
3318 goto fail;
3319 while (*cp == ' ')
3320 cp++;
3321 if ((newname = imap_strex(cp, NULL)) == NULL)
3322 goto fail;
3323 IMAP_OUT(o, MB_COMD, continue)
3324 while (mp->mb_active & MB_COMD)
3325 ok = imap_answer(mp, twice);
3326 if (response_status == RESPONSE_NO && twice++ == 0)
3327 goto trycreate;
3328 if (response_status == RESPONSE_OK && mp->mb_flags & MB_UIDPLUS) {
3329 imap_copyuid(mp, NULL, imap_unquotestr(newname));
3330 }
3331 } else if (ascncasecmp(bp, "UID STORE ", 10) == 0) {
3332 IMAP_OUT(o, MB_COMD, continue)
3333 while (mp->mb_active & MB_COMD)
3334 ok = imap_answer(mp, 1);
3335 if (ok == OKAY)
3336 gotcha++;
3337 } else if (ascncasecmp(bp, "APPEND ", 7) == 0) {
3338 if ((cp = strrchr(bp, '{')) == NULL)
3339 goto fail;
3340 octets = atol(&cp[1]) + 2;
3341 if ((newname = imap_strex(&bp[7], NULL)) == NULL)
3342 goto fail;
3343 IMAP_OUT(o, MB_COMD, continue)
3344 while (mp->mb_active & MB_COMD) {
3345 ok = imap_answer(mp, twice);
3346 if (response_type == RESPONSE_CONT)
3347 break;
3348 }
3349 if (ok == STOP) {
3350 if (twice++ == 0 && fseek(fp, offs, SEEK_SET) >= 0)
3351 goto trycreate;
3352 goto fail;
3353 }
3354 while (octets > 0) {
3355 size_t n = (UICMP(z, octets, >, sizeof iob)
3356 ? sizeof iob : (size_t)octets);
3357 octets -= n;
3358 if (n != fread(iob, 1, n, fp))
3359 goto fail;
3360 swrite1(&mp->mb_sock, iob, n, 1);
3361 }
3362 swrite(&mp->mb_sock, "");
3363 while (mp->mb_active & MB_COMD) {
3364 ok = imap_answer(mp, 0);
3365 if (response_status == RESPONSE_NO && twice++ == 0) {
3366 if (fseek(fp, offs, SEEK_SET) < 0)
3367 goto fail;
3368 goto trycreate;
3369 }
3370 }
3371 if (response_status == RESPONSE_OK && mp->mb_flags & MB_UIDPLUS) {
3372 if ((offs2 = ftell(fp)) < 0)
3373 goto fail;
3374 fseek(fp, offs1, SEEK_SET);
3375 if (imap_appenduid_cached(mp, fp) == STOP) {
3376 (void)fseek(fp, offs2, SEEK_SET);
3377 goto fail;
3378 }
3379 }
3380 } else {
3381 fail:
3382 fprintf(stderr, "Invalid command in IMAP cache queue: \"%s\"\n", bp);
3383 rok = STOP;
3384 }
3385 continue;
3386 trycreate:
3387 snprintf(o, sizeof o, "%s CREATE %s\r\n", tag(1), newname);
3388 IMAP_OUT(o, MB_COMD, continue)
3389 while (mp->mb_active & MB_COMD)
3390 ok = imap_answer(mp, 1);
3391 if (ok == OKAY)
3392 goto again;
3393 }
3394 fflush(fp);
3395 rewind(fp);
3396 ftruncate(fileno(fp), 0);
3397 if (gotcha)
3398 imap_close(mp);
3399 free(buf);
3400 return rok;
3401 }
3402
3403 static char *
3404 imap_strex(char const *cp, char const **xp)
3405 {
3406 char const *cq;
3407 char *n = NULL;
3408 NYD_ENTER;
3409
3410 if (*cp != '"')
3411 goto jleave;
3412
3413 for (cq = cp + 1; *cq != '\0'; ++cq) {
3414 if (*cq == '\\')
3415 cq++;
3416 else if (*cq == '"')
3417 break;
3418 }
3419 if (*cq != '"')
3420 goto jleave;
3421
3422 n = salloc(cq - cp + 2);
3423 memcpy(n, cp, cq - cp +1);
3424 n[cq - cp + 1] = '\0';
3425 if (xp != NULL)
3426 *xp = cq + 1;
3427 jleave:
3428 NYD_LEAVE;
3429 return n;
3430 }
3431
3432 static enum okay
3433 check_expunged(void)
3434 {
3435 enum okay rv;
3436 NYD_ENTER;
3437
3438 if (expunged_messages > 0) {
3439 fprintf(stderr, "Command not executed - messages have been expunged\n");
3440 rv = STOP;
3441 } else
3442 rv = OKAY;
3443 NYD_LEAVE;
3444 return rv;
3445 }
3446
3447 FL int
3448 c_connect(void *vp)
3449 {
3450 char *cp, *cq;
3451 int rv, omsgCount = msgCount;
3452 NYD_ENTER;
3453 UNUSED(vp);
3454
3455 if (mb.mb_type == MB_IMAP && mb.mb_sock.s_fd > 0) {
3456 fprintf(stderr, "Already connected.\n");
3457 rv = 1;
3458 goto jleave;
3459 }
3460
3461 var_clear_allow_undefined = TRU1;
3462 ok_bclear(disconnected);
3463
3464 cp = protbase(mailname);
3465 if (strncmp(cp, "imap://", 7) == 0)
3466 cp += 7;
3467 else if (strncmp(cp, "imaps://", 8) == 0)
3468 cp += 8;
3469 if ((cq = strchr(cp, ':')) != NULL)
3470 *cq = '\0';
3471
3472 vok_bclear(savecat("disconnected-", cp));
3473 var_clear_allow_undefined = FAL0;
3474
3475 if (mb.mb_type == MB_CACHE) {
3476 imap_setfile1(mailname, 0, edit, 1);
3477 if (msgCount > omsgCount)
3478 newmailinfo(omsgCount);
3479 }
3480 rv = 0;
3481 jleave:
3482 NYD_LEAVE;
3483 return rv;
3484 }
3485
3486 FL int
3487 c_disconnect(void *vp)
3488 {
3489 int rv = 1, *msgvec = vp;
3490 NYD_ENTER;
3491
3492 if (mb.mb_type == MB_CACHE) {
3493 fprintf(stderr, "Not connected.\n");
3494 goto jleave;
3495 }
3496 if (mb.mb_type == MB_IMAP) {
3497 if (cached_uidvalidity(&mb) == 0) {
3498 fprintf(stderr, "The current mailbox is not cached.\n");
3499 goto jleave;
3500 }
3501 }
3502
3503 if (*msgvec)
3504 c_cache(vp);
3505 ok_bset(disconnected, TRU1);
3506 if (mb.mb_type == MB_IMAP) {
3507 sclose(&mb.mb_sock);
3508 imap_setfile1(mailname, 0, edit, 1);
3509 }
3510 rv = 0;
3511 jleave:
3512 NYD_LEAVE;
3513 return rv;
3514 }
3515
3516 FL int
3517 c_cache(void *vp)
3518 {
3519 int rv = 1, *msgvec = vp, *ip;
3520 struct message *mp;
3521 NYD_ENTER;
3522
3523 if (mb.mb_type != MB_IMAP) {
3524 fprintf(stderr, "Not connected to an IMAP server.\n");
3525 goto jleave;
3526 }
3527 if (cached_uidvalidity(&mb) == 0) {
3528 fprintf(stderr, "The current mailbox is not cached.\n");
3529 goto jleave;
3530 }
3531
3532 for (ip = msgvec; *ip; ++ip) {
3533 mp = &message[*ip - 1];
3534 if (!(mp->m_have & HAVE_BODY))
3535 get_body(mp);
3536 }
3537 rv = 0;
3538 jleave:
3539 NYD_LEAVE;
3540 return rv;
3541 }
3542
3543 FL int
3544 disconnected(const char *file)
3545 {
3546 char *cp, *cq, *vp;
3547 int vs, r = 1;
3548 NYD_ENTER;
3549
3550 if (ok_blook(disconnected))
3551 goto jleave;
3552
3553 cp = protbase(file);
3554 if (strncmp(cp, "imap://", 7) == 0)
3555 cp += 7;
3556 else if (strncmp(cp, "imaps://", 8) == 0)
3557 cp += 8;
3558 else {
3559 r = 0;
3560 goto jleave;
3561 }
3562
3563 if ((cq = strchr(cp, ':')) != NULL)
3564 *cq = '\0';
3565 vp = ac_alloc(vs = strlen(cp) + 14);
3566 snprintf(vp, vs, "disconnected-%s", cp);
3567 r = vok_blook(vp);
3568 ac_free(vp);
3569 jleave:
3570 NYD_LEAVE;
3571 return r;
3572 }
3573
3574 FL void
3575 transflags(struct message *omessage, long omsgCount, int transparent)
3576 {
3577 struct message *omp, *nmp, *newdot, *newprevdot;
3578 int hf;
3579 NYD_ENTER;
3580
3581 omp = omessage;
3582 nmp = message;
3583 newdot = message;
3584 newprevdot = NULL;
3585 while (PTRCMP(omp, <, omessage + omsgCount) &&
3586 PTRCMP(nmp, <, message + msgCount)) {
3587 if (dot && nmp->m_uid == dot->m_uid)
3588 newdot = nmp;
3589 if (prevdot && nmp->m_uid == prevdot->m_uid)
3590 newprevdot = nmp;
3591 if (omp->m_uid == nmp->m_uid) {
3592 hf = nmp->m_flag & MHIDDEN;
3593 if (transparent && mb.mb_type == MB_IMAP)
3594 omp->m_flag &= ~MHIDDEN;
3595 *nmp++ = *omp++;
3596 if (transparent && mb.mb_type == MB_CACHE)
3597 nmp[-1].m_flag |= hf;
3598 } else if (omp->m_uid < nmp->m_uid)
3599 ++omp;
3600 else
3601 ++nmp;
3602 }
3603 dot = newdot;
3604 setdot(newdot);
3605 prevdot = newprevdot;
3606 free(omessage);
3607 NYD_LEAVE;
3608 }
3609
3610 FL time_t
3611 imap_read_date_time(const char *cp)
3612 {
3613 char buf[3];
3614 time_t t;
3615 int i, year, month, day, hour, minute, second, sign = -1;
3616 NYD_ENTER;
3617
3618 /* "25-Jul-2004 15:33:44 +0200"
3619 * | | | | | |
3620 * 0 5 10 15 20 25 */
3621 if (cp[0] != '"' || strlen(cp) < 28 || cp[27] != '"')
3622 goto jinvalid;
3623 day = strtol(&cp[1], NULL, 10);
3624 for (i = 0;;) {
3625 if (ascncasecmp(&cp[4], month_names[i], 3) == 0)
3626 break;
3627 if (month_names[++i][0] == '\0')
3628 goto jinvalid;
3629 }
3630 month = i + 1;
3631 year = strtol(&cp[8], NULL, 10);
3632 hour = strtol(&cp[13], NULL, 10);
3633 minute = strtol(&cp[16], NULL, 10);
3634 second = strtol(&cp[19], NULL, 10);
3635 if ((t = combinetime(year, month, day, hour, minute, second)) == (time_t)-1)
3636 goto jinvalid;
3637 switch (cp[22]) {
3638 case '-':
3639 sign = 1;
3640 break;
3641 case '+':
3642 break;
3643 default:
3644 goto jinvalid;
3645 }
3646 buf[2] = '\0';
3647 buf[0] = cp[23];
3648 buf[1] = cp[24];
3649 t += strtol(buf, NULL, 10) * sign * 3600;
3650 buf[0] = cp[25];
3651 buf[1] = cp[26];
3652 t += strtol(buf, NULL, 10) * sign * 60;
3653 jleave:
3654 NYD_LEAVE;
3655 return t;
3656 jinvalid:
3657 time(&t);
3658 goto jleave;
3659 }
3660
3661 FL const char *
3662 imap_make_date_time(time_t t)
3663 {
3664 static char s[30];
3665 struct tm *tmptr;
3666 int tzdiff, tzdiff_hour, tzdiff_min;
3667 NYD_ENTER;
3668
3669 tzdiff = t - mktime(gmtime(&t));
3670 tzdiff_hour = (int)(tzdiff / 60);
3671 tzdiff_min = tzdiff_hour % 60;
3672 tzdiff_hour /= 60;
3673 tmptr = localtime(&t);
3674 if (tmptr->tm_isdst > 0)
3675 tzdiff_hour++;
3676 snprintf(s, sizeof s, "\"%02d-%s-%04d %02d:%02d:%02d %+03d%02d\"",
3677 tmptr->tm_mday, month_names[tmptr->tm_mon], tmptr->tm_year + 1900,
3678 tmptr->tm_hour, tmptr->tm_min, tmptr->tm_sec, tzdiff_hour, tzdiff_min);
3679 NYD_LEAVE;
3680 return s;
3681 }
3682 #endif /* HAVE_IMAP */
3683
3684 #if defined HAVE_IMAP || defined HAVE_IMAP_SEARCH
3685 FL char *
3686 imap_quotestr(char const *s)
3687 {
3688 char *n, *np;
3689 NYD_ENTER;
3690
3691 np = n = salloc(2 * strlen(s) + 3);
3692 *np++ = '"';
3693 while (*s) {
3694 if (*s == '"' || *s == '\\')
3695 *np++ = '\\';
3696 *np++ = *s++;
3697 }
3698 *np++ = '"';
3699 *np = '\0';
3700 NYD_LEAVE;
3701 return n;
3702 }
3703
3704 FL char *
3705 imap_unquotestr(char const *s)
3706 {
3707 char *n, *np;
3708 NYD_ENTER;
3709
3710 if (*s != '"') {
3711 n = savestr(s);
3712 goto jleave;
3713 }
3714
3715 np = n = salloc(strlen(s) + 1);
3716 while (*++s) {
3717 if (*s == '\\')
3718 s++;
3719 else if (*s == '"')
3720 break;
3721 *np++ = *s;
3722 }
3723 *np = '\0';
3724 jleave:
3725 NYD_LEAVE;
3726 return n;
3727 }
3728 #endif /* defined HAVE_IMAP || defined HAVE_IMAP_SEARCH */
3729
3730 /* vim:set fenc=utf-8:s-it-mode */
A mail processing system intended to provide the functionality of the POSIX mailx(1) command