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"
|
2009-01-18 12:00:12 +00:00
|
|
|
#include "exec_cmd.h"
|
2009-10-19 15:42:04 +00:00
|
|
|
#include "run-command.h"
|
2008-07-09 21:29:00 +00:00
|
|
|
#ifdef NO_OPENSSL
|
|
|
|
typedef void *SSL;
|
|
|
|
#endif
|
2006-03-10 05:32:50 +00:00
|
|
|
|
2008-07-09 23:37:38 +00:00
|
|
|
struct store_conf {
|
2006-03-10 05:32:50 +00:00
|
|
|
char *name;
|
|
|
|
const char *path; /* should this be here? its interpretation is driver-specific */
|
|
|
|
char *map_inbox;
|
|
|
|
char *trash;
|
|
|
|
unsigned max_size; /* off_t is overkill */
|
|
|
|
unsigned trash_remote_new:1, trash_only_new:1;
|
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 string_list {
|
2006-03-10 05:32:50 +00:00
|
|
|
struct string_list *next;
|
|
|
|
char string[1];
|
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 channel_conf {
|
2006-03-10 05:32:50 +00:00
|
|
|
struct channel_conf *next;
|
|
|
|
char *name;
|
2008-07-09 23:37:38 +00:00
|
|
|
struct store_conf *master, *slave;
|
2006-03-10 05:32:50 +00:00
|
|
|
char *master_name, *slave_name;
|
|
|
|
char *sync_state;
|
2008-07-09 23:37:38 +00:00
|
|
|
struct string_list *patterns;
|
2006-03-10 05:32:50 +00:00
|
|
|
int mops, sops;
|
|
|
|
unsigned max_messages; /* for slave only */
|
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 group_conf {
|
2006-03-10 05:32:50 +00:00
|
|
|
struct group_conf *next;
|
|
|
|
char *name;
|
2008-07-09 23:37:38 +00:00
|
|
|
struct string_list *channels;
|
|
|
|
};
|
2006-03-10 05:32:50 +00:00
|
|
|
|
|
|
|
/* For message->status */
|
|
|
|
#define M_RECENT (1<<0) /* unsyncable flag; maildir_* depend on this being 1<<0 */
|
|
|
|
#define M_DEAD (1<<1) /* expunged */
|
|
|
|
#define M_FLAGS (1<<2) /* flags fetched */
|
|
|
|
|
2008-07-09 23:37:38 +00:00
|
|
|
struct message {
|
2006-03-10 05:32:50 +00:00
|
|
|
struct message *next;
|
2008-07-09 23:37:38 +00:00
|
|
|
/* struct string_list *keywords; */
|
2006-03-10 05:32:50 +00:00
|
|
|
size_t size; /* zero implies "not fetched" */
|
|
|
|
int uid;
|
|
|
|
unsigned char flags, status;
|
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 store {
|
|
|
|
struct store_conf *conf; /* foreign */
|
2006-03-10 05:32:50 +00:00
|
|
|
|
|
|
|
/* currently open mailbox */
|
|
|
|
const char *name; /* foreign! maybe preset? */
|
|
|
|
char *path; /* own */
|
2008-07-09 23:37:38 +00:00
|
|
|
struct message *msgs; /* own */
|
2006-03-10 05:32:50 +00:00
|
|
|
int uidvalidity;
|
|
|
|
unsigned char opts; /* maybe preset? */
|
|
|
|
/* note that the following do _not_ reflect stats from msgs, but mailbox totals */
|
|
|
|
int count; /* # of messages */
|
|
|
|
int recent; /* # of recent messages - don't trust this beyond the initial read */
|
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 msg_data {
|
2006-03-10 05:32:50 +00:00
|
|
|
char *data;
|
|
|
|
int len;
|
|
|
|
unsigned char flags;
|
2006-06-18 15:18:08 +00:00
|
|
|
unsigned int crlf:1;
|
2008-07-09 23:37:38 +00:00
|
|
|
};
|
2006-03-10 05:32:50 +00:00
|
|
|
|
2009-11-09 15:04:51 +00:00
|
|
|
static const char imap_send_usage[] = "git imap-send < <mbox>";
|
|
|
|
|
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
|
|
|
|
|
|
|
|
static int Verbose, Quiet;
|
|
|
|
|
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
|
|
|
|
2008-07-09 23:37:38 +00:00
|
|
|
static void free_generic_messages(struct message *);
|
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;
|
|
|
|
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;
|
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_store_conf {
|
|
|
|
struct store_conf gen;
|
|
|
|
struct imap_server_conf *server;
|
2006-03-10 05:32:50 +00:00
|
|
|
unsigned use_namespace:1;
|
2008-07-09 23:37:38 +00:00
|
|
|
};
|
2006-03-10 05:32:50 +00:00
|
|
|
|
2008-07-09 23:37:38 +00:00
|
|
|
#define NIL (void *)0x1
|
|
|
|
#define LIST (void *)0x2
|
2006-03-10 05:32:50 +00:00
|
|
|
|
2008-07-09 23:37:38 +00:00
|
|
|
struct imap_list {
|
|
|
|
struct imap_list *next, *child;
|
2006-03-10 05:32:50 +00:00
|
|
|
char *val;
|
|
|
|
int len;
|
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 */
|
2008-07-09 23:37:38 +00:00
|
|
|
struct imap_list *ns_personal, *ns_other, *ns_shared; /* NAMESPACE info */
|
2006-03-10 05:32:50 +00:00
|
|
|
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 {
|
|
|
|
struct store gen;
|
2006-03-10 05:32:50 +00:00
|
|
|
int uidvalidity;
|
2008-07-09 23:37:38 +00:00
|
|
|
struct imap *imap;
|
2006-03-10 05:32:50 +00:00
|
|
|
const char *prefix;
|
|
|
|
unsigned /*currentnc:1,*/ trashnc:1;
|
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;
|
|
|
|
unsigned create:1, trycreate:1;
|
|
|
|
};
|
|
|
|
|
|
|
|
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,
|
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",
|
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
|
|
|
|
|
|
|
|
|
|
|
static const char *Flags[] = {
|
|
|
|
"Draft",
|
|
|
|
"Flagged",
|
|
|
|
"Answered",
|
|
|
|
"Seen",
|
|
|
|
"Deleted",
|
|
|
|
};
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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
|
|
|
{
|
|
|
|
#ifdef NO_OPENSSL
|
|
|
|
fprintf(stderr, "SSL requested but SSL support not compiled in\n");
|
|
|
|
return -1;
|
2009-10-31 06:36:03 +00:00
|
|
|
#else
|
|
|
|
#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;
|
|
|
|
|
|
|
|
SSL_library_init();
|
|
|
|
SSL_load_error_strings();
|
|
|
|
|
|
|
|
if (use_tls_only)
|
|
|
|
meth = TLSv1_method();
|
2006-03-10 05:32:50 +00:00
|
|
|
else
|
2008-07-09 21:29:00 +00:00
|
|
|
meth = SSLv23_method();
|
|
|
|
|
|
|
|
if (!meth) {
|
|
|
|
ssl_socket_perror("SSLv23_method");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx = SSL_CTX_new(meth);
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = SSL_connect(sock->ssl);
|
|
|
|
if (ret <= 0) {
|
|
|
|
socket_perror("SSL_connect", sock, ret);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
#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 */
|
|
|
|
if (Verbose)
|
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;
|
|
|
|
|
|
|
|
if (!Quiet) {
|
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;
|
|
|
|
|
|
|
|
if (Quiet < 2) {
|
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 23:37:38 +00:00
|
|
|
static void free_generic_messages(struct message *msgs)
|
2006-03-10 05:32:50 +00:00
|
|
|
{
|
2008-07-09 23:37:38 +00:00
|
|
|
struct message *tmsg;
|
2006-03-10 05:32:50 +00:00
|
|
|
|
|
|
|
for (; msgs; msgs = tmsg) {
|
|
|
|
tmsg = msgs->next;
|
2008-07-09 21:29:01 +00:00
|
|
|
free(msgs);
|
2006-03-10 05:32:50 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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)
|
2009-01-04 18:38:41 +00:00
|
|
|
die("Fatal: 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;
|
|
|
|
}
|
|
|
|
|
2008-07-09 23:37:38 +00:00
|
|
|
static struct imap_cmd *v_issue_imap_cmd(struct imap_store *ctx,
|
2008-07-09 21:29:01 +00:00
|
|
|
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
|
|
|
|
2008-07-09 21:29:01 +00:00
|
|
|
bufl = nfsnprintf(buf, sizeof(buf), cmd->cb.data ? CAP(LITERALPLUS) ?
|
2006-03-10 05:32:50 +00:00
|
|
|
"%d %s{%d+}\r\n" : "%d %s{%d}\r\n" : "%d %s\r\n",
|
2008-07-09 21:29:01 +00:00
|
|
|
cmd->tag, cmd->cmd, cmd->cb.dlen);
|
2006-03-10 05:32:50 +00:00
|
|
|
if (Verbose) {
|
|
|
|
if (imap->num_in_progress)
|
2008-07-09 21:29:01 +00:00
|
|
|
printf("(%d in progress) ", imap->num_in_progress);
|
|
|
|
if (memcmp(cmd->cmd, "LOGIN", 5))
|
|
|
|
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 struct imap_cmd *issue_imap_cmd(struct imap_store *ctx,
|
2008-07-09 21:29:01 +00:00
|
|
|
struct imap_cmd_cb *cb,
|
|
|
|
const char *fmt, ...)
|
2006-03-10 05:32:50 +00:00
|
|
|
{
|
|
|
|
struct imap_cmd *ret;
|
|
|
|
va_list ap;
|
|
|
|
|
2008-07-09 21:29:01 +00:00
|
|
|
va_start(ap, fmt);
|
|
|
|
ret = v_issue_imap_cmd(ctx, cb, fmt, ap);
|
|
|
|
va_end(ap);
|
2006-03-10 05:32:50 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
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);
|
|
|
|
cmdp = v_issue_imap_cmd(ctx, cb, fmt, ap);
|
|
|
|
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);
|
|
|
|
cmdp = v_issue_imap_cmd(ctx, cb, fmt, ap);
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-07-09 23:37:38 +00:00
|
|
|
static int is_atom(struct imap_list *list)
|
2006-03-10 05:32:50 +00:00
|
|
|
{
|
|
|
|
return list && list->val && list->val != NIL && list->val != LIST;
|
|
|
|
}
|
|
|
|
|
2008-07-09 23:37:38 +00:00
|
|
|
static int is_list(struct imap_list *list)
|
2006-03-10 05:32:50 +00:00
|
|
|
{
|
|
|
|
return list && list->val == LIST;
|
|
|
|
}
|
|
|
|
|
2008-07-09 23:37:38 +00:00
|
|
|
static void free_list(struct imap_list *list)
|
2006-03-10 05:32:50 +00:00
|
|
|
{
|
2008-07-09 23:37:38 +00:00
|
|
|
struct imap_list *tmp;
|
2006-03-10 05:32:50 +00:00
|
|
|
|
|
|
|
for (; list; list = tmp) {
|
|
|
|
tmp = list->next;
|
2008-07-09 21:29:01 +00:00
|
|
|
if (is_list(list))
|
|
|
|
free_list(list->child);
|
|
|
|
else if (is_atom(list))
|
|
|
|
free(list->val);
|
|
|
|
free(list);
|
2006-03-10 05:32:50 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-07-09 23:37:38 +00:00
|
|
|
static int parse_imap_list_l(struct imap *imap, char **sp, struct imap_list **curp, int level)
|
2006-03-10 05:32:50 +00:00
|
|
|
{
|
2008-07-09 23:37:38 +00:00
|
|
|
struct imap_list *cur;
|
2006-03-10 05:32:50 +00:00
|
|
|
char *s = *sp, *p;
|
|
|
|
int n, bytes;
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
2008-07-09 21:29:01 +00:00
|
|
|
*curp = cur = xmalloc(sizeof(*cur));
|
2006-03-10 05:32:50 +00:00
|
|
|
curp = &cur->next;
|
2006-04-02 11:13:01 +00:00
|
|
|
cur->val = NULL; /* for clean bail */
|
2006-03-10 05:32:50 +00:00
|
|
|
if (*s == '(') {
|
|
|
|
/* sublist */
|
|
|
|
s++;
|
|
|
|
cur->val = LIST;
|
2008-07-09 21:29:01 +00:00
|
|
|
if (parse_imap_list_l(imap, &s, &cur->child, level + 1))
|
2006-03-10 05:32:50 +00:00
|
|
|
goto bail;
|
|
|
|
} else if (imap && *s == '{') {
|
|
|
|
/* literal */
|
2008-07-09 21:29:01 +00:00
|
|
|
bytes = cur->len = strtol(s + 1, &s, 10);
|
2006-03-10 05:32:50 +00:00
|
|
|
if (*s != '}')
|
|
|
|
goto bail;
|
|
|
|
|
2008-07-09 21:29:01 +00:00
|
|
|
s = cur->val = xmalloc(cur->len);
|
2006-03-10 05:32:50 +00:00
|
|
|
|
|
|
|
/* dump whats left over in the input buffer */
|
|
|
|
n = imap->buf.bytes - imap->buf.offset;
|
|
|
|
|
|
|
|
if (n > bytes)
|
|
|
|
/* the entire message fit in the buffer */
|
|
|
|
n = bytes;
|
|
|
|
|
2008-07-09 21:29:01 +00:00
|
|
|
memcpy(s, imap->buf.buf + imap->buf.offset, n);
|
2006-03-10 05:32:50 +00:00
|
|
|
s += n;
|
|
|
|
bytes -= n;
|
|
|
|
|
|
|
|
/* mark that we used part of the buffer */
|
|
|
|
imap->buf.offset += n;
|
|
|
|
|
|
|
|
/* now read the rest of the message */
|
|
|
|
while (bytes > 0) {
|
2008-07-09 21:29:01 +00:00
|
|
|
if ((n = socket_read(&imap->buf.sock, s, bytes)) <= 0)
|
2006-03-10 05:32:50 +00:00
|
|
|
goto bail;
|
|
|
|
s += n;
|
|
|
|
bytes -= n;
|
|
|
|
}
|
|
|
|
|
2008-07-09 21:29:01 +00:00
|
|
|
if (buffer_gets(&imap->buf, &s))
|
2006-03-10 05:32:50 +00:00
|
|
|
goto bail;
|
|
|
|
} else if (*s == '"') {
|
|
|
|
/* quoted string */
|
|
|
|
s++;
|
|
|
|
p = s;
|
|
|
|
for (; *s != '"'; s++)
|
|
|
|
if (!*s)
|
|
|
|
goto bail;
|
|
|
|
cur->len = s - p;
|
|
|
|
s++;
|
2007-09-15 22:32:36 +00:00
|
|
|
cur->val = xmemdupz(p, cur->len);
|
2006-03-10 05:32:50 +00:00
|
|
|
} else {
|
|
|
|
/* atom */
|
|
|
|
p = s;
|
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;
|
|
|
|
cur->len = s - p;
|
2008-07-09 23:37:38 +00:00
|
|
|
if (cur->len == 3 && !memcmp("NIL", p, 3))
|
2006-03-10 05:32:50 +00:00
|
|
|
cur->val = NIL;
|
2008-07-09 23:37:38 +00:00
|
|
|
else
|
2007-09-15 22:32:36 +00:00
|
|
|
cur->val = xmemdupz(p, cur->len);
|
2006-03-10 05:32:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!level)
|
|
|
|
break;
|
|
|
|
if (!*s)
|
|
|
|
goto bail;
|
|
|
|
}
|
|
|
|
*sp = s;
|
2006-04-02 11:13:01 +00:00
|
|
|
*curp = NULL;
|
2006-03-10 05:32:50 +00:00
|
|
|
return 0;
|
|
|
|
|
2008-07-09 23:37:38 +00:00
|
|
|
bail:
|
2006-04-02 11:13:01 +00:00
|
|
|
*curp = NULL;
|
2006-03-10 05:32:50 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2008-07-09 23:37:38 +00:00
|
|
|
static struct imap_list *parse_imap_list(struct imap *imap, char **sp)
|
2006-03-10 05:32:50 +00:00
|
|
|
{
|
2008-07-09 23:37:38 +00:00
|
|
|
struct imap_list *head;
|
2006-03-10 05:32:50 +00:00
|
|
|
|
2008-07-09 21:29:01 +00:00
|
|
|
if (!parse_imap_list_l(imap, sp, &head, 0))
|
2006-03-10 05:32:50 +00:00
|
|
|
return head;
|
2008-07-09 21:29:01 +00:00
|
|
|
free_list(head);
|
2006-03-10 05:32:50 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2008-07-09 23:37:38 +00:00
|
|
|
static struct imap_list *parse_list(char **sp)
|
2006-03-10 05:32:50 +00:00
|
|
|
{
|
2008-07-09 21:29:01 +00:00
|
|
|
return parse_imap_list(NULL, sp);
|
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)) {
|
|
|
|
if (!(arg = next_arg(&s)) || !(ctx->gen.uidvalidity = atoi(arg))) {
|
|
|
|
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)) {
|
|
|
|
if (!(arg = next_arg(&s)) || !(ctx->gen.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;
|
2006-03-10 05:32:50 +00:00
|
|
|
struct imap_cmd *cmdp, **pcmdp, *ncmdp;
|
|
|
|
char *cmd, *arg, *arg1, *p;
|
|
|
|
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)) {
|
|
|
|
imap->ns_personal = parse_list(&cmd);
|
|
|
|
imap->ns_other = parse_list(&cmd);
|
|
|
|
imap->ns_shared = parse_list(&cmd);
|
|
|
|
} 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;
|
2008-07-09 21:29:01 +00:00
|
|
|
} else if (!strcmp("CAPABILITY", arg))
|
|
|
|
parse_capability(imap, cmd);
|
|
|
|
else if ((arg1 = next_arg(&cmd))) {
|
|
|
|
if (!strcmp("EXISTS", arg1))
|
|
|
|
ctx->gen.count = atoi(arg);
|
|
|
|
else if (!strcmp("RECENT", arg1))
|
|
|
|
ctx->gen.recent = atoi(arg);
|
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 {
|
2008-07-09 21:29:01 +00:00
|
|
|
if (!strcmp("NO", arg)) {
|
|
|
|
if (cmdp->cb.create && cmd && (cmdp->cb.trycreate || !memcmp(cmd, "[TRYCREATE]", 11))) { /* SELECT, APPEND or UID COPY */
|
|
|
|
p = strchr(cmdp->cmd, '"');
|
2009-11-14 21:33:13 +00:00
|
|
|
if (!issue_imap_cmd(ctx, NULL, "CREATE \"%.*s\"", (int)(strchr(p + 1, '"') - p + 1), p)) {
|
2006-03-10 05:32:50 +00:00
|
|
|
resp = RESP_BAD;
|
|
|
|
goto normal;
|
|
|
|
}
|
|
|
|
/* not waiting here violates the spec, but a server that does not
|
|
|
|
grok this nonetheless violates it too. */
|
|
|
|
cmdp->cb.create = 0;
|
2008-07-09 21:29:01 +00:00
|
|
|
if (!(ncmdp = issue_imap_cmd(ctx, &cmdp->cb, "%s", cmdp->cmd))) {
|
2006-03-10 05:32:50 +00:00
|
|
|
resp = RESP_BAD;
|
|
|
|
goto normal;
|
|
|
|
}
|
2008-07-09 21:29:01 +00:00
|
|
|
free(cmdp->cmd);
|
|
|
|
free(cmdp);
|
2006-03-10 05:32:50 +00:00
|
|
|
if (!tcmd)
|
|
|
|
return 0; /* ignored */
|
|
|
|
if (cmdp == tcmd)
|
|
|
|
tcmd = ncmdp;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
resp = RESP_NO;
|
2008-07-09 21:29:01 +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",
|
|
|
|
memcmp(cmdp->cmd, "LOGIN", 5) ?
|
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;
|
2008-07-09 23:37:38 +00:00
|
|
|
normal:
|
2006-03-10 05:32:50 +00:00
|
|
|
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_list(imap->ns_personal);
|
|
|
|
free_list(imap->ns_other);
|
|
|
|
free_list(imap->ns_shared);
|
|
|
|
free(imap);
|
2006-03-10 05:32:50 +00:00
|
|
|
}
|
|
|
|
|
2008-07-09 23:37:38 +00:00
|
|
|
static void imap_close_store(struct store *ctx)
|
2006-03-10 05:32:50 +00:00
|
|
|
{
|
2008-07-09 23:37:38 +00:00
|
|
|
imap_close_server((struct imap_store *)ctx);
|
2008-07-09 21:29:01 +00:00
|
|
|
free_generic_messages(ctx->msgs);
|
|
|
|
free(ctx);
|
2006-03-10 05:32:50 +00:00
|
|
|
}
|
|
|
|
|
2008-07-09 23:37:38 +00:00
|
|
|
static struct store *imap_open_store(struct imap_server_conf *srvc)
|
2006-03-10 05:32:50 +00:00
|
|
|
{
|
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
|
|
|
|
2008-07-09 21:29:01 +00:00
|
|
|
ctx = xcalloc(sizeof(*ctx), 1);
|
2006-03-10 05:32:50 +00:00
|
|
|
|
2008-07-09 21:29:01 +00:00
|
|
|
ctx->imap = imap = xcalloc(sizeof(*imap), 1);
|
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) {
|
2009-10-19 15:42:04 +00:00
|
|
|
const char *argv[4];
|
|
|
|
struct child_process tunnel = {0};
|
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
|
|
|
|
2009-10-19 15:42:04 +00:00
|
|
|
argv[0] = "sh";
|
|
|
|
argv[1] = "-c";
|
|
|
|
argv[2] = srvc->tunnel;
|
|
|
|
argv[3] = NULL;
|
2006-03-10 05:32:50 +00:00
|
|
|
|
2009-10-19 15:42:04 +00:00
|
|
|
tunnel.argv = argv;
|
|
|
|
tunnel.in = -1;
|
|
|
|
tunnel.out = -1;
|
|
|
|
if (start_command(&tunnel))
|
|
|
|
die("cannot start proxy %s", argv[0]);
|
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];
|
|
|
|
|
|
|
|
snprintf(portstr, sizeof(portstr), "%hu", srvc->port);
|
|
|
|
|
|
|
|
memset(&hints, 0, sizeof(hints));
|
|
|
|
hints.ai_socktype = SOCK_STREAM;
|
|
|
|
hints.ai_protocol = IPPROTO_TCP;
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
imap_info("ok\n");
|
|
|
|
|
|
|
|
for (ai0 = ai; ai; ai = ai->ai_next) {
|
|
|
|
char addr[NI_MAXHOST];
|
|
|
|
|
|
|
|
s = socket(ai->ai_family, ai->ai_socktype,
|
|
|
|
ai->ai_protocol);
|
|
|
|
if (s < 0)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
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)) {
|
|
|
|
if (imap_exec(ctx, 0, "STARTTLS") != RESP_OK)
|
|
|
|
goto bail;
|
|
|
|
if (ssl_socket_connect(&imap->buf.sock, 1,
|
|
|
|
srvc->ssl_verify))
|
|
|
|
goto bail;
|
|
|
|
/* capabilities may have changed, so get the new capabilities */
|
|
|
|
if (imap_exec(ctx, 0, "CAPABILITY") != RESP_OK)
|
|
|
|
goto bail;
|
|
|
|
}
|
|
|
|
#endif
|
2008-07-09 21:29:01 +00:00
|
|
|
imap_info("Logging in...\n");
|
2006-03-10 05:32:50 +00:00
|
|
|
if (!srvc->user) {
|
2008-07-09 21:29:01 +00:00
|
|
|
fprintf(stderr, "Skipping server %s, no user\n", srvc->host);
|
2006-03-10 05:32:50 +00:00
|
|
|
goto bail;
|
|
|
|
}
|
|
|
|
if (!srvc->pass) {
|
|
|
|
char prompt[80];
|
2008-07-09 21:29:01 +00:00
|
|
|
sprintf(prompt, "Password (%s@%s): ", srvc->user, srvc->host);
|
|
|
|
arg = getpass(prompt);
|
2006-03-10 05:32:50 +00:00
|
|
|
if (!arg) {
|
2008-07-09 21:29:01 +00:00
|
|
|
perror("getpass");
|
|
|
|
exit(1);
|
2006-03-10 05:32:50 +00:00
|
|
|
}
|
|
|
|
if (!*arg) {
|
2008-07-09 21:29:01 +00:00
|
|
|
fprintf(stderr, "Skipping account %s@%s, no password\n", srvc->user, srvc->host);
|
2006-03-10 05:32:50 +00:00
|
|
|
goto bail;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* getpass() returns a pointer to a static buffer. make a copy
|
|
|
|
* for long term storage.
|
|
|
|
*/
|
2008-07-09 21:29:01 +00:00
|
|
|
srvc->pass = xstrdup(arg);
|
2006-03-10 05:32:50 +00:00
|
|
|
}
|
|
|
|
if (CAP(NOLOGIN)) {
|
2008-07-09 21:29:01 +00:00
|
|
|
fprintf(stderr, "Skipping account %s@%s, server forbids LOGIN\n", srvc->user, srvc->host);
|
2006-03-10 05:32:50 +00:00
|
|
|
goto bail;
|
|
|
|
}
|
2008-07-09 21:29:00 +00:00
|
|
|
if (!imap->buf.sock.ssl)
|
2008-07-09 23:37:38 +00:00
|
|
|
imap_warn("*** IMAP Warning *** Password is being "
|
|
|
|
"sent in the clear\n");
|
2008-07-09 21:29:01 +00:00
|
|
|
if (imap_exec(ctx, NULL, "LOGIN \"%s\" \"%s\"", srvc->user, srvc->pass) != RESP_OK) {
|
|
|
|
fprintf(stderr, "IMAP error: LOGIN failed\n");
|
2006-03-10 05:32:50 +00:00
|
|
|
goto bail;
|
|
|
|
}
|
|
|
|
} /* !preauth */
|
|
|
|
|
|
|
|
ctx->prefix = "";
|
|
|
|
ctx->trashnc = 1;
|
2008-07-09 23:37:38 +00:00
|
|
|
return (struct store *)ctx;
|
2006-03-10 05:32:50 +00:00
|
|
|
|
2008-07-09 23:37:38 +00:00
|
|
|
bail:
|
2008-07-09 21:29:01 +00:00
|
|
|
imap_close_store(&ctx->gen);
|
2006-04-02 11:13:01 +00:00
|
|
|
return NULL;
|
2006-03-10 05:32:50 +00:00
|
|
|
}
|
|
|
|
|
2008-07-09 21:29:01 +00:00
|
|
|
static int imap_make_flags(int flags, char *buf)
|
2006-03-10 05:32:50 +00:00
|
|
|
{
|
|
|
|
const char *s;
|
|
|
|
unsigned i, d;
|
|
|
|
|
|
|
|
for (i = d = 0; i < ARRAY_SIZE(Flags); i++)
|
|
|
|
if (flags & (1 << i)) {
|
|
|
|
buf[d++] = ' ';
|
|
|
|
buf[d++] = '\\';
|
|
|
|
for (s = Flags[i]; *s; s++)
|
|
|
|
buf[d++] = *s;
|
|
|
|
}
|
|
|
|
buf[0] = '(';
|
|
|
|
buf[d++] = ')';
|
|
|
|
return d;
|
|
|
|
}
|
|
|
|
|
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
|
|
|
static int imap_store_msg(struct store *gctx, struct msg_data *data)
|
2006-03-10 05:32:50 +00:00
|
|
|
{
|
2008-07-09 23:37:38 +00:00
|
|
|
struct imap_store *ctx = (struct imap_store *)gctx;
|
|
|
|
struct imap *imap = ctx->imap;
|
2006-03-10 05:32:50 +00:00
|
|
|
struct imap_cmd_cb cb;
|
|
|
|
const char *prefix, *box;
|
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
|
|
|
int ret, d;
|
|
|
|
char flagstr[128];
|
2006-03-10 05:32:50 +00:00
|
|
|
|
2008-07-09 21:29:01 +00:00
|
|
|
memset(&cb, 0, sizeof(cb));
|
2006-03-10 05:32:50 +00:00
|
|
|
|
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
|
|
|
cb.dlen = data->len;
|
|
|
|
cb.data = xmalloc(cb.dlen);
|
|
|
|
memcpy(cb.data, data->data, data->len);
|
2006-03-10 05:32:50 +00:00
|
|
|
|
|
|
|
d = 0;
|
|
|
|
if (data->flags) {
|
2008-07-09 21:29:01 +00:00
|
|
|
d = imap_make_flags(data->flags, flagstr);
|
2006-03-10 05:32:50 +00:00
|
|
|
flagstr[d++] = ' ';
|
|
|
|
}
|
|
|
|
flagstr[d] = 0;
|
|
|
|
|
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
|
|
|
box = gctx->name;
|
|
|
|
prefix = !strcmp(box, "INBOX") ? "" : ctx->prefix;
|
|
|
|
cb.create = 0;
|
2008-07-09 21:29:01 +00:00
|
|
|
ret = imap_exec_m(ctx, &cb, "APPEND \"%s%s\" %s", prefix, box, flagstr);
|
2006-03-10 05:32:50 +00:00
|
|
|
imap->caps = imap->rcaps;
|
|
|
|
if (ret != DRV_OK)
|
|
|
|
return ret;
|
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
|
|
|
gctx->count++;
|
2006-03-10 05:32:50 +00:00
|
|
|
|
|
|
|
return DRV_OK;
|
|
|
|
}
|
|
|
|
|
2009-02-12 14:58:12 +00:00
|
|
|
static void encode_html_chars(struct strbuf *p)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < p->len; i++) {
|
|
|
|
if (p->buf[i] == '&')
|
|
|
|
strbuf_splice(p, i, 1, "&", 5);
|
|
|
|
if (p->buf[i] == '<')
|
|
|
|
strbuf_splice(p, i, 1, "<", 4);
|
|
|
|
if (p->buf[i] == '>')
|
|
|
|
strbuf_splice(p, i, 1, ">", 4);
|
|
|
|
if (p->buf[i] == '"')
|
|
|
|
strbuf_splice(p, i, 1, """, 6);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
static void wrap_in_html(struct msg_data *msg)
|
|
|
|
{
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
struct strbuf **lines;
|
|
|
|
struct strbuf **p;
|
|
|
|
static char *content_type = "Content-Type: text/html;\n";
|
|
|
|
static char *pre_open = "<pre>\n";
|
|
|
|
static char *pre_close = "</pre>\n";
|
|
|
|
int added_header = 0;
|
|
|
|
|
|
|
|
strbuf_attach(&buf, msg->data, msg->len, msg->len);
|
|
|
|
lines = strbuf_split(&buf, '\n');
|
|
|
|
strbuf_release(&buf);
|
|
|
|
for (p = lines; *p; p++) {
|
|
|
|
if (! added_header) {
|
|
|
|
if ((*p)->len == 1 && *((*p)->buf) == '\n') {
|
|
|
|
strbuf_addstr(&buf, content_type);
|
|
|
|
strbuf_addbuf(&buf, *p);
|
|
|
|
strbuf_addstr(&buf, pre_open);
|
|
|
|
added_header = 1;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
encode_html_chars(*p);
|
|
|
|
strbuf_addbuf(&buf, *p);
|
|
|
|
}
|
|
|
|
strbuf_addstr(&buf, pre_close);
|
|
|
|
strbuf_list_free(lines);
|
|
|
|
msg->len = buf.len;
|
|
|
|
msg->data = strbuf_detach(&buf, NULL);
|
|
|
|
}
|
|
|
|
|
2006-03-10 05:32:50 +00:00
|
|
|
#define CHUNKSIZE 0x1000
|
|
|
|
|
2008-07-09 23:37:38 +00:00
|
|
|
static int read_message(FILE *f, struct msg_data *msg)
|
2006-03-10 05:32:50 +00:00
|
|
|
{
|
2008-10-09 19:12:12 +00:00
|
|
|
struct strbuf buf = STRBUF_INIT;
|
2006-03-10 05:32:50 +00:00
|
|
|
|
2007-09-10 10:35:08 +00:00
|
|
|
memset(msg, 0, sizeof(*msg));
|
|
|
|
|
|
|
|
do {
|
|
|
|
if (strbuf_fread(&buf, CHUNKSIZE, f) <= 0)
|
2006-03-10 05:32:50 +00:00
|
|
|
break;
|
2007-09-10 10:35:08 +00:00
|
|
|
} while (!feof(f));
|
|
|
|
|
|
|
|
msg->len = buf.len;
|
2007-09-27 10:58:23 +00:00
|
|
|
msg->data = strbuf_detach(&buf, NULL);
|
2006-03-10 05:32:50 +00:00
|
|
|
return msg->len;
|
|
|
|
}
|
|
|
|
|
2008-07-09 23:37:38 +00:00
|
|
|
static int count_messages(struct msg_data *msg)
|
2006-03-10 05:32:50 +00:00
|
|
|
{
|
|
|
|
int count = 0;
|
|
|
|
char *p = msg->data;
|
|
|
|
|
|
|
|
while (1) {
|
2007-02-20 09:55:07 +00:00
|
|
|
if (!prefixcmp(p, "From ")) {
|
2006-03-10 05:32:50 +00:00
|
|
|
count++;
|
|
|
|
p += 5;
|
|
|
|
}
|
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;
|
|
|
|
}
|
|
|
|
|
2008-07-09 23:37:38 +00:00
|
|
|
static int split_msg(struct msg_data *all_msgs, struct msg_data *msg, int *ofs)
|
2006-03-10 05:32:50 +00:00
|
|
|
{
|
|
|
|
char *p, *data;
|
|
|
|
|
2008-07-09 21:29:01 +00:00
|
|
|
memset(msg, 0, sizeof *msg);
|
2006-03-10 05:32:50 +00:00
|
|
|
if (*ofs >= all_msgs->len)
|
|
|
|
return 0;
|
|
|
|
|
2008-07-09 21:29:01 +00:00
|
|
|
data = &all_msgs->data[*ofs];
|
2006-03-10 05:32:50 +00:00
|
|
|
msg->len = all_msgs->len - *ofs;
|
|
|
|
|
2007-02-20 09:55:07 +00:00
|
|
|
if (msg->len < 5 || prefixcmp(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) {
|
|
|
|
p = &p[1];
|
|
|
|
msg->len -= p-data;
|
|
|
|
*ofs += p-data;
|
|
|
|
data = p;
|
|
|
|
}
|
|
|
|
|
2008-07-09 21:29:01 +00:00
|
|
|
p = strstr(data, "\nFrom ");
|
2006-03-10 05:32:50 +00:00
|
|
|
if (p)
|
|
|
|
msg->len = &p[1] - data;
|
|
|
|
|
2007-09-15 22:32:36 +00:00
|
|
|
msg->data = xmemdupz(data, msg->len);
|
2006-03-10 05:32:50 +00:00
|
|
|
*ofs += msg->len;
|
2007-06-07 07:04:01 +00:00
|
|
|
return 1;
|
2006-03-10 05:32:50 +00:00
|
|
|
}
|
|
|
|
|
2008-07-09 23:37:38 +00:00
|
|
|
static struct imap_server_conf server = {
|
2006-03-10 05:32:50 +00:00
|
|
|
NULL, /* name */
|
|
|
|
NULL, /* tunnel */
|
|
|
|
NULL, /* host */
|
|
|
|
0, /* port */
|
|
|
|
NULL, /* user */
|
|
|
|
NULL, /* pass */
|
2008-07-09 21:29:00 +00:00
|
|
|
0, /* use_ssl */
|
|
|
|
1, /* ssl_verify */
|
2009-02-12 14:58:12 +00:00
|
|
|
0, /* use_html */
|
2006-03-10 05:32:50 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static char *imap_folder;
|
|
|
|
|
2008-07-09 21:29:01 +00:00
|
|
|
static int git_imap_config(const char *key, const char *val, void *cb)
|
2006-03-10 05:32:50 +00:00
|
|
|
{
|
|
|
|
char imap_key[] = "imap.";
|
|
|
|
|
2008-07-09 21:29:01 +00:00
|
|
|
if (strncmp(key, imap_key, sizeof imap_key - 1))
|
2006-03-10 05:32:50 +00:00
|
|
|
return 0;
|
2008-02-11 20:04:00 +00:00
|
|
|
|
|
|
|
if (!val)
|
|
|
|
return config_error_nonbool(key);
|
|
|
|
|
2006-03-10 05:32:50 +00:00
|
|
|
key += sizeof imap_key - 1;
|
|
|
|
|
2008-07-09 21:29:01 +00:00
|
|
|
if (!strcmp("folder", key)) {
|
|
|
|
imap_folder = xstrdup(val);
|
|
|
|
} else if (!strcmp("host", key)) {
|
2008-07-09 21:29:00 +00:00
|
|
|
if (!prefixcmp(val, "imap:"))
|
|
|
|
val += 5;
|
|
|
|
else if (!prefixcmp(val, "imaps:")) {
|
|
|
|
val += 6;
|
|
|
|
server.use_ssl = 1;
|
2006-03-10 05:32:50 +00:00
|
|
|
}
|
2007-02-20 09:55:07 +00:00
|
|
|
if (!prefixcmp(val, "//"))
|
2006-03-10 05:32:50 +00:00
|
|
|
val += 2;
|
2008-07-09 21:29:01 +00:00
|
|
|
server.host = xstrdup(val);
|
2008-07-09 23:37:38 +00:00
|
|
|
} else if (!strcmp("user", key))
|
2008-07-09 21:29:01 +00:00
|
|
|
server.user = xstrdup(val);
|
|
|
|
else if (!strcmp("pass", key))
|
|
|
|
server.pass = xstrdup(val);
|
|
|
|
else if (!strcmp("port", key))
|
|
|
|
server.port = git_config_int(key, val);
|
|
|
|
else if (!strcmp("tunnel", key))
|
|
|
|
server.tunnel = xstrdup(val);
|
|
|
|
else if (!strcmp("sslverify", key))
|
|
|
|
server.ssl_verify = git_config_bool(key, val);
|
2009-02-12 14:58:12 +00:00
|
|
|
else if (!strcmp("preformattedHTML", key))
|
|
|
|
server.use_html = git_config_bool(key, val);
|
2006-03-10 05:32:50 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-07-09 21:29:01 +00:00
|
|
|
int main(int argc, char **argv)
|
2006-03-10 05:32:50 +00:00
|
|
|
{
|
2008-07-09 23:37:38 +00:00
|
|
|
struct msg_data all_msgs, msg;
|
|
|
|
struct store *ctx = NULL;
|
2006-03-10 05:32:50 +00:00
|
|
|
int ofs = 0;
|
|
|
|
int r;
|
|
|
|
int total, n = 0;
|
2008-07-09 21:28:59 +00:00
|
|
|
int nongit_ok;
|
2006-03-10 05:32:50 +00:00
|
|
|
|
2009-01-18 12:00:12 +00:00
|
|
|
git_extract_argv0_path(argv[0]);
|
|
|
|
|
2009-11-09 15:04:51 +00:00
|
|
|
if (argc != 1)
|
|
|
|
usage(imap_send_usage);
|
|
|
|
|
2008-07-09 21:28:59 +00:00
|
|
|
setup_git_directory_gently(&nongit_ok);
|
2008-05-14 17:46:53 +00:00
|
|
|
git_config(git_imap_config, NULL);
|
2006-03-10 05:32:50 +00:00
|
|
|
|
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
|
|
|
if (!imap_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 */
|
2008-07-09 21:29:01 +00:00
|
|
|
if (!read_message(stdin, &all_msgs)) {
|
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-04-05 14:22:52 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2006-03-10 05:32:50 +00:00
|
|
|
/* write it to the imap server */
|
2008-07-09 21:29:01 +00:00
|
|
|
ctx = imap_open_store(&server);
|
2006-03-10 05:32:50 +00:00
|
|
|
if (!ctx) {
|
2008-07-09 23:37:38 +00:00
|
|
|
fprintf(stderr, "failed to open store\n");
|
2006-03-10 05:32:50 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2008-07-09 23:37:38 +00:00
|
|
|
fprintf(stderr, "sending %d message%s\n", total, (total != 1) ? "s" : "");
|
2006-03-10 05:32:50 +00:00
|
|
|
ctx->name = imap_folder;
|
|
|
|
while (1) {
|
|
|
|
unsigned percent = n * 100 / total;
|
2008-07-09 21:29:01 +00:00
|
|
|
fprintf(stderr, "%4u%% (%d/%d) done\r", percent, n, total);
|
|
|
|
if (!split_msg(&all_msgs, &msg, &ofs))
|
2006-03-10 05:32:50 +00:00
|
|
|
break;
|
2009-02-12 14:58:12 +00:00
|
|
|
if (server.use_html)
|
|
|
|
wrap_in_html(&msg);
|
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
|
|
|
r = imap_store_msg(ctx, &msg);
|
2008-07-09 23:37:38 +00:00
|
|
|
if (r != DRV_OK)
|
|
|
|
break;
|
2006-03-10 05:32:50 +00:00
|
|
|
n++;
|
|
|
|
}
|
2008-07-09 21:29:01 +00:00
|
|
|
fprintf(stderr, "\n");
|
2006-03-10 05:32:50 +00:00
|
|
|
|
2008-07-09 21:29:01 +00:00
|
|
|
imap_close_store(ctx);
|
2006-03-10 05:32:50 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|