]>
git.ipfire.org Git - thirdparty/git.git/blob - imap-send.c
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, see <http://www.gnu.org/licenses/>.
24 #include "git-compat-util.h"
26 #include "credential.h"
29 #include "run-command.h"
30 #include "parse-options.h"
32 #if defined(NO_OPENSSL) && !defined(HAVE_OPENSSL_CSPRNG)
35 #ifdef USE_CURL_FOR_IMAP_SEND
39 #if defined(USE_CURL_FOR_IMAP_SEND)
40 /* Always default to curl if it's available. */
41 #define USE_CURL_DEFAULT 1
43 /* We don't have curl, so continue to use the historical implementation */
44 #define USE_CURL_DEFAULT 0
48 static int use_curl
= USE_CURL_DEFAULT
;
50 static const char * const imap_send_usage
[] = { "git imap-send [-v] [-q] [--[no-]curl] < <mbox>", NULL
};
52 static struct option imap_send_options
[] = {
53 OPT__VERBOSITY(&verbosity
),
54 OPT_BOOL(0, "curl", &use_curl
, "use libcurl to communicate with the IMAP server"),
60 #define DRV_MSG_BAD -1
61 #define DRV_BOX_BAD -2
62 #define DRV_STORE_BAD -3
64 __attribute__((format (printf
, 1, 2)))
65 static void imap_info(const char *, ...);
66 __attribute__((format (printf
, 1, 2)))
67 static void imap_warn(const char *, ...);
69 static char *next_arg(char **);
71 __attribute__((format (printf
, 3, 4)))
72 static int nfsnprintf(char *buf
, int blen
, const char *fmt
, ...);
74 static int nfvasprintf(char **strp
, const char *fmt
, va_list ap
)
79 len
= vsnprintf(tmp
, sizeof(tmp
), fmt
, ap
);
81 die("Fatal: Out of memory");
82 if (len
>= sizeof(tmp
))
83 die("imap command overflow!");
84 *strp
= xmemdupz(tmp
, len
);
88 struct imap_server_conf
{
99 const char *auth_method
;
102 static struct imap_server_conf server
= {
112 struct imap_socket sock
;
121 int uidnext
; /* from SELECT responses */
122 unsigned caps
, rcaps
; /* CAPABILITY results */
124 int nexttag
, num_in_progress
, literal_pending
;
125 struct imap_cmd
*in_progress
, **in_progress_append
;
126 struct imap_buffer buf
; /* this is BIG, so put it last */
130 /* currently open mailbox */
131 const char *name
; /* foreign! maybe preset? */
138 int (*cont
)(struct imap_store
*ctx
, struct imap_cmd
*cmd
, const char *prompt
);
139 void (*done
)(struct imap_store
*ctx
, struct imap_cmd
*cmd
, int response
);
147 struct imap_cmd
*next
;
148 struct imap_cmd_cb cb
;
153 #define CAP(cap) (imap->caps & (1 << (cap)))
164 static const char *cap_list
[] = {
177 static int get_cmd_result(struct imap_store
*ctx
, struct imap_cmd
*tcmd
);
181 static void ssl_socket_perror(const char *func
)
183 fprintf(stderr
, "%s: %s\n", func
, ERR_error_string(ERR_get_error(), NULL
));
187 static void socket_perror(const char *func
, struct imap_socket
*sock
, int ret
)
191 int sslerr
= SSL_get_error(sock
->ssl
, ret
);
195 case SSL_ERROR_SYSCALL
:
196 perror("SSL_connect");
199 ssl_socket_perror("SSL_connect");
208 fprintf(stderr
, "%s: unexpected EOF\n", func
);
213 static int ssl_socket_connect(struct imap_socket
*sock
, int use_tls_only
, int verify
)
215 fprintf(stderr
, "SSL requested but SSL support not compiled in\n");
221 static int host_matches(const char *host
, const char *pattern
)
223 if (pattern
[0] == '*' && pattern
[1] == '.') {
225 if (!(host
= strchr(host
, '.')))
230 return *host
&& *pattern
&& !strcasecmp(host
, pattern
);
233 static int verify_hostname(X509
*cert
, const char *hostname
)
239 STACK_OF(GENERAL_NAME
) *subj_alt_names
;
241 /* try the DNS subjectAltNames */
243 if ((subj_alt_names
= X509_get_ext_d2i(cert
, NID_subject_alt_name
, NULL
, NULL
))) {
244 int num_subj_alt_names
= sk_GENERAL_NAME_num(subj_alt_names
);
245 for (i
= 0; !found
&& i
< num_subj_alt_names
; i
++) {
246 GENERAL_NAME
*subj_alt_name
= sk_GENERAL_NAME_value(subj_alt_names
, i
);
247 if (subj_alt_name
->type
== GEN_DNS
&&
248 strlen((const char *)subj_alt_name
->d
.ia5
->data
) == (size_t)subj_alt_name
->d
.ia5
->length
&&
249 host_matches(hostname
, (const char *)(subj_alt_name
->d
.ia5
->data
)))
252 sk_GENERAL_NAME_pop_free(subj_alt_names
, GENERAL_NAME_free
);
257 /* try the common name */
258 if (!(subj
= X509_get_subject_name(cert
)))
259 return error("cannot get certificate subject");
260 if ((len
= X509_NAME_get_text_by_NID(subj
, NID_commonName
, cname
, sizeof(cname
))) < 0)
261 return error("cannot get certificate common name");
262 if (strlen(cname
) == (size_t)len
&& host_matches(hostname
, cname
))
264 return error("certificate owner '%s' does not match hostname '%s'",
268 static int ssl_socket_connect(struct imap_socket
*sock
, int use_tls_only
, int verify
)
270 #if (OPENSSL_VERSION_NUMBER >= 0x10000000L)
271 const SSL_METHOD
*meth
;
280 SSL_load_error_strings();
282 meth
= SSLv23_method();
284 ssl_socket_perror("SSLv23_method");
288 ctx
= SSL_CTX_new(meth
);
290 ssl_socket_perror("SSL_CTX_new");
295 SSL_CTX_set_options(ctx
, SSL_OP_NO_SSLv2
| SSL_OP_NO_SSLv3
);
298 SSL_CTX_set_verify(ctx
, SSL_VERIFY_PEER
, NULL
);
300 if (!SSL_CTX_set_default_verify_paths(ctx
)) {
301 ssl_socket_perror("SSL_CTX_set_default_verify_paths");
304 sock
->ssl
= SSL_new(ctx
);
306 ssl_socket_perror("SSL_new");
309 if (!SSL_set_rfd(sock
->ssl
, sock
->fd
[0])) {
310 ssl_socket_perror("SSL_set_rfd");
313 if (!SSL_set_wfd(sock
->ssl
, sock
->fd
[1])) {
314 ssl_socket_perror("SSL_set_wfd");
318 #ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
321 * OpenSSL does not document this function, but the implementation
322 * returns 1 on success, 0 on failure after calling SSLerr().
324 ret
= SSL_set_tlsext_host_name(sock
->ssl
, server
.host
);
326 warning("SSL_set_tlsext_host_name(%s) failed.", server
.host
);
329 ret
= SSL_connect(sock
->ssl
);
331 socket_perror("SSL_connect", sock
, ret
);
336 /* make sure the hostname matches that of the certificate */
337 cert
= SSL_get_peer_certificate(sock
->ssl
);
339 return error("unable to get peer certificate.");
340 if (verify_hostname(cert
, server
.host
) < 0)
348 static int socket_read(struct imap_socket
*sock
, char *buf
, int len
)
353 n
= SSL_read(sock
->ssl
, buf
, len
);
356 n
= xread(sock
->fd
[0], buf
, len
);
358 socket_perror("read", sock
, n
);
361 sock
->fd
[0] = sock
->fd
[1] = -1;
366 static int socket_write(struct imap_socket
*sock
, const char *buf
, int len
)
371 n
= SSL_write(sock
->ssl
, buf
, len
);
374 n
= write_in_full(sock
->fd
[1], buf
, len
);
376 socket_perror("write", sock
, n
);
379 sock
->fd
[0] = sock
->fd
[1] = -1;
384 static void socket_shutdown(struct imap_socket
*sock
)
388 SSL_shutdown(sock
->ssl
);
396 /* simple line buffering */
397 static int buffer_gets(struct imap_buffer
*b
, char **s
)
400 int start
= b
->offset
;
405 /* make sure we have enough data to read the \r\n sequence */
406 if (b
->offset
+ 1 >= b
->bytes
) {
408 /* shift down used bytes */
411 assert(start
<= b
->bytes
);
412 n
= b
->bytes
- start
;
415 memmove(b
->buf
, b
->buf
+ start
, n
);
421 n
= socket_read(&b
->sock
, b
->buf
+ b
->bytes
,
422 sizeof(b
->buf
) - b
->bytes
);
430 if (b
->buf
[b
->offset
] == '\r') {
431 assert(b
->offset
+ 1 < b
->bytes
);
432 if (b
->buf
[b
->offset
+ 1] == '\n') {
433 b
->buf
[b
->offset
] = 0; /* terminate the string */
434 b
->offset
+= 2; /* next line */
446 __attribute__((format (printf
, 1, 2)))
447 static void imap_info(const char *msg
, ...)
451 if (0 <= verbosity
) {
459 __attribute__((format (printf
, 1, 2)))
460 static void imap_warn(const char *msg
, ...)
464 if (-2 < verbosity
) {
466 vfprintf(stderr
, msg
, va
);
471 static char *next_arg(char **s
)
477 while (isspace((unsigned char) **s
))
486 *s
= strchr(*s
, '"');
489 while (**s
&& !isspace((unsigned char) **s
))
501 __attribute__((format (printf
, 3, 4)))
502 static int nfsnprintf(char *buf
, int blen
, const char *fmt
, ...)
508 if (blen
<= 0 || (unsigned)(ret
= vsnprintf(buf
, blen
, fmt
, va
)) >= (unsigned)blen
)
509 BUG("buffer too small. Please report a bug.");
514 static struct imap_cmd
*issue_imap_cmd(struct imap_store
*ctx
,
515 struct imap_cmd_cb
*cb
,
516 const char *fmt
, va_list ap
)
518 struct imap
*imap
= ctx
->imap
;
519 struct imap_cmd
*cmd
;
523 cmd
= xmalloc(sizeof(struct imap_cmd
));
524 nfvasprintf(&cmd
->cmd
, fmt
, ap
);
525 cmd
->tag
= ++imap
->nexttag
;
530 memset(&cmd
->cb
, 0, sizeof(cmd
->cb
));
532 while (imap
->literal_pending
)
533 get_cmd_result(ctx
, NULL
);
536 bufl
= nfsnprintf(buf
, sizeof(buf
), "%d %s\r\n", cmd
->tag
, cmd
->cmd
);
538 bufl
= nfsnprintf(buf
, sizeof(buf
), "%d %s{%d%s}\r\n",
539 cmd
->tag
, cmd
->cmd
, cmd
->cb
.dlen
,
540 CAP(LITERALPLUS
) ? "+" : "");
543 if (imap
->num_in_progress
)
544 printf("(%d in progress) ", imap
->num_in_progress
);
545 if (!starts_with(cmd
->cmd
, "LOGIN"))
546 printf(">>> %s", buf
);
548 printf(">>> %d LOGIN <user> <pass>\n", cmd
->tag
);
550 if (socket_write(&imap
->buf
.sock
, buf
, bufl
) != bufl
) {
558 if (CAP(LITERALPLUS
)) {
559 n
= socket_write(&imap
->buf
.sock
, cmd
->cb
.data
, cmd
->cb
.dlen
);
561 if (n
!= cmd
->cb
.dlen
||
562 socket_write(&imap
->buf
.sock
, "\r\n", 2) != 2) {
569 imap
->literal_pending
= 1;
570 } else if (cmd
->cb
.cont
)
571 imap
->literal_pending
= 1;
573 *imap
->in_progress_append
= cmd
;
574 imap
->in_progress_append
= &cmd
->next
;
575 imap
->num_in_progress
++;
579 __attribute__((format (printf
, 3, 4)))
580 static int imap_exec(struct imap_store
*ctx
, struct imap_cmd_cb
*cb
,
581 const char *fmt
, ...)
584 struct imap_cmd
*cmdp
;
587 cmdp
= issue_imap_cmd(ctx
, cb
, fmt
, ap
);
592 return get_cmd_result(ctx
, cmdp
);
595 __attribute__((format (printf
, 3, 4)))
596 static int imap_exec_m(struct imap_store
*ctx
, struct imap_cmd_cb
*cb
,
597 const char *fmt
, ...)
600 struct imap_cmd
*cmdp
;
603 cmdp
= issue_imap_cmd(ctx
, cb
, fmt
, ap
);
606 return DRV_STORE_BAD
;
608 switch (get_cmd_result(ctx
, cmdp
)) {
609 case RESP_BAD
: return DRV_STORE_BAD
;
610 case RESP_NO
: return DRV_MSG_BAD
;
611 default: return DRV_OK
;
615 static int skip_imap_list_l(char **sp
, int level
)
620 while (isspace((unsigned char)*s
))
622 if (level
&& *s
== ')') {
629 if (skip_imap_list_l(&s
, level
+ 1))
631 } else if (*s
== '"') {
634 for (; *s
!= '"'; s
++)
640 for (; *s
&& !isspace((unsigned char)*s
); s
++)
641 if (level
&& *s
== ')')
657 static void skip_list(char **sp
)
659 skip_imap_list_l(sp
, 0);
662 static void parse_capability(struct imap
*imap
, char *cmd
)
667 imap
->caps
= 0x80000000;
668 while ((arg
= next_arg(&cmd
)))
669 for (i
= 0; i
< ARRAY_SIZE(cap_list
); i
++)
670 if (!strcmp(cap_list
[i
], arg
))
671 imap
->caps
|= 1 << i
;
672 imap
->rcaps
= imap
->caps
;
675 static int parse_response_code(struct imap_store
*ctx
, struct imap_cmd_cb
*cb
,
678 struct imap
*imap
= ctx
->imap
;
682 return RESP_OK
; /* no response code */
684 if (!(p
= strchr(s
, ']'))) {
685 fprintf(stderr
, "IMAP error: malformed response code\n");
691 fprintf(stderr
, "IMAP error: empty response code\n");
694 if (!strcmp("UIDVALIDITY", arg
)) {
695 if (!(arg
= next_arg(&s
)) || !(ctx
->uidvalidity
= atoi(arg
))) {
696 fprintf(stderr
, "IMAP error: malformed UIDVALIDITY status\n");
699 } else if (!strcmp("UIDNEXT", arg
)) {
700 if (!(arg
= next_arg(&s
)) || !(imap
->uidnext
= atoi(arg
))) {
701 fprintf(stderr
, "IMAP error: malformed NEXTUID status\n");
704 } else if (!strcmp("CAPABILITY", arg
)) {
705 parse_capability(imap
, s
);
706 } else if (!strcmp("ALERT", arg
)) {
707 /* RFC2060 says that these messages MUST be displayed
710 for (; isspace((unsigned char)*p
); p
++);
711 fprintf(stderr
, "*** IMAP ALERT *** %s\n", p
);
712 } else if (cb
&& cb
->ctx
&& !strcmp("APPENDUID", arg
)) {
713 if (!(arg
= next_arg(&s
)) || !(ctx
->uidvalidity
= atoi(arg
)) ||
714 !(arg
= next_arg(&s
)) || !(*(int *)cb
->ctx
= atoi(arg
))) {
715 fprintf(stderr
, "IMAP error: malformed APPENDUID status\n");
722 static int get_cmd_result(struct imap_store
*ctx
, struct imap_cmd
*tcmd
)
724 struct imap
*imap
= ctx
->imap
;
725 struct imap_cmd
*cmdp
, **pcmdp
;
727 const char *arg
, *arg1
;
728 int n
, resp
, resp2
, tag
;
731 if (buffer_gets(&imap
->buf
, &cmd
))
734 arg
= next_arg(&cmd
);
736 fprintf(stderr
, "IMAP error: empty response\n");
740 arg
= next_arg(&cmd
);
742 fprintf(stderr
, "IMAP error: unable to parse untagged response\n");
746 if (!strcmp("NAMESPACE", arg
)) {
747 /* rfc2342 NAMESPACE response. */
748 skip_list(&cmd
); /* Personal mailboxes */
749 skip_list(&cmd
); /* Others' mailboxes */
750 skip_list(&cmd
); /* Shared mailboxes */
751 } else if (!strcmp("OK", arg
) || !strcmp("BAD", arg
) ||
752 !strcmp("NO", arg
) || !strcmp("BYE", arg
)) {
753 if ((resp
= parse_response_code(ctx
, NULL
, cmd
)) != RESP_OK
)
755 } else if (!strcmp("CAPABILITY", arg
)) {
756 parse_capability(imap
, cmd
);
757 } else if ((arg1
= next_arg(&cmd
))) {
759 * Unhandled response-data with at least two words.
762 * NEEDSWORK: Previously this case handled '<num> EXISTS'
763 * and '<num> RECENT' but as a probably-unintended side
764 * effect it ignores other unrecognized two-word
765 * responses. imap-send doesn't ever try to read
766 * messages or mailboxes these days, so consider
767 * eliminating this case.
770 fprintf(stderr
, "IMAP error: unable to parse untagged response\n");
773 } else if (!imap
->in_progress
) {
774 fprintf(stderr
, "IMAP error: unexpected reply: %s %s\n", arg
, cmd
? cmd
: "");
776 } else if (*arg
== '+') {
777 /* This can happen only with the last command underway, as
778 it enforces a round-trip. */
779 cmdp
= (struct imap_cmd
*)((char *)imap
->in_progress_append
-
780 offsetof(struct imap_cmd
, next
));
782 n
= socket_write(&imap
->buf
.sock
, cmdp
->cb
.data
, cmdp
->cb
.dlen
);
783 FREE_AND_NULL(cmdp
->cb
.data
);
784 if (n
!= (int)cmdp
->cb
.dlen
)
786 } else if (cmdp
->cb
.cont
) {
787 if (cmdp
->cb
.cont(ctx
, cmdp
, cmd
))
790 fprintf(stderr
, "IMAP error: unexpected command continuation request\n");
793 if (socket_write(&imap
->buf
.sock
, "\r\n", 2) != 2)
796 imap
->literal_pending
= 0;
801 for (pcmdp
= &imap
->in_progress
; (cmdp
= *pcmdp
); pcmdp
= &cmdp
->next
)
802 if (cmdp
->tag
== tag
)
804 fprintf(stderr
, "IMAP error: unexpected tag %s\n", arg
);
807 if (!(*pcmdp
= cmdp
->next
))
808 imap
->in_progress_append
= pcmdp
;
809 imap
->num_in_progress
--;
810 if (cmdp
->cb
.cont
|| cmdp
->cb
.data
)
811 imap
->literal_pending
= 0;
812 arg
= next_arg(&cmd
);
815 if (!strcmp("OK", arg
))
818 if (!strcmp("NO", arg
))
820 else /*if (!strcmp("BAD", arg))*/
822 fprintf(stderr
, "IMAP command '%s' returned response (%s) - %s\n",
823 !starts_with(cmdp
->cmd
, "LOGIN") ?
824 cmdp
->cmd
: "LOGIN <user> <pass>",
825 arg
, cmd
? cmd
: "");
827 if ((resp2
= parse_response_code(ctx
, &cmdp
->cb
, cmd
)) > resp
)
830 cmdp
->cb
.done(ctx
, cmdp
, resp
);
834 if (!tcmd
|| tcmd
== cmdp
)
841 static void imap_close_server(struct imap_store
*ictx
)
843 struct imap
*imap
= ictx
->imap
;
845 if (imap
->buf
.sock
.fd
[0] != -1) {
846 imap_exec(ictx
, NULL
, "LOGOUT");
847 socket_shutdown(&imap
->buf
.sock
);
852 static void imap_close_store(struct imap_store
*ctx
)
854 imap_close_server(ctx
);
861 * hexchar() and cram() functions are based on the code from the isync
862 * project (http://isync.sf.net/).
864 static char hexchar(unsigned int b
)
866 return b
< 10 ? '0' + b
: 'a' + (b
- 10);
869 #define ENCODED_SIZE(n) (4 * DIV_ROUND_UP((n), 3))
870 static char *cram(const char *challenge_64
, const char *user
, const char *pass
)
872 int i
, resp_len
, encoded_len
, decoded_len
;
873 unsigned char hash
[16];
875 char *response
, *response_64
, *challenge
;
878 * length of challenge_64 (i.e. base-64 encoded string) is a good
879 * enough upper bound for challenge (decoded result).
881 encoded_len
= strlen(challenge_64
);
882 challenge
= xmalloc(encoded_len
);
883 decoded_len
= EVP_DecodeBlock((unsigned char *)challenge
,
884 (unsigned char *)challenge_64
, encoded_len
);
886 die("invalid challenge %s", challenge_64
);
887 if (!HMAC(EVP_md5(), pass
, strlen(pass
), (unsigned char *)challenge
, decoded_len
, hash
, NULL
))
891 for (i
= 0; i
< 16; i
++) {
892 hex
[2 * i
] = hexchar((hash
[i
] >> 4) & 0xf);
893 hex
[2 * i
+ 1] = hexchar(hash
[i
] & 0xf);
896 /* response: "<user> <digest in hex>" */
897 response
= xstrfmt("%s %s", user
, hex
);
898 resp_len
= strlen(response
);
900 response_64
= xmallocz(ENCODED_SIZE(resp_len
));
901 encoded_len
= EVP_EncodeBlock((unsigned char *)response_64
,
902 (unsigned char *)response
, resp_len
);
904 die("EVP_EncodeBlock error");
905 return (char *)response_64
;
910 static char *cram(const char *challenge_64
, const char *user
, const char *pass
)
912 die("If you want to use CRAM-MD5 authenticate method, "
913 "you have to build git-imap-send with OpenSSL library.");
918 static int auth_cram_md5(struct imap_store
*ctx
, struct imap_cmd
*cmd
, const char *prompt
)
923 response
= cram(prompt
, server
.user
, server
.pass
);
925 ret
= socket_write(&ctx
->imap
->buf
.sock
, response
, strlen(response
));
926 if (ret
!= strlen(response
))
927 return error("IMAP error: sending response failed");
934 static void server_fill_credential(struct imap_server_conf
*srvc
, struct credential
*cred
)
936 if (srvc
->user
&& srvc
->pass
)
939 cred
->protocol
= xstrdup(srvc
->use_ssl
? "imaps" : "imap");
940 cred
->host
= xstrdup(srvc
->host
);
942 cred
->username
= xstrdup_or_null(srvc
->user
);
943 cred
->password
= xstrdup_or_null(srvc
->pass
);
945 credential_fill(cred
);
948 srvc
->user
= xstrdup(cred
->username
);
950 srvc
->pass
= xstrdup(cred
->password
);
953 static struct imap_store
*imap_open_store(struct imap_server_conf
*srvc
, const char *folder
)
955 struct credential cred
= CREDENTIAL_INIT
;
956 struct imap_store
*ctx
;
961 CALLOC_ARRAY(ctx
, 1);
963 ctx
->imap
= CALLOC_ARRAY(imap
, 1);
964 imap
->buf
.sock
.fd
[0] = imap
->buf
.sock
.fd
[1] = -1;
965 imap
->in_progress_append
= &imap
->in_progress
;
967 /* open connection to IMAP server */
970 struct child_process tunnel
= CHILD_PROCESS_INIT
;
972 imap_info("Starting tunnel '%s'... ", srvc
->tunnel
);
974 strvec_push(&tunnel
.args
, srvc
->tunnel
);
975 tunnel
.use_shell
= 1;
978 if (start_command(&tunnel
))
979 die("cannot start proxy %s", srvc
->tunnel
);
981 imap
->buf
.sock
.fd
[0] = tunnel
.out
;
982 imap
->buf
.sock
.fd
[1] = tunnel
.in
;
987 struct addrinfo hints
, *ai0
, *ai
;
991 xsnprintf(portstr
, sizeof(portstr
), "%d", srvc
->port
);
993 memset(&hints
, 0, sizeof(hints
));
994 hints
.ai_socktype
= SOCK_STREAM
;
995 hints
.ai_protocol
= IPPROTO_TCP
;
997 imap_info("Resolving %s... ", srvc
->host
);
998 gai
= getaddrinfo(srvc
->host
, portstr
, &hints
, &ai
);
1000 fprintf(stderr
, "getaddrinfo: %s\n", gai_strerror(gai
));
1005 for (ai0
= ai
; ai
; ai
= ai
->ai_next
) {
1006 char addr
[NI_MAXHOST
];
1008 s
= socket(ai
->ai_family
, ai
->ai_socktype
,
1013 getnameinfo(ai
->ai_addr
, ai
->ai_addrlen
, addr
,
1014 sizeof(addr
), NULL
, 0, NI_NUMERICHOST
);
1015 imap_info("Connecting to [%s]:%s... ", addr
, portstr
);
1017 if (connect(s
, ai
->ai_addr
, ai
->ai_addrlen
) < 0) {
1029 struct sockaddr_in addr
;
1031 memset(&addr
, 0, sizeof(addr
));
1032 addr
.sin_port
= htons(srvc
->port
);
1033 addr
.sin_family
= AF_INET
;
1035 imap_info("Resolving %s... ", srvc
->host
);
1036 he
= gethostbyname(srvc
->host
);
1038 perror("gethostbyname");
1043 addr
.sin_addr
.s_addr
= *((int *) he
->h_addr_list
[0]);
1045 s
= socket(PF_INET
, SOCK_STREAM
, 0);
1047 imap_info("Connecting to %s:%hu... ", inet_ntoa(addr
.sin_addr
), ntohs(addr
.sin_port
));
1048 if (connect(s
, (struct sockaddr
*)&addr
, sizeof(addr
))) {
1055 fputs("Error: unable to connect to server.\n", stderr
);
1059 imap
->buf
.sock
.fd
[0] = s
;
1060 imap
->buf
.sock
.fd
[1] = dup(s
);
1062 if (srvc
->use_ssl
&&
1063 ssl_socket_connect(&imap
->buf
.sock
, 0, srvc
->ssl_verify
)) {
1070 /* read the greeting string */
1071 if (buffer_gets(&imap
->buf
, &rsp
)) {
1072 fprintf(stderr
, "IMAP error: no greeting response\n");
1075 arg
= next_arg(&rsp
);
1076 if (!arg
|| *arg
!= '*' || (arg
= next_arg(&rsp
)) == NULL
) {
1077 fprintf(stderr
, "IMAP error: invalid greeting response\n");
1081 if (!strcmp("PREAUTH", arg
))
1083 else if (strcmp("OK", arg
) != 0) {
1084 fprintf(stderr
, "IMAP error: unknown greeting response\n");
1087 parse_response_code(ctx
, NULL
, rsp
);
1088 if (!imap
->caps
&& imap_exec(ctx
, NULL
, "CAPABILITY") != RESP_OK
)
1093 if (!srvc
->use_ssl
&& CAP(STARTTLS
)) {
1094 if (imap_exec(ctx
, NULL
, "STARTTLS") != RESP_OK
)
1096 if (ssl_socket_connect(&imap
->buf
.sock
, 1,
1099 /* capabilities may have changed, so get the new capabilities */
1100 if (imap_exec(ctx
, NULL
, "CAPABILITY") != RESP_OK
)
1104 imap_info("Logging in...\n");
1105 server_fill_credential(srvc
, &cred
);
1107 if (srvc
->auth_method
) {
1108 struct imap_cmd_cb cb
;
1110 if (!strcmp(srvc
->auth_method
, "CRAM-MD5")) {
1111 if (!CAP(AUTH_CRAM_MD5
)) {
1112 fprintf(stderr
, "You specified "
1113 "CRAM-MD5 as authentication method, "
1114 "but %s doesn't support it.\n", srvc
->host
);
1119 memset(&cb
, 0, sizeof(cb
));
1120 cb
.cont
= auth_cram_md5
;
1121 if (imap_exec(ctx
, &cb
, "AUTHENTICATE CRAM-MD5") != RESP_OK
) {
1122 fprintf(stderr
, "IMAP error: AUTHENTICATE CRAM-MD5 failed\n");
1126 fprintf(stderr
, "Unknown authentication method:%s\n", srvc
->host
);
1131 fprintf(stderr
, "Skipping account %s@%s, server forbids LOGIN\n",
1132 srvc
->user
, srvc
->host
);
1135 if (!imap
->buf
.sock
.ssl
)
1136 imap_warn("*** IMAP Warning *** Password is being "
1137 "sent in the clear\n");
1138 if (imap_exec(ctx
, NULL
, "LOGIN \"%s\" \"%s\"", srvc
->user
, srvc
->pass
) != RESP_OK
) {
1139 fprintf(stderr
, "IMAP error: LOGIN failed\n");
1146 credential_approve(&cred
);
1147 credential_clear(&cred
);
1149 /* check the target mailbox exists */
1151 switch (imap_exec(ctx
, NULL
, "EXAMINE \"%s\"", ctx
->name
)) {
1156 fprintf(stderr
, "IMAP error: could not check mailbox\n");
1159 if (imap_exec(ctx
, NULL
, "CREATE \"%s\"", ctx
->name
) == RESP_OK
) {
1160 imap_info("Created missing mailbox\n");
1162 fprintf(stderr
, "IMAP error: could not create missing mailbox\n");
1173 credential_reject(&cred
);
1174 credential_clear(&cred
);
1177 imap_close_store(ctx
);
1182 * Insert CR characters as necessary in *msg to ensure that every LF
1183 * character in *msg is preceded by a CR.
1185 static void lf_to_crlf(struct strbuf
*msg
)
1191 /* First pass: tally, in j, the size of the new_msg string: */
1192 for (i
= j
= 0, lastc
= '\0'; i
< msg
->len
; i
++) {
1193 if (msg
->buf
[i
] == '\n' && lastc
!= '\r')
1194 j
++; /* a CR will need to be added here */
1195 lastc
= msg
->buf
[i
];
1199 new_msg
= xmallocz(j
);
1202 * Second pass: write the new_msg string. Note that this loop is
1203 * otherwise identical to the first pass.
1205 for (i
= j
= 0, lastc
= '\0'; i
< msg
->len
; i
++) {
1206 if (msg
->buf
[i
] == '\n' && lastc
!= '\r')
1207 new_msg
[j
++] = '\r';
1208 lastc
= new_msg
[j
++] = msg
->buf
[i
];
1210 strbuf_attach(msg
, new_msg
, j
, j
+ 1);
1214 * Store msg to IMAP. Also detach and free the data from msg->data,
1215 * leaving msg->data empty.
1217 static int imap_store_msg(struct imap_store
*ctx
, struct strbuf
*msg
)
1219 struct imap
*imap
= ctx
->imap
;
1220 struct imap_cmd_cb cb
;
1221 const char *prefix
, *box
;
1225 memset(&cb
, 0, sizeof(cb
));
1228 cb
.data
= strbuf_detach(msg
, NULL
);
1231 prefix
= !strcmp(box
, "INBOX") ? "" : ctx
->prefix
;
1232 ret
= imap_exec_m(ctx
, &cb
, "APPEND \"%s%s\" ", prefix
, box
);
1233 imap
->caps
= imap
->rcaps
;
1240 static void wrap_in_html(struct strbuf
*msg
)
1242 struct strbuf buf
= STRBUF_INIT
;
1243 static char *content_type
= "Content-Type: text/html;\n";
1244 static char *pre_open
= "<pre>\n";
1245 static char *pre_close
= "</pre>\n";
1246 const char *body
= strstr(msg
->buf
, "\n\n");
1249 return; /* Headers but no body; no wrapping needed */
1253 strbuf_add(&buf
, msg
->buf
, body
- msg
->buf
- 1);
1254 strbuf_addstr(&buf
, content_type
);
1255 strbuf_addch(&buf
, '\n');
1256 strbuf_addstr(&buf
, pre_open
);
1257 strbuf_addstr_xml_quoted(&buf
, body
);
1258 strbuf_addstr(&buf
, pre_close
);
1260 strbuf_release(msg
);
1264 static int count_messages(struct strbuf
*all_msgs
)
1267 char *p
= all_msgs
->buf
;
1270 if (starts_with(p
, "From ")) {
1271 p
= strstr(p
+5, "\nFrom: ");
1273 p
= strstr(p
+7, "\nDate: ");
1275 p
= strstr(p
+7, "\nSubject: ");
1280 p
= strstr(p
+5, "\nFrom ");
1289 * Copy the next message from all_msgs, starting at offset *ofs, to
1290 * msg. Update *ofs to the start of the following message. Return
1291 * true iff a message was successfully copied.
1293 static int split_msg(struct strbuf
*all_msgs
, struct strbuf
*msg
, int *ofs
)
1298 if (*ofs
>= all_msgs
->len
)
1301 data
= &all_msgs
->buf
[*ofs
];
1302 len
= all_msgs
->len
- *ofs
;
1304 if (len
< 5 || !starts_with(data
, "From "))
1307 p
= strchr(data
, '\n');
1315 p
= strstr(data
, "\nFrom ");
1319 strbuf_add(msg
, data
, len
);
1324 static int git_imap_config(const char *var
, const char *val
, void *cb
)
1327 if (!strcmp("imap.sslverify", var
))
1328 server
.ssl_verify
= git_config_bool(var
, val
);
1329 else if (!strcmp("imap.preformattedhtml", var
))
1330 server
.use_html
= git_config_bool(var
, val
);
1331 else if (!strcmp("imap.folder", var
))
1332 return git_config_string(&server
.folder
, var
, val
);
1333 else if (!strcmp("imap.user", var
))
1334 return git_config_string(&server
.user
, var
, val
);
1335 else if (!strcmp("imap.pass", var
))
1336 return git_config_string(&server
.pass
, var
, val
);
1337 else if (!strcmp("imap.tunnel", var
))
1338 return git_config_string(&server
.tunnel
, var
, val
);
1339 else if (!strcmp("imap.authmethod", var
))
1340 return git_config_string(&server
.auth_method
, var
, val
);
1341 else if (!strcmp("imap.port", var
))
1342 server
.port
= git_config_int(var
, val
);
1343 else if (!strcmp("imap.host", var
)) {
1345 git_die_config("imap.host", "Missing value for 'imap.host'");
1347 if (starts_with(val
, "imap:"))
1349 else if (starts_with(val
, "imaps:")) {
1353 if (starts_with(val
, "//"))
1355 server
.host
= xstrdup(val
);
1358 return git_default_config(var
, val
, cb
);
1363 static int append_msgs_to_imap(struct imap_server_conf
*server
,
1364 struct strbuf
* all_msgs
, int total
)
1366 struct strbuf msg
= STRBUF_INIT
;
1367 struct imap_store
*ctx
= NULL
;
1372 ctx
= imap_open_store(server
, server
->folder
);
1374 fprintf(stderr
, "failed to open store\n");
1377 ctx
->name
= server
->folder
;
1379 fprintf(stderr
, "sending %d message%s\n", total
, (total
!= 1) ? "s" : "");
1381 unsigned percent
= n
* 100 / total
;
1383 fprintf(stderr
, "%4u%% (%d/%d) done\r", percent
, n
, total
);
1385 if (!split_msg(all_msgs
, &msg
, &ofs
))
1387 if (server
->use_html
)
1389 r
= imap_store_msg(ctx
, &msg
);
1394 fprintf(stderr
, "\n");
1396 imap_close_store(ctx
);
1401 #ifdef USE_CURL_FOR_IMAP_SEND
1402 static CURL
*setup_curl(struct imap_server_conf
*srvc
, struct credential
*cred
)
1405 struct strbuf path
= STRBUF_INIT
;
1406 char *uri_encoded_folder
;
1408 if (curl_global_init(CURL_GLOBAL_ALL
) != CURLE_OK
)
1409 die("curl_global_init failed");
1411 curl
= curl_easy_init();
1414 die("curl_easy_init failed");
1416 server_fill_credential(&server
, cred
);
1417 curl_easy_setopt(curl
, CURLOPT_USERNAME
, server
.user
);
1418 curl_easy_setopt(curl
, CURLOPT_PASSWORD
, server
.pass
);
1420 strbuf_addstr(&path
, server
.use_ssl
? "imaps://" : "imap://");
1421 strbuf_addstr(&path
, server
.host
);
1422 if (!path
.len
|| path
.buf
[path
.len
- 1] != '/')
1423 strbuf_addch(&path
, '/');
1425 uri_encoded_folder
= curl_easy_escape(curl
, server
.folder
, 0);
1426 if (!uri_encoded_folder
)
1427 die("failed to encode server folder");
1428 strbuf_addstr(&path
, uri_encoded_folder
);
1429 curl_free(uri_encoded_folder
);
1431 curl_easy_setopt(curl
, CURLOPT_URL
, path
.buf
);
1432 strbuf_release(&path
);
1433 curl_easy_setopt(curl
, CURLOPT_PORT
, server
.port
);
1435 if (server
.auth_method
) {
1436 #ifndef GIT_CURL_HAVE_CURLOPT_LOGIN_OPTIONS
1437 warning("No LOGIN_OPTIONS support in this cURL version");
1439 struct strbuf auth
= STRBUF_INIT
;
1440 strbuf_addstr(&auth
, "AUTH=");
1441 strbuf_addstr(&auth
, server
.auth_method
);
1442 curl_easy_setopt(curl
, CURLOPT_LOGIN_OPTIONS
, auth
.buf
);
1443 strbuf_release(&auth
);
1447 if (!server
.use_ssl
)
1448 curl_easy_setopt(curl
, CURLOPT_USE_SSL
, (long)CURLUSESSL_TRY
);
1450 curl_easy_setopt(curl
, CURLOPT_SSL_VERIFYPEER
, server
.ssl_verify
);
1451 curl_easy_setopt(curl
, CURLOPT_SSL_VERIFYHOST
, server
.ssl_verify
);
1453 curl_easy_setopt(curl
, CURLOPT_READFUNCTION
, fread_buffer
);
1455 curl_easy_setopt(curl
, CURLOPT_UPLOAD
, 1L);
1457 if (0 < verbosity
|| getenv("GIT_CURL_VERBOSE"))
1458 http_trace_curl_no_data();
1459 setup_curl_trace(curl
);
1464 static int curl_append_msgs_to_imap(struct imap_server_conf
*server
,
1465 struct strbuf
* all_msgs
, int total
)
1469 struct buffer msgbuf
= { STRBUF_INIT
, 0 };
1471 CURLcode res
= CURLE_OK
;
1472 struct credential cred
= CREDENTIAL_INIT
;
1474 curl
= setup_curl(server
, &cred
);
1475 curl_easy_setopt(curl
, CURLOPT_READDATA
, &msgbuf
);
1477 fprintf(stderr
, "sending %d message%s\n", total
, (total
!= 1) ? "s" : "");
1479 unsigned percent
= n
* 100 / total
;
1482 fprintf(stderr
, "%4u%% (%d/%d) done\r", percent
, n
, total
);
1484 prev_len
= msgbuf
.buf
.len
;
1485 if (!split_msg(all_msgs
, &msgbuf
.buf
, &ofs
))
1487 if (server
->use_html
)
1488 wrap_in_html(&msgbuf
.buf
);
1489 lf_to_crlf(&msgbuf
.buf
);
1491 curl_easy_setopt(curl
, CURLOPT_INFILESIZE_LARGE
,
1492 (curl_off_t
)(msgbuf
.buf
.len
-prev_len
));
1494 res
= curl_easy_perform(curl
);
1496 if(res
!= CURLE_OK
) {
1497 fprintf(stderr
, "curl_easy_perform() failed: %s\n",
1498 curl_easy_strerror(res
));
1504 fprintf(stderr
, "\n");
1506 curl_easy_cleanup(curl
);
1507 curl_global_cleanup();
1509 if (cred
.username
) {
1510 if (res
== CURLE_OK
)
1511 credential_approve(&cred
);
1512 else if (res
== CURLE_LOGIN_DENIED
)
1513 credential_reject(&cred
);
1516 credential_clear(&cred
);
1518 return res
!= CURLE_OK
;
1522 int cmd_main(int argc
, const char **argv
)
1524 struct strbuf all_msgs
= STRBUF_INIT
;
1528 setup_git_directory_gently(&nongit_ok
);
1529 git_config(git_imap_config
, NULL
);
1531 argc
= parse_options(argc
, (const char **)argv
, "", imap_send_options
, imap_send_usage
, 0);
1534 usage_with_options(imap_send_usage
, imap_send_options
);
1536 #ifndef USE_CURL_FOR_IMAP_SEND
1538 warning("--curl not supported in this build");
1541 #elif defined(NO_OPENSSL)
1543 warning("--no-curl not supported in this build");
1549 server
.port
= server
.use_ssl
? 993 : 143;
1551 if (!server
.folder
) {
1552 fprintf(stderr
, "no imap store specified\n");
1556 if (!server
.tunnel
) {
1557 fprintf(stderr
, "no imap host specified\n");
1560 server
.host
= "tunnel";
1563 /* read the messages */
1564 if (strbuf_read(&all_msgs
, 0, 0) < 0) {
1565 error_errno(_("could not read from stdin"));
1569 if (all_msgs
.len
== 0) {
1570 fprintf(stderr
, "nothing to send\n");
1574 total
= count_messages(&all_msgs
);
1576 fprintf(stderr
, "no messages to send\n");
1580 /* write it to the imap server */
1583 return append_msgs_to_imap(&server
, &all_msgs
, total
);
1585 #ifdef USE_CURL_FOR_IMAP_SEND
1587 return curl_append_msgs_to_imap(&server
, &all_msgs
, total
);
1590 return append_msgs_to_imap(&server
, &all_msgs
, total
);