2 * git-imap-send - drops patches into an imap Drafts folder
3 * derived from isync/mbsync - mailbox synchronizer
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
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.
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.
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
33 const char *path
; /* should this be here? its interpretation is driver-specific */
36 unsigned max_size
; /* off_t is overkill */
37 unsigned trash_remote_new
:1, trash_only_new
:1;
41 struct string_list
*next
;
46 struct channel_conf
*next
;
48 struct store_conf
*master
, *slave
;
49 char *master_name
, *slave_name
;
51 struct string_list
*patterns
;
53 unsigned max_messages
; /* for slave only */
57 struct group_conf
*next
;
59 struct string_list
*channels
;
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 */
69 /* struct string_list *keywords; */
70 size_t size
; /* zero implies "not fetched" */
72 unsigned char flags
, status
;
76 struct store_conf
*conf
; /* foreign */
78 /* currently open mailbox */
79 const char *name
; /* foreign! maybe preset? */
81 struct message
*msgs
; /* own */
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 */
97 #define DRV_MSG_BAD -1
98 #define DRV_BOX_BAD -2
99 #define DRV_STORE_BAD -3
101 static int Verbose
, Quiet
;
103 __attribute__((format (printf
, 1, 2)))
104 static void imap_info(const char *, ...);
105 __attribute__((format (printf
, 1, 2)))
106 static void imap_warn(const char *, ...);
108 static char *next_arg(char **);
110 static void free_generic_messages(struct message
*);
112 __attribute__((format (printf
, 3, 4)))
113 static int nfsnprintf(char *buf
, int blen
, const char *fmt
, ...);
115 static int nfvasprintf(char **strp
, const char *fmt
, va_list ap
)
120 len
= vsnprintf(tmp
, sizeof(tmp
), fmt
, ap
);
122 die("Fatal: Out of memory");
123 if (len
>= sizeof(tmp
))
124 die("imap command overflow!");
125 *strp
= xmemdupz(tmp
, len
);
129 static void arc4_init(void);
130 static unsigned char arc4_getbyte(void);
132 struct imap_server_conf
{
144 struct imap_store_conf
{
145 struct store_conf gen
;
146 struct imap_server_conf
*server
;
147 unsigned use_namespace
:1;
150 #define NIL (void *)0x1
151 #define LIST (void *)0x2
154 struct imap_list
*next
, *child
;
165 struct imap_socket sock
;
174 int uidnext
; /* from SELECT responses */
175 struct imap_list
*ns_personal
, *ns_other
, *ns_shared
; /* NAMESPACE info */
176 unsigned caps
, rcaps
; /* CAPABILITY results */
178 int nexttag
, num_in_progress
, literal_pending
;
179 struct imap_cmd
*in_progress
, **in_progress_append
;
180 struct imap_buffer buf
; /* this is BIG, so put it last */
188 unsigned /*currentnc:1,*/ trashnc
:1;
192 int (*cont
)(struct imap_store
*ctx
, struct imap_cmd
*cmd
, const char *prompt
);
193 void (*done
)(struct imap_store
*ctx
, struct imap_cmd
*cmd
, int response
);
198 unsigned create
:1, trycreate
:1;
202 struct imap_cmd
*next
;
203 struct imap_cmd_cb cb
;
208 #define CAP(cap) (imap->caps & (1 << (cap)))
218 static const char *cap_list
[] = {
230 static int get_cmd_result(struct imap_store
*ctx
, struct imap_cmd
*tcmd
);
233 static const char *Flags
[] = {
242 static void ssl_socket_perror(const char *func
)
244 fprintf(stderr
, "%s: %s\n", func
, ERR_error_string(ERR_get_error(), NULL
));
248 static void socket_perror(const char *func
, struct imap_socket
*sock
, int ret
)
252 int sslerr
= SSL_get_error(sock
->ssl
, ret
);
256 case SSL_ERROR_SYSCALL
:
257 perror("SSL_connect");
260 ssl_socket_perror("SSL_connect");
269 fprintf(stderr
, "%s: unexpected EOF\n", func
);
273 static int ssl_socket_connect(struct imap_socket
*sock
, int use_tls_only
, int verify
)
276 fprintf(stderr
, "SSL requested but SSL support not compiled in\n");
279 #if (OPENSSL_VERSION_NUMBER >= 0x10000000L)
280 const SSL_METHOD
*meth
;
288 SSL_load_error_strings();
291 meth
= TLSv1_method();
293 meth
= SSLv23_method();
296 ssl_socket_perror("SSLv23_method");
300 ctx
= SSL_CTX_new(meth
);
303 SSL_CTX_set_verify(ctx
, SSL_VERIFY_PEER
, NULL
);
305 if (!SSL_CTX_set_default_verify_paths(ctx
)) {
306 ssl_socket_perror("SSL_CTX_set_default_verify_paths");
309 sock
->ssl
= SSL_new(ctx
);
311 ssl_socket_perror("SSL_new");
314 if (!SSL_set_fd(sock
->ssl
, sock
->fd
)) {
315 ssl_socket_perror("SSL_set_fd");
319 ret
= SSL_connect(sock
->ssl
);
321 socket_perror("SSL_connect", sock
, ret
);
329 static int socket_read(struct imap_socket
*sock
, char *buf
, int len
)
334 n
= SSL_read(sock
->ssl
, buf
, len
);
337 n
= xread(sock
->fd
, buf
, len
);
339 socket_perror("read", sock
, n
);
346 static int socket_write(struct imap_socket
*sock
, const char *buf
, int len
)
351 n
= SSL_write(sock
->ssl
, buf
, len
);
354 n
= write_in_full(sock
->fd
, buf
, len
);
356 socket_perror("write", sock
, n
);
363 static void socket_shutdown(struct imap_socket
*sock
)
367 SSL_shutdown(sock
->ssl
);
374 /* simple line buffering */
375 static int buffer_gets(struct imap_buffer
*b
, char **s
)
378 int start
= b
->offset
;
383 /* make sure we have enough data to read the \r\n sequence */
384 if (b
->offset
+ 1 >= b
->bytes
) {
386 /* shift down used bytes */
389 assert(start
<= b
->bytes
);
390 n
= b
->bytes
- start
;
393 memmove(b
->buf
, b
->buf
+ start
, n
);
399 n
= socket_read(&b
->sock
, b
->buf
+ b
->bytes
,
400 sizeof(b
->buf
) - b
->bytes
);
408 if (b
->buf
[b
->offset
] == '\r') {
409 assert(b
->offset
+ 1 < b
->bytes
);
410 if (b
->buf
[b
->offset
+ 1] == '\n') {
411 b
->buf
[b
->offset
] = 0; /* terminate the string */
412 b
->offset
+= 2; /* next line */
424 static void imap_info(const char *msg
, ...)
436 static void imap_warn(const char *msg
, ...)
442 vfprintf(stderr
, msg
, va
);
447 static char *next_arg(char **s
)
453 while (isspace((unsigned char) **s
))
462 *s
= strchr(*s
, '"');
465 while (**s
&& !isspace((unsigned char) **s
))
477 static void free_generic_messages(struct message
*msgs
)
479 struct message
*tmsg
;
481 for (; msgs
; msgs
= tmsg
) {
487 static int nfsnprintf(char *buf
, int blen
, const char *fmt
, ...)
493 if (blen
<= 0 || (unsigned)(ret
= vsnprintf(buf
, blen
, fmt
, va
)) >= (unsigned)blen
)
494 die("Fatal: buffer too small. Please report a bug.");
500 unsigned char i
, j
, s
[256];
503 static void arc4_init(void)
506 unsigned char j
, si
, dat
[128];
508 if ((fd
= open("/dev/urandom", O_RDONLY
)) < 0 && (fd
= open("/dev/random", O_RDONLY
)) < 0) {
509 fprintf(stderr
, "Fatal: no random number source available.\n");
512 if (read_in_full(fd
, dat
, 128) != 128) {
513 fprintf(stderr
, "Fatal: cannot read random number source.\n");
518 for (i
= 0; i
< 256; i
++)
520 for (i
= j
= 0; i
< 256; i
++) {
522 j
+= si
+ dat
[i
& 127];
528 for (i
= 0; i
< 256; i
++)
532 static unsigned char arc4_getbyte(void)
534 unsigned char si
, sj
;
542 return rs
.s
[(si
+ sj
) & 0xff];
545 static struct imap_cmd
*v_issue_imap_cmd(struct imap_store
*ctx
,
546 struct imap_cmd_cb
*cb
,
547 const char *fmt
, va_list ap
)
549 struct imap
*imap
= ctx
->imap
;
550 struct imap_cmd
*cmd
;
554 cmd
= xmalloc(sizeof(struct imap_cmd
));
555 nfvasprintf(&cmd
->cmd
, fmt
, ap
);
556 cmd
->tag
= ++imap
->nexttag
;
561 memset(&cmd
->cb
, 0, sizeof(cmd
->cb
));
563 while (imap
->literal_pending
)
564 get_cmd_result(ctx
, NULL
);
566 bufl
= nfsnprintf(buf
, sizeof(buf
), cmd
->cb
.data
? CAP(LITERALPLUS
) ?
567 "%d %s{%d+}\r\n" : "%d %s{%d}\r\n" : "%d %s\r\n",
568 cmd
->tag
, cmd
->cmd
, cmd
->cb
.dlen
);
570 if (imap
->num_in_progress
)
571 printf("(%d in progress) ", imap
->num_in_progress
);
572 if (memcmp(cmd
->cmd
, "LOGIN", 5))
573 printf(">>> %s", buf
);
575 printf(">>> %d LOGIN <user> <pass>\n", cmd
->tag
);
577 if (socket_write(&imap
->buf
.sock
, buf
, bufl
) != bufl
) {
585 if (CAP(LITERALPLUS
)) {
586 n
= socket_write(&imap
->buf
.sock
, cmd
->cb
.data
, cmd
->cb
.dlen
);
588 if (n
!= cmd
->cb
.dlen
||
589 socket_write(&imap
->buf
.sock
, "\r\n", 2) != 2) {
596 imap
->literal_pending
= 1;
597 } else if (cmd
->cb
.cont
)
598 imap
->literal_pending
= 1;
600 *imap
->in_progress_append
= cmd
;
601 imap
->in_progress_append
= &cmd
->next
;
602 imap
->num_in_progress
++;
606 __attribute__((format (printf
, 3, 4)))
607 static struct imap_cmd
*issue_imap_cmd(struct imap_store
*ctx
,
608 struct imap_cmd_cb
*cb
,
609 const char *fmt
, ...)
611 struct imap_cmd
*ret
;
615 ret
= v_issue_imap_cmd(ctx
, cb
, fmt
, ap
);
620 __attribute__((format (printf
, 3, 4)))
621 static int imap_exec(struct imap_store
*ctx
, struct imap_cmd_cb
*cb
,
622 const char *fmt
, ...)
625 struct imap_cmd
*cmdp
;
628 cmdp
= v_issue_imap_cmd(ctx
, cb
, fmt
, ap
);
633 return get_cmd_result(ctx
, cmdp
);
636 __attribute__((format (printf
, 3, 4)))
637 static int imap_exec_m(struct imap_store
*ctx
, struct imap_cmd_cb
*cb
,
638 const char *fmt
, ...)
641 struct imap_cmd
*cmdp
;
644 cmdp
= v_issue_imap_cmd(ctx
, cb
, fmt
, ap
);
647 return DRV_STORE_BAD
;
649 switch (get_cmd_result(ctx
, cmdp
)) {
650 case RESP_BAD
: return DRV_STORE_BAD
;
651 case RESP_NO
: return DRV_MSG_BAD
;
652 default: return DRV_OK
;
656 static int is_atom(struct imap_list
*list
)
658 return list
&& list
->val
&& list
->val
!= NIL
&& list
->val
!= LIST
;
661 static int is_list(struct imap_list
*list
)
663 return list
&& list
->val
== LIST
;
666 static void free_list(struct imap_list
*list
)
668 struct imap_list
*tmp
;
670 for (; list
; list
= tmp
) {
673 free_list(list
->child
);
674 else if (is_atom(list
))
680 static int parse_imap_list_l(struct imap
*imap
, char **sp
, struct imap_list
**curp
, int level
)
682 struct imap_list
*cur
;
687 while (isspace((unsigned char)*s
))
689 if (level
&& *s
== ')') {
693 *curp
= cur
= xmalloc(sizeof(*cur
));
695 cur
->val
= NULL
; /* for clean bail */
700 if (parse_imap_list_l(imap
, &s
, &cur
->child
, level
+ 1))
702 } else if (imap
&& *s
== '{') {
704 bytes
= cur
->len
= strtol(s
+ 1, &s
, 10);
708 s
= cur
->val
= xmalloc(cur
->len
);
710 /* dump whats left over in the input buffer */
711 n
= imap
->buf
.bytes
- imap
->buf
.offset
;
714 /* the entire message fit in the buffer */
717 memcpy(s
, imap
->buf
.buf
+ imap
->buf
.offset
, n
);
721 /* mark that we used part of the buffer */
722 imap
->buf
.offset
+= n
;
724 /* now read the rest of the message */
726 if ((n
= socket_read(&imap
->buf
.sock
, s
, bytes
)) <= 0)
732 if (buffer_gets(&imap
->buf
, &s
))
734 } else if (*s
== '"') {
738 for (; *s
!= '"'; s
++)
743 cur
->val
= xmemdupz(p
, cur
->len
);
747 for (; *s
&& !isspace((unsigned char)*s
); s
++)
748 if (level
&& *s
== ')')
751 if (cur
->len
== 3 && !memcmp("NIL", p
, 3))
754 cur
->val
= xmemdupz(p
, cur
->len
);
771 static struct imap_list
*parse_imap_list(struct imap
*imap
, char **sp
)
773 struct imap_list
*head
;
775 if (!parse_imap_list_l(imap
, sp
, &head
, 0))
781 static struct imap_list
*parse_list(char **sp
)
783 return parse_imap_list(NULL
, sp
);
786 static void parse_capability(struct imap
*imap
, char *cmd
)
791 imap
->caps
= 0x80000000;
792 while ((arg
= next_arg(&cmd
)))
793 for (i
= 0; i
< ARRAY_SIZE(cap_list
); i
++)
794 if (!strcmp(cap_list
[i
], arg
))
795 imap
->caps
|= 1 << i
;
796 imap
->rcaps
= imap
->caps
;
799 static int parse_response_code(struct imap_store
*ctx
, struct imap_cmd_cb
*cb
,
802 struct imap
*imap
= ctx
->imap
;
806 return RESP_OK
; /* no response code */
808 if (!(p
= strchr(s
, ']'))) {
809 fprintf(stderr
, "IMAP error: malformed response code\n");
814 if (!strcmp("UIDVALIDITY", arg
)) {
815 if (!(arg
= next_arg(&s
)) || !(ctx
->gen
.uidvalidity
= atoi(arg
))) {
816 fprintf(stderr
, "IMAP error: malformed UIDVALIDITY status\n");
819 } else if (!strcmp("UIDNEXT", arg
)) {
820 if (!(arg
= next_arg(&s
)) || !(imap
->uidnext
= atoi(arg
))) {
821 fprintf(stderr
, "IMAP error: malformed NEXTUID status\n");
824 } else if (!strcmp("CAPABILITY", arg
)) {
825 parse_capability(imap
, s
);
826 } else if (!strcmp("ALERT", arg
)) {
827 /* RFC2060 says that these messages MUST be displayed
830 for (; isspace((unsigned char)*p
); p
++);
831 fprintf(stderr
, "*** IMAP ALERT *** %s\n", p
);
832 } else if (cb
&& cb
->ctx
&& !strcmp("APPENDUID", arg
)) {
833 if (!(arg
= next_arg(&s
)) || !(ctx
->gen
.uidvalidity
= atoi(arg
)) ||
834 !(arg
= next_arg(&s
)) || !(*(int *)cb
->ctx
= atoi(arg
))) {
835 fprintf(stderr
, "IMAP error: malformed APPENDUID status\n");
842 static int get_cmd_result(struct imap_store
*ctx
, struct imap_cmd
*tcmd
)
844 struct imap
*imap
= ctx
->imap
;
845 struct imap_cmd
*cmdp
, **pcmdp
, *ncmdp
;
846 char *cmd
, *arg
, *arg1
, *p
;
847 int n
, resp
, resp2
, tag
;
850 if (buffer_gets(&imap
->buf
, &cmd
))
853 arg
= next_arg(&cmd
);
855 arg
= next_arg(&cmd
);
857 fprintf(stderr
, "IMAP error: unable to parse untagged response\n");
861 if (!strcmp("NAMESPACE", arg
)) {
862 imap
->ns_personal
= parse_list(&cmd
);
863 imap
->ns_other
= parse_list(&cmd
);
864 imap
->ns_shared
= parse_list(&cmd
);
865 } else if (!strcmp("OK", arg
) || !strcmp("BAD", arg
) ||
866 !strcmp("NO", arg
) || !strcmp("BYE", arg
)) {
867 if ((resp
= parse_response_code(ctx
, NULL
, cmd
)) != RESP_OK
)
869 } else if (!strcmp("CAPABILITY", arg
))
870 parse_capability(imap
, cmd
);
871 else if ((arg1
= next_arg(&cmd
))) {
872 if (!strcmp("EXISTS", arg1
))
873 ctx
->gen
.count
= atoi(arg
);
874 else if (!strcmp("RECENT", arg1
))
875 ctx
->gen
.recent
= atoi(arg
);
877 fprintf(stderr
, "IMAP error: unable to parse untagged response\n");
880 } else if (!imap
->in_progress
) {
881 fprintf(stderr
, "IMAP error: unexpected reply: %s %s\n", arg
, cmd
? cmd
: "");
883 } else if (*arg
== '+') {
884 /* This can happen only with the last command underway, as
885 it enforces a round-trip. */
886 cmdp
= (struct imap_cmd
*)((char *)imap
->in_progress_append
-
887 offsetof(struct imap_cmd
, next
));
889 n
= socket_write(&imap
->buf
.sock
, cmdp
->cb
.data
, cmdp
->cb
.dlen
);
891 cmdp
->cb
.data
= NULL
;
892 if (n
!= (int)cmdp
->cb
.dlen
)
894 } else if (cmdp
->cb
.cont
) {
895 if (cmdp
->cb
.cont(ctx
, cmdp
, cmd
))
898 fprintf(stderr
, "IMAP error: unexpected command continuation request\n");
901 if (socket_write(&imap
->buf
.sock
, "\r\n", 2) != 2)
904 imap
->literal_pending
= 0;
909 for (pcmdp
= &imap
->in_progress
; (cmdp
= *pcmdp
); pcmdp
= &cmdp
->next
)
910 if (cmdp
->tag
== tag
)
912 fprintf(stderr
, "IMAP error: unexpected tag %s\n", arg
);
915 if (!(*pcmdp
= cmdp
->next
))
916 imap
->in_progress_append
= pcmdp
;
917 imap
->num_in_progress
--;
918 if (cmdp
->cb
.cont
|| cmdp
->cb
.data
)
919 imap
->literal_pending
= 0;
920 arg
= next_arg(&cmd
);
921 if (!strcmp("OK", arg
))
924 if (!strcmp("NO", arg
)) {
925 if (cmdp
->cb
.create
&& cmd
&& (cmdp
->cb
.trycreate
|| !memcmp(cmd
, "[TRYCREATE]", 11))) { /* SELECT, APPEND or UID COPY */
926 p
= strchr(cmdp
->cmd
, '"');
927 if (!issue_imap_cmd(ctx
, NULL
, "CREATE \"%.*s\"", (int)(strchr(p
+ 1, '"') - p
+ 1), p
)) {
931 /* not waiting here violates the spec, but a server that does not
932 grok this nonetheless violates it too. */
934 if (!(ncmdp
= issue_imap_cmd(ctx
, &cmdp
->cb
, "%s", cmdp
->cmd
))) {
941 return 0; /* ignored */
947 } else /*if (!strcmp("BAD", arg))*/
949 fprintf(stderr
, "IMAP command '%s' returned response (%s) - %s\n",
950 memcmp(cmdp
->cmd
, "LOGIN", 5) ?
951 cmdp
->cmd
: "LOGIN <user> <pass>",
952 arg
, cmd
? cmd
: "");
954 if ((resp2
= parse_response_code(ctx
, &cmdp
->cb
, cmd
)) > resp
)
958 cmdp
->cb
.done(ctx
, cmdp
, resp
);
962 if (!tcmd
|| tcmd
== cmdp
)
969 static void imap_close_server(struct imap_store
*ictx
)
971 struct imap
*imap
= ictx
->imap
;
973 if (imap
->buf
.sock
.fd
!= -1) {
974 imap_exec(ictx
, NULL
, "LOGOUT");
975 socket_shutdown(&imap
->buf
.sock
);
977 free_list(imap
->ns_personal
);
978 free_list(imap
->ns_other
);
979 free_list(imap
->ns_shared
);
983 static void imap_close_store(struct store
*ctx
)
985 imap_close_server((struct imap_store
*)ctx
);
986 free_generic_messages(ctx
->msgs
);
990 static struct store
*imap_open_store(struct imap_server_conf
*srvc
)
992 struct imap_store
*ctx
;
995 int s
= -1, a
[2], preauth
;
998 ctx
= xcalloc(sizeof(*ctx
), 1);
1000 ctx
->imap
= imap
= xcalloc(sizeof(*imap
), 1);
1001 imap
->buf
.sock
.fd
= -1;
1002 imap
->in_progress_append
= &imap
->in_progress
;
1004 /* open connection to IMAP server */
1007 imap_info("Starting tunnel '%s'... ", srvc
->tunnel
);
1009 if (socketpair(PF_UNIX
, SOCK_STREAM
, 0, a
)) {
1010 perror("socketpair");
1018 if (dup2(a
[0], 0) == -1 || dup2(a
[0], 1) == -1)
1022 execl("/bin/sh", "sh", "-c", srvc
->tunnel
, NULL
);
1028 imap
->buf
.sock
.fd
= a
[1];
1033 struct addrinfo hints
, *ai0
, *ai
;
1037 snprintf(portstr
, sizeof(portstr
), "%hu", srvc
->port
);
1039 memset(&hints
, 0, sizeof(hints
));
1040 hints
.ai_socktype
= SOCK_STREAM
;
1041 hints
.ai_protocol
= IPPROTO_TCP
;
1043 imap_info("Resolving %s... ", srvc
->host
);
1044 gai
= getaddrinfo(srvc
->host
, portstr
, &hints
, &ai
);
1046 fprintf(stderr
, "getaddrinfo: %s\n", gai_strerror(gai
));
1051 for (ai0
= ai
; ai
; ai
= ai
->ai_next
) {
1052 char addr
[NI_MAXHOST
];
1054 s
= socket(ai
->ai_family
, ai
->ai_socktype
,
1059 getnameinfo(ai
->ai_addr
, ai
->ai_addrlen
, addr
,
1060 sizeof(addr
), NULL
, 0, NI_NUMERICHOST
);
1061 imap_info("Connecting to [%s]:%s... ", addr
, portstr
);
1063 if (connect(s
, ai
->ai_addr
, ai
->ai_addrlen
) < 0) {
1075 struct sockaddr_in addr
;
1077 memset(&addr
, 0, sizeof(addr
));
1078 addr
.sin_port
= htons(srvc
->port
);
1079 addr
.sin_family
= AF_INET
;
1081 imap_info("Resolving %s... ", srvc
->host
);
1082 he
= gethostbyname(srvc
->host
);
1084 perror("gethostbyname");
1089 addr
.sin_addr
.s_addr
= *((int *) he
->h_addr_list
[0]);
1091 s
= socket(PF_INET
, SOCK_STREAM
, 0);
1093 imap_info("Connecting to %s:%hu... ", inet_ntoa(addr
.sin_addr
), ntohs(addr
.sin_port
));
1094 if (connect(s
, (struct sockaddr
*)&addr
, sizeof(addr
))) {
1101 fputs("Error: unable to connect to server.\n", stderr
);
1105 imap
->buf
.sock
.fd
= s
;
1107 if (srvc
->use_ssl
&&
1108 ssl_socket_connect(&imap
->buf
.sock
, 0, srvc
->ssl_verify
)) {
1115 /* read the greeting string */
1116 if (buffer_gets(&imap
->buf
, &rsp
)) {
1117 fprintf(stderr
, "IMAP error: no greeting response\n");
1120 arg
= next_arg(&rsp
);
1121 if (!arg
|| *arg
!= '*' || (arg
= next_arg(&rsp
)) == NULL
) {
1122 fprintf(stderr
, "IMAP error: invalid greeting response\n");
1126 if (!strcmp("PREAUTH", arg
))
1128 else if (strcmp("OK", arg
) != 0) {
1129 fprintf(stderr
, "IMAP error: unknown greeting response\n");
1132 parse_response_code(ctx
, NULL
, rsp
);
1133 if (!imap
->caps
&& imap_exec(ctx
, NULL
, "CAPABILITY") != RESP_OK
)
1138 if (!srvc
->use_ssl
&& CAP(STARTTLS
)) {
1139 if (imap_exec(ctx
, 0, "STARTTLS") != RESP_OK
)
1141 if (ssl_socket_connect(&imap
->buf
.sock
, 1,
1144 /* capabilities may have changed, so get the new capabilities */
1145 if (imap_exec(ctx
, 0, "CAPABILITY") != RESP_OK
)
1149 imap_info("Logging in...\n");
1151 fprintf(stderr
, "Skipping server %s, no user\n", srvc
->host
);
1156 sprintf(prompt
, "Password (%s@%s): ", srvc
->user
, srvc
->host
);
1157 arg
= getpass(prompt
);
1163 fprintf(stderr
, "Skipping account %s@%s, no password\n", srvc
->user
, srvc
->host
);
1167 * getpass() returns a pointer to a static buffer. make a copy
1168 * for long term storage.
1170 srvc
->pass
= xstrdup(arg
);
1173 fprintf(stderr
, "Skipping account %s@%s, server forbids LOGIN\n", srvc
->user
, srvc
->host
);
1176 if (!imap
->buf
.sock
.ssl
)
1177 imap_warn("*** IMAP Warning *** Password is being "
1178 "sent in the clear\n");
1179 if (imap_exec(ctx
, NULL
, "LOGIN \"%s\" \"%s\"", srvc
->user
, srvc
->pass
) != RESP_OK
) {
1180 fprintf(stderr
, "IMAP error: LOGIN failed\n");
1187 return (struct store
*)ctx
;
1190 imap_close_store(&ctx
->gen
);
1194 static int imap_make_flags(int flags
, char *buf
)
1199 for (i
= d
= 0; i
< ARRAY_SIZE(Flags
); i
++)
1200 if (flags
& (1 << i
)) {
1203 for (s
= Flags
[i
]; *s
; s
++)
1213 static int imap_store_msg(struct store
*gctx
, struct msg_data
*data
, int *uid
)
1215 struct imap_store
*ctx
= (struct imap_store
*)gctx
;
1216 struct imap
*imap
= ctx
->imap
;
1217 struct imap_cmd_cb cb
;
1219 const char *prefix
, *box
;
1220 int ret
, i
, j
, d
, len
, extra
, nocr
;
1221 int start
, sbreak
= 0, ebreak
= 0;
1222 char flagstr
[128], tuid
[TUIDL
* 2 + 1];
1224 memset(&cb
, 0, sizeof(cb
));
1230 if (!CAP(UIDPLUS
) && uid
) {
1234 if (fmap
[i
++] == '\n') {
1236 if (i
- 2 + nocr
== start
) {
1237 sbreak
= ebreak
= i
- 2 + nocr
;
1240 if (!memcmp(fmap
+ start
, "X-TUID: ", 8)) {
1241 extra
-= (ebreak
= i
) - (sbreak
= start
) + nocr
;
1246 /* invalid message */
1250 for (j
= 0; j
< TUIDL
; j
++)
1251 sprintf(tuid
+ j
* 2, "%02x", arc4_getbyte());
1252 extra
+= 8 + TUIDL
* 2 + 2;
1255 for (; i
< len
; i
++)
1256 if (fmap
[i
] == '\n')
1259 cb
.dlen
= len
+ extra
;
1260 buf
= cb
.data
= xmalloc(cb
.dlen
);
1262 if (!CAP(UIDPLUS
) && uid
) {
1264 for (; i
< sbreak
; i
++)
1265 if (fmap
[i
] == '\n') {
1271 memcpy(buf
, fmap
, sbreak
);
1274 memcpy(buf
, "X-TUID: ", 8);
1276 memcpy(buf
, tuid
, TUIDL
* 2);
1283 for (; i
< len
; i
++)
1284 if (fmap
[i
] == '\n') {
1290 memcpy(buf
, fmap
+ i
, len
- i
);
1296 d
= imap_make_flags(data
->flags
, flagstr
);
1302 box
= gctx
->conf
->trash
;
1303 prefix
= ctx
->prefix
;
1306 imap
->caps
= imap
->rcaps
& ~(1 << LITERALPLUS
);
1309 prefix
= !strcmp(box
, "INBOX") ? "" : ctx
->prefix
;
1313 ret
= imap_exec_m(ctx
, &cb
, "APPEND \"%s%s\" %s", prefix
, box
, flagstr
);
1314 imap
->caps
= imap
->rcaps
;
1325 static void encode_html_chars(struct strbuf
*p
)
1328 for (i
= 0; i
< p
->len
; i
++) {
1329 if (p
->buf
[i
] == '&')
1330 strbuf_splice(p
, i
, 1, "&", 5);
1331 if (p
->buf
[i
] == '<')
1332 strbuf_splice(p
, i
, 1, "<", 4);
1333 if (p
->buf
[i
] == '>')
1334 strbuf_splice(p
, i
, 1, ">", 4);
1335 if (p
->buf
[i
] == '"')
1336 strbuf_splice(p
, i
, 1, """, 6);
1339 static void wrap_in_html(struct msg_data
*msg
)
1341 struct strbuf buf
= STRBUF_INIT
;
1342 struct strbuf
**lines
;
1344 static char *content_type
= "Content-Type: text/html;\n";
1345 static char *pre_open
= "<pre>\n";
1346 static char *pre_close
= "</pre>\n";
1347 int added_header
= 0;
1349 strbuf_attach(&buf
, msg
->data
, msg
->len
, msg
->len
);
1350 lines
= strbuf_split(&buf
, '\n');
1351 strbuf_release(&buf
);
1352 for (p
= lines
; *p
; p
++) {
1353 if (! added_header
) {
1354 if ((*p
)->len
== 1 && *((*p
)->buf
) == '\n') {
1355 strbuf_addstr(&buf
, content_type
);
1356 strbuf_addbuf(&buf
, *p
);
1357 strbuf_addstr(&buf
, pre_open
);
1363 encode_html_chars(*p
);
1364 strbuf_addbuf(&buf
, *p
);
1366 strbuf_addstr(&buf
, pre_close
);
1367 strbuf_list_free(lines
);
1369 msg
->data
= strbuf_detach(&buf
, NULL
);
1372 #define CHUNKSIZE 0x1000
1374 static int read_message(FILE *f
, struct msg_data
*msg
)
1376 struct strbuf buf
= STRBUF_INIT
;
1378 memset(msg
, 0, sizeof(*msg
));
1381 if (strbuf_fread(&buf
, CHUNKSIZE
, f
) <= 0)
1386 msg
->data
= strbuf_detach(&buf
, NULL
);
1390 static int count_messages(struct msg_data
*msg
)
1393 char *p
= msg
->data
;
1396 if (!prefixcmp(p
, "From ")) {
1400 p
= strstr(p
+5, "\nFrom ");
1408 static int split_msg(struct msg_data
*all_msgs
, struct msg_data
*msg
, int *ofs
)
1412 memset(msg
, 0, sizeof *msg
);
1413 if (*ofs
>= all_msgs
->len
)
1416 data
= &all_msgs
->data
[*ofs
];
1417 msg
->len
= all_msgs
->len
- *ofs
;
1419 if (msg
->len
< 5 || prefixcmp(data
, "From "))
1422 p
= strchr(data
, '\n');
1430 p
= strstr(data
, "\nFrom ");
1432 msg
->len
= &p
[1] - data
;
1434 msg
->data
= xmemdupz(data
, msg
->len
);
1439 static struct imap_server_conf server
= {
1451 static char *imap_folder
;
1453 static int git_imap_config(const char *key
, const char *val
, void *cb
)
1455 char imap_key
[] = "imap.";
1457 if (strncmp(key
, imap_key
, sizeof imap_key
- 1))
1461 return config_error_nonbool(key
);
1463 key
+= sizeof imap_key
- 1;
1465 if (!strcmp("folder", key
)) {
1466 imap_folder
= xstrdup(val
);
1467 } else if (!strcmp("host", key
)) {
1468 if (!prefixcmp(val
, "imap:"))
1470 else if (!prefixcmp(val
, "imaps:")) {
1474 if (!prefixcmp(val
, "//"))
1476 server
.host
= xstrdup(val
);
1477 } else if (!strcmp("user", key
))
1478 server
.user
= xstrdup(val
);
1479 else if (!strcmp("pass", key
))
1480 server
.pass
= xstrdup(val
);
1481 else if (!strcmp("port", key
))
1482 server
.port
= git_config_int(key
, val
);
1483 else if (!strcmp("tunnel", key
))
1484 server
.tunnel
= xstrdup(val
);
1485 else if (!strcmp("sslverify", key
))
1486 server
.ssl_verify
= git_config_bool(key
, val
);
1487 else if (!strcmp("preformattedHTML", key
))
1488 server
.use_html
= git_config_bool(key
, val
);
1492 int main(int argc
, char **argv
)
1494 struct msg_data all_msgs
, msg
;
1495 struct store
*ctx
= NULL
;
1502 git_extract_argv0_path(argv
[0]);
1504 /* init the random number generator */
1507 setup_git_directory_gently(&nongit_ok
);
1508 git_config(git_imap_config
, NULL
);
1511 server
.port
= server
.use_ssl
? 993 : 143;
1514 fprintf(stderr
, "no imap store specified\n");
1518 if (!server
.tunnel
) {
1519 fprintf(stderr
, "no imap host specified\n");
1522 server
.host
= "tunnel";
1525 /* read the messages */
1526 if (!read_message(stdin
, &all_msgs
)) {
1527 fprintf(stderr
, "nothing to send\n");
1531 total
= count_messages(&all_msgs
);
1533 fprintf(stderr
, "no messages to send\n");
1537 /* write it to the imap server */
1538 ctx
= imap_open_store(&server
);
1540 fprintf(stderr
, "failed to open store\n");
1544 fprintf(stderr
, "sending %d message%s\n", total
, (total
!= 1) ? "s" : "");
1545 ctx
->name
= imap_folder
;
1547 unsigned percent
= n
* 100 / total
;
1548 fprintf(stderr
, "%4u%% (%d/%d) done\r", percent
, n
, total
);
1549 if (!split_msg(&all_msgs
, &msg
, &ofs
))
1551 if (server
.use_html
)
1553 r
= imap_store_msg(ctx
, &msg
, &uid
);
1558 fprintf(stderr
, "\n");
1560 imap_close_store(ctx
);