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