2006-03-10 05:32:50 +00:00
|
|
|
/*
|
|
|
|
* git-imap-send - drops patches into an imap Drafts folder
|
|
|
|
* derived from isync/mbsync - mailbox synchronizer
|
|
|
|
*
|
|
|
|
* Copyright (C) 2000-2002 Michael R. Elkins <me@mutt.org>
|
|
|
|
* Copyright (C) 2002-2004 Oswald Buddenhagen <ossi@users.sf.net>
|
|
|
|
* Copyright (C) 2004 Theodore Y. Ts'o <tytso@mit.edu>
|
|
|
|
* Copyright (C) 2006 Mike McCormack
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "cache.h"
|
2017-06-14 18:07:36 +00:00
|
|
|
#include "config.h"
|
2014-04-29 03:00:04 +00:00
|
|
|
#include "credential.h"
|
2009-01-18 12:00:12 +00:00
|
|
|
#include "exec_cmd.h"
|
2009-10-19 15:42:04 +00:00
|
|
|
#include "run-command.h"
|
2014-11-05 14:29:21 +00:00
|
|
|
#include "parse-options.h"
|
2008-07-09 21:29:00 +00:00
|
|
|
#ifdef NO_OPENSSL
|
|
|
|
typedef void *SSL;
|
|
|
|
#endif
|
2014-11-09 14:55:53 +00:00
|
|
|
#ifdef USE_CURL_FOR_IMAP_SEND
|
|
|
|
#include "http.h"
|
|
|
|
#endif
|
2006-03-10 05:32:50 +00:00
|
|
|
|
2015-03-08 05:13:55 +00:00
|
|
|
#if defined(USE_CURL_FOR_IMAP_SEND) && defined(NO_OPENSSL)
|
|
|
|
/* only available option */
|
|
|
|
#define USE_CURL_DEFAULT 1
|
|
|
|
#else
|
|
|
|
/* strictly opt in */
|
|
|
|
#define USE_CURL_DEFAULT 0
|
|
|
|
#endif
|
|
|
|
|
2014-11-05 14:29:21 +00:00
|
|
|
static int verbosity;
|
2015-03-08 05:13:55 +00:00
|
|
|
static int use_curl = USE_CURL_DEFAULT;
|
2014-11-05 14:29:21 +00:00
|
|
|
|
2014-11-09 14:55:53 +00:00
|
|
|
static const char * const imap_send_usage[] = { "git imap-send [-v] [-q] [--[no-]curl] < <mbox>", NULL };
|
2014-11-05 14:29:21 +00:00
|
|
|
|
|
|
|
static struct option imap_send_options[] = {
|
|
|
|
OPT__VERBOSITY(&verbosity),
|
2014-11-09 14:55:53 +00:00
|
|
|
OPT_BOOL(0, "curl", &use_curl, "use libcurl to communicate with the IMAP server"),
|
2014-11-05 14:29:21 +00:00
|
|
|
OPT_END()
|
|
|
|
};
|
2006-03-10 05:32:50 +00:00
|
|
|
|
2009-10-19 15:42:05 +00:00
|
|
|
#undef DRV_OK
|
2006-03-10 05:32:50 +00:00
|
|
|
#define DRV_OK 0
|
|
|
|
#define DRV_MSG_BAD -1
|
|
|
|
#define DRV_BOX_BAD -2
|
|
|
|
#define DRV_STORE_BAD -3
|
|
|
|
|
2009-11-14 21:33:13 +00:00
|
|
|
__attribute__((format (printf, 1, 2)))
|
2008-07-09 21:29:01 +00:00
|
|
|
static void imap_info(const char *, ...);
|
2009-11-14 21:33:13 +00:00
|
|
|
__attribute__((format (printf, 1, 2)))
|
2008-07-09 21:29:01 +00:00
|
|
|
static void imap_warn(const char *, ...);
|
2006-03-10 05:32:50 +00:00
|
|
|
|
2008-07-09 21:29:01 +00:00
|
|
|
static char *next_arg(char **);
|
2006-03-10 05:32:50 +00:00
|
|
|
|
2009-11-14 21:33:13 +00:00
|
|
|
__attribute__((format (printf, 3, 4)))
|
2008-07-09 21:29:01 +00:00
|
|
|
static int nfsnprintf(char *buf, int blen, const char *fmt, ...);
|
2006-03-10 05:32:50 +00:00
|
|
|
|
nfv?asprintf are broken without va_copy, workaround them.
* drop nfasprintf.
* move nfvasprintf into imap-send.c back, and let it work on a 8k buffer,
and die() in case of overflow. It should be enough for imap commands, if
someone cares about imap-send, he's welcomed to fix it properly.
* replace nfvasprintf use in merge-recursive with a copy of the strbuf_addf
logic, it's one place, we'll live with it.
To ease the change, output_buffer string list is replaced with a strbuf ;)
* rework trace.c to call vsnprintf itself. It's used to format strerror()s
and git command names, it should never be more than a few octets long, let
it work on a 8k static buffer with vsnprintf or die loudly.
Signed-off-by: Pierre Habouzit <madcoder@debian.org>
2007-09-20 08:43:11 +00:00
|
|
|
static int nfvasprintf(char **strp, const char *fmt, va_list ap)
|
|
|
|
{
|
|
|
|
int len;
|
|
|
|
char tmp[8192];
|
|
|
|
|
|
|
|
len = vsnprintf(tmp, sizeof(tmp), fmt, ap);
|
|
|
|
if (len < 0)
|
2009-01-04 18:38:41 +00:00
|
|
|
die("Fatal: Out of memory");
|
nfv?asprintf are broken without va_copy, workaround them.
* drop nfasprintf.
* move nfvasprintf into imap-send.c back, and let it work on a 8k buffer,
and die() in case of overflow. It should be enough for imap commands, if
someone cares about imap-send, he's welcomed to fix it properly.
* replace nfvasprintf use in merge-recursive with a copy of the strbuf_addf
logic, it's one place, we'll live with it.
To ease the change, output_buffer string list is replaced with a strbuf ;)
* rework trace.c to call vsnprintf itself. It's used to format strerror()s
and git command names, it should never be more than a few octets long, let
it work on a 8k static buffer with vsnprintf or die loudly.
Signed-off-by: Pierre Habouzit <madcoder@debian.org>
2007-09-20 08:43:11 +00:00
|
|
|
if (len >= sizeof(tmp))
|
2009-01-04 18:38:41 +00:00
|
|
|
die("imap command overflow!");
|
nfv?asprintf are broken without va_copy, workaround them.
* drop nfasprintf.
* move nfvasprintf into imap-send.c back, and let it work on a 8k buffer,
and die() in case of overflow. It should be enough for imap commands, if
someone cares about imap-send, he's welcomed to fix it properly.
* replace nfvasprintf use in merge-recursive with a copy of the strbuf_addf
logic, it's one place, we'll live with it.
To ease the change, output_buffer string list is replaced with a strbuf ;)
* rework trace.c to call vsnprintf itself. It's used to format strerror()s
and git command names, it should never be more than a few octets long, let
it work on a 8k static buffer with vsnprintf or die loudly.
Signed-off-by: Pierre Habouzit <madcoder@debian.org>
2007-09-20 08:43:11 +00:00
|
|
|
*strp = xmemdupz(tmp, len);
|
|
|
|
return len;
|
|
|
|
}
|
2006-03-10 05:32:50 +00:00
|
|
|
|
2008-07-09 23:37:38 +00:00
|
|
|
struct imap_server_conf {
|
2006-03-10 05:32:50 +00:00
|
|
|
char *name;
|
|
|
|
char *tunnel;
|
|
|
|
char *host;
|
|
|
|
int port;
|
2014-08-19 21:27:11 +00:00
|
|
|
char *folder;
|
2006-03-10 05:32:50 +00:00
|
|
|
char *user;
|
|
|
|
char *pass;
|
2008-07-09 21:29:00 +00:00
|
|
|
int use_ssl;
|
|
|
|
int ssl_verify;
|
2009-02-12 14:58:12 +00:00
|
|
|
int use_html;
|
2010-02-16 06:34:07 +00:00
|
|
|
char *auth_method;
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct imap_server_conf server = {
|
|
|
|
NULL, /* name */
|
|
|
|
NULL, /* tunnel */
|
|
|
|
NULL, /* host */
|
|
|
|
0, /* port */
|
2014-08-19 21:27:11 +00:00
|
|
|
NULL, /* folder */
|
2010-02-16 06:34:07 +00:00
|
|
|
NULL, /* user */
|
|
|
|
NULL, /* pass */
|
|
|
|
0, /* use_ssl */
|
|
|
|
1, /* ssl_verify */
|
|
|
|
0, /* use_html */
|
|
|
|
NULL, /* auth_method */
|
2008-07-09 23:37:38 +00:00
|
|
|
};
|
2006-03-10 05:32:50 +00:00
|
|
|
|
2008-07-09 23:37:38 +00:00
|
|
|
struct imap_socket {
|
2009-10-19 15:42:03 +00:00
|
|
|
int fd[2];
|
2008-07-09 21:29:00 +00:00
|
|
|
SSL *ssl;
|
2008-07-09 23:37:38 +00:00
|
|
|
};
|
2006-03-10 05:32:50 +00:00
|
|
|
|
2008-07-09 23:37:38 +00:00
|
|
|
struct imap_buffer {
|
|
|
|
struct imap_socket sock;
|
2006-03-10 05:32:50 +00:00
|
|
|
int bytes;
|
|
|
|
int offset;
|
|
|
|
char buf[1024];
|
2008-07-09 23:37:38 +00:00
|
|
|
};
|
2006-03-10 05:32:50 +00:00
|
|
|
|
|
|
|
struct imap_cmd;
|
|
|
|
|
2008-07-09 23:37:38 +00:00
|
|
|
struct imap {
|
2006-03-10 05:32:50 +00:00
|
|
|
int uidnext; /* from SELECT responses */
|
|
|
|
unsigned caps, rcaps; /* CAPABILITY results */
|
|
|
|
/* command queue */
|
|
|
|
int nexttag, num_in_progress, literal_pending;
|
|
|
|
struct imap_cmd *in_progress, **in_progress_append;
|
2008-07-09 23:37:38 +00:00
|
|
|
struct imap_buffer buf; /* this is BIG, so put it last */
|
|
|
|
};
|
2006-03-10 05:32:50 +00:00
|
|
|
|
2008-07-09 23:37:38 +00:00
|
|
|
struct imap_store {
|
2013-01-15 08:06:31 +00:00
|
|
|
/* currently open mailbox */
|
|
|
|
const char *name; /* foreign! maybe preset? */
|
|
|
|
int uidvalidity;
|
2008-07-09 23:37:38 +00:00
|
|
|
struct imap *imap;
|
2006-03-10 05:32:50 +00:00
|
|
|
const char *prefix;
|
2008-07-09 23:37:38 +00:00
|
|
|
};
|
2006-03-10 05:32:50 +00:00
|
|
|
|
|
|
|
struct imap_cmd_cb {
|
2008-07-09 23:37:38 +00:00
|
|
|
int (*cont)(struct imap_store *ctx, struct imap_cmd *cmd, const char *prompt);
|
|
|
|
void (*done)(struct imap_store *ctx, struct imap_cmd *cmd, int response);
|
2006-03-10 05:32:50 +00:00
|
|
|
void *ctx;
|
|
|
|
char *data;
|
|
|
|
int dlen;
|
|
|
|
int uid;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct imap_cmd {
|
|
|
|
struct imap_cmd *next;
|
|
|
|
struct imap_cmd_cb cb;
|
|
|
|
char *cmd;
|
|
|
|
int tag;
|
|
|
|
};
|
|
|
|
|
|
|
|
#define CAP(cap) (imap->caps & (1 << (cap)))
|
|
|
|
|
|
|
|
enum CAPABILITY {
|
|
|
|
NOLOGIN = 0,
|
|
|
|
UIDPLUS,
|
|
|
|
LITERALPLUS,
|
|
|
|
NAMESPACE,
|
2008-07-09 21:29:00 +00:00
|
|
|
STARTTLS,
|
2010-05-14 09:31:35 +00:00
|
|
|
AUTH_CRAM_MD5
|
2006-03-10 05:32:50 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static const char *cap_list[] = {
|
|
|
|
"LOGINDISABLED",
|
|
|
|
"UIDPLUS",
|
|
|
|
"LITERAL+",
|
|
|
|
"NAMESPACE",
|
2008-07-09 21:29:00 +00:00
|
|
|
"STARTTLS",
|
2010-02-16 06:34:07 +00:00
|
|
|
"AUTH=CRAM-MD5",
|
2006-03-10 05:32:50 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
#define RESP_OK 0
|
|
|
|
#define RESP_NO 1
|
|
|
|
#define RESP_BAD 2
|
|
|
|
|
2008-07-09 23:37:38 +00:00
|
|
|
static int get_cmd_result(struct imap_store *ctx, struct imap_cmd *tcmd);
|
2006-03-10 05:32:50 +00:00
|
|
|
|
|
|
|
|
2008-07-09 21:29:00 +00:00
|
|
|
#ifndef NO_OPENSSL
|
|
|
|
static void ssl_socket_perror(const char *func)
|
|
|
|
{
|
2009-06-18 17:28:43 +00:00
|
|
|
fprintf(stderr, "%s: %s\n", func, ERR_error_string(ERR_get_error(), NULL));
|
2008-07-09 21:29:00 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2008-07-09 23:37:38 +00:00
|
|
|
static void socket_perror(const char *func, struct imap_socket *sock, int ret)
|
2006-03-10 05:32:50 +00:00
|
|
|
{
|
2008-07-09 21:29:00 +00:00
|
|
|
#ifndef NO_OPENSSL
|
|
|
|
if (sock->ssl) {
|
|
|
|
int sslerr = SSL_get_error(sock->ssl, ret);
|
|
|
|
switch (sslerr) {
|
|
|
|
case SSL_ERROR_NONE:
|
|
|
|
break;
|
|
|
|
case SSL_ERROR_SYSCALL:
|
|
|
|
perror("SSL_connect");
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
ssl_socket_perror("SSL_connect");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
#endif
|
|
|
|
{
|
|
|
|
if (ret < 0)
|
|
|
|
perror(func);
|
|
|
|
else
|
|
|
|
fprintf(stderr, "%s: unexpected EOF\n", func);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-02-15 20:32:19 +00:00
|
|
|
#ifdef NO_OPENSSL
|
2008-07-09 23:37:38 +00:00
|
|
|
static int ssl_socket_connect(struct imap_socket *sock, int use_tls_only, int verify)
|
2008-07-09 21:29:00 +00:00
|
|
|
{
|
|
|
|
fprintf(stderr, "SSL requested but SSL support not compiled in\n");
|
|
|
|
return -1;
|
2013-02-15 20:32:19 +00:00
|
|
|
}
|
|
|
|
|
2009-10-31 06:36:03 +00:00
|
|
|
#else
|
2013-02-15 20:32:19 +00:00
|
|
|
|
2013-02-15 20:50:35 +00:00
|
|
|
static int host_matches(const char *host, const char *pattern)
|
|
|
|
{
|
|
|
|
if (pattern[0] == '*' && pattern[1] == '.') {
|
|
|
|
pattern += 2;
|
|
|
|
if (!(host = strchr(host, '.')))
|
|
|
|
return 0;
|
|
|
|
host++;
|
|
|
|
}
|
|
|
|
|
|
|
|
return *host && *pattern && !strcasecmp(host, pattern);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int verify_hostname(X509 *cert, const char *hostname)
|
|
|
|
{
|
|
|
|
int len;
|
|
|
|
X509_NAME *subj;
|
|
|
|
char cname[1000];
|
2013-02-15 20:59:53 +00:00
|
|
|
int i, found;
|
|
|
|
STACK_OF(GENERAL_NAME) *subj_alt_names;
|
|
|
|
|
|
|
|
/* try the DNS subjectAltNames */
|
|
|
|
found = 0;
|
|
|
|
if ((subj_alt_names = X509_get_ext_d2i(cert, NID_subject_alt_name, NULL, NULL))) {
|
|
|
|
int num_subj_alt_names = sk_GENERAL_NAME_num(subj_alt_names);
|
|
|
|
for (i = 0; !found && i < num_subj_alt_names; i++) {
|
|
|
|
GENERAL_NAME *subj_alt_name = sk_GENERAL_NAME_value(subj_alt_names, i);
|
|
|
|
if (subj_alt_name->type == GEN_DNS &&
|
|
|
|
strlen((const char *)subj_alt_name->d.ia5->data) == (size_t)subj_alt_name->d.ia5->length &&
|
|
|
|
host_matches(hostname, (const char *)(subj_alt_name->d.ia5->data)))
|
|
|
|
found = 1;
|
|
|
|
}
|
|
|
|
sk_GENERAL_NAME_pop_free(subj_alt_names, GENERAL_NAME_free);
|
|
|
|
}
|
|
|
|
if (found)
|
|
|
|
return 0;
|
2013-02-15 20:50:35 +00:00
|
|
|
|
|
|
|
/* try the common name */
|
|
|
|
if (!(subj = X509_get_subject_name(cert)))
|
|
|
|
return error("cannot get certificate subject");
|
|
|
|
if ((len = X509_NAME_get_text_by_NID(subj, NID_commonName, cname, sizeof(cname))) < 0)
|
|
|
|
return error("cannot get certificate common name");
|
|
|
|
if (strlen(cname) == (size_t)len && host_matches(hostname, cname))
|
|
|
|
return 0;
|
|
|
|
return error("certificate owner '%s' does not match hostname '%s'",
|
|
|
|
cname, hostname);
|
|
|
|
}
|
|
|
|
|
2013-02-15 20:32:19 +00:00
|
|
|
static int ssl_socket_connect(struct imap_socket *sock, int use_tls_only, int verify)
|
|
|
|
{
|
2009-10-31 06:36:03 +00:00
|
|
|
#if (OPENSSL_VERSION_NUMBER >= 0x10000000L)
|
|
|
|
const SSL_METHOD *meth;
|
2008-07-09 21:29:00 +00:00
|
|
|
#else
|
|
|
|
SSL_METHOD *meth;
|
2009-10-31 06:36:03 +00:00
|
|
|
#endif
|
2008-07-09 21:29:00 +00:00
|
|
|
SSL_CTX *ctx;
|
|
|
|
int ret;
|
2013-02-15 20:50:35 +00:00
|
|
|
X509 *cert;
|
2008-07-09 21:29:00 +00:00
|
|
|
|
|
|
|
SSL_library_init();
|
|
|
|
SSL_load_error_strings();
|
|
|
|
|
2016-04-08 16:22:15 +00:00
|
|
|
meth = SSLv23_method();
|
2008-07-09 21:29:00 +00:00
|
|
|
if (!meth) {
|
|
|
|
ssl_socket_perror("SSLv23_method");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = SSL_CTX_new(meth);
|
2016-04-08 16:22:14 +00:00
|
|
|
if (!ctx) {
|
|
|
|
ssl_socket_perror("SSL_CTX_new");
|
|
|
|
return -1;
|
|
|
|
}
|
2008-07-09 21:29:00 +00:00
|
|
|
|
2016-04-08 16:22:15 +00:00
|
|
|
if (use_tls_only)
|
|
|
|
SSL_CTX_set_options(ctx, SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3);
|
2008-07-09 21:29:00 +00:00
|
|
|
|
|
|
|
if (verify)
|
|
|
|
SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER, NULL);
|
|
|
|
|
|
|
|
if (!SSL_CTX_set_default_verify_paths(ctx)) {
|
|
|
|
ssl_socket_perror("SSL_CTX_set_default_verify_paths");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
sock->ssl = SSL_new(ctx);
|
|
|
|
if (!sock->ssl) {
|
|
|
|
ssl_socket_perror("SSL_new");
|
|
|
|
return -1;
|
|
|
|
}
|
2009-10-19 15:42:03 +00:00
|
|
|
if (!SSL_set_rfd(sock->ssl, sock->fd[0])) {
|
|
|
|
ssl_socket_perror("SSL_set_rfd");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (!SSL_set_wfd(sock->ssl, sock->fd[1])) {
|
|
|
|
ssl_socket_perror("SSL_set_wfd");
|
2008-07-09 21:29:00 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2013-02-21 00:02:42 +00:00
|
|
|
#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
|
|
|
|
/*
|
|
|
|
* SNI (RFC4366)
|
|
|
|
* OpenSSL does not document this function, but the implementation
|
|
|
|
* returns 1 on success, 0 on failure after calling SSLerr().
|
|
|
|
*/
|
|
|
|
ret = SSL_set_tlsext_host_name(sock->ssl, server.host);
|
|
|
|
if (ret != 1)
|
|
|
|
warning("SSL_set_tlsext_host_name(%s) failed.", server.host);
|
|
|
|
#endif
|
|
|
|
|
2008-07-09 21:29:00 +00:00
|
|
|
ret = SSL_connect(sock->ssl);
|
|
|
|
if (ret <= 0) {
|
|
|
|
socket_perror("SSL_connect", sock, ret);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2013-02-15 20:50:35 +00:00
|
|
|
if (verify) {
|
|
|
|
/* make sure the hostname matches that of the certificate */
|
|
|
|
cert = SSL_get_peer_certificate(sock->ssl);
|
|
|
|
if (!cert)
|
|
|
|
return error("unable to get peer certificate.");
|
|
|
|
if (verify_hostname(cert, server.host) < 0)
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2008-07-09 21:29:00 +00:00
|
|
|
return 0;
|
2006-03-10 05:32:50 +00:00
|
|
|
}
|
2013-02-15 20:32:19 +00:00
|
|
|
#endif
|
2006-03-10 05:32:50 +00:00
|
|
|
|
2008-07-09 23:37:38 +00:00
|
|
|
static int socket_read(struct imap_socket *sock, char *buf, int len)
|
2006-03-10 05:32:50 +00:00
|
|
|
{
|
2008-07-09 21:29:00 +00:00
|
|
|
ssize_t n;
|
|
|
|
#ifndef NO_OPENSSL
|
|
|
|
if (sock->ssl)
|
|
|
|
n = SSL_read(sock->ssl, buf, len);
|
|
|
|
else
|
|
|
|
#endif
|
2009-10-19 15:42:03 +00:00
|
|
|
n = xread(sock->fd[0], buf, len);
|
2006-03-10 05:32:50 +00:00
|
|
|
if (n <= 0) {
|
2008-07-09 21:29:01 +00:00
|
|
|
socket_perror("read", sock, n);
|
2009-10-19 15:42:03 +00:00
|
|
|
close(sock->fd[0]);
|
|
|
|
close(sock->fd[1]);
|
|
|
|
sock->fd[0] = sock->fd[1] = -1;
|
2006-03-10 05:32:50 +00:00
|
|
|
}
|
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
2008-07-09 23:37:38 +00:00
|
|
|
static int socket_write(struct imap_socket *sock, const char *buf, int len)
|
2006-03-10 05:32:50 +00:00
|
|
|
{
|
2008-07-09 21:29:00 +00:00
|
|
|
int n;
|
|
|
|
#ifndef NO_OPENSSL
|
|
|
|
if (sock->ssl)
|
|
|
|
n = SSL_write(sock->ssl, buf, len);
|
|
|
|
else
|
|
|
|
#endif
|
2009-10-19 15:42:03 +00:00
|
|
|
n = write_in_full(sock->fd[1], buf, len);
|
2006-03-10 05:32:50 +00:00
|
|
|
if (n != len) {
|
2008-07-09 21:29:01 +00:00
|
|
|
socket_perror("write", sock, n);
|
2009-10-19 15:42:03 +00:00
|
|
|
close(sock->fd[0]);
|
|
|
|
close(sock->fd[1]);
|
|
|
|
sock->fd[0] = sock->fd[1] = -1;
|
2006-03-10 05:32:50 +00:00
|
|
|
}
|
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
2008-07-09 23:37:38 +00:00
|
|
|
static void socket_shutdown(struct imap_socket *sock)
|
2008-07-09 21:29:00 +00:00
|
|
|
{
|
|
|
|
#ifndef NO_OPENSSL
|
|
|
|
if (sock->ssl) {
|
|
|
|
SSL_shutdown(sock->ssl);
|
|
|
|
SSL_free(sock->ssl);
|
|
|
|
}
|
|
|
|
#endif
|
2009-10-19 15:42:03 +00:00
|
|
|
close(sock->fd[0]);
|
|
|
|
close(sock->fd[1]);
|
2008-07-09 21:29:00 +00:00
|
|
|
}
|
|
|
|
|
2006-03-10 05:32:50 +00:00
|
|
|
/* simple line buffering */
|
2008-07-09 23:37:38 +00:00
|
|
|
static int buffer_gets(struct imap_buffer *b, char **s)
|
2006-03-10 05:32:50 +00:00
|
|
|
{
|
|
|
|
int n;
|
|
|
|
int start = b->offset;
|
|
|
|
|
|
|
|
*s = b->buf + start;
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
/* make sure we have enough data to read the \r\n sequence */
|
|
|
|
if (b->offset + 1 >= b->bytes) {
|
|
|
|
if (start) {
|
|
|
|
/* shift down used bytes */
|
|
|
|
*s = b->buf;
|
|
|
|
|
2008-07-09 21:29:01 +00:00
|
|
|
assert(start <= b->bytes);
|
2006-03-10 05:32:50 +00:00
|
|
|
n = b->bytes - start;
|
|
|
|
|
|
|
|
if (n)
|
2006-10-31 01:39:17 +00:00
|
|
|
memmove(b->buf, b->buf + start, n);
|
2006-03-10 05:32:50 +00:00
|
|
|
b->offset -= start;
|
|
|
|
b->bytes = n;
|
|
|
|
start = 0;
|
|
|
|
}
|
|
|
|
|
2008-07-09 21:29:01 +00:00
|
|
|
n = socket_read(&b->sock, b->buf + b->bytes,
|
|
|
|
sizeof(b->buf) - b->bytes);
|
2006-03-10 05:32:50 +00:00
|
|
|
|
|
|
|
if (n <= 0)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
b->bytes += n;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (b->buf[b->offset] == '\r') {
|
2008-07-09 21:29:01 +00:00
|
|
|
assert(b->offset + 1 < b->bytes);
|
2006-03-10 05:32:50 +00:00
|
|
|
if (b->buf[b->offset + 1] == '\n') {
|
|
|
|
b->buf[b->offset] = 0; /* terminate the string */
|
|
|
|
b->offset += 2; /* next line */
|
2014-11-05 14:29:21 +00:00
|
|
|
if (0 < verbosity)
|
2008-07-09 21:29:01 +00:00
|
|
|
puts(*s);
|
2006-03-10 05:32:50 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
b->offset++;
|
|
|
|
}
|
|
|
|
/* not reached */
|
|
|
|
}
|
|
|
|
|
2008-07-09 21:29:01 +00:00
|
|
|
static void imap_info(const char *msg, ...)
|
2006-03-10 05:32:50 +00:00
|
|
|
{
|
|
|
|
va_list va;
|
|
|
|
|
2014-11-05 14:29:21 +00:00
|
|
|
if (0 <= verbosity) {
|
2008-07-09 21:29:01 +00:00
|
|
|
va_start(va, msg);
|
|
|
|
vprintf(msg, va);
|
|
|
|
va_end(va);
|
|
|
|
fflush(stdout);
|
2006-03-10 05:32:50 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-07-09 21:29:01 +00:00
|
|
|
static void imap_warn(const char *msg, ...)
|
2006-03-10 05:32:50 +00:00
|
|
|
{
|
|
|
|
va_list va;
|
|
|
|
|
2014-11-05 14:29:21 +00:00
|
|
|
if (-2 < verbosity) {
|
2008-07-09 21:29:01 +00:00
|
|
|
va_start(va, msg);
|
|
|
|
vfprintf(stderr, msg, va);
|
|
|
|
va_end(va);
|
2006-03-10 05:32:50 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-07-09 21:29:01 +00:00
|
|
|
static char *next_arg(char **s)
|
2006-03-10 05:32:50 +00:00
|
|
|
{
|
|
|
|
char *ret;
|
|
|
|
|
|
|
|
if (!s || !*s)
|
2006-04-02 11:13:01 +00:00
|
|
|
return NULL;
|
2008-07-09 21:29:01 +00:00
|
|
|
while (isspace((unsigned char) **s))
|
2006-03-10 05:32:50 +00:00
|
|
|
(*s)++;
|
|
|
|
if (!**s) {
|
2006-04-02 11:13:01 +00:00
|
|
|
*s = NULL;
|
|
|
|
return NULL;
|
2006-03-10 05:32:50 +00:00
|
|
|
}
|
|
|
|
if (**s == '"') {
|
|
|
|
++*s;
|
|
|
|
ret = *s;
|
2008-07-09 21:29:01 +00:00
|
|
|
*s = strchr(*s, '"');
|
2006-03-10 05:32:50 +00:00
|
|
|
} else {
|
|
|
|
ret = *s;
|
2008-07-09 21:29:01 +00:00
|
|
|
while (**s && !isspace((unsigned char) **s))
|
2006-03-10 05:32:50 +00:00
|
|
|
(*s)++;
|
|
|
|
}
|
|
|
|
if (*s) {
|
|
|
|
if (**s)
|
|
|
|
*(*s)++ = 0;
|
|
|
|
if (!**s)
|
2006-04-02 11:13:01 +00:00
|
|
|
*s = NULL;
|
2006-03-10 05:32:50 +00:00
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-07-09 21:29:01 +00:00
|
|
|
static int nfsnprintf(char *buf, int blen, const char *fmt, ...)
|
2006-03-10 05:32:50 +00:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
va_list va;
|
|
|
|
|
2008-07-09 21:29:01 +00:00
|
|
|
va_start(va, fmt);
|
|
|
|
if (blen <= 0 || (unsigned)(ret = vsnprintf(buf, blen, fmt, va)) >= (unsigned)blen)
|
2016-07-26 16:05:50 +00:00
|
|
|
die("BUG: buffer too small. Please report a bug.");
|
2008-07-09 21:29:01 +00:00
|
|
|
va_end(va);
|
2006-03-10 05:32:50 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-08-01 08:15:52 +00:00
|
|
|
static struct imap_cmd *issue_imap_cmd(struct imap_store *ctx,
|
|
|
|
struct imap_cmd_cb *cb,
|
|
|
|
const char *fmt, va_list ap)
|
2006-03-10 05:32:50 +00:00
|
|
|
{
|
2008-07-09 23:37:38 +00:00
|
|
|
struct imap *imap = ctx->imap;
|
2006-03-10 05:32:50 +00:00
|
|
|
struct imap_cmd *cmd;
|
|
|
|
int n, bufl;
|
|
|
|
char buf[1024];
|
|
|
|
|
2008-07-09 21:29:01 +00:00
|
|
|
cmd = xmalloc(sizeof(struct imap_cmd));
|
|
|
|
nfvasprintf(&cmd->cmd, fmt, ap);
|
2006-03-10 05:32:50 +00:00
|
|
|
cmd->tag = ++imap->nexttag;
|
|
|
|
|
|
|
|
if (cb)
|
|
|
|
cmd->cb = *cb;
|
|
|
|
else
|
2008-07-09 21:29:01 +00:00
|
|
|
memset(&cmd->cb, 0, sizeof(cmd->cb));
|
2006-03-10 05:32:50 +00:00
|
|
|
|
|
|
|
while (imap->literal_pending)
|
2008-07-09 21:29:01 +00:00
|
|
|
get_cmd_result(ctx, NULL);
|
2006-03-10 05:32:50 +00:00
|
|
|
|
2010-08-07 23:09:45 +00:00
|
|
|
if (!cmd->cb.data)
|
|
|
|
bufl = nfsnprintf(buf, sizeof(buf), "%d %s\r\n", cmd->tag, cmd->cmd);
|
|
|
|
else
|
|
|
|
bufl = nfsnprintf(buf, sizeof(buf), "%d %s{%d%s}\r\n",
|
|
|
|
cmd->tag, cmd->cmd, cmd->cb.dlen,
|
|
|
|
CAP(LITERALPLUS) ? "+" : "");
|
2006-03-10 05:32:50 +00:00
|
|
|
|
2014-11-05 14:29:21 +00:00
|
|
|
if (0 < verbosity) {
|
2006-03-10 05:32:50 +00:00
|
|
|
if (imap->num_in_progress)
|
2008-07-09 21:29:01 +00:00
|
|
|
printf("(%d in progress) ", imap->num_in_progress);
|
2014-08-30 16:14:24 +00:00
|
|
|
if (!starts_with(cmd->cmd, "LOGIN"))
|
2008-07-09 21:29:01 +00:00
|
|
|
printf(">>> %s", buf);
|
2006-03-10 05:32:50 +00:00
|
|
|
else
|
2008-07-09 21:29:01 +00:00
|
|
|
printf(">>> %d LOGIN <user> <pass>\n", cmd->tag);
|
2006-03-10 05:32:50 +00:00
|
|
|
}
|
2008-07-09 21:29:01 +00:00
|
|
|
if (socket_write(&imap->buf.sock, buf, bufl) != bufl) {
|
|
|
|
free(cmd->cmd);
|
|
|
|
free(cmd);
|
Avoid unnecessary "if-before-free" tests.
This change removes all obvious useless if-before-free tests.
E.g., it replaces code like this:
if (some_expression)
free (some_expression);
with the now-equivalent:
free (some_expression);
It is equivalent not just because POSIX has required free(NULL)
to work for a long time, but simply because it has worked for
so long that no reasonable porting target fails the test.
Here's some evidence from nearly 1.5 years ago:
http://www.winehq.org/pipermail/wine-patches/2006-October/031544.html
FYI, the change below was prepared by running the following:
git ls-files -z | xargs -0 \
perl -0x3b -pi -e \
's/\bif\s*\(\s*(\S+?)(?:\s*!=\s*NULL)?\s*\)\s+(free\s*\(\s*\1\s*\))/$2/s'
Note however, that it doesn't handle brace-enclosed blocks like
"if (x) { free (x); }". But that's ok, since there were none like
that in git sources.
Beware: if you do use the above snippet, note that it can
produce syntactically invalid C code. That happens when the
affected "if"-statement has a matching "else".
E.g., it would transform this
if (x)
free (x);
else
foo ();
into this:
free (x);
else
foo ();
There were none of those here, either.
If you're interested in automating detection of the useless
tests, you might like the useless-if-before-free script in gnulib:
[it *does* detect brace-enclosed free statements, and has a --name=S
option to make it detect free-like functions with different names]
http://git.sv.gnu.org/gitweb/?p=gnulib.git;a=blob;f=build-aux/useless-if-before-free
Addendum:
Remove one more (in imap-send.c), spotted by Jean-Luc Herren <jlh@gmx.ch>.
Signed-off-by: Jim Meyering <meyering@redhat.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-01-31 17:26:32 +00:00
|
|
|
if (cb)
|
2008-07-09 21:29:01 +00:00
|
|
|
free(cb->data);
|
2006-03-10 05:32:50 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
if (cmd->cb.data) {
|
|
|
|
if (CAP(LITERALPLUS)) {
|
2008-07-09 21:29:01 +00:00
|
|
|
n = socket_write(&imap->buf.sock, cmd->cb.data, cmd->cb.dlen);
|
|
|
|
free(cmd->cb.data);
|
2006-03-10 05:32:50 +00:00
|
|
|
if (n != cmd->cb.dlen ||
|
2009-03-13 12:51:33 +00:00
|
|
|
socket_write(&imap->buf.sock, "\r\n", 2) != 2) {
|
2008-07-09 21:29:01 +00:00
|
|
|
free(cmd->cmd);
|
|
|
|
free(cmd);
|
2006-03-10 05:32:50 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
2006-04-02 11:13:01 +00:00
|
|
|
cmd->cb.data = NULL;
|
2006-03-10 05:32:50 +00:00
|
|
|
} else
|
|
|
|
imap->literal_pending = 1;
|
|
|
|
} else if (cmd->cb.cont)
|
|
|
|
imap->literal_pending = 1;
|
2006-04-02 11:13:01 +00:00
|
|
|
cmd->next = NULL;
|
2006-03-10 05:32:50 +00:00
|
|
|
*imap->in_progress_append = cmd;
|
|
|
|
imap->in_progress_append = &cmd->next;
|
|
|
|
imap->num_in_progress++;
|
|
|
|
return cmd;
|
|
|
|
}
|
|
|
|
|
2009-11-14 21:33:13 +00:00
|
|
|
__attribute__((format (printf, 3, 4)))
|
2008-07-09 23:37:38 +00:00
|
|
|
static int imap_exec(struct imap_store *ctx, struct imap_cmd_cb *cb,
|
2008-07-09 21:29:01 +00:00
|
|
|
const char *fmt, ...)
|
2006-03-10 05:32:50 +00:00
|
|
|
{
|
|
|
|
va_list ap;
|
|
|
|
struct imap_cmd *cmdp;
|
|
|
|
|
2008-07-09 21:29:01 +00:00
|
|
|
va_start(ap, fmt);
|
2014-08-01 08:15:52 +00:00
|
|
|
cmdp = issue_imap_cmd(ctx, cb, fmt, ap);
|
2008-07-09 21:29:01 +00:00
|
|
|
va_end(ap);
|
2006-03-10 05:32:50 +00:00
|
|
|
if (!cmdp)
|
|
|
|
return RESP_BAD;
|
|
|
|
|
2008-07-09 21:29:01 +00:00
|
|
|
return get_cmd_result(ctx, cmdp);
|
2006-03-10 05:32:50 +00:00
|
|
|
}
|
|
|
|
|
2009-11-14 21:33:13 +00:00
|
|
|
__attribute__((format (printf, 3, 4)))
|
2008-07-09 23:37:38 +00:00
|
|
|
static int imap_exec_m(struct imap_store *ctx, struct imap_cmd_cb *cb,
|
2008-07-09 21:29:01 +00:00
|
|
|
const char *fmt, ...)
|
2006-03-10 05:32:50 +00:00
|
|
|
{
|
|
|
|
va_list ap;
|
|
|
|
struct imap_cmd *cmdp;
|
|
|
|
|
2008-07-09 21:29:01 +00:00
|
|
|
va_start(ap, fmt);
|
2014-08-01 08:15:52 +00:00
|
|
|
cmdp = issue_imap_cmd(ctx, cb, fmt, ap);
|
2008-07-09 21:29:01 +00:00
|
|
|
va_end(ap);
|
2006-03-10 05:32:50 +00:00
|
|
|
if (!cmdp)
|
|
|
|
return DRV_STORE_BAD;
|
|
|
|
|
2008-07-09 21:29:01 +00:00
|
|
|
switch (get_cmd_result(ctx, cmdp)) {
|
2006-03-10 05:32:50 +00:00
|
|
|
case RESP_BAD: return DRV_STORE_BAD;
|
|
|
|
case RESP_NO: return DRV_MSG_BAD;
|
|
|
|
default: return DRV_OK;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-01-15 08:06:27 +00:00
|
|
|
static int skip_imap_list_l(char **sp, int level)
|
2006-03-10 05:32:50 +00:00
|
|
|
{
|
2013-01-15 08:06:27 +00:00
|
|
|
char *s = *sp;
|
2006-03-10 05:32:50 +00:00
|
|
|
|
|
|
|
for (;;) {
|
2008-07-09 21:29:01 +00:00
|
|
|
while (isspace((unsigned char)*s))
|
2006-03-10 05:32:50 +00:00
|
|
|
s++;
|
|
|
|
if (level && *s == ')') {
|
|
|
|
s++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (*s == '(') {
|
|
|
|
/* sublist */
|
|
|
|
s++;
|
2013-01-15 08:06:27 +00:00
|
|
|
if (skip_imap_list_l(&s, level + 1))
|
2006-03-10 05:32:50 +00:00
|
|
|
goto bail;
|
|
|
|
} else if (*s == '"') {
|
|
|
|
/* quoted string */
|
|
|
|
s++;
|
|
|
|
for (; *s != '"'; s++)
|
|
|
|
if (!*s)
|
|
|
|
goto bail;
|
|
|
|
s++;
|
|
|
|
} else {
|
|
|
|
/* atom */
|
2008-07-09 21:29:01 +00:00
|
|
|
for (; *s && !isspace((unsigned char)*s); s++)
|
2006-03-10 05:32:50 +00:00
|
|
|
if (level && *s == ')')
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!level)
|
|
|
|
break;
|
|
|
|
if (!*s)
|
|
|
|
goto bail;
|
|
|
|
}
|
|
|
|
*sp = s;
|
|
|
|
return 0;
|
|
|
|
|
2008-07-09 23:37:38 +00:00
|
|
|
bail:
|
2006-03-10 05:32:50 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2013-01-15 08:06:27 +00:00
|
|
|
static void skip_list(char **sp)
|
2006-03-10 05:32:50 +00:00
|
|
|
{
|
2013-01-15 08:06:27 +00:00
|
|
|
skip_imap_list_l(sp, 0);
|
2006-03-10 05:32:50 +00:00
|
|
|
}
|
|
|
|
|
2008-07-09 23:37:38 +00:00
|
|
|
static void parse_capability(struct imap *imap, char *cmd)
|
2006-03-10 05:32:50 +00:00
|
|
|
{
|
|
|
|
char *arg;
|
|
|
|
unsigned i;
|
|
|
|
|
|
|
|
imap->caps = 0x80000000;
|
2008-07-09 21:29:01 +00:00
|
|
|
while ((arg = next_arg(&cmd)))
|
2006-03-10 05:32:50 +00:00
|
|
|
for (i = 0; i < ARRAY_SIZE(cap_list); i++)
|
2008-07-09 21:29:01 +00:00
|
|
|
if (!strcmp(cap_list[i], arg))
|
2006-03-10 05:32:50 +00:00
|
|
|
imap->caps |= 1 << i;
|
|
|
|
imap->rcaps = imap->caps;
|
|
|
|
}
|
|
|
|
|
2008-07-09 23:37:38 +00:00
|
|
|
static int parse_response_code(struct imap_store *ctx, struct imap_cmd_cb *cb,
|
2008-07-09 21:29:01 +00:00
|
|
|
char *s)
|
2006-03-10 05:32:50 +00:00
|
|
|
{
|
2008-07-09 23:37:38 +00:00
|
|
|
struct imap *imap = ctx->imap;
|
2006-03-10 05:32:50 +00:00
|
|
|
char *arg, *p;
|
|
|
|
|
|
|
|
if (*s != '[')
|
|
|
|
return RESP_OK; /* no response code */
|
|
|
|
s++;
|
2008-07-09 21:29:01 +00:00
|
|
|
if (!(p = strchr(s, ']'))) {
|
|
|
|
fprintf(stderr, "IMAP error: malformed response code\n");
|
2006-03-10 05:32:50 +00:00
|
|
|
return RESP_BAD;
|
|
|
|
}
|
|
|
|
*p++ = 0;
|
2008-07-09 21:29:01 +00:00
|
|
|
arg = next_arg(&s);
|
|
|
|
if (!strcmp("UIDVALIDITY", arg)) {
|
2013-01-15 08:06:31 +00:00
|
|
|
if (!(arg = next_arg(&s)) || !(ctx->uidvalidity = atoi(arg))) {
|
2008-07-09 21:29:01 +00:00
|
|
|
fprintf(stderr, "IMAP error: malformed UIDVALIDITY status\n");
|
2006-03-10 05:32:50 +00:00
|
|
|
return RESP_BAD;
|
|
|
|
}
|
2008-07-09 21:29:01 +00:00
|
|
|
} else if (!strcmp("UIDNEXT", arg)) {
|
|
|
|
if (!(arg = next_arg(&s)) || !(imap->uidnext = atoi(arg))) {
|
|
|
|
fprintf(stderr, "IMAP error: malformed NEXTUID status\n");
|
2006-03-10 05:32:50 +00:00
|
|
|
return RESP_BAD;
|
|
|
|
}
|
2008-07-09 21:29:01 +00:00
|
|
|
} else if (!strcmp("CAPABILITY", arg)) {
|
|
|
|
parse_capability(imap, s);
|
|
|
|
} else if (!strcmp("ALERT", arg)) {
|
2006-03-10 05:32:50 +00:00
|
|
|
/* RFC2060 says that these messages MUST be displayed
|
|
|
|
* to the user
|
|
|
|
*/
|
2008-07-09 21:29:01 +00:00
|
|
|
for (; isspace((unsigned char)*p); p++);
|
|
|
|
fprintf(stderr, "*** IMAP ALERT *** %s\n", p);
|
|
|
|
} else if (cb && cb->ctx && !strcmp("APPENDUID", arg)) {
|
2013-01-15 08:06:31 +00:00
|
|
|
if (!(arg = next_arg(&s)) || !(ctx->uidvalidity = atoi(arg)) ||
|
2008-07-09 23:37:38 +00:00
|
|
|
!(arg = next_arg(&s)) || !(*(int *)cb->ctx = atoi(arg))) {
|
2008-07-09 21:29:01 +00:00
|
|
|
fprintf(stderr, "IMAP error: malformed APPENDUID status\n");
|
2006-03-10 05:32:50 +00:00
|
|
|
return RESP_BAD;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return RESP_OK;
|
|
|
|
}
|
|
|
|
|
2008-07-09 23:37:38 +00:00
|
|
|
static int get_cmd_result(struct imap_store *ctx, struct imap_cmd *tcmd)
|
2006-03-10 05:32:50 +00:00
|
|
|
{
|
2008-07-09 23:37:38 +00:00
|
|
|
struct imap *imap = ctx->imap;
|
2014-08-01 08:15:52 +00:00
|
|
|
struct imap_cmd *cmdp, **pcmdp;
|
|
|
|
char *cmd, *arg, *arg1;
|
2006-03-10 05:32:50 +00:00
|
|
|
int n, resp, resp2, tag;
|
|
|
|
|
|
|
|
for (;;) {
|
2008-07-09 21:29:01 +00:00
|
|
|
if (buffer_gets(&imap->buf, &cmd))
|
2006-03-10 05:32:50 +00:00
|
|
|
return RESP_BAD;
|
|
|
|
|
2008-07-09 21:29:01 +00:00
|
|
|
arg = next_arg(&cmd);
|
2006-03-10 05:32:50 +00:00
|
|
|
if (*arg == '*') {
|
2008-07-09 21:29:01 +00:00
|
|
|
arg = next_arg(&cmd);
|
2006-03-10 05:32:50 +00:00
|
|
|
if (!arg) {
|
2008-07-09 21:29:01 +00:00
|
|
|
fprintf(stderr, "IMAP error: unable to parse untagged response\n");
|
2006-03-10 05:32:50 +00:00
|
|
|
return RESP_BAD;
|
|
|
|
}
|
|
|
|
|
2008-07-09 21:29:01 +00:00
|
|
|
if (!strcmp("NAMESPACE", arg)) {
|
2013-01-15 08:06:27 +00:00
|
|
|
/* rfc2342 NAMESPACE response. */
|
|
|
|
skip_list(&cmd); /* Personal mailboxes */
|
|
|
|
skip_list(&cmd); /* Others' mailboxes */
|
|
|
|
skip_list(&cmd); /* Shared mailboxes */
|
2008-07-09 21:29:01 +00:00
|
|
|
} else if (!strcmp("OK", arg) || !strcmp("BAD", arg) ||
|
|
|
|
!strcmp("NO", arg) || !strcmp("BYE", arg)) {
|
|
|
|
if ((resp = parse_response_code(ctx, NULL, cmd)) != RESP_OK)
|
2006-03-10 05:32:50 +00:00
|
|
|
return resp;
|
2013-01-15 08:06:24 +00:00
|
|
|
} else if (!strcmp("CAPABILITY", arg)) {
|
2008-07-09 21:29:01 +00:00
|
|
|
parse_capability(imap, cmd);
|
2013-01-15 08:06:24 +00:00
|
|
|
} else if ((arg1 = next_arg(&cmd))) {
|
|
|
|
; /*
|
|
|
|
* Unhandled response-data with at least two words.
|
|
|
|
* Ignore it.
|
|
|
|
*
|
|
|
|
* NEEDSWORK: Previously this case handled '<num> EXISTS'
|
|
|
|
* and '<num> RECENT' but as a probably-unintended side
|
|
|
|
* effect it ignores other unrecognized two-word
|
|
|
|
* responses. imap-send doesn't ever try to read
|
|
|
|
* messages or mailboxes these days, so consider
|
|
|
|
* eliminating this case.
|
|
|
|
*/
|
2006-03-10 05:32:50 +00:00
|
|
|
} else {
|
2008-07-09 21:29:01 +00:00
|
|
|
fprintf(stderr, "IMAP error: unable to parse untagged response\n");
|
2006-03-10 05:32:50 +00:00
|
|
|
return RESP_BAD;
|
|
|
|
}
|
|
|
|
} else if (!imap->in_progress) {
|
2008-07-09 21:29:01 +00:00
|
|
|
fprintf(stderr, "IMAP error: unexpected reply: %s %s\n", arg, cmd ? cmd : "");
|
2006-03-10 05:32:50 +00:00
|
|
|
return RESP_BAD;
|
|
|
|
} else if (*arg == '+') {
|
|
|
|
/* This can happen only with the last command underway, as
|
|
|
|
it enforces a round-trip. */
|
|
|
|
cmdp = (struct imap_cmd *)((char *)imap->in_progress_append -
|
|
|
|
offsetof(struct imap_cmd, next));
|
|
|
|
if (cmdp->cb.data) {
|
2008-07-09 21:29:01 +00:00
|
|
|
n = socket_write(&imap->buf.sock, cmdp->cb.data, cmdp->cb.dlen);
|
|
|
|
free(cmdp->cb.data);
|
2006-04-02 11:13:01 +00:00
|
|
|
cmdp->cb.data = NULL;
|
2006-03-10 05:32:50 +00:00
|
|
|
if (n != (int)cmdp->cb.dlen)
|
|
|
|
return RESP_BAD;
|
|
|
|
} else if (cmdp->cb.cont) {
|
2008-07-09 21:29:01 +00:00
|
|
|
if (cmdp->cb.cont(ctx, cmdp, cmd))
|
2006-03-10 05:32:50 +00:00
|
|
|
return RESP_BAD;
|
|
|
|
} else {
|
2008-07-09 21:29:01 +00:00
|
|
|
fprintf(stderr, "IMAP error: unexpected command continuation request\n");
|
2006-03-10 05:32:50 +00:00
|
|
|
return RESP_BAD;
|
|
|
|
}
|
2008-07-09 21:29:01 +00:00
|
|
|
if (socket_write(&imap->buf.sock, "\r\n", 2) != 2)
|
2006-03-10 05:32:50 +00:00
|
|
|
return RESP_BAD;
|
|
|
|
if (!cmdp->cb.cont)
|
|
|
|
imap->literal_pending = 0;
|
|
|
|
if (!tcmd)
|
|
|
|
return DRV_OK;
|
|
|
|
} else {
|
2008-07-09 21:29:01 +00:00
|
|
|
tag = atoi(arg);
|
2006-03-10 05:32:50 +00:00
|
|
|
for (pcmdp = &imap->in_progress; (cmdp = *pcmdp); pcmdp = &cmdp->next)
|
|
|
|
if (cmdp->tag == tag)
|
|
|
|
goto gottag;
|
2008-07-09 21:29:01 +00:00
|
|
|
fprintf(stderr, "IMAP error: unexpected tag %s\n", arg);
|
2006-03-10 05:32:50 +00:00
|
|
|
return RESP_BAD;
|
2008-07-09 23:37:38 +00:00
|
|
|
gottag:
|
2006-03-10 05:32:50 +00:00
|
|
|
if (!(*pcmdp = cmdp->next))
|
|
|
|
imap->in_progress_append = pcmdp;
|
|
|
|
imap->num_in_progress--;
|
|
|
|
if (cmdp->cb.cont || cmdp->cb.data)
|
|
|
|
imap->literal_pending = 0;
|
2008-07-09 21:29:01 +00:00
|
|
|
arg = next_arg(&cmd);
|
|
|
|
if (!strcmp("OK", arg))
|
2006-03-10 05:32:50 +00:00
|
|
|
resp = DRV_OK;
|
|
|
|
else {
|
2014-08-01 08:15:52 +00:00
|
|
|
if (!strcmp("NO", arg))
|
2006-03-10 05:32:50 +00:00
|
|
|
resp = RESP_NO;
|
2014-08-01 08:15:52 +00:00
|
|
|
else /*if (!strcmp("BAD", arg))*/
|
2006-03-10 05:32:50 +00:00
|
|
|
resp = RESP_BAD;
|
2008-07-09 21:29:01 +00:00
|
|
|
fprintf(stderr, "IMAP command '%s' returned response (%s) - %s\n",
|
2014-08-30 16:14:24 +00:00
|
|
|
!starts_with(cmdp->cmd, "LOGIN") ?
|
2006-03-10 05:32:50 +00:00
|
|
|
cmdp->cmd : "LOGIN <user> <pass>",
|
|
|
|
arg, cmd ? cmd : "");
|
|
|
|
}
|
2008-07-09 21:29:01 +00:00
|
|
|
if ((resp2 = parse_response_code(ctx, &cmdp->cb, cmd)) > resp)
|
2006-03-10 05:32:50 +00:00
|
|
|
resp = resp2;
|
|
|
|
if (cmdp->cb.done)
|
2008-07-09 21:29:01 +00:00
|
|
|
cmdp->cb.done(ctx, cmdp, resp);
|
|
|
|
free(cmdp->cb.data);
|
|
|
|
free(cmdp->cmd);
|
|
|
|
free(cmdp);
|
2006-03-10 05:32:50 +00:00
|
|
|
if (!tcmd || tcmd == cmdp)
|
|
|
|
return resp;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* not reached */
|
|
|
|
}
|
|
|
|
|
2008-07-09 23:37:38 +00:00
|
|
|
static void imap_close_server(struct imap_store *ictx)
|
2006-03-10 05:32:50 +00:00
|
|
|
{
|
2008-07-09 23:37:38 +00:00
|
|
|
struct imap *imap = ictx->imap;
|
2006-03-10 05:32:50 +00:00
|
|
|
|
2009-10-19 15:42:03 +00:00
|
|
|
if (imap->buf.sock.fd[0] != -1) {
|
2008-07-09 21:29:01 +00:00
|
|
|
imap_exec(ictx, NULL, "LOGOUT");
|
|
|
|
socket_shutdown(&imap->buf.sock);
|
2006-03-10 05:32:50 +00:00
|
|
|
}
|
2008-07-09 21:29:01 +00:00
|
|
|
free(imap);
|
2006-03-10 05:32:50 +00:00
|
|
|
}
|
|
|
|
|
2013-01-15 08:06:29 +00:00
|
|
|
static void imap_close_store(struct imap_store *ctx)
|
2006-03-10 05:32:50 +00:00
|
|
|
{
|
2013-01-15 08:06:29 +00:00
|
|
|
imap_close_server(ctx);
|
2008-07-09 21:29:01 +00:00
|
|
|
free(ctx);
|
2006-03-10 05:32:50 +00:00
|
|
|
}
|
|
|
|
|
2010-02-16 06:34:07 +00:00
|
|
|
#ifndef NO_OPENSSL
|
|
|
|
|
|
|
|
/*
|
|
|
|
* hexchar() and cram() functions are based on the code from the isync
|
|
|
|
* project (http://isync.sf.net/).
|
|
|
|
*/
|
|
|
|
static char hexchar(unsigned int b)
|
2006-03-10 05:32:50 +00:00
|
|
|
{
|
2010-02-16 06:34:07 +00:00
|
|
|
return b < 10 ? '0' + b : 'a' + (b - 10);
|
2006-03-10 05:32:50 +00:00
|
|
|
}
|
|
|
|
|
2010-02-16 06:34:07 +00:00
|
|
|
#define ENCODED_SIZE(n) (4*((n+2)/3))
|
|
|
|
static char *cram(const char *challenge_64, const char *user, const char *pass)
|
2006-03-10 05:32:50 +00:00
|
|
|
{
|
2010-02-16 06:34:07 +00:00
|
|
|
int i, resp_len, encoded_len, decoded_len;
|
|
|
|
unsigned char hash[16];
|
|
|
|
char hex[33];
|
|
|
|
char *response, *response_64, *challenge;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* length of challenge_64 (i.e. base-64 encoded string) is a good
|
|
|
|
* enough upper bound for challenge (decoded result).
|
|
|
|
*/
|
|
|
|
encoded_len = strlen(challenge_64);
|
|
|
|
challenge = xmalloc(encoded_len);
|
|
|
|
decoded_len = EVP_DecodeBlock((unsigned char *)challenge,
|
|
|
|
(unsigned char *)challenge_64, encoded_len);
|
|
|
|
if (decoded_len < 0)
|
|
|
|
die("invalid challenge %s", challenge_64);
|
2016-04-08 16:22:13 +00:00
|
|
|
if (!HMAC(EVP_md5(), pass, strlen(pass), (unsigned char *)challenge, decoded_len, hash, NULL))
|
|
|
|
die("HMAC error");
|
2010-02-16 06:34:07 +00:00
|
|
|
|
|
|
|
hex[32] = 0;
|
|
|
|
for (i = 0; i < 16; i++) {
|
|
|
|
hex[2 * i] = hexchar((hash[i] >> 4) & 0xf);
|
|
|
|
hex[2 * i + 1] = hexchar(hash[i] & 0xf);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* response: "<user> <digest in hex>" */
|
2015-09-24 21:07:03 +00:00
|
|
|
response = xstrfmt("%s %s", user, hex);
|
2016-04-08 14:02:30 +00:00
|
|
|
resp_len = strlen(response);
|
2010-02-16 06:34:07 +00:00
|
|
|
|
2016-02-22 22:44:28 +00:00
|
|
|
response_64 = xmallocz(ENCODED_SIZE(resp_len));
|
2010-02-16 06:34:07 +00:00
|
|
|
encoded_len = EVP_EncodeBlock((unsigned char *)response_64,
|
|
|
|
(unsigned char *)response, resp_len);
|
|
|
|
if (encoded_len < 0)
|
|
|
|
die("EVP_EncodeBlock error");
|
|
|
|
return (char *)response_64;
|
|
|
|
}
|
|
|
|
|
|
|
|
#else
|
|
|
|
|
|
|
|
static char *cram(const char *challenge_64, const char *user, const char *pass)
|
|
|
|
{
|
|
|
|
die("If you want to use CRAM-MD5 authenticate method, "
|
|
|
|
"you have to build git-imap-send with OpenSSL library.");
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static int auth_cram_md5(struct imap_store *ctx, struct imap_cmd *cmd, const char *prompt)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
char *response;
|
|
|
|
|
|
|
|
response = cram(prompt, server.user, server.pass);
|
|
|
|
|
|
|
|
ret = socket_write(&ctx->imap->buf.sock, response, strlen(response));
|
|
|
|
if (ret != strlen(response))
|
2012-04-30 00:28:45 +00:00
|
|
|
return error("IMAP error: sending response failed");
|
2010-02-16 06:34:07 +00:00
|
|
|
|
|
|
|
free(response);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-08-01 08:15:52 +00:00
|
|
|
static struct imap_store *imap_open_store(struct imap_server_conf *srvc, char *folder)
|
2006-03-10 05:32:50 +00:00
|
|
|
{
|
2014-04-29 03:00:04 +00:00
|
|
|
struct credential cred = CREDENTIAL_INIT;
|
2008-07-09 23:37:38 +00:00
|
|
|
struct imap_store *ctx;
|
|
|
|
struct imap *imap;
|
2006-03-10 05:32:50 +00:00
|
|
|
char *arg, *rsp;
|
2009-10-19 15:42:04 +00:00
|
|
|
int s = -1, preauth;
|
2006-03-10 05:32:50 +00:00
|
|
|
|
2014-05-26 15:33:51 +00:00
|
|
|
ctx = xcalloc(1, sizeof(*ctx));
|
2006-03-10 05:32:50 +00:00
|
|
|
|
2014-08-30 06:54:23 +00:00
|
|
|
ctx->imap = imap = xcalloc(1, sizeof(*imap));
|
2009-10-19 15:42:03 +00:00
|
|
|
imap->buf.sock.fd[0] = imap->buf.sock.fd[1] = -1;
|
2006-03-10 05:32:50 +00:00
|
|
|
imap->in_progress_append = &imap->in_progress;
|
|
|
|
|
|
|
|
/* open connection to IMAP server */
|
|
|
|
|
|
|
|
if (srvc->tunnel) {
|
2014-08-19 19:09:35 +00:00
|
|
|
struct child_process tunnel = CHILD_PROCESS_INIT;
|
2006-03-10 05:32:50 +00:00
|
|
|
|
2009-10-19 15:42:04 +00:00
|
|
|
imap_info("Starting tunnel '%s'... ", srvc->tunnel);
|
2006-03-10 05:32:50 +00:00
|
|
|
|
2014-08-13 17:30:43 +00:00
|
|
|
argv_array_push(&tunnel.args, srvc->tunnel);
|
2009-12-30 10:53:57 +00:00
|
|
|
tunnel.use_shell = 1;
|
2009-10-19 15:42:04 +00:00
|
|
|
tunnel.in = -1;
|
|
|
|
tunnel.out = -1;
|
|
|
|
if (start_command(&tunnel))
|
2014-08-13 17:30:43 +00:00
|
|
|
die("cannot start proxy %s", srvc->tunnel);
|
2006-03-10 05:32:50 +00:00
|
|
|
|
2009-10-19 15:42:04 +00:00
|
|
|
imap->buf.sock.fd[0] = tunnel.out;
|
|
|
|
imap->buf.sock.fd[1] = tunnel.in;
|
2006-03-10 05:32:50 +00:00
|
|
|
|
2008-07-09 21:29:01 +00:00
|
|
|
imap_info("ok\n");
|
2006-03-10 05:32:50 +00:00
|
|
|
} else {
|
2009-05-25 19:13:54 +00:00
|
|
|
#ifndef NO_IPV6
|
|
|
|
struct addrinfo hints, *ai0, *ai;
|
|
|
|
int gai;
|
|
|
|
char portstr[6];
|
|
|
|
|
2017-03-28 19:46:56 +00:00
|
|
|
xsnprintf(portstr, sizeof(portstr), "%d", srvc->port);
|
2009-05-25 19:13:54 +00:00
|
|
|
|
|
|
|
memset(&hints, 0, sizeof(hints));
|
|
|
|
hints.ai_socktype = SOCK_STREAM;
|
|
|
|
hints.ai_protocol = IPPROTO_TCP;
|
2006-03-10 05:32:50 +00:00
|
|
|
|
2009-05-25 19:13:54 +00:00
|
|
|
imap_info("Resolving %s... ", srvc->host);
|
|
|
|
gai = getaddrinfo(srvc->host, portstr, &hints, &ai);
|
|
|
|
if (gai) {
|
|
|
|
fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(gai));
|
|
|
|
goto bail;
|
2006-03-10 05:32:50 +00:00
|
|
|
}
|
2009-05-25 19:13:54 +00:00
|
|
|
imap_info("ok\n");
|
2006-03-10 05:32:50 +00:00
|
|
|
|
2009-05-25 19:13:54 +00:00
|
|
|
for (ai0 = ai; ai; ai = ai->ai_next) {
|
|
|
|
char addr[NI_MAXHOST];
|
2006-03-10 05:32:50 +00:00
|
|
|
|
2009-05-25 19:13:54 +00:00
|
|
|
s = socket(ai->ai_family, ai->ai_socktype,
|
|
|
|
ai->ai_protocol);
|
|
|
|
if (s < 0)
|
|
|
|
continue;
|
2006-03-10 05:32:50 +00:00
|
|
|
|
2009-05-25 19:13:54 +00:00
|
|
|
getnameinfo(ai->ai_addr, ai->ai_addrlen, addr,
|
|
|
|
sizeof(addr), NULL, 0, NI_NUMERICHOST);
|
|
|
|
imap_info("Connecting to [%s]:%s... ", addr, portstr);
|
|
|
|
|
|
|
|
if (connect(s, ai->ai_addr, ai->ai_addrlen) < 0) {
|
|
|
|
close(s);
|
|
|
|
s = -1;
|
|
|
|
perror("connect");
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
freeaddrinfo(ai0);
|
|
|
|
#else /* NO_IPV6 */
|
|
|
|
struct hostent *he;
|
|
|
|
struct sockaddr_in addr;
|
|
|
|
|
2008-07-09 21:29:01 +00:00
|
|
|
memset(&addr, 0, sizeof(addr));
|
|
|
|
addr.sin_port = htons(srvc->port);
|
2006-03-10 05:32:50 +00:00
|
|
|
addr.sin_family = AF_INET;
|
|
|
|
|
2008-07-09 21:29:01 +00:00
|
|
|
imap_info("Resolving %s... ", srvc->host);
|
|
|
|
he = gethostbyname(srvc->host);
|
2006-03-10 05:32:50 +00:00
|
|
|
if (!he) {
|
2008-07-09 21:29:01 +00:00
|
|
|
perror("gethostbyname");
|
2006-03-10 05:32:50 +00:00
|
|
|
goto bail;
|
|
|
|
}
|
2008-07-09 21:29:01 +00:00
|
|
|
imap_info("ok\n");
|
2006-03-10 05:32:50 +00:00
|
|
|
|
|
|
|
addr.sin_addr.s_addr = *((int *) he->h_addr_list[0]);
|
|
|
|
|
2008-07-09 21:29:01 +00:00
|
|
|
s = socket(PF_INET, SOCK_STREAM, 0);
|
2006-03-10 05:32:50 +00:00
|
|
|
|
2008-07-09 21:29:01 +00:00
|
|
|
imap_info("Connecting to %s:%hu... ", inet_ntoa(addr.sin_addr), ntohs(addr.sin_port));
|
|
|
|
if (connect(s, (struct sockaddr *)&addr, sizeof(addr))) {
|
|
|
|
close(s);
|
2009-05-25 19:13:54 +00:00
|
|
|
s = -1;
|
2008-07-09 21:29:01 +00:00
|
|
|
perror("connect");
|
2009-05-25 19:13:54 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
if (s < 0) {
|
|
|
|
fputs("Error: unable to connect to server.\n", stderr);
|
2006-03-10 05:32:50 +00:00
|
|
|
goto bail;
|
|
|
|
}
|
|
|
|
|
2009-10-19 15:42:03 +00:00
|
|
|
imap->buf.sock.fd[0] = s;
|
|
|
|
imap->buf.sock.fd[1] = dup(s);
|
2006-03-10 05:32:50 +00:00
|
|
|
|
2008-07-09 21:29:00 +00:00
|
|
|
if (srvc->use_ssl &&
|
|
|
|
ssl_socket_connect(&imap->buf.sock, 0, srvc->ssl_verify)) {
|
|
|
|
close(s);
|
|
|
|
goto bail;
|
|
|
|
}
|
2008-07-09 21:29:01 +00:00
|
|
|
imap_info("ok\n");
|
2006-03-10 05:32:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* read the greeting string */
|
2008-07-09 21:29:01 +00:00
|
|
|
if (buffer_gets(&imap->buf, &rsp)) {
|
|
|
|
fprintf(stderr, "IMAP error: no greeting response\n");
|
2006-03-10 05:32:50 +00:00
|
|
|
goto bail;
|
|
|
|
}
|
2008-07-09 21:29:01 +00:00
|
|
|
arg = next_arg(&rsp);
|
|
|
|
if (!arg || *arg != '*' || (arg = next_arg(&rsp)) == NULL) {
|
|
|
|
fprintf(stderr, "IMAP error: invalid greeting response\n");
|
2006-03-10 05:32:50 +00:00
|
|
|
goto bail;
|
|
|
|
}
|
|
|
|
preauth = 0;
|
2008-07-09 21:29:01 +00:00
|
|
|
if (!strcmp("PREAUTH", arg))
|
2006-03-10 05:32:50 +00:00
|
|
|
preauth = 1;
|
2008-07-09 21:29:01 +00:00
|
|
|
else if (strcmp("OK", arg) != 0) {
|
|
|
|
fprintf(stderr, "IMAP error: unknown greeting response\n");
|
2006-03-10 05:32:50 +00:00
|
|
|
goto bail;
|
|
|
|
}
|
2008-07-09 21:29:01 +00:00
|
|
|
parse_response_code(ctx, NULL, rsp);
|
|
|
|
if (!imap->caps && imap_exec(ctx, NULL, "CAPABILITY") != RESP_OK)
|
2006-03-10 05:32:50 +00:00
|
|
|
goto bail;
|
|
|
|
|
|
|
|
if (!preauth) {
|
2008-07-09 21:29:00 +00:00
|
|
|
#ifndef NO_OPENSSL
|
|
|
|
if (!srvc->use_ssl && CAP(STARTTLS)) {
|
2011-04-07 18:24:57 +00:00
|
|
|
if (imap_exec(ctx, NULL, "STARTTLS") != RESP_OK)
|
2008-07-09 21:29:00 +00:00
|
|
|
goto bail;
|
|
|
|
if (ssl_socket_connect(&imap->buf.sock, 1,
|
|
|
|
srvc->ssl_verify))
|
|
|
|
goto bail;
|
|
|
|
/* capabilities may have changed, so get the new capabilities */
|
2011-04-07 18:24:57 +00:00
|
|
|
if (imap_exec(ctx, NULL, "CAPABILITY") != RESP_OK)
|
2008-07-09 21:29:00 +00:00
|
|
|
goto bail;
|
|
|
|
}
|
|
|
|
#endif
|
2008-07-09 21:29:01 +00:00
|
|
|
imap_info("Logging in...\n");
|
2014-04-29 03:00:04 +00:00
|
|
|
if (!srvc->user || !srvc->pass) {
|
|
|
|
cred.protocol = xstrdup(srvc->use_ssl ? "imaps" : "imap");
|
|
|
|
cred.host = xstrdup(srvc->host);
|
|
|
|
|
2016-10-12 18:20:23 +00:00
|
|
|
cred.username = xstrdup_or_null(srvc->user);
|
|
|
|
cred.password = xstrdup_or_null(srvc->pass);
|
2014-04-29 03:00:04 +00:00
|
|
|
|
|
|
|
credential_fill(&cred);
|
|
|
|
|
|
|
|
if (!srvc->user)
|
|
|
|
srvc->user = xstrdup(cred.username);
|
|
|
|
if (!srvc->pass)
|
|
|
|
srvc->pass = xstrdup(cred.password);
|
2006-03-10 05:32:50 +00:00
|
|
|
}
|
2014-04-29 03:00:04 +00:00
|
|
|
|
2010-02-16 06:34:07 +00:00
|
|
|
if (srvc->auth_method) {
|
|
|
|
struct imap_cmd_cb cb;
|
|
|
|
|
|
|
|
if (!strcmp(srvc->auth_method, "CRAM-MD5")) {
|
|
|
|
if (!CAP(AUTH_CRAM_MD5)) {
|
|
|
|
fprintf(stderr, "You specified"
|
|
|
|
"CRAM-MD5 as authentication method, "
|
|
|
|
"but %s doesn't support it.\n", srvc->host);
|
|
|
|
goto bail;
|
|
|
|
}
|
|
|
|
/* CRAM-MD5 */
|
|
|
|
|
|
|
|
memset(&cb, 0, sizeof(cb));
|
|
|
|
cb.cont = auth_cram_md5;
|
|
|
|
if (imap_exec(ctx, &cb, "AUTHENTICATE CRAM-MD5") != RESP_OK) {
|
|
|
|
fprintf(stderr, "IMAP error: AUTHENTICATE CRAM-MD5 failed\n");
|
|
|
|
goto bail;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
fprintf(stderr, "Unknown authentication method:%s\n", srvc->host);
|
|
|
|
goto bail;
|
|
|
|
}
|
|
|
|
} else {
|
2016-04-08 14:02:24 +00:00
|
|
|
if (CAP(NOLOGIN)) {
|
|
|
|
fprintf(stderr, "Skipping account %s@%s, server forbids LOGIN\n",
|
|
|
|
srvc->user, srvc->host);
|
|
|
|
goto bail;
|
|
|
|
}
|
2010-03-27 15:00:19 +00:00
|
|
|
if (!imap->buf.sock.ssl)
|
|
|
|
imap_warn("*** IMAP Warning *** Password is being "
|
|
|
|
"sent in the clear\n");
|
2010-02-16 06:34:07 +00:00
|
|
|
if (imap_exec(ctx, NULL, "LOGIN \"%s\" \"%s\"", srvc->user, srvc->pass) != RESP_OK) {
|
|
|
|
fprintf(stderr, "IMAP error: LOGIN failed\n");
|
|
|
|
goto bail;
|
|
|
|
}
|
2006-03-10 05:32:50 +00:00
|
|
|
}
|
|
|
|
} /* !preauth */
|
|
|
|
|
2014-04-29 03:00:04 +00:00
|
|
|
if (cred.username)
|
|
|
|
credential_approve(&cred);
|
|
|
|
credential_clear(&cred);
|
|
|
|
|
2014-08-01 08:15:52 +00:00
|
|
|
/* check the target mailbox exists */
|
|
|
|
ctx->name = folder;
|
|
|
|
switch (imap_exec(ctx, NULL, "EXAMINE \"%s\"", ctx->name)) {
|
|
|
|
case RESP_OK:
|
|
|
|
/* ok */
|
|
|
|
break;
|
|
|
|
case RESP_BAD:
|
|
|
|
fprintf(stderr, "IMAP error: could not check mailbox\n");
|
|
|
|
goto out;
|
|
|
|
case RESP_NO:
|
|
|
|
if (imap_exec(ctx, NULL, "CREATE \"%s\"", ctx->name) == RESP_OK) {
|
|
|
|
imap_info("Created missing mailbox\n");
|
|
|
|
} else {
|
|
|
|
fprintf(stderr, "IMAP error: could not create missing mailbox\n");
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2006-03-10 05:32:50 +00:00
|
|
|
ctx->prefix = "";
|
2013-01-15 08:06:29 +00:00
|
|
|
return ctx;
|
2006-03-10 05:32:50 +00:00
|
|
|
|
2008-07-09 23:37:38 +00:00
|
|
|
bail:
|
2014-04-29 03:00:04 +00:00
|
|
|
if (cred.username)
|
|
|
|
credential_reject(&cred);
|
|
|
|
credential_clear(&cred);
|
|
|
|
|
2014-08-01 08:15:52 +00:00
|
|
|
out:
|
2013-01-15 08:06:29 +00:00
|
|
|
imap_close_store(ctx);
|
2006-04-02 11:13:01 +00:00
|
|
|
return NULL;
|
2006-03-10 05:32:50 +00:00
|
|
|
}
|
|
|
|
|
2013-01-15 08:06:32 +00:00
|
|
|
/*
|
|
|
|
* Insert CR characters as necessary in *msg to ensure that every LF
|
|
|
|
* character in *msg is preceded by a CR.
|
|
|
|
*/
|
imap-send: change msg_data from storing (ptr, len) to storing strbuf
struct msg_data stored (ptr, len) of the data to be included in a
message, kept the character data NUL-terminated, etc., much like a
strbuf would do. So change it to use a struct strbuf. This makes
the code clearer and reduces copying a little bit.
A side effect of this change is that the memory for each message is
freed after it is used rather than leaked, though that detail is
unimportant given that imap-send is a top-level command.
By the way, there is a bunch of infrastructure in this file for
dealing with IMAP flags, although there is nothing in the code that
actually allows any flags to be set. If there is no plan to add
support for flags in the future, a bunch of code could be ripped out
and "struct msg_data" could be completely replaced with strbuf, but
that would be a separate topic.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-11-25 11:08:39 +00:00
|
|
|
static void lf_to_crlf(struct strbuf *msg)
|
2006-03-10 05:32:50 +00:00
|
|
|
{
|
2010-02-12 11:36:12 +00:00
|
|
|
char *new;
|
2013-01-15 08:06:32 +00:00
|
|
|
size_t i, j;
|
|
|
|
char lastc;
|
|
|
|
|
|
|
|
/* First pass: tally, in j, the size of the new string: */
|
|
|
|
for (i = j = 0, lastc = '\0'; i < msg->len; i++) {
|
|
|
|
if (msg->buf[i] == '\n' && lastc != '\r')
|
|
|
|
j++; /* a CR will need to be added here */
|
|
|
|
lastc = msg->buf[i];
|
|
|
|
j++;
|
2006-03-10 05:32:50 +00:00
|
|
|
}
|
2010-02-12 11:36:12 +00:00
|
|
|
|
2016-02-22 22:44:28 +00:00
|
|
|
new = xmallocz(j);
|
2013-01-15 08:06:32 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Second pass: write the new string. Note that this loop is
|
|
|
|
* otherwise identical to the first pass.
|
|
|
|
*/
|
|
|
|
for (i = j = 0, lastc = '\0'; i < msg->len; i++) {
|
|
|
|
if (msg->buf[i] == '\n' && lastc != '\r')
|
2010-02-12 11:36:12 +00:00
|
|
|
new[j++] = '\r';
|
2013-01-15 08:06:32 +00:00
|
|
|
lastc = new[j++] = msg->buf[i];
|
2006-03-10 05:32:50 +00:00
|
|
|
}
|
2013-01-15 08:06:32 +00:00
|
|
|
strbuf_attach(msg, new, j, j + 1);
|
2010-02-12 11:36:12 +00:00
|
|
|
}
|
2006-03-10 05:32:50 +00:00
|
|
|
|
imap-send: change msg_data from storing (ptr, len) to storing strbuf
struct msg_data stored (ptr, len) of the data to be included in a
message, kept the character data NUL-terminated, etc., much like a
strbuf would do. So change it to use a struct strbuf. This makes
the code clearer and reduces copying a little bit.
A side effect of this change is that the memory for each message is
freed after it is used rather than leaked, though that detail is
unimportant given that imap-send is a top-level command.
By the way, there is a bunch of infrastructure in this file for
dealing with IMAP flags, although there is nothing in the code that
actually allows any flags to be set. If there is no plan to add
support for flags in the future, a bunch of code could be ripped out
and "struct msg_data" could be completely replaced with strbuf, but
that would be a separate topic.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-11-25 11:08:39 +00:00
|
|
|
/*
|
|
|
|
* Store msg to IMAP. Also detach and free the data from msg->data,
|
|
|
|
* leaving msg->data empty.
|
|
|
|
*/
|
2013-01-15 08:06:29 +00:00
|
|
|
static int imap_store_msg(struct imap_store *ctx, struct strbuf *msg)
|
2006-03-10 05:32:50 +00:00
|
|
|
{
|
2008-07-09 23:37:38 +00:00
|
|
|
struct imap *imap = ctx->imap;
|
2006-03-10 05:32:50 +00:00
|
|
|
struct imap_cmd_cb cb;
|
|
|
|
const char *prefix, *box;
|
2013-01-15 08:06:19 +00:00
|
|
|
int ret;
|
2006-03-10 05:32:50 +00:00
|
|
|
|
2013-01-15 08:06:20 +00:00
|
|
|
lf_to_crlf(msg);
|
2008-07-09 21:29:01 +00:00
|
|
|
memset(&cb, 0, sizeof(cb));
|
2006-03-10 05:32:50 +00:00
|
|
|
|
2013-01-15 08:06:20 +00:00
|
|
|
cb.dlen = msg->len;
|
|
|
|
cb.data = strbuf_detach(msg, NULL);
|
2006-03-10 05:32:50 +00:00
|
|
|
|
2013-01-15 08:06:31 +00:00
|
|
|
box = ctx->name;
|
imap-send: remove useless uid code
The imap-send code is based on code from isync, a program
for syncing imap mailboxes. Because of this, it has
inherited some code that makes sense for isync, but not for
imap-send.
In particular, when storing a message, it does one of:
- if the server supports it, note the server-assigned
unique identifier (UID) given to each message
- otherwise, assigned a random UID and store it in the
message header as X-TUID
Presumably this is used in isync to be able to synchronize
mailstores multiple times without duplication. But for
imap-send, the values are useless; we never do anything
with them and simply forget them at the end of the program.
This patch removes the useless code. Not only is it nice for
maintainability to get rid of dead code, but the removed
code relied on the existence of /dev/urandom, which made it
a portability problem for non-Unix platforms.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Erik Faye-Lund <kusmabite@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-10-19 15:42:02 +00:00
|
|
|
prefix = !strcmp(box, "INBOX") ? "" : ctx->prefix;
|
2013-01-15 08:06:19 +00:00
|
|
|
ret = imap_exec_m(ctx, &cb, "APPEND \"%s%s\" ", prefix, box);
|
2006-03-10 05:32:50 +00:00
|
|
|
imap->caps = imap->rcaps;
|
|
|
|
if (ret != DRV_OK)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
return DRV_OK;
|
|
|
|
}
|
|
|
|
|
imap-send: change msg_data from storing (ptr, len) to storing strbuf
struct msg_data stored (ptr, len) of the data to be included in a
message, kept the character data NUL-terminated, etc., much like a
strbuf would do. So change it to use a struct strbuf. This makes
the code clearer and reduces copying a little bit.
A side effect of this change is that the memory for each message is
freed after it is used rather than leaked, though that detail is
unimportant given that imap-send is a top-level command.
By the way, there is a bunch of infrastructure in this file for
dealing with IMAP flags, although there is nothing in the code that
actually allows any flags to be set. If there is no plan to add
support for flags in the future, a bunch of code could be ripped out
and "struct msg_data" could be completely replaced with strbuf, but
that would be a separate topic.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-11-25 11:08:39 +00:00
|
|
|
static void wrap_in_html(struct strbuf *msg)
|
2009-02-12 14:58:12 +00:00
|
|
|
{
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
static char *content_type = "Content-Type: text/html;\n";
|
|
|
|
static char *pre_open = "<pre>\n";
|
|
|
|
static char *pre_close = "</pre>\n";
|
2012-11-25 11:08:41 +00:00
|
|
|
const char *body = strstr(msg->buf, "\n\n");
|
|
|
|
|
|
|
|
if (!body)
|
|
|
|
return; /* Headers but no body; no wrapping needed */
|
|
|
|
|
|
|
|
body += 2;
|
|
|
|
|
|
|
|
strbuf_add(&buf, msg->buf, body - msg->buf - 1);
|
|
|
|
strbuf_addstr(&buf, content_type);
|
|
|
|
strbuf_addch(&buf, '\n');
|
|
|
|
strbuf_addstr(&buf, pre_open);
|
|
|
|
strbuf_addstr_xml_quoted(&buf, body);
|
2009-02-12 14:58:12 +00:00
|
|
|
strbuf_addstr(&buf, pre_close);
|
2012-11-25 11:08:41 +00:00
|
|
|
|
imap-send: change msg_data from storing (ptr, len) to storing strbuf
struct msg_data stored (ptr, len) of the data to be included in a
message, kept the character data NUL-terminated, etc., much like a
strbuf would do. So change it to use a struct strbuf. This makes
the code clearer and reduces copying a little bit.
A side effect of this change is that the memory for each message is
freed after it is used rather than leaked, though that detail is
unimportant given that imap-send is a top-level command.
By the way, there is a bunch of infrastructure in this file for
dealing with IMAP flags, although there is nothing in the code that
actually allows any flags to be set. If there is no plan to add
support for flags in the future, a bunch of code could be ripped out
and "struct msg_data" could be completely replaced with strbuf, but
that would be a separate topic.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-11-25 11:08:39 +00:00
|
|
|
strbuf_release(msg);
|
|
|
|
*msg = buf;
|
2009-02-12 14:58:12 +00:00
|
|
|
}
|
|
|
|
|
2006-03-10 05:32:50 +00:00
|
|
|
#define CHUNKSIZE 0x1000
|
|
|
|
|
2012-11-25 11:08:37 +00:00
|
|
|
static int read_message(FILE *f, struct strbuf *all_msgs)
|
2006-03-10 05:32:50 +00:00
|
|
|
{
|
2007-09-10 10:35:08 +00:00
|
|
|
do {
|
2012-11-25 11:08:37 +00:00
|
|
|
if (strbuf_fread(all_msgs, CHUNKSIZE, f) <= 0)
|
2006-03-10 05:32:50 +00:00
|
|
|
break;
|
2007-09-10 10:35:08 +00:00
|
|
|
} while (!feof(f));
|
|
|
|
|
2012-11-25 11:08:38 +00:00
|
|
|
return ferror(f) ? -1 : 0;
|
2006-03-10 05:32:50 +00:00
|
|
|
}
|
|
|
|
|
2012-11-25 11:08:37 +00:00
|
|
|
static int count_messages(struct strbuf *all_msgs)
|
2006-03-10 05:32:50 +00:00
|
|
|
{
|
|
|
|
int count = 0;
|
2012-11-25 11:08:37 +00:00
|
|
|
char *p = all_msgs->buf;
|
2006-03-10 05:32:50 +00:00
|
|
|
|
|
|
|
while (1) {
|
2013-11-30 20:55:40 +00:00
|
|
|
if (starts_with(p, "From ")) {
|
2010-03-22 18:07:52 +00:00
|
|
|
p = strstr(p+5, "\nFrom: ");
|
|
|
|
if (!p) break;
|
|
|
|
p = strstr(p+7, "\nDate: ");
|
|
|
|
if (!p) break;
|
|
|
|
p = strstr(p+7, "\nSubject: ");
|
|
|
|
if (!p) break;
|
|
|
|
p += 10;
|
2006-03-10 05:32:50 +00:00
|
|
|
count++;
|
|
|
|
}
|
2008-07-09 21:29:01 +00:00
|
|
|
p = strstr(p+5, "\nFrom ");
|
2006-03-10 05:32:50 +00:00
|
|
|
if (!p)
|
|
|
|
break;
|
|
|
|
p++;
|
|
|
|
}
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
imap-send: change msg_data from storing (ptr, len) to storing strbuf
struct msg_data stored (ptr, len) of the data to be included in a
message, kept the character data NUL-terminated, etc., much like a
strbuf would do. So change it to use a struct strbuf. This makes
the code clearer and reduces copying a little bit.
A side effect of this change is that the memory for each message is
freed after it is used rather than leaked, though that detail is
unimportant given that imap-send is a top-level command.
By the way, there is a bunch of infrastructure in this file for
dealing with IMAP flags, although there is nothing in the code that
actually allows any flags to be set. If there is no plan to add
support for flags in the future, a bunch of code could be ripped out
and "struct msg_data" could be completely replaced with strbuf, but
that would be a separate topic.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-11-25 11:08:39 +00:00
|
|
|
/*
|
|
|
|
* Copy the next message from all_msgs, starting at offset *ofs, to
|
|
|
|
* msg. Update *ofs to the start of the following message. Return
|
|
|
|
* true iff a message was successfully copied.
|
|
|
|
*/
|
|
|
|
static int split_msg(struct strbuf *all_msgs, struct strbuf *msg, int *ofs)
|
2006-03-10 05:32:50 +00:00
|
|
|
{
|
|
|
|
char *p, *data;
|
imap-send: change msg_data from storing (ptr, len) to storing strbuf
struct msg_data stored (ptr, len) of the data to be included in a
message, kept the character data NUL-terminated, etc., much like a
strbuf would do. So change it to use a struct strbuf. This makes
the code clearer and reduces copying a little bit.
A side effect of this change is that the memory for each message is
freed after it is used rather than leaked, though that detail is
unimportant given that imap-send is a top-level command.
By the way, there is a bunch of infrastructure in this file for
dealing with IMAP flags, although there is nothing in the code that
actually allows any flags to be set. If there is no plan to add
support for flags in the future, a bunch of code could be ripped out
and "struct msg_data" could be completely replaced with strbuf, but
that would be a separate topic.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-11-25 11:08:39 +00:00
|
|
|
size_t len;
|
2006-03-10 05:32:50 +00:00
|
|
|
|
|
|
|
if (*ofs >= all_msgs->len)
|
|
|
|
return 0;
|
|
|
|
|
2012-11-25 11:08:37 +00:00
|
|
|
data = &all_msgs->buf[*ofs];
|
imap-send: change msg_data from storing (ptr, len) to storing strbuf
struct msg_data stored (ptr, len) of the data to be included in a
message, kept the character data NUL-terminated, etc., much like a
strbuf would do. So change it to use a struct strbuf. This makes
the code clearer and reduces copying a little bit.
A side effect of this change is that the memory for each message is
freed after it is used rather than leaked, though that detail is
unimportant given that imap-send is a top-level command.
By the way, there is a bunch of infrastructure in this file for
dealing with IMAP flags, although there is nothing in the code that
actually allows any flags to be set. If there is no plan to add
support for flags in the future, a bunch of code could be ripped out
and "struct msg_data" could be completely replaced with strbuf, but
that would be a separate topic.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-11-25 11:08:39 +00:00
|
|
|
len = all_msgs->len - *ofs;
|
2006-03-10 05:32:50 +00:00
|
|
|
|
2013-11-30 20:55:40 +00:00
|
|
|
if (len < 5 || !starts_with(data, "From "))
|
2006-03-10 05:32:50 +00:00
|
|
|
return 0;
|
|
|
|
|
2008-07-09 21:29:01 +00:00
|
|
|
p = strchr(data, '\n');
|
2006-10-12 22:19:35 +00:00
|
|
|
if (p) {
|
imap-send: change msg_data from storing (ptr, len) to storing strbuf
struct msg_data stored (ptr, len) of the data to be included in a
message, kept the character data NUL-terminated, etc., much like a
strbuf would do. So change it to use a struct strbuf. This makes
the code clearer and reduces copying a little bit.
A side effect of this change is that the memory for each message is
freed after it is used rather than leaked, though that detail is
unimportant given that imap-send is a top-level command.
By the way, there is a bunch of infrastructure in this file for
dealing with IMAP flags, although there is nothing in the code that
actually allows any flags to be set. If there is no plan to add
support for flags in the future, a bunch of code could be ripped out
and "struct msg_data" could be completely replaced with strbuf, but
that would be a separate topic.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-11-25 11:08:39 +00:00
|
|
|
p++;
|
|
|
|
len -= p - data;
|
|
|
|
*ofs += p - data;
|
2006-10-12 22:19:35 +00:00
|
|
|
data = p;
|
|
|
|
}
|
|
|
|
|
2008-07-09 21:29:01 +00:00
|
|
|
p = strstr(data, "\nFrom ");
|
2006-03-10 05:32:50 +00:00
|
|
|
if (p)
|
imap-send: change msg_data from storing (ptr, len) to storing strbuf
struct msg_data stored (ptr, len) of the data to be included in a
message, kept the character data NUL-terminated, etc., much like a
strbuf would do. So change it to use a struct strbuf. This makes
the code clearer and reduces copying a little bit.
A side effect of this change is that the memory for each message is
freed after it is used rather than leaked, though that detail is
unimportant given that imap-send is a top-level command.
By the way, there is a bunch of infrastructure in this file for
dealing with IMAP flags, although there is nothing in the code that
actually allows any flags to be set. If there is no plan to add
support for flags in the future, a bunch of code could be ripped out
and "struct msg_data" could be completely replaced with strbuf, but
that would be a separate topic.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-11-25 11:08:39 +00:00
|
|
|
len = &p[1] - data;
|
2006-03-10 05:32:50 +00:00
|
|
|
|
imap-send: change msg_data from storing (ptr, len) to storing strbuf
struct msg_data stored (ptr, len) of the data to be included in a
message, kept the character data NUL-terminated, etc., much like a
strbuf would do. So change it to use a struct strbuf. This makes
the code clearer and reduces copying a little bit.
A side effect of this change is that the memory for each message is
freed after it is used rather than leaked, though that detail is
unimportant given that imap-send is a top-level command.
By the way, there is a bunch of infrastructure in this file for
dealing with IMAP flags, although there is nothing in the code that
actually allows any flags to be set. If there is no plan to add
support for flags in the future, a bunch of code could be ripped out
and "struct msg_data" could be completely replaced with strbuf, but
that would be a separate topic.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-11-25 11:08:39 +00:00
|
|
|
strbuf_add(msg, data, len);
|
|
|
|
*ofs += len;
|
2007-06-07 07:04:01 +00:00
|
|
|
return 1;
|
2006-03-10 05:32:50 +00:00
|
|
|
}
|
|
|
|
|
2014-08-07 16:21:24 +00:00
|
|
|
static void git_imap_config(void)
|
2006-03-10 05:32:50 +00:00
|
|
|
{
|
2014-08-07 16:21:24 +00:00
|
|
|
const char *val = NULL;
|
|
|
|
|
|
|
|
git_config_get_bool("imap.sslverify", &server.ssl_verify);
|
|
|
|
git_config_get_bool("imap.preformattedhtml", &server.use_html);
|
2014-09-11 17:33:37 +00:00
|
|
|
git_config_get_string("imap.folder", &server.folder);
|
2008-02-11 20:04:00 +00:00
|
|
|
|
2014-08-07 16:21:24 +00:00
|
|
|
if (!git_config_get_value("imap.host", &val)) {
|
|
|
|
if (!val) {
|
|
|
|
git_die_config("imap.host", "Missing value for 'imap.host'");
|
|
|
|
} else {
|
|
|
|
if (starts_with(val, "imap:"))
|
|
|
|
val += 5;
|
|
|
|
else if (starts_with(val, "imaps:")) {
|
|
|
|
val += 6;
|
|
|
|
server.use_ssl = 1;
|
|
|
|
}
|
|
|
|
if (starts_with(val, "//"))
|
|
|
|
val += 2;
|
|
|
|
server.host = xstrdup(val);
|
2006-03-10 05:32:50 +00:00
|
|
|
}
|
2014-08-07 16:21:24 +00:00
|
|
|
}
|
2010-02-16 06:34:07 +00:00
|
|
|
|
2014-08-07 16:21:24 +00:00
|
|
|
git_config_get_string("imap.user", &server.user);
|
|
|
|
git_config_get_string("imap.pass", &server.pass);
|
|
|
|
git_config_get_int("imap.port", &server.port);
|
|
|
|
git_config_get_string("imap.tunnel", &server.tunnel);
|
|
|
|
git_config_get_string("imap.authmethod", &server.auth_method);
|
2006-03-10 05:32:50 +00:00
|
|
|
}
|
|
|
|
|
2014-11-09 14:55:53 +00:00
|
|
|
static int append_msgs_to_imap(struct imap_server_conf *server,
|
|
|
|
struct strbuf* all_msgs, int total)
|
2006-03-10 05:32:50 +00:00
|
|
|
{
|
2013-01-15 08:06:20 +00:00
|
|
|
struct strbuf msg = STRBUF_INIT;
|
2013-01-15 08:06:29 +00:00
|
|
|
struct imap_store *ctx = NULL;
|
2006-03-10 05:32:50 +00:00
|
|
|
int ofs = 0;
|
|
|
|
int r;
|
2014-11-09 14:55:53 +00:00
|
|
|
int n = 0;
|
|
|
|
|
|
|
|
ctx = imap_open_store(server, server->folder);
|
|
|
|
if (!ctx) {
|
|
|
|
fprintf(stderr, "failed to open store\n");
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
ctx->name = server->folder;
|
|
|
|
|
|
|
|
fprintf(stderr, "sending %d message%s\n", total, (total != 1) ? "s" : "");
|
|
|
|
while (1) {
|
|
|
|
unsigned percent = n * 100 / total;
|
|
|
|
|
|
|
|
fprintf(stderr, "%4u%% (%d/%d) done\r", percent, n, total);
|
|
|
|
|
|
|
|
if (!split_msg(all_msgs, &msg, &ofs))
|
|
|
|
break;
|
|
|
|
if (server->use_html)
|
|
|
|
wrap_in_html(&msg);
|
|
|
|
r = imap_store_msg(ctx, &msg);
|
|
|
|
if (r != DRV_OK)
|
|
|
|
break;
|
|
|
|
n++;
|
|
|
|
}
|
|
|
|
fprintf(stderr, "\n");
|
|
|
|
|
|
|
|
imap_close_store(ctx);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef USE_CURL_FOR_IMAP_SEND
|
|
|
|
static CURL *setup_curl(struct imap_server_conf *srvc)
|
|
|
|
{
|
|
|
|
CURL *curl;
|
|
|
|
struct strbuf path = STRBUF_INIT;
|
|
|
|
|
|
|
|
if (curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK)
|
|
|
|
die("curl_global_init failed");
|
|
|
|
|
|
|
|
curl = curl_easy_init();
|
|
|
|
|
|
|
|
if (!curl)
|
|
|
|
die("curl_easy_init failed");
|
|
|
|
|
|
|
|
curl_easy_setopt(curl, CURLOPT_USERNAME, server.user);
|
|
|
|
curl_easy_setopt(curl, CURLOPT_PASSWORD, server.pass);
|
|
|
|
|
2016-08-17 18:58:58 +00:00
|
|
|
strbuf_addstr(&path, server.use_ssl ? "imaps://" : "imap://");
|
2014-11-09 14:55:53 +00:00
|
|
|
strbuf_addstr(&path, server.host);
|
|
|
|
if (!path.len || path.buf[path.len - 1] != '/')
|
|
|
|
strbuf_addch(&path, '/');
|
|
|
|
strbuf_addstr(&path, server.folder);
|
|
|
|
|
|
|
|
curl_easy_setopt(curl, CURLOPT_URL, path.buf);
|
|
|
|
strbuf_release(&path);
|
|
|
|
curl_easy_setopt(curl, CURLOPT_PORT, server.port);
|
|
|
|
|
|
|
|
if (server.auth_method) {
|
2015-10-26 13:14:58 +00:00
|
|
|
#if LIBCURL_VERSION_NUM < 0x072200
|
|
|
|
warning("No LOGIN_OPTIONS support in this cURL version");
|
|
|
|
#else
|
2014-11-09 14:55:53 +00:00
|
|
|
struct strbuf auth = STRBUF_INIT;
|
|
|
|
strbuf_addstr(&auth, "AUTH=");
|
|
|
|
strbuf_addstr(&auth, server.auth_method);
|
|
|
|
curl_easy_setopt(curl, CURLOPT_LOGIN_OPTIONS, auth.buf);
|
|
|
|
strbuf_release(&auth);
|
2015-10-26 13:14:58 +00:00
|
|
|
#endif
|
2014-11-09 14:55:53 +00:00
|
|
|
}
|
|
|
|
|
2015-01-06 11:20:37 +00:00
|
|
|
if (!server.use_ssl)
|
|
|
|
curl_easy_setopt(curl, CURLOPT_USE_SSL, (long)CURLUSESSL_TRY);
|
2014-11-09 14:55:53 +00:00
|
|
|
|
|
|
|
curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, server.ssl_verify);
|
|
|
|
curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, server.ssl_verify);
|
|
|
|
|
|
|
|
curl_easy_setopt(curl, CURLOPT_READFUNCTION, fread_buffer);
|
|
|
|
|
|
|
|
curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L);
|
|
|
|
|
2015-01-06 11:00:55 +00:00
|
|
|
if (0 < verbosity || getenv("GIT_CURL_VERBOSE"))
|
2014-11-09 14:55:53 +00:00
|
|
|
curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
|
2016-05-23 13:44:03 +00:00
|
|
|
setup_curl_trace(curl);
|
2014-11-09 14:55:53 +00:00
|
|
|
|
|
|
|
return curl;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int curl_append_msgs_to_imap(struct imap_server_conf *server,
|
|
|
|
struct strbuf* all_msgs, int total) {
|
|
|
|
int ofs = 0;
|
|
|
|
int n = 0;
|
|
|
|
struct buffer msgbuf = { STRBUF_INIT, 0 };
|
|
|
|
CURL *curl;
|
|
|
|
CURLcode res = CURLE_OK;
|
|
|
|
|
|
|
|
curl = setup_curl(server);
|
|
|
|
curl_easy_setopt(curl, CURLOPT_READDATA, &msgbuf);
|
|
|
|
|
|
|
|
fprintf(stderr, "sending %d message%s\n", total, (total != 1) ? "s" : "");
|
|
|
|
while (1) {
|
|
|
|
unsigned percent = n * 100 / total;
|
|
|
|
int prev_len;
|
|
|
|
|
|
|
|
fprintf(stderr, "%4u%% (%d/%d) done\r", percent, n, total);
|
|
|
|
|
|
|
|
prev_len = msgbuf.buf.len;
|
|
|
|
if (!split_msg(all_msgs, &msgbuf.buf, &ofs))
|
|
|
|
break;
|
|
|
|
if (server->use_html)
|
|
|
|
wrap_in_html(&msgbuf.buf);
|
|
|
|
lf_to_crlf(&msgbuf.buf);
|
|
|
|
|
|
|
|
curl_easy_setopt(curl, CURLOPT_INFILESIZE_LARGE,
|
|
|
|
(curl_off_t)(msgbuf.buf.len-prev_len));
|
|
|
|
|
|
|
|
res = curl_easy_perform(curl);
|
|
|
|
|
|
|
|
if(res != CURLE_OK) {
|
|
|
|
fprintf(stderr, "curl_easy_perform() failed: %s\n",
|
|
|
|
curl_easy_strerror(res));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
n++;
|
|
|
|
}
|
|
|
|
fprintf(stderr, "\n");
|
|
|
|
|
|
|
|
curl_easy_cleanup(curl);
|
|
|
|
curl_global_cleanup();
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
add an extra level of indirection to main()
There are certain startup tasks that we expect every git
process to do. In some cases this is just to improve the
quality of the program (e.g., setting up gettext()). In
others it is a requirement for using certain functions in
libgit.a (e.g., system_path() expects that you have called
git_extract_argv0_path()).
Most commands are builtins and are covered by the git.c
version of main(). However, there are still a few external
commands that use their own main(). Each of these has to
remember to include the correct startup sequence, and we are
not always consistent.
Rather than just fix the inconsistencies, let's make this
harder to get wrong by providing a common main() that can
run this standard startup.
We basically have two options to do this:
- the compat/mingw.h file already does something like this by
adding a #define that replaces the definition of main with a
wrapper that calls mingw_startup().
The upside is that the code in each program doesn't need
to be changed at all; it's rewritten on the fly by the
preprocessor.
The downside is that it may make debugging of the startup
sequence a bit more confusing, as the preprocessor is
quietly inserting new code.
- the builtin functions are all of the form cmd_foo(),
and git.c's main() calls them.
This is much more explicit, which may make things more
obvious to somebody reading the code. It's also more
flexible (because of course we have to figure out _which_
cmd_foo() to call).
The downside is that each of the builtins must define
cmd_foo(), instead of just main().
This patch chooses the latter option, preferring the more
explicit approach, even though it is more invasive. We
introduce a new file common-main.c, with the "real" main. It
expects to call cmd_main() from whatever other objects it is
linked against.
We link common-main.o against anything that links against
libgit.a, since we know that such programs will need to do
this setup. Note that common-main.o can't actually go inside
libgit.a, as the linker would not pick up its main()
function automatically (it has no callers).
The rest of the patch is just adjusting all of the various
external programs (mostly in t/helper) to use cmd_main().
I've provided a global declaration for cmd_main(), which
means that all of the programs also need to match its
signature. In particular, many functions need to switch to
"const char **" instead of "char **" for argv. This effect
ripples out to a few other variables and functions, as well.
This makes the patch even more invasive, but the end result
is much better. We should be treating argv strings as const
anyway, and now all programs conform to the same signature
(which also matches the way builtins are defined).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-07-01 05:58:58 +00:00
|
|
|
int cmd_main(int argc, const char **argv)
|
2014-11-09 14:55:53 +00:00
|
|
|
{
|
|
|
|
struct strbuf all_msgs = STRBUF_INIT;
|
|
|
|
int total;
|
2008-07-09 21:28:59 +00:00
|
|
|
int nongit_ok;
|
2006-03-10 05:32:50 +00:00
|
|
|
|
2008-07-09 21:28:59 +00:00
|
|
|
setup_git_directory_gently(&nongit_ok);
|
2014-08-07 16:21:24 +00:00
|
|
|
git_imap_config();
|
2006-03-10 05:32:50 +00:00
|
|
|
|
2014-11-05 14:29:21 +00:00
|
|
|
argc = parse_options(argc, (const char **)argv, "", imap_send_options, imap_send_usage, 0);
|
|
|
|
|
|
|
|
if (argc)
|
|
|
|
usage_with_options(imap_send_usage, imap_send_options);
|
|
|
|
|
2014-11-09 14:55:53 +00:00
|
|
|
#ifndef USE_CURL_FOR_IMAP_SEND
|
|
|
|
if (use_curl) {
|
2015-03-08 05:13:55 +00:00
|
|
|
warning("--curl not supported in this build");
|
2014-11-09 14:55:53 +00:00
|
|
|
use_curl = 0;
|
|
|
|
}
|
2015-03-08 05:13:55 +00:00
|
|
|
#elif defined(NO_OPENSSL)
|
|
|
|
if (!use_curl) {
|
|
|
|
warning("--no-curl not supported in this build");
|
|
|
|
use_curl = 1;
|
|
|
|
}
|
2014-11-09 14:55:53 +00:00
|
|
|
#endif
|
|
|
|
|
2008-07-09 21:29:00 +00:00
|
|
|
if (!server.port)
|
|
|
|
server.port = server.use_ssl ? 993 : 143;
|
2006-03-10 05:32:50 +00:00
|
|
|
|
2014-08-19 21:27:11 +00:00
|
|
|
if (!server.folder) {
|
2008-07-09 21:29:01 +00:00
|
|
|
fprintf(stderr, "no imap store specified\n");
|
2006-03-10 05:32:50 +00:00
|
|
|
return 1;
|
|
|
|
}
|
2008-03-26 18:05:17 +00:00
|
|
|
if (!server.host) {
|
2008-04-22 10:41:47 +00:00
|
|
|
if (!server.tunnel) {
|
2008-07-09 21:29:01 +00:00
|
|
|
fprintf(stderr, "no imap host specified\n");
|
2008-04-22 10:41:47 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
server.host = "tunnel";
|
2008-03-26 18:05:17 +00:00
|
|
|
}
|
2006-03-10 05:32:50 +00:00
|
|
|
|
|
|
|
/* read the messages */
|
2012-11-25 11:08:38 +00:00
|
|
|
if (read_message(stdin, &all_msgs)) {
|
|
|
|
fprintf(stderr, "error reading input\n");
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (all_msgs.len == 0) {
|
2008-07-09 23:37:38 +00:00
|
|
|
fprintf(stderr, "nothing to send\n");
|
2006-03-10 05:32:50 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2008-07-09 21:29:01 +00:00
|
|
|
total = count_messages(&all_msgs);
|
2006-04-05 14:22:52 +00:00
|
|
|
if (!total) {
|
2008-07-09 23:37:38 +00:00
|
|
|
fprintf(stderr, "no messages to send\n");
|
2006-03-10 05:32:50 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* write it to the imap server */
|
imap-send: change msg_data from storing (ptr, len) to storing strbuf
struct msg_data stored (ptr, len) of the data to be included in a
message, kept the character data NUL-terminated, etc., much like a
strbuf would do. So change it to use a struct strbuf. This makes
the code clearer and reduces copying a little bit.
A side effect of this change is that the memory for each message is
freed after it is used rather than leaked, though that detail is
unimportant given that imap-send is a top-level command.
By the way, there is a bunch of infrastructure in this file for
dealing with IMAP flags, although there is nothing in the code that
actually allows any flags to be set. If there is no plan to add
support for flags in the future, a bunch of code could be ripped out
and "struct msg_data" could be completely replaced with strbuf, but
that would be a separate topic.
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-11-25 11:08:39 +00:00
|
|
|
|
2014-11-09 14:55:53 +00:00
|
|
|
if (server.tunnel)
|
|
|
|
return append_msgs_to_imap(&server, &all_msgs, total);
|
2006-03-10 05:32:50 +00:00
|
|
|
|
2014-11-09 14:55:53 +00:00
|
|
|
#ifdef USE_CURL_FOR_IMAP_SEND
|
|
|
|
if (use_curl)
|
|
|
|
return curl_append_msgs_to_imap(&server, &all_msgs, total);
|
|
|
|
#endif
|
2006-03-10 05:32:50 +00:00
|
|
|
|
2014-11-09 14:55:53 +00:00
|
|
|
return append_msgs_to_imap(&server, &all_msgs, total);
|
2006-03-10 05:32:50 +00:00
|
|
|
}
|