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