Documentation: push.default applies to all remotes
[git] / imap-send.c
1 /*
2  * git-imap-send - drops patches into an imap Drafts folder
3  *                 derived from isync/mbsync - mailbox synchronizer
4  *
5  * Copyright (C) 2000-2002 Michael R. Elkins <me@mutt.org>
6  * Copyright (C) 2002-2004 Oswald Buddenhagen <ossi@users.sf.net>
7  * Copyright (C) 2004 Theodore Y. Ts'o <tytso@mit.edu>
8  * Copyright (C) 2006 Mike McCormack
9  *
10  *  This program is free software; you can redistribute it and/or modify
11  *  it under the terms of the GNU General Public License as published by
12  *  the Free Software Foundation; either version 2 of the License, or
13  *  (at your option) any later version.
14  *
15  *  This program is distributed in the hope that it will be useful,
16  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  *  GNU General Public License for more details.
19  *
20  *  You should have received a copy of the GNU General Public License
21  *  along with this program; if not, write to the Free Software
22  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
23  */
24
25 #include "cache.h"
26 #include "exec_cmd.h"
27 #ifdef NO_OPENSSL
28 typedef void *SSL;
29 #endif
30
31 struct store_conf {
32         char *name;
33         const char *path; /* should this be here? its interpretation is driver-specific */
34         char *map_inbox;
35         char *trash;
36         unsigned max_size; /* off_t is overkill */
37         unsigned trash_remote_new:1, trash_only_new:1;
38 };
39
40 struct string_list {
41         struct string_list *next;
42         char string[1];
43 };
44
45 struct channel_conf {
46         struct channel_conf *next;
47         char *name;
48         struct store_conf *master, *slave;
49         char *master_name, *slave_name;
50         char *sync_state;
51         struct string_list *patterns;
52         int mops, sops;
53         unsigned max_messages; /* for slave only */
54 };
55
56 struct group_conf {
57         struct group_conf *next;
58         char *name;
59         struct string_list *channels;
60 };
61
62 /* For message->status */
63 #define M_RECENT       (1<<0) /* unsyncable flag; maildir_* depend on this being 1<<0 */
64 #define M_DEAD         (1<<1) /* expunged */
65 #define M_FLAGS        (1<<2) /* flags fetched */
66
67 struct message {
68         struct message *next;
69         /* struct string_list *keywords; */
70         size_t size; /* zero implies "not fetched" */
71         int uid;
72         unsigned char flags, status;
73 };
74
75 struct store {
76         struct store_conf *conf; /* foreign */
77
78         /* currently open mailbox */
79         const char *name; /* foreign! maybe preset? */
80         char *path; /* own */
81         struct message *msgs; /* own */
82         int uidvalidity;
83         unsigned char opts; /* maybe preset? */
84         /* note that the following do _not_ reflect stats from msgs, but mailbox totals */
85         int count; /* # of messages */
86         int recent; /* # of recent messages - don't trust this beyond the initial read */
87 };
88
89 struct msg_data {
90         char *data;
91         int len;
92         unsigned char flags;
93         unsigned int crlf:1;
94 };
95
96 #define DRV_OK          0
97 #define DRV_MSG_BAD     -1
98 #define DRV_BOX_BAD     -2
99 #define DRV_STORE_BAD   -3
100
101 static int Verbose, Quiet;
102
103 static void imap_info(const char *, ...);
104 static void imap_warn(const char *, ...);
105
106 static char *next_arg(char **);
107
108 static void free_generic_messages(struct message *);
109
110 static int nfsnprintf(char *buf, int blen, const char *fmt, ...);
111
112 static int nfvasprintf(char **strp, const char *fmt, va_list ap)
113 {
114         int len;
115         char tmp[8192];
116
117         len = vsnprintf(tmp, sizeof(tmp), fmt, ap);
118         if (len < 0)
119                 die("Fatal: Out of memory");
120         if (len >= sizeof(tmp))
121                 die("imap command overflow!");
122         *strp = xmemdupz(tmp, len);
123         return len;
124 }
125
126 static void arc4_init(void);
127 static unsigned char arc4_getbyte(void);
128
129 struct imap_server_conf {
130         char *name;
131         char *tunnel;
132         char *host;
133         int port;
134         char *user;
135         char *pass;
136         int use_ssl;
137         int ssl_verify;
138         int use_html;
139 };
140
141 struct imap_store_conf {
142         struct store_conf gen;
143         struct imap_server_conf *server;
144         unsigned use_namespace:1;
145 };
146
147 #define NIL     (void *)0x1
148 #define LIST    (void *)0x2
149
150 struct imap_list {
151         struct imap_list *next, *child;
152         char *val;
153         int len;
154 };
155
156 struct imap_socket {
157         int fd;
158         SSL *ssl;
159 };
160
161 struct imap_buffer {
162         struct imap_socket sock;
163         int bytes;
164         int offset;
165         char buf[1024];
166 };
167
168 struct imap_cmd;
169
170 struct imap {
171         int uidnext; /* from SELECT responses */
172         struct imap_list *ns_personal, *ns_other, *ns_shared; /* NAMESPACE info */
173         unsigned caps, rcaps; /* CAPABILITY results */
174         /* command queue */
175         int nexttag, num_in_progress, literal_pending;
176         struct imap_cmd *in_progress, **in_progress_append;
177         struct imap_buffer buf; /* this is BIG, so put it last */
178 };
179
180 struct imap_store {
181         struct store gen;
182         int uidvalidity;
183         struct imap *imap;
184         const char *prefix;
185         unsigned /*currentnc:1,*/ trashnc:1;
186 };
187
188 struct imap_cmd_cb {
189         int (*cont)(struct imap_store *ctx, struct imap_cmd *cmd, const char *prompt);
190         void (*done)(struct imap_store *ctx, struct imap_cmd *cmd, int response);
191         void *ctx;
192         char *data;
193         int dlen;
194         int uid;
195         unsigned create:1, trycreate:1;
196 };
197
198 struct imap_cmd {
199         struct imap_cmd *next;
200         struct imap_cmd_cb cb;
201         char *cmd;
202         int tag;
203 };
204
205 #define CAP(cap) (imap->caps & (1 << (cap)))
206
207 enum CAPABILITY {
208         NOLOGIN = 0,
209         UIDPLUS,
210         LITERALPLUS,
211         NAMESPACE,
212         STARTTLS,
213 };
214
215 static const char *cap_list[] = {
216         "LOGINDISABLED",
217         "UIDPLUS",
218         "LITERAL+",
219         "NAMESPACE",
220         "STARTTLS",
221 };
222
223 #define RESP_OK    0
224 #define RESP_NO    1
225 #define RESP_BAD   2
226
227 static int get_cmd_result(struct imap_store *ctx, struct imap_cmd *tcmd);
228
229
230 static const char *Flags[] = {
231         "Draft",
232         "Flagged",
233         "Answered",
234         "Seen",
235         "Deleted",
236 };
237
238 #ifndef NO_OPENSSL
239 static void ssl_socket_perror(const char *func)
240 {
241         fprintf(stderr, "%s: %s\n", func, ERR_error_string(ERR_get_error(), 0));
242 }
243 #endif
244
245 static void socket_perror(const char *func, struct imap_socket *sock, int ret)
246 {
247 #ifndef NO_OPENSSL
248         if (sock->ssl) {
249                 int sslerr = SSL_get_error(sock->ssl, ret);
250                 switch (sslerr) {
251                 case SSL_ERROR_NONE:
252                         break;
253                 case SSL_ERROR_SYSCALL:
254                         perror("SSL_connect");
255                         break;
256                 default:
257                         ssl_socket_perror("SSL_connect");
258                         break;
259                 }
260         } else
261 #endif
262         {
263                 if (ret < 0)
264                         perror(func);
265                 else
266                         fprintf(stderr, "%s: unexpected EOF\n", func);
267         }
268 }
269
270 static int ssl_socket_connect(struct imap_socket *sock, int use_tls_only, int verify)
271 {
272 #ifdef NO_OPENSSL
273         fprintf(stderr, "SSL requested but SSL support not compiled in\n");
274         return -1;
275 #else
276         SSL_METHOD *meth;
277         SSL_CTX *ctx;
278         int ret;
279
280         SSL_library_init();
281         SSL_load_error_strings();
282
283         if (use_tls_only)
284                 meth = TLSv1_method();
285         else
286                 meth = SSLv23_method();
287
288         if (!meth) {
289                 ssl_socket_perror("SSLv23_method");
290                 return -1;
291         }
292
293         ctx = SSL_CTX_new(meth);
294
295         if (verify)
296                 SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER, NULL);
297
298         if (!SSL_CTX_set_default_verify_paths(ctx)) {
299                 ssl_socket_perror("SSL_CTX_set_default_verify_paths");
300                 return -1;
301         }
302         sock->ssl = SSL_new(ctx);
303         if (!sock->ssl) {
304                 ssl_socket_perror("SSL_new");
305                 return -1;
306         }
307         if (!SSL_set_fd(sock->ssl, sock->fd)) {
308                 ssl_socket_perror("SSL_set_fd");
309                 return -1;
310         }
311
312         ret = SSL_connect(sock->ssl);
313         if (ret <= 0) {
314                 socket_perror("SSL_connect", sock, ret);
315                 return -1;
316         }
317
318         return 0;
319 #endif
320 }
321
322 static int socket_read(struct imap_socket *sock, char *buf, int len)
323 {
324         ssize_t n;
325 #ifndef NO_OPENSSL
326         if (sock->ssl)
327                 n = SSL_read(sock->ssl, buf, len);
328         else
329 #endif
330                 n = xread(sock->fd, buf, len);
331         if (n <= 0) {
332                 socket_perror("read", sock, n);
333                 close(sock->fd);
334                 sock->fd = -1;
335         }
336         return n;
337 }
338
339 static int socket_write(struct imap_socket *sock, const char *buf, int len)
340 {
341         int n;
342 #ifndef NO_OPENSSL
343         if (sock->ssl)
344                 n = SSL_write(sock->ssl, buf, len);
345         else
346 #endif
347                 n = write_in_full(sock->fd, buf, len);
348         if (n != len) {
349                 socket_perror("write", sock, n);
350                 close(sock->fd);
351                 sock->fd = -1;
352         }
353         return n;
354 }
355
356 static void socket_shutdown(struct imap_socket *sock)
357 {
358 #ifndef NO_OPENSSL
359         if (sock->ssl) {
360                 SSL_shutdown(sock->ssl);
361                 SSL_free(sock->ssl);
362         }
363 #endif
364         close(sock->fd);
365 }
366
367 /* simple line buffering */
368 static int buffer_gets(struct imap_buffer *b, char **s)
369 {
370         int n;
371         int start = b->offset;
372
373         *s = b->buf + start;
374
375         for (;;) {
376                 /* make sure we have enough data to read the \r\n sequence */
377                 if (b->offset + 1 >= b->bytes) {
378                         if (start) {
379                                 /* shift down used bytes */
380                                 *s = b->buf;
381
382                                 assert(start <= b->bytes);
383                                 n = b->bytes - start;
384
385                                 if (n)
386                                         memmove(b->buf, b->buf + start, n);
387                                 b->offset -= start;
388                                 b->bytes = n;
389                                 start = 0;
390                         }
391
392                         n = socket_read(&b->sock, b->buf + b->bytes,
393                                          sizeof(b->buf) - b->bytes);
394
395                         if (n <= 0)
396                                 return -1;
397
398                         b->bytes += n;
399                 }
400
401                 if (b->buf[b->offset] == '\r') {
402                         assert(b->offset + 1 < b->bytes);
403                         if (b->buf[b->offset + 1] == '\n') {
404                                 b->buf[b->offset] = 0;  /* terminate the string */
405                                 b->offset += 2; /* next line */
406                                 if (Verbose)
407                                         puts(*s);
408                                 return 0;
409                         }
410                 }
411
412                 b->offset++;
413         }
414         /* not reached */
415 }
416
417 static void imap_info(const char *msg, ...)
418 {
419         va_list va;
420
421         if (!Quiet) {
422                 va_start(va, msg);
423                 vprintf(msg, va);
424                 va_end(va);
425                 fflush(stdout);
426         }
427 }
428
429 static void imap_warn(const char *msg, ...)
430 {
431         va_list va;
432
433         if (Quiet < 2) {
434                 va_start(va, msg);
435                 vfprintf(stderr, msg, va);
436                 va_end(va);
437         }
438 }
439
440 static char *next_arg(char **s)
441 {
442         char *ret;
443
444         if (!s || !*s)
445                 return NULL;
446         while (isspace((unsigned char) **s))
447                 (*s)++;
448         if (!**s) {
449                 *s = NULL;
450                 return NULL;
451         }
452         if (**s == '"') {
453                 ++*s;
454                 ret = *s;
455                 *s = strchr(*s, '"');
456         } else {
457                 ret = *s;
458                 while (**s && !isspace((unsigned char) **s))
459                         (*s)++;
460         }
461         if (*s) {
462                 if (**s)
463                         *(*s)++ = 0;
464                 if (!**s)
465                         *s = NULL;
466         }
467         return ret;
468 }
469
470 static void free_generic_messages(struct message *msgs)
471 {
472         struct message *tmsg;
473
474         for (; msgs; msgs = tmsg) {
475                 tmsg = msgs->next;
476                 free(msgs);
477         }
478 }
479
480 static int nfsnprintf(char *buf, int blen, const char *fmt, ...)
481 {
482         int ret;
483         va_list va;
484
485         va_start(va, fmt);
486         if (blen <= 0 || (unsigned)(ret = vsnprintf(buf, blen, fmt, va)) >= (unsigned)blen)
487                 die("Fatal: buffer too small. Please report a bug.");
488         va_end(va);
489         return ret;
490 }
491
492 static struct {
493         unsigned char i, j, s[256];
494 } rs;
495
496 static void arc4_init(void)
497 {
498         int i, fd;
499         unsigned char j, si, dat[128];
500
501         if ((fd = open("/dev/urandom", O_RDONLY)) < 0 && (fd = open("/dev/random", O_RDONLY)) < 0) {
502                 fprintf(stderr, "Fatal: no random number source available.\n");
503                 exit(3);
504         }
505         if (read_in_full(fd, dat, 128) != 128) {
506                 fprintf(stderr, "Fatal: cannot read random number source.\n");
507                 exit(3);
508         }
509         close(fd);
510
511         for (i = 0; i < 256; i++)
512                 rs.s[i] = i;
513         for (i = j = 0; i < 256; i++) {
514                 si = rs.s[i];
515                 j += si + dat[i & 127];
516                 rs.s[i] = rs.s[j];
517                 rs.s[j] = si;
518         }
519         rs.i = rs.j = 0;
520
521         for (i = 0; i < 256; i++)
522                 arc4_getbyte();
523 }
524
525 static unsigned char arc4_getbyte(void)
526 {
527         unsigned char si, sj;
528
529         rs.i++;
530         si = rs.s[rs.i];
531         rs.j += si;
532         sj = rs.s[rs.j];
533         rs.s[rs.i] = sj;
534         rs.s[rs.j] = si;
535         return rs.s[(si + sj) & 0xff];
536 }
537
538 static struct imap_cmd *v_issue_imap_cmd(struct imap_store *ctx,
539                                          struct imap_cmd_cb *cb,
540                                          const char *fmt, va_list ap)
541 {
542         struct imap *imap = ctx->imap;
543         struct imap_cmd *cmd;
544         int n, bufl;
545         char buf[1024];
546
547         cmd = xmalloc(sizeof(struct imap_cmd));
548         nfvasprintf(&cmd->cmd, fmt, ap);
549         cmd->tag = ++imap->nexttag;
550
551         if (cb)
552                 cmd->cb = *cb;
553         else
554                 memset(&cmd->cb, 0, sizeof(cmd->cb));
555
556         while (imap->literal_pending)
557                 get_cmd_result(ctx, NULL);
558
559         bufl = nfsnprintf(buf, sizeof(buf), cmd->cb.data ? CAP(LITERALPLUS) ?
560                            "%d %s{%d+}\r\n" : "%d %s{%d}\r\n" : "%d %s\r\n",
561                            cmd->tag, cmd->cmd, cmd->cb.dlen);
562         if (Verbose) {
563                 if (imap->num_in_progress)
564                         printf("(%d in progress) ", imap->num_in_progress);
565                 if (memcmp(cmd->cmd, "LOGIN", 5))
566                         printf(">>> %s", buf);
567                 else
568                         printf(">>> %d LOGIN <user> <pass>\n", cmd->tag);
569         }
570         if (socket_write(&imap->buf.sock, buf, bufl) != bufl) {
571                 free(cmd->cmd);
572                 free(cmd);
573                 if (cb)
574                         free(cb->data);
575                 return NULL;
576         }
577         if (cmd->cb.data) {
578                 if (CAP(LITERALPLUS)) {
579                         n = socket_write(&imap->buf.sock, cmd->cb.data, cmd->cb.dlen);
580                         free(cmd->cb.data);
581                         if (n != cmd->cb.dlen ||
582                             socket_write(&imap->buf.sock, "\r\n", 2) != 2) {
583                                 free(cmd->cmd);
584                                 free(cmd);
585                                 return NULL;
586                         }
587                         cmd->cb.data = NULL;
588                 } else
589                         imap->literal_pending = 1;
590         } else if (cmd->cb.cont)
591                 imap->literal_pending = 1;
592         cmd->next = NULL;
593         *imap->in_progress_append = cmd;
594         imap->in_progress_append = &cmd->next;
595         imap->num_in_progress++;
596         return cmd;
597 }
598
599 static struct imap_cmd *issue_imap_cmd(struct imap_store *ctx,
600                                        struct imap_cmd_cb *cb,
601                                        const char *fmt, ...)
602 {
603         struct imap_cmd *ret;
604         va_list ap;
605
606         va_start(ap, fmt);
607         ret = v_issue_imap_cmd(ctx, cb, fmt, ap);
608         va_end(ap);
609         return ret;
610 }
611
612 static int imap_exec(struct imap_store *ctx, struct imap_cmd_cb *cb,
613                      const char *fmt, ...)
614 {
615         va_list ap;
616         struct imap_cmd *cmdp;
617
618         va_start(ap, fmt);
619         cmdp = v_issue_imap_cmd(ctx, cb, fmt, ap);
620         va_end(ap);
621         if (!cmdp)
622                 return RESP_BAD;
623
624         return get_cmd_result(ctx, cmdp);
625 }
626
627 static int imap_exec_m(struct imap_store *ctx, struct imap_cmd_cb *cb,
628                        const char *fmt, ...)
629 {
630         va_list ap;
631         struct imap_cmd *cmdp;
632
633         va_start(ap, fmt);
634         cmdp = v_issue_imap_cmd(ctx, cb, fmt, ap);
635         va_end(ap);
636         if (!cmdp)
637                 return DRV_STORE_BAD;
638
639         switch (get_cmd_result(ctx, cmdp)) {
640         case RESP_BAD: return DRV_STORE_BAD;
641         case RESP_NO: return DRV_MSG_BAD;
642         default: return DRV_OK;
643         }
644 }
645
646 static int is_atom(struct imap_list *list)
647 {
648         return list && list->val && list->val != NIL && list->val != LIST;
649 }
650
651 static int is_list(struct imap_list *list)
652 {
653         return list && list->val == LIST;
654 }
655
656 static void free_list(struct imap_list *list)
657 {
658         struct imap_list *tmp;
659
660         for (; list; list = tmp) {
661                 tmp = list->next;
662                 if (is_list(list))
663                         free_list(list->child);
664                 else if (is_atom(list))
665                         free(list->val);
666                 free(list);
667         }
668 }
669
670 static int parse_imap_list_l(struct imap *imap, char **sp, struct imap_list **curp, int level)
671 {
672         struct imap_list *cur;
673         char *s = *sp, *p;
674         int n, bytes;
675
676         for (;;) {
677                 while (isspace((unsigned char)*s))
678                         s++;
679                 if (level && *s == ')') {
680                         s++;
681                         break;
682                 }
683                 *curp = cur = xmalloc(sizeof(*cur));
684                 curp = &cur->next;
685                 cur->val = NULL; /* for clean bail */
686                 if (*s == '(') {
687                         /* sublist */
688                         s++;
689                         cur->val = LIST;
690                         if (parse_imap_list_l(imap, &s, &cur->child, level + 1))
691                                 goto bail;
692                 } else if (imap && *s == '{') {
693                         /* literal */
694                         bytes = cur->len = strtol(s + 1, &s, 10);
695                         if (*s != '}')
696                                 goto bail;
697
698                         s = cur->val = xmalloc(cur->len);
699
700                         /* dump whats left over in the input buffer */
701                         n = imap->buf.bytes - imap->buf.offset;
702
703                         if (n > bytes)
704                                 /* the entire message fit in the buffer */
705                                 n = bytes;
706
707                         memcpy(s, imap->buf.buf + imap->buf.offset, n);
708                         s += n;
709                         bytes -= n;
710
711                         /* mark that we used part of the buffer */
712                         imap->buf.offset += n;
713
714                         /* now read the rest of the message */
715                         while (bytes > 0) {
716                                 if ((n = socket_read(&imap->buf.sock, s, bytes)) <= 0)
717                                         goto bail;
718                                 s += n;
719                                 bytes -= n;
720                         }
721
722                         if (buffer_gets(&imap->buf, &s))
723                                 goto bail;
724                 } else if (*s == '"') {
725                         /* quoted string */
726                         s++;
727                         p = s;
728                         for (; *s != '"'; s++)
729                                 if (!*s)
730                                         goto bail;
731                         cur->len = s - p;
732                         s++;
733                         cur->val = xmemdupz(p, cur->len);
734                 } else {
735                         /* atom */
736                         p = s;
737                         for (; *s && !isspace((unsigned char)*s); s++)
738                                 if (level && *s == ')')
739                                         break;
740                         cur->len = s - p;
741                         if (cur->len == 3 && !memcmp("NIL", p, 3))
742                                 cur->val = NIL;
743                         else
744                                 cur->val = xmemdupz(p, cur->len);
745                 }
746
747                 if (!level)
748                         break;
749                 if (!*s)
750                         goto bail;
751         }
752         *sp = s;
753         *curp = NULL;
754         return 0;
755
756 bail:
757         *curp = NULL;
758         return -1;
759 }
760
761 static struct imap_list *parse_imap_list(struct imap *imap, char **sp)
762 {
763         struct imap_list *head;
764
765         if (!parse_imap_list_l(imap, sp, &head, 0))
766                 return head;
767         free_list(head);
768         return NULL;
769 }
770
771 static struct imap_list *parse_list(char **sp)
772 {
773         return parse_imap_list(NULL, sp);
774 }
775
776 static void parse_capability(struct imap *imap, char *cmd)
777 {
778         char *arg;
779         unsigned i;
780
781         imap->caps = 0x80000000;
782         while ((arg = next_arg(&cmd)))
783                 for (i = 0; i < ARRAY_SIZE(cap_list); i++)
784                         if (!strcmp(cap_list[i], arg))
785                                 imap->caps |= 1 << i;
786         imap->rcaps = imap->caps;
787 }
788
789 static int parse_response_code(struct imap_store *ctx, struct imap_cmd_cb *cb,
790                                char *s)
791 {
792         struct imap *imap = ctx->imap;
793         char *arg, *p;
794
795         if (*s != '[')
796                 return RESP_OK;         /* no response code */
797         s++;
798         if (!(p = strchr(s, ']'))) {
799                 fprintf(stderr, "IMAP error: malformed response code\n");
800                 return RESP_BAD;
801         }
802         *p++ = 0;
803         arg = next_arg(&s);
804         if (!strcmp("UIDVALIDITY", arg)) {
805                 if (!(arg = next_arg(&s)) || !(ctx->gen.uidvalidity = atoi(arg))) {
806                         fprintf(stderr, "IMAP error: malformed UIDVALIDITY status\n");
807                         return RESP_BAD;
808                 }
809         } else if (!strcmp("UIDNEXT", arg)) {
810                 if (!(arg = next_arg(&s)) || !(imap->uidnext = atoi(arg))) {
811                         fprintf(stderr, "IMAP error: malformed NEXTUID status\n");
812                         return RESP_BAD;
813                 }
814         } else if (!strcmp("CAPABILITY", arg)) {
815                 parse_capability(imap, s);
816         } else if (!strcmp("ALERT", arg)) {
817                 /* RFC2060 says that these messages MUST be displayed
818                  * to the user
819                  */
820                 for (; isspace((unsigned char)*p); p++);
821                 fprintf(stderr, "*** IMAP ALERT *** %s\n", p);
822         } else if (cb && cb->ctx && !strcmp("APPENDUID", arg)) {
823                 if (!(arg = next_arg(&s)) || !(ctx->gen.uidvalidity = atoi(arg)) ||
824                     !(arg = next_arg(&s)) || !(*(int *)cb->ctx = atoi(arg))) {
825                         fprintf(stderr, "IMAP error: malformed APPENDUID status\n");
826                         return RESP_BAD;
827                 }
828         }
829         return RESP_OK;
830 }
831
832 static int get_cmd_result(struct imap_store *ctx, struct imap_cmd *tcmd)
833 {
834         struct imap *imap = ctx->imap;
835         struct imap_cmd *cmdp, **pcmdp, *ncmdp;
836         char *cmd, *arg, *arg1, *p;
837         int n, resp, resp2, tag;
838
839         for (;;) {
840                 if (buffer_gets(&imap->buf, &cmd))
841                         return RESP_BAD;
842
843                 arg = next_arg(&cmd);
844                 if (*arg == '*') {
845                         arg = next_arg(&cmd);
846                         if (!arg) {
847                                 fprintf(stderr, "IMAP error: unable to parse untagged response\n");
848                                 return RESP_BAD;
849                         }
850
851                         if (!strcmp("NAMESPACE", arg)) {
852                                 imap->ns_personal = parse_list(&cmd);
853                                 imap->ns_other = parse_list(&cmd);
854                                 imap->ns_shared = parse_list(&cmd);
855                         } else if (!strcmp("OK", arg) || !strcmp("BAD", arg) ||
856                                    !strcmp("NO", arg) || !strcmp("BYE", arg)) {
857                                 if ((resp = parse_response_code(ctx, NULL, cmd)) != RESP_OK)
858                                         return resp;
859                         } else if (!strcmp("CAPABILITY", arg))
860                                 parse_capability(imap, cmd);
861                         else if ((arg1 = next_arg(&cmd))) {
862                                 if (!strcmp("EXISTS", arg1))
863                                         ctx->gen.count = atoi(arg);
864                                 else if (!strcmp("RECENT", arg1))
865                                         ctx->gen.recent = atoi(arg);
866                         } else {
867                                 fprintf(stderr, "IMAP error: unable to parse untagged response\n");
868                                 return RESP_BAD;
869                         }
870                 } else if (!imap->in_progress) {
871                         fprintf(stderr, "IMAP error: unexpected reply: %s %s\n", arg, cmd ? cmd : "");
872                         return RESP_BAD;
873                 } else if (*arg == '+') {
874                         /* This can happen only with the last command underway, as
875                            it enforces a round-trip. */
876                         cmdp = (struct imap_cmd *)((char *)imap->in_progress_append -
877                                offsetof(struct imap_cmd, next));
878                         if (cmdp->cb.data) {
879                                 n = socket_write(&imap->buf.sock, cmdp->cb.data, cmdp->cb.dlen);
880                                 free(cmdp->cb.data);
881                                 cmdp->cb.data = NULL;
882                                 if (n != (int)cmdp->cb.dlen)
883                                         return RESP_BAD;
884                         } else if (cmdp->cb.cont) {
885                                 if (cmdp->cb.cont(ctx, cmdp, cmd))
886                                         return RESP_BAD;
887                         } else {
888                                 fprintf(stderr, "IMAP error: unexpected command continuation request\n");
889                                 return RESP_BAD;
890                         }
891                         if (socket_write(&imap->buf.sock, "\r\n", 2) != 2)
892                                 return RESP_BAD;
893                         if (!cmdp->cb.cont)
894                                 imap->literal_pending = 0;
895                         if (!tcmd)
896                                 return DRV_OK;
897                 } else {
898                         tag = atoi(arg);
899                         for (pcmdp = &imap->in_progress; (cmdp = *pcmdp); pcmdp = &cmdp->next)
900                                 if (cmdp->tag == tag)
901                                         goto gottag;
902                         fprintf(stderr, "IMAP error: unexpected tag %s\n", arg);
903                         return RESP_BAD;
904                 gottag:
905                         if (!(*pcmdp = cmdp->next))
906                                 imap->in_progress_append = pcmdp;
907                         imap->num_in_progress--;
908                         if (cmdp->cb.cont || cmdp->cb.data)
909                                 imap->literal_pending = 0;
910                         arg = next_arg(&cmd);
911                         if (!strcmp("OK", arg))
912                                 resp = DRV_OK;
913                         else {
914                                 if (!strcmp("NO", arg)) {
915                                         if (cmdp->cb.create && cmd && (cmdp->cb.trycreate || !memcmp(cmd, "[TRYCREATE]", 11))) { /* SELECT, APPEND or UID COPY */
916                                                 p = strchr(cmdp->cmd, '"');
917                                                 if (!issue_imap_cmd(ctx, NULL, "CREATE \"%.*s\"", strchr(p + 1, '"') - p + 1, p)) {
918                                                         resp = RESP_BAD;
919                                                         goto normal;
920                                                 }
921                                                 /* not waiting here violates the spec, but a server that does not
922                                                    grok this nonetheless violates it too. */
923                                                 cmdp->cb.create = 0;
924                                                 if (!(ncmdp = issue_imap_cmd(ctx, &cmdp->cb, "%s", cmdp->cmd))) {
925                                                         resp = RESP_BAD;
926                                                         goto normal;
927                                                 }
928                                                 free(cmdp->cmd);
929                                                 free(cmdp);
930                                                 if (!tcmd)
931                                                         return 0;       /* ignored */
932                                                 if (cmdp == tcmd)
933                                                         tcmd = ncmdp;
934                                                 continue;
935                                         }
936                                         resp = RESP_NO;
937                                 } else /*if (!strcmp("BAD", arg))*/
938                                         resp = RESP_BAD;
939                                 fprintf(stderr, "IMAP command '%s' returned response (%s) - %s\n",
940                                          memcmp(cmdp->cmd, "LOGIN", 5) ?
941                                                         cmdp->cmd : "LOGIN <user> <pass>",
942                                                         arg, cmd ? cmd : "");
943                         }
944                         if ((resp2 = parse_response_code(ctx, &cmdp->cb, cmd)) > resp)
945                                 resp = resp2;
946                 normal:
947                         if (cmdp->cb.done)
948                                 cmdp->cb.done(ctx, cmdp, resp);
949                         free(cmdp->cb.data);
950                         free(cmdp->cmd);
951                         free(cmdp);
952                         if (!tcmd || tcmd == cmdp)
953                                 return resp;
954                 }
955         }
956         /* not reached */
957 }
958
959 static void imap_close_server(struct imap_store *ictx)
960 {
961         struct imap *imap = ictx->imap;
962
963         if (imap->buf.sock.fd != -1) {
964                 imap_exec(ictx, NULL, "LOGOUT");
965                 socket_shutdown(&imap->buf.sock);
966         }
967         free_list(imap->ns_personal);
968         free_list(imap->ns_other);
969         free_list(imap->ns_shared);
970         free(imap);
971 }
972
973 static void imap_close_store(struct store *ctx)
974 {
975         imap_close_server((struct imap_store *)ctx);
976         free_generic_messages(ctx->msgs);
977         free(ctx);
978 }
979
980 static struct store *imap_open_store(struct imap_server_conf *srvc)
981 {
982         struct imap_store *ctx;
983         struct imap *imap;
984         char *arg, *rsp;
985         struct hostent *he;
986         struct sockaddr_in addr;
987         int s, a[2], preauth;
988         pid_t pid;
989
990         ctx = xcalloc(sizeof(*ctx), 1);
991
992         ctx->imap = imap = xcalloc(sizeof(*imap), 1);
993         imap->buf.sock.fd = -1;
994         imap->in_progress_append = &imap->in_progress;
995
996         /* open connection to IMAP server */
997
998         if (srvc->tunnel) {
999                 imap_info("Starting tunnel '%s'... ", srvc->tunnel);
1000
1001                 if (socketpair(PF_UNIX, SOCK_STREAM, 0, a)) {
1002                         perror("socketpair");
1003                         exit(1);
1004                 }
1005
1006                 pid = fork();
1007                 if (pid < 0)
1008                         _exit(127);
1009                 if (!pid) {
1010                         if (dup2(a[0], 0) == -1 || dup2(a[0], 1) == -1)
1011                                 _exit(127);
1012                         close(a[0]);
1013                         close(a[1]);
1014                         execl("/bin/sh", "sh", "-c", srvc->tunnel, NULL);
1015                         _exit(127);
1016                 }
1017
1018                 close(a[0]);
1019
1020                 imap->buf.sock.fd = a[1];
1021
1022                 imap_info("ok\n");
1023         } else {
1024                 memset(&addr, 0, sizeof(addr));
1025                 addr.sin_port = htons(srvc->port);
1026                 addr.sin_family = AF_INET;
1027
1028                 imap_info("Resolving %s... ", srvc->host);
1029                 he = gethostbyname(srvc->host);
1030                 if (!he) {
1031                         perror("gethostbyname");
1032                         goto bail;
1033                 }
1034                 imap_info("ok\n");
1035
1036                 addr.sin_addr.s_addr = *((int *) he->h_addr_list[0]);
1037
1038                 s = socket(PF_INET, SOCK_STREAM, 0);
1039
1040                 imap_info("Connecting to %s:%hu... ", inet_ntoa(addr.sin_addr), ntohs(addr.sin_port));
1041                 if (connect(s, (struct sockaddr *)&addr, sizeof(addr))) {
1042                         close(s);
1043                         perror("connect");
1044                         goto bail;
1045                 }
1046
1047                 imap->buf.sock.fd = s;
1048
1049                 if (srvc->use_ssl &&
1050                     ssl_socket_connect(&imap->buf.sock, 0, srvc->ssl_verify)) {
1051                         close(s);
1052                         goto bail;
1053                 }
1054                 imap_info("ok\n");
1055         }
1056
1057         /* read the greeting string */
1058         if (buffer_gets(&imap->buf, &rsp)) {
1059                 fprintf(stderr, "IMAP error: no greeting response\n");
1060                 goto bail;
1061         }
1062         arg = next_arg(&rsp);
1063         if (!arg || *arg != '*' || (arg = next_arg(&rsp)) == NULL) {
1064                 fprintf(stderr, "IMAP error: invalid greeting response\n");
1065                 goto bail;
1066         }
1067         preauth = 0;
1068         if (!strcmp("PREAUTH", arg))
1069                 preauth = 1;
1070         else if (strcmp("OK", arg) != 0) {
1071                 fprintf(stderr, "IMAP error: unknown greeting response\n");
1072                 goto bail;
1073         }
1074         parse_response_code(ctx, NULL, rsp);
1075         if (!imap->caps && imap_exec(ctx, NULL, "CAPABILITY") != RESP_OK)
1076                 goto bail;
1077
1078         if (!preauth) {
1079 #ifndef NO_OPENSSL
1080                 if (!srvc->use_ssl && CAP(STARTTLS)) {
1081                         if (imap_exec(ctx, 0, "STARTTLS") != RESP_OK)
1082                                 goto bail;
1083                         if (ssl_socket_connect(&imap->buf.sock, 1,
1084                                                srvc->ssl_verify))
1085                                 goto bail;
1086                         /* capabilities may have changed, so get the new capabilities */
1087                         if (imap_exec(ctx, 0, "CAPABILITY") != RESP_OK)
1088                                 goto bail;
1089                 }
1090 #endif
1091                 imap_info("Logging in...\n");
1092                 if (!srvc->user) {
1093                         fprintf(stderr, "Skipping server %s, no user\n", srvc->host);
1094                         goto bail;
1095                 }
1096                 if (!srvc->pass) {
1097                         char prompt[80];
1098                         sprintf(prompt, "Password (%s@%s): ", srvc->user, srvc->host);
1099                         arg = getpass(prompt);
1100                         if (!arg) {
1101                                 perror("getpass");
1102                                 exit(1);
1103                         }
1104                         if (!*arg) {
1105                                 fprintf(stderr, "Skipping account %s@%s, no password\n", srvc->user, srvc->host);
1106                                 goto bail;
1107                         }
1108                         /*
1109                          * getpass() returns a pointer to a static buffer.  make a copy
1110                          * for long term storage.
1111                          */
1112                         srvc->pass = xstrdup(arg);
1113                 }
1114                 if (CAP(NOLOGIN)) {
1115                         fprintf(stderr, "Skipping account %s@%s, server forbids LOGIN\n", srvc->user, srvc->host);
1116                         goto bail;
1117                 }
1118                 if (!imap->buf.sock.ssl)
1119                         imap_warn("*** IMAP Warning *** Password is being "
1120                                   "sent in the clear\n");
1121                 if (imap_exec(ctx, NULL, "LOGIN \"%s\" \"%s\"", srvc->user, srvc->pass) != RESP_OK) {
1122                         fprintf(stderr, "IMAP error: LOGIN failed\n");
1123                         goto bail;
1124                 }
1125         } /* !preauth */
1126
1127         ctx->prefix = "";
1128         ctx->trashnc = 1;
1129         return (struct store *)ctx;
1130
1131 bail:
1132         imap_close_store(&ctx->gen);
1133         return NULL;
1134 }
1135
1136 static int imap_make_flags(int flags, char *buf)
1137 {
1138         const char *s;
1139         unsigned i, d;
1140
1141         for (i = d = 0; i < ARRAY_SIZE(Flags); i++)
1142                 if (flags & (1 << i)) {
1143                         buf[d++] = ' ';
1144                         buf[d++] = '\\';
1145                         for (s = Flags[i]; *s; s++)
1146                                 buf[d++] = *s;
1147                 }
1148         buf[0] = '(';
1149         buf[d++] = ')';
1150         return d;
1151 }
1152
1153 #define TUIDL 8
1154
1155 static int imap_store_msg(struct store *gctx, struct msg_data *data, int *uid)
1156 {
1157         struct imap_store *ctx = (struct imap_store *)gctx;
1158         struct imap *imap = ctx->imap;
1159         struct imap_cmd_cb cb;
1160         char *fmap, *buf;
1161         const char *prefix, *box;
1162         int ret, i, j, d, len, extra, nocr;
1163         int start, sbreak = 0, ebreak = 0;
1164         char flagstr[128], tuid[TUIDL * 2 + 1];
1165
1166         memset(&cb, 0, sizeof(cb));
1167
1168         fmap = data->data;
1169         len = data->len;
1170         nocr = !data->crlf;
1171         extra = 0, i = 0;
1172         if (!CAP(UIDPLUS) && uid) {
1173         nloop:
1174                 start = i;
1175                 while (i < len)
1176                         if (fmap[i++] == '\n') {
1177                                 extra += nocr;
1178                                 if (i - 2 + nocr == start) {
1179                                         sbreak = ebreak = i - 2 + nocr;
1180                                         goto mktid;
1181                                 }
1182                                 if (!memcmp(fmap + start, "X-TUID: ", 8)) {
1183                                         extra -= (ebreak = i) - (sbreak = start) + nocr;
1184                                         goto mktid;
1185                                 }
1186                                 goto nloop;
1187                         }
1188                 /* invalid message */
1189                 free(fmap);
1190                 return DRV_MSG_BAD;
1191         mktid:
1192                 for (j = 0; j < TUIDL; j++)
1193                         sprintf(tuid + j * 2, "%02x", arc4_getbyte());
1194                 extra += 8 + TUIDL * 2 + 2;
1195         }
1196         if (nocr)
1197                 for (; i < len; i++)
1198                         if (fmap[i] == '\n')
1199                                 extra++;
1200
1201         cb.dlen = len + extra;
1202         buf = cb.data = xmalloc(cb.dlen);
1203         i = 0;
1204         if (!CAP(UIDPLUS) && uid) {
1205                 if (nocr) {
1206                         for (; i < sbreak; i++)
1207                                 if (fmap[i] == '\n') {
1208                                         *buf++ = '\r';
1209                                         *buf++ = '\n';
1210                                 } else
1211                                         *buf++ = fmap[i];
1212                 } else {
1213                         memcpy(buf, fmap, sbreak);
1214                         buf += sbreak;
1215                 }
1216                 memcpy(buf, "X-TUID: ", 8);
1217                 buf += 8;
1218                 memcpy(buf, tuid, TUIDL * 2);
1219                 buf += TUIDL * 2;
1220                 *buf++ = '\r';
1221                 *buf++ = '\n';
1222                 i = ebreak;
1223         }
1224         if (nocr) {
1225                 for (; i < len; i++)
1226                         if (fmap[i] == '\n') {
1227                                 *buf++ = '\r';
1228                                 *buf++ = '\n';
1229                         } else
1230                                 *buf++ = fmap[i];
1231         } else
1232                 memcpy(buf, fmap + i, len - i);
1233
1234         free(fmap);
1235
1236         d = 0;
1237         if (data->flags) {
1238                 d = imap_make_flags(data->flags, flagstr);
1239                 flagstr[d++] = ' ';
1240         }
1241         flagstr[d] = 0;
1242
1243         if (!uid) {
1244                 box = gctx->conf->trash;
1245                 prefix = ctx->prefix;
1246                 cb.create = 1;
1247                 if (ctx->trashnc)
1248                         imap->caps = imap->rcaps & ~(1 << LITERALPLUS);
1249         } else {
1250                 box = gctx->name;
1251                 prefix = !strcmp(box, "INBOX") ? "" : ctx->prefix;
1252                 cb.create = 0;
1253         }
1254         cb.ctx = uid;
1255         ret = imap_exec_m(ctx, &cb, "APPEND \"%s%s\" %s", prefix, box, flagstr);
1256         imap->caps = imap->rcaps;
1257         if (ret != DRV_OK)
1258                 return ret;
1259         if (!uid)
1260                 ctx->trashnc = 0;
1261         else
1262                 gctx->count++;
1263
1264         return DRV_OK;
1265 }
1266
1267 static void encode_html_chars(struct strbuf *p)
1268 {
1269         int i;
1270         for (i = 0; i < p->len; i++) {
1271                 if (p->buf[i] == '&')
1272                         strbuf_splice(p, i, 1, "&amp;", 5);
1273                 if (p->buf[i] == '<')
1274                         strbuf_splice(p, i, 1, "&lt;", 4);
1275                 if (p->buf[i] == '>')
1276                         strbuf_splice(p, i, 1, "&gt;", 4);
1277                 if (p->buf[i] == '"')
1278                         strbuf_splice(p, i, 1, "&quot;", 6);
1279         }
1280 }
1281 static void wrap_in_html(struct msg_data *msg)
1282 {
1283         struct strbuf buf = STRBUF_INIT;
1284         struct strbuf **lines;
1285         struct strbuf **p;
1286         static char *content_type = "Content-Type: text/html;\n";
1287         static char *pre_open = "<pre>\n";
1288         static char *pre_close = "</pre>\n";
1289         int added_header = 0;
1290
1291         strbuf_attach(&buf, msg->data, msg->len, msg->len);
1292         lines = strbuf_split(&buf, '\n');
1293         strbuf_release(&buf);
1294         for (p = lines; *p; p++) {
1295                 if (! added_header) {
1296                         if ((*p)->len == 1 && *((*p)->buf) == '\n') {
1297                                 strbuf_addstr(&buf, content_type);
1298                                 strbuf_addbuf(&buf, *p);
1299                                 strbuf_addstr(&buf, pre_open);
1300                                 added_header = 1;
1301                                 continue;
1302                         }
1303                 }
1304                 else
1305                         encode_html_chars(*p);
1306                 strbuf_addbuf(&buf, *p);
1307         }
1308         strbuf_addstr(&buf, pre_close);
1309         strbuf_list_free(lines);
1310         msg->len  = buf.len;
1311         msg->data = strbuf_detach(&buf, NULL);
1312 }
1313
1314 #define CHUNKSIZE 0x1000
1315
1316 static int read_message(FILE *f, struct msg_data *msg)
1317 {
1318         struct strbuf buf = STRBUF_INIT;
1319
1320         memset(msg, 0, sizeof(*msg));
1321
1322         do {
1323                 if (strbuf_fread(&buf, CHUNKSIZE, f) <= 0)
1324                         break;
1325         } while (!feof(f));
1326
1327         msg->len  = buf.len;
1328         msg->data = strbuf_detach(&buf, NULL);
1329         return msg->len;
1330 }
1331
1332 static int count_messages(struct msg_data *msg)
1333 {
1334         int count = 0;
1335         char *p = msg->data;
1336
1337         while (1) {
1338                 if (!prefixcmp(p, "From ")) {
1339                         count++;
1340                         p += 5;
1341                 }
1342                 p = strstr(p+5, "\nFrom ");
1343                 if (!p)
1344                         break;
1345                 p++;
1346         }
1347         return count;
1348 }
1349
1350 static int split_msg(struct msg_data *all_msgs, struct msg_data *msg, int *ofs)
1351 {
1352         char *p, *data;
1353
1354         memset(msg, 0, sizeof *msg);
1355         if (*ofs >= all_msgs->len)
1356                 return 0;
1357
1358         data = &all_msgs->data[*ofs];
1359         msg->len = all_msgs->len - *ofs;
1360
1361         if (msg->len < 5 || prefixcmp(data, "From "))
1362                 return 0;
1363
1364         p = strchr(data, '\n');
1365         if (p) {
1366                 p = &p[1];
1367                 msg->len -= p-data;
1368                 *ofs += p-data;
1369                 data = p;
1370         }
1371
1372         p = strstr(data, "\nFrom ");
1373         if (p)
1374                 msg->len = &p[1] - data;
1375
1376         msg->data = xmemdupz(data, msg->len);
1377         *ofs += msg->len;
1378         return 1;
1379 }
1380
1381 static struct imap_server_conf server = {
1382         NULL,   /* name */
1383         NULL,   /* tunnel */
1384         NULL,   /* host */
1385         0,      /* port */
1386         NULL,   /* user */
1387         NULL,   /* pass */
1388         0,      /* use_ssl */
1389         1,      /* ssl_verify */
1390         0,      /* use_html */
1391 };
1392
1393 static char *imap_folder;
1394
1395 static int git_imap_config(const char *key, const char *val, void *cb)
1396 {
1397         char imap_key[] = "imap.";
1398
1399         if (strncmp(key, imap_key, sizeof imap_key - 1))
1400                 return 0;
1401
1402         if (!val)
1403                 return config_error_nonbool(key);
1404
1405         key += sizeof imap_key - 1;
1406
1407         if (!strcmp("folder", key)) {
1408                 imap_folder = xstrdup(val);
1409         } else if (!strcmp("host", key)) {
1410                 if (!prefixcmp(val, "imap:"))
1411                         val += 5;
1412                 else if (!prefixcmp(val, "imaps:")) {
1413                         val += 6;
1414                         server.use_ssl = 1;
1415                 }
1416                 if (!prefixcmp(val, "//"))
1417                         val += 2;
1418                 server.host = xstrdup(val);
1419         } else if (!strcmp("user", key))
1420                 server.user = xstrdup(val);
1421         else if (!strcmp("pass", key))
1422                 server.pass = xstrdup(val);
1423         else if (!strcmp("port", key))
1424                 server.port = git_config_int(key, val);
1425         else if (!strcmp("tunnel", key))
1426                 server.tunnel = xstrdup(val);
1427         else if (!strcmp("sslverify", key))
1428                 server.ssl_verify = git_config_bool(key, val);
1429         else if (!strcmp("preformattedHTML", key))
1430                 server.use_html = git_config_bool(key, val);
1431         return 0;
1432 }
1433
1434 int main(int argc, char **argv)
1435 {
1436         struct msg_data all_msgs, msg;
1437         struct store *ctx = NULL;
1438         int uid = 0;
1439         int ofs = 0;
1440         int r;
1441         int total, n = 0;
1442         int nongit_ok;
1443
1444         git_extract_argv0_path(argv[0]);
1445
1446         /* init the random number generator */
1447         arc4_init();
1448
1449         setup_git_directory_gently(&nongit_ok);
1450         git_config(git_imap_config, NULL);
1451
1452         if (!server.port)
1453                 server.port = server.use_ssl ? 993 : 143;
1454
1455         if (!imap_folder) {
1456                 fprintf(stderr, "no imap store specified\n");
1457                 return 1;
1458         }
1459         if (!server.host) {
1460                 if (!server.tunnel) {
1461                         fprintf(stderr, "no imap host specified\n");
1462                         return 1;
1463                 }
1464                 server.host = "tunnel";
1465         }
1466
1467         /* read the messages */
1468         if (!read_message(stdin, &all_msgs)) {
1469                 fprintf(stderr, "nothing to send\n");
1470                 return 1;
1471         }
1472
1473         total = count_messages(&all_msgs);
1474         if (!total) {
1475                 fprintf(stderr, "no messages to send\n");
1476                 return 1;
1477         }
1478
1479         /* write it to the imap server */
1480         ctx = imap_open_store(&server);
1481         if (!ctx) {
1482                 fprintf(stderr, "failed to open store\n");
1483                 return 1;
1484         }
1485
1486         fprintf(stderr, "sending %d message%s\n", total, (total != 1) ? "s" : "");
1487         ctx->name = imap_folder;
1488         while (1) {
1489                 unsigned percent = n * 100 / total;
1490                 fprintf(stderr, "%4u%% (%d/%d) done\r", percent, n, total);
1491                 if (!split_msg(&all_msgs, &msg, &ofs))
1492                         break;
1493                 if (server.use_html)
1494                         wrap_in_html(&msg);
1495                 r = imap_store_msg(ctx, &msg, &uid);
1496                 if (r != DRV_OK)
1497                         break;
1498                 n++;
1499         }
1500         fprintf(stderr, "\n");
1501
1502         imap_close_store(ctx);
1503
1504         return 0;
1505 }