5f4ec07e79c58a061bb19116d482baff004f199d
[claws.git] / src / etpan / imap-thread.c
1 /*
2  * Claws Mail -- a GTK+ based, lightweight, and fast e-mail client
3  * Copyright (C) 2005-2007 DINH Viet Hoa and the Claws Mail team
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 3 of the License, or
8  * (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program. If not, see <http://www.gnu.org/licenses/>.
17  * 
18  */
19
20 #ifdef HAVE_CONFIG_H
21 #  include "config.h"
22 #endif
23
24 #ifdef HAVE_LIBETPAN
25
26 #include "imap-thread.h"
27 #include <imap.h>
28 #include <sys/types.h>
29 #include <sys/stat.h>
30 #if (defined(__DragonFly__) || defined (__NetBSD__) || defined (__FreeBSD__) || defined (__OpenBSD__) || defined (__CYGWIN__))
31 #include <sys/socket.h>
32 #endif
33 #include <fcntl.h>
34 #ifndef G_OS_WIN32
35 #include <sys/mman.h>
36 #include <sys/wait.h>
37 #endif
38 #include <gtk/gtk.h>
39 #include <log.h>
40 #include "etpan-thread-manager.h"
41 #include "utils.h"
42 #include "mainwindow.h"
43 #include "ssl.h"
44 #include "ssl_certificate.h"
45 #include "socket.h"
46 #include "remotefolder.h"
47
48 #define DISABLE_LOG_DURING_LOGIN
49
50 static struct etpan_thread_manager * thread_manager = NULL;
51 static chash * courier_workaround_hash = NULL;
52 static chash * imap_hash = NULL;
53 static chash * session_hash = NULL;
54 static guint thread_manager_signal = 0;
55 static GIOChannel * io_channel = NULL;
56
57 static void delete_imap(Folder *folder, mailimap *imap)
58 {
59         chashdatum key;
60         chashdatum value;
61
62         key.data = &folder;
63         key.len = sizeof(folder);
64         value.data = imap;
65         value.len = 0;
66         chash_delete(session_hash, &key, NULL);
67         
68         key.data = &imap;
69         key.len = sizeof(imap);
70         chash_delete(courier_workaround_hash, &key, NULL);
71         if (imap && imap->imap_stream) {
72                 /* we don't want libetpan to logout */
73                 mailstream_close(imap->imap_stream);
74                 imap->imap_stream = NULL;
75         }
76         debug_print("removing mailimap %p\n", imap);
77         mailimap_free(imap);    
78 }
79
80 static gboolean thread_manager_event(GIOChannel * source,
81     GIOCondition condition,
82     gpointer data)
83 {
84         etpan_thread_manager_loop(thread_manager);
85         
86         return TRUE;
87 }
88
89 static void imap_logger_noop(int direction, const char * str, size_t size) 
90 {
91         /* inhibit logging */
92 }
93
94 static void imap_logger_cmd(int direction, const char * str, size_t size) 
95 {
96         gchar *buf;
97         gchar **lines;
98         int i = 0;
99
100         if (size > 8192) {
101                 log_print(LOG_PROTOCOL, "IMAP4%c [CMD data - %zd bytes]\n", direction?'>':'<', size);
102                 return;
103         }
104         buf = malloc(size+1);
105         memset(buf, 0, size+1);
106         strncpy(buf, str, size);
107         buf[size] = '\0';
108
109         if (!strncmp(buf, "<<<<<<<", 7) 
110         ||  !strncmp(buf, ">>>>>>>", 7)) {
111                 free(buf);
112                 return;
113         }
114         while (strstr(buf, "\r"))
115                 *strstr(buf, "\r") = ' ';
116         while (strlen(buf) > 0 && buf[strlen(buf)-1] == '\n')
117                 buf[strlen(buf)-1] = '\0';
118
119         lines = g_strsplit(buf, "\n", -1);
120
121         while (lines[i] && *lines[i]) {
122                 log_print(LOG_PROTOCOL, "IMAP4%c %s\n", direction?'>':'<', lines[i]);
123                 i++;
124         }
125         g_strfreev(lines);
126         free(buf);
127 }
128
129 static void imap_logger_fetch(int direction, const char * str, size_t size) 
130 {
131         gchar *buf;
132         gchar **lines;
133         int i = 0;
134
135         if (size > 128 && !direction) {
136                 log_print(LOG_PROTOCOL, "IMAP4%c [FETCH data - %zd bytes]\n", direction?'>':'<', size);
137                 return;
138         }
139         
140         buf = malloc(size+1);
141         memset(buf, 0, size+1);
142         strncpy(buf, str, size);
143         buf[size] = '\0';
144         if (!strncmp(buf, "<<<<<<<", 7) 
145         ||  !strncmp(buf, ">>>>>>>", 7)) {
146                 free(buf);
147                 return;
148         }
149         while (strstr(buf, "\r"))
150                 *strstr(buf, "\r") = ' ';
151         while (strlen(buf) > 0 && buf[strlen(buf)-1] == '\n')
152                 buf[strlen(buf)-1] = '\0';
153
154         lines = g_strsplit(buf, "\n", -1);
155
156         if (direction != 0 || (buf[0] == '*' && buf[1] == ' ') || size < 32) {
157                 while (lines[i] && *lines[i]) {
158                         log_print(LOG_PROTOCOL, "IMAP4%c %s\n", direction?'>':'<', lines[i]);
159                         i++;
160                 }
161         } else {
162                 log_print(LOG_PROTOCOL, "IMAP4%c [data - %zd bytes]\n", direction?'>':'<', size);
163         }
164         g_strfreev(lines);
165         free(buf);
166 }
167
168 static void imap_logger_uid(int direction, const char * str, size_t size) 
169 {
170         gchar *buf;
171         gchar **lines;
172         int i = 0;
173
174         if (size > 8192) {
175                 log_print(LOG_PROTOCOL, "IMAP4%c [UID data - %zd bytes]\n", direction?'>':'<', size);
176                 return;
177         }
178         buf = malloc(size+1);
179         memset(buf, 0, size+1);
180         strncpy(buf, str, size);
181         buf[size] = '\0';
182         if (!strncmp(buf, "<<<<<<<", 7) 
183         ||  !strncmp(buf, ">>>>>>>", 7)) {
184                 free(buf);
185                 return;
186         }
187         while (strstr(buf, "\r"))
188                 *strstr(buf, "\r") = ' ';
189         while (strlen(buf) > 0 && buf[strlen(buf)-1] == '\n')
190                 buf[strlen(buf)-1] = '\0';
191
192         lines = g_strsplit(buf, "\n", -1);
193
194         while (lines[i] && *lines[i]) {
195                 int llen = strlen(lines[i]);
196                 if (llen < 64)
197                         log_print(LOG_PROTOCOL, "IMAP4%c %s\n", direction?'>':'<', lines[i]);
198                 else {
199                         gchar tmp[64];
200                         strncpy2(tmp, lines[i], 63);
201                         log_print(LOG_PROTOCOL, "IMAP4%c %s[... - %d bytes more]\n", direction?'>':'<', tmp,
202                                   llen-64);
203                 }
204                 i++;
205         }
206         g_strfreev(lines);
207         free(buf);
208 }
209
210 static void imap_logger_append(int direction, const char * str, size_t size) 
211 {
212         gchar *buf;
213         gchar **lines;
214         int i = 0;
215
216         if (size > 8192) {
217                 log_print(LOG_PROTOCOL, "IMAP4%c [APPEND data - %zd bytes]\n", direction?'>':'<', size);
218                 return;
219         } else if (direction == 0 && size > 64) {
220                 log_print(LOG_PROTOCOL, "IMAP4%c [APPEND data - %zd bytes]\n", direction?'>':'<', size);
221                 return;
222         } 
223         buf = malloc(size+1);
224         memset(buf, 0, size+1);
225         strncpy(buf, str, size);
226         buf[size] = '\0';
227         if (!strncmp(buf, "<<<<<<<", 7) 
228         ||  !strncmp(buf, ">>>>>>>", 7)) {
229                 free(buf);
230                 return;
231         }
232         while (strstr(buf, "\r"))
233                 *strstr(buf, "\r") = ' ';
234         while (strlen(buf) > 0 && buf[strlen(buf)-1] == '\n')
235                 buf[strlen(buf)-1] = '\0';
236
237         lines = g_strsplit(buf, "\n", -1);
238
239         if (direction == 0 || (buf[0] == '*' && buf[1] == ' ') || size < 64) {
240                 while (lines[i] && *lines[i]) {
241                         log_print(LOG_PROTOCOL, "IMAP4%c %s\n", direction?'>':'<', lines[i]);
242                         i++;
243                 }
244         } else {
245                 log_print(LOG_PROTOCOL, "IMAP4%c [data - %zd bytes]\n", direction?'>':'<', size);
246         }
247         g_strfreev(lines);
248         free(buf);
249 }
250
251 #define ETPAN_DEFAULT_NETWORK_TIMEOUT 60
252 gboolean etpan_skip_ssl_cert_check = FALSE;
253 extern void mailsasl_ref(void);
254
255 void imap_main_init(gboolean skip_ssl_cert_check)
256 {
257         int fd_thread_manager;
258         
259         etpan_skip_ssl_cert_check = skip_ssl_cert_check;
260         mailstream_network_delay.tv_sec = ETPAN_DEFAULT_NETWORK_TIMEOUT;
261         mailstream_network_delay.tv_usec = 0;
262         
263         mailstream_debug = 1;
264         mailstream_logger = imap_logger_cmd;
265         mailsasl_ref();
266         
267         imap_hash = chash_new(CHASH_COPYKEY, CHASH_DEFAULTSIZE);
268         session_hash = chash_new(CHASH_COPYKEY, CHASH_DEFAULTSIZE);
269         courier_workaround_hash = chash_new(CHASH_COPYKEY, CHASH_DEFAULTSIZE);
270         
271         thread_manager = etpan_thread_manager_new();
272         
273         fd_thread_manager = etpan_thread_manager_get_fd(thread_manager);
274         
275         io_channel = g_io_channel_unix_new(fd_thread_manager);
276         
277         thread_manager_signal = g_io_add_watch_full(io_channel, 0, G_IO_IN,
278                                                     thread_manager_event,
279                                                     (gpointer) NULL,
280                                                     NULL);
281 }
282
283 void imap_main_set_timeout(int sec)
284 {
285         mailstream_network_delay.tv_sec = sec;
286         mailstream_network_delay.tv_usec = 0;
287 }
288
289 void imap_main_done(void)
290 {
291         imap_disconnect_all();
292         etpan_thread_manager_stop(thread_manager);
293 #if defined(__NetBSD__) || defined(__OpenBSD__) || defined(__FreeBSD__)
294         return;
295 #endif
296         etpan_thread_manager_join(thread_manager);
297         
298         g_source_remove(thread_manager_signal);
299         g_io_channel_unref(io_channel);
300         
301         etpan_thread_manager_free(thread_manager);
302         
303         chash_free(courier_workaround_hash);
304         chash_free(session_hash);
305         chash_free(imap_hash);
306 }
307
308 void imap_init(Folder * folder)
309 {
310         struct etpan_thread * thread;
311         chashdatum key;
312         chashdatum value;
313         
314         thread = etpan_thread_manager_get_thread(thread_manager);
315         
316         key.data = &folder;
317         key.len = sizeof(folder);
318         value.data = thread;
319         value.len = 0;
320         
321         chash_set(imap_hash, &key, &value, NULL);
322 }
323
324 void imap_done(Folder * folder)
325 {
326         struct etpan_thread * thread;
327         chashdatum key;
328         chashdatum value;
329         int r;
330         
331         key.data = &folder;
332         key.len = sizeof(folder);
333         
334         r = chash_get(imap_hash, &key, &value);
335         if (r < 0)
336                 return;
337         
338         thread = value.data;
339         
340         etpan_thread_unbind(thread);
341         
342         chash_delete(imap_hash, &key, NULL);
343         
344         debug_print("remove thread");
345 }
346
347 static struct etpan_thread * get_thread(Folder * folder)
348 {
349         struct etpan_thread * thread;
350         chashdatum key;
351         chashdatum value;
352         
353         key.data = &folder;
354         key.len = sizeof(folder);
355         
356         chash_get(imap_hash, &key, &value);
357         thread = value.data;
358         
359         return thread;
360 }
361
362 static mailimap * get_imap(Folder * folder)
363 {
364         mailimap * imap;
365         chashdatum key;
366         chashdatum value;
367         int r;
368         
369         key.data = &folder;
370         key.len = sizeof(folder);
371         
372         r = chash_get(session_hash, &key, &value);
373         if (r < 0)
374                 return NULL;
375         
376         imap = value.data;
377         debug_print("found imap %p\n", imap);
378         return imap;
379 }
380
381 static gboolean cb_show_error(gpointer data)
382 {
383         mainwindow_show_error();
384         return FALSE;
385 }
386
387 static void generic_cb(int cancelled, void * result, void * callback_data)
388 {
389         struct etpan_thread_op * op;
390         
391         op = (struct etpan_thread_op *) callback_data;
392
393         debug_print("generic_cb\n");
394         if (op->imap && op->imap->imap_response_info &&
395             op->imap->imap_response_info->rsp_alert) {
396                 log_error(LOG_PROTOCOL, "IMAP4< Alert: %s\n", 
397                         op->imap->imap_response_info->rsp_alert);
398                 g_timeout_add(10, cb_show_error, NULL);
399         } 
400         op->finished = 1;
401 }
402
403 static void threaded_run(Folder * folder, void * param, void * result,
404                          void (* func)(struct etpan_thread_op * ))
405 {
406         struct etpan_thread_op * op;
407         struct etpan_thread * thread;
408         
409         imap_folder_ref(folder);
410
411         op = etpan_thread_op_new();
412         
413         op->imap = get_imap(folder);
414         op->param = param;
415         op->result = result;
416         
417         op->cancellable = 0;
418         op->run = func;
419         op->callback = generic_cb;
420         op->callback_data = op;
421         op->cleanup = NULL;
422         
423         op->finished = 0;
424         
425         thread = get_thread(folder);
426         etpan_thread_op_schedule(thread, op);
427         
428         while (!op->finished) {
429                 gtk_main_iteration();
430         }
431         
432         etpan_thread_op_free(op);
433
434         imap_folder_unref(folder);
435 }
436
437
438 /* connect */
439
440 struct connect_param {
441         mailimap * imap;
442         PrefsAccount *account;
443         const char * server;
444         int port;
445 };
446
447 struct connect_result {
448         int error;
449 };
450
451 #define CHECK_IMAP() {                                          \
452         if (!param->imap) {                                     \
453                 result->error = MAILIMAP_ERROR_BAD_STATE;       \
454                 return;                                         \
455         }                                                       \
456 }
457
458 static void connect_run(struct etpan_thread_op * op)
459 {
460         int r;
461         struct connect_param * param;
462         struct connect_result * result;
463         
464         param = op->param;
465         result = op->result;
466         
467         CHECK_IMAP();
468
469         r = mailimap_socket_connect(param->imap,
470                                     param->server, param->port);
471         
472         result->error = r;
473 }
474
475
476 int imap_threaded_connect(Folder * folder, const char * server, int port)
477 {
478         struct connect_param param;
479         struct connect_result result;
480         chashdatum key;
481         chashdatum value;
482         mailimap * imap, * oldimap;
483         
484         oldimap = get_imap(folder);
485
486         imap = mailimap_new(0, NULL);
487         
488         if (oldimap) {
489                 debug_print("deleting old imap %p\n", oldimap);
490                 delete_imap(folder, oldimap);
491         }
492         
493         key.data = &folder;
494         key.len = sizeof(folder);
495         value.data = imap;
496         value.len = 0;
497         chash_set(session_hash, &key, &value, NULL);
498         
499         param.imap = imap;
500         param.server = server;
501         param.port = port;
502         
503         refresh_resolvers();
504         threaded_run(folder, &param, &result, connect_run);
505         
506         debug_print("connect ok %i with imap %p\n", result.error, imap);
507         
508         return result.error;
509 }
510
511 static int etpan_certificate_check(const unsigned char *certificate, int len, void *data)
512 {
513 #ifdef USE_OPENSSL
514         struct connect_param *param = (struct connect_param *)data;
515         X509 *cert = NULL;
516         
517         if (certificate == NULL || len < 0) {
518                 g_warning("no cert presented.\n");
519                 return 0;
520         }
521         cert = d2i_X509(NULL, (const unsigned char **)&certificate, len);
522         if (cert == NULL) {
523                 g_warning("IMAP: can't get cert\n");
524                 return 0;
525         } else if (ssl_certificate_check(cert, NULL,
526                 (gchar *)param->server, (gushort)param->port) == TRUE) {
527                 X509_free(cert);
528                 return 0;
529         } else {
530                 X509_free(cert);
531                 return -1;
532         }
533 #elif USE_GNUTLS
534         struct connect_param *param = (struct connect_param *)data;
535         gnutls_x509_crt cert = NULL;
536         gnutls_datum tmp;
537         
538         if (certificate == NULL || len < 0) {
539                 g_warning("no cert presented.\n");
540                 return 0;
541         }
542         
543         tmp.data = malloc(len);
544         memcpy(tmp.data, certificate, len);
545         tmp.size = len;
546         gnutls_x509_crt_init(&cert);
547         if (gnutls_x509_crt_import(cert, &tmp, GNUTLS_X509_FMT_DER) < 0) {
548                 g_warning("IMAP: can't get cert\n");
549                 return 0;
550         } else if (ssl_certificate_check(cert, (guint)-1, NULL,
551                 (gchar *)param->server, (gushort)param->port) == TRUE) {
552                 gnutls_x509_crt_deinit(cert);
553                 return 0;
554         } else {
555                 gnutls_x509_crt_deinit(cert);
556                 return -1;
557         }
558 #endif
559         return 0;
560 }
561
562 static void connect_ssl_context_cb(struct mailstream_ssl_context * ssl_context, void * data)
563 {
564 #if (defined(USE_OPENSSL) || defined(USE_GNUTLS))
565         PrefsAccount *account = (PrefsAccount *)data;
566         const gchar *cert_path = NULL;
567         const gchar *password = NULL;
568 #ifdef USE_OPENSSL
569         X509 *x509 = NULL;
570         EVP_PKEY *pkey = NULL;
571 #else
572         gnutls_x509_crt x509 = NULL;
573         gnutls_x509_privkey pkey = NULL;
574 #endif
575
576         if (account->in_ssl_client_cert_file && *account->in_ssl_client_cert_file)
577                 cert_path = account->in_ssl_client_cert_file;
578         if (account->in_ssl_client_cert_pass && *account->in_ssl_client_cert_pass)
579                 password = account->in_ssl_client_cert_pass;
580         
581         if (mailstream_ssl_set_client_certificate_data(ssl_context, NULL, 0) < 0 ||
582             mailstream_ssl_set_client_private_key_data(ssl_context, NULL, 0) < 0)
583                 debug_print("Impossible to set the client certificate.\n");
584         x509 = ssl_certificate_get_x509_from_pem_file(cert_path);
585         pkey = ssl_certificate_get_pkey_from_pem_file(cert_path);
586         if (!(x509 && pkey)) {
587                 /* try pkcs12 format */
588                 ssl_certificate_get_x509_and_pkey_from_p12_file(cert_path, password, &x509, &pkey);
589         }
590         if (x509 && pkey) {
591                 unsigned char *x509_der = NULL, *pkey_der = NULL;
592                 size_t x509_len, pkey_len;
593                 
594 #ifndef USE_GNUTLS
595                 x509_len = (size_t)i2d_X509(x509, &x509_der);
596                 pkey_len = (size_t)i2d_PrivateKey(pkey, &pkey_der);
597 #else
598                 x509_len = (size_t)gnutls_i2d_X509(x509, &x509_der);
599                 pkey_len = (size_t)gnutls_i2d_PrivateKey(pkey, &pkey_der);
600 #endif
601                 if (x509_len > 0 && pkey_len > 0) {
602                         if (mailstream_ssl_set_client_certificate_data(ssl_context, x509_der, x509_len) < 0 ||
603                             mailstream_ssl_set_client_private_key_data(ssl_context, pkey_der, pkey_len) < 0) 
604                                 log_error(LOG_PROTOCOL, "Impossible to set the client certificate.\n");
605                         g_free(x509_der);
606                         g_free(pkey_der);
607                 }
608 #ifdef USE_GNUTLS
609                 gnutls_x509_crt_deinit(x509);
610                 gnutls_x509_privkey_deinit(pkey);
611 #endif
612         }
613 #endif
614 }
615
616 static void connect_ssl_run(struct etpan_thread_op * op)
617 {
618         int r;
619         struct connect_param * param;
620         struct connect_result * result;
621         
622         param = op->param;
623         result = op->result;
624         
625         CHECK_IMAP();
626
627         r = mailimap_ssl_connect_with_callback(param->imap,
628                                                 param->server, param->port,
629                                                 connect_ssl_context_cb, param->account);
630         result->error = r;
631 }
632
633 int imap_threaded_connect_ssl(Folder * folder, const char * server, int port)
634 {
635         struct connect_param param;
636         struct connect_result result;
637         chashdatum key;
638         chashdatum value;
639         mailimap * imap, * oldimap;
640         unsigned char *certificate = NULL;
641         int cert_len;
642         
643         oldimap = get_imap(folder);
644
645         imap = mailimap_new(0, NULL);
646         
647         if (oldimap) {
648                 debug_print("deleting old imap %p\n", oldimap);
649                 delete_imap(folder, oldimap);
650         }
651
652         key.data = &folder;
653         key.len = sizeof(folder);
654         value.data = imap;
655         value.len = 0;
656         chash_set(session_hash, &key, &value, NULL);
657         
658         param.imap = imap;
659         param.server = server;
660         param.port = port;
661         param.account = folder->account;
662
663         refresh_resolvers();
664         threaded_run(folder, &param, &result, connect_ssl_run);
665
666         if ((result.error == MAILIMAP_NO_ERROR_AUTHENTICATED ||
667              result.error == MAILIMAP_NO_ERROR_NON_AUTHENTICATED) && !etpan_skip_ssl_cert_check) {
668                 cert_len = (int)mailstream_ssl_get_certificate(imap->imap_stream, &certificate);
669                 if (etpan_certificate_check(certificate, cert_len, &param) < 0)
670                         return -1;
671                 if (certificate) 
672                         free(certificate); 
673         }
674         debug_print("connect %d with imap %p\n", result.error, imap);
675         
676         return result.error;
677 }
678
679 struct capa_param {
680         mailimap * imap;
681 };
682
683 struct capa_result {
684         int error;
685         struct mailimap_capability_data *caps;
686 };
687
688 static void capability_run(struct etpan_thread_op * op)
689 {
690         int r;
691         struct capa_param * param;
692         struct capa_result * result;
693         struct mailimap_capability_data *caps;
694
695         param = op->param;
696         result = op->result;
697         
698         CHECK_IMAP();
699
700         r = mailimap_capability(param->imap, &caps);
701         
702         result->error = r;
703         result->caps = (r == 0 ? caps : NULL);
704 }
705
706
707 struct mailimap_capability_data * imap_threaded_capability(Folder *folder, int *ok)
708 {
709         struct capa_param param;
710         struct capa_result result;
711         mailimap *imap;
712         
713         imap = get_imap(folder);
714         
715         param.imap = imap;
716         
717         threaded_run(folder, &param, &result, capability_run);
718         
719         debug_print("capa %d\n", result.error);
720         
721         if (ok)
722                 *ok = result.error;
723
724         return result.caps;
725         
726 }
727         
728 struct disconnect_param {
729         mailimap * imap;
730 };
731
732 struct disconnect_result {
733         int error;
734 };
735
736 static void disconnect_run(struct etpan_thread_op * op)
737 {
738         int r;
739         struct disconnect_param * param;
740         struct disconnect_result * result;
741         
742         param = op->param;
743         result = op->result;
744         
745         CHECK_IMAP();
746
747         r = mailimap_logout(param->imap);
748         
749         result->error = r;
750 }
751
752 void imap_threaded_disconnect(Folder * folder)
753 {
754         struct connect_param param;
755         struct connect_result result;
756         mailimap * imap;
757         
758         imap = get_imap(folder);
759         if (imap == NULL) {
760                 debug_print("was disconnected\n");
761                 return;
762         }
763         
764         param.imap = imap;
765         
766         threaded_run(folder, &param, &result, disconnect_run);
767         
768         if (imap == get_imap(folder)) {
769                 debug_print("deleting old imap %p\n", imap);
770                 delete_imap(folder, imap);
771         } else {
772                 debug_print("imap already deleted %p\n", imap);
773         }
774         
775         debug_print("disconnect ok\n");
776 }
777
778
779 struct list_param {
780         mailimap * imap;
781         const char * base;
782         const char * wildcard;
783         gboolean sub_only;
784 };
785
786 struct list_result {
787         int error;
788         clist * list;
789 };
790
791 static void list_run(struct etpan_thread_op * op)
792 {
793         struct list_param * param;
794         struct list_result * result;
795         int r;
796         clist * list;
797         
798         param = op->param;
799         result = op->result;
800
801         CHECK_IMAP();
802
803         list = NULL;
804         
805         if (param->base == NULL || param->wildcard == NULL) {
806                 result->list = list;
807                 result->error = -1;
808                 debug_print("no base or wildcard (%p %p)\n", param->base, param->wildcard);
809                 return;
810         }
811         if (param->sub_only)
812                 r = mailimap_lsub(param->imap, param->base,
813                           param->wildcard, &list);
814         else
815                 r = mailimap_list(param->imap, param->base,
816                           param->wildcard, &list);
817         result->error = r;
818         result->list = list;
819         debug_print("imap list run - end\n");
820 }
821
822 int imap_threaded_list(Folder * folder, const char * base,
823                        const char * wildcard,
824                        clist ** p_result)
825 {
826         struct list_param param;
827         struct list_result result;
828         
829         debug_print("imap list - begin\n");
830         
831         param.imap = get_imap(folder);
832         param.base = base;
833         param.wildcard = wildcard;
834         param.sub_only = FALSE;
835
836         threaded_run(folder, &param, &result, list_run);
837         
838         * p_result = result.list;
839         
840         debug_print("imap list - end %p\n", result.list);
841         
842         return result.error;
843 }
844
845 int imap_threaded_lsub(Folder * folder, const char * base,
846                        const char * wildcard,
847                        clist ** p_result)
848 {
849         struct list_param param;
850         struct list_result result;
851         
852         debug_print("imap lsub - begin\n");
853         
854         param.imap = get_imap(folder);
855         param.base = base;
856         param.wildcard = wildcard;
857         param.sub_only = TRUE;
858         
859         threaded_run(folder, &param, &result, list_run);
860         
861         * p_result = result.list;
862         
863         debug_print("imap lsub - end %p\n", result.list);
864         
865         return result.error;
866 }
867
868 struct subscribe_param {
869         mailimap * imap;
870         const char * mb;
871         gboolean subscribe;
872 };
873
874 struct subscribe_result {
875         int error;
876 };
877
878 static void subscribe_run(struct etpan_thread_op * op)
879 {
880         struct subscribe_param * param;
881         struct subscribe_result * result;
882         int r;
883         
884         param = op->param;
885         result = op->result;
886
887         CHECK_IMAP();
888
889         if (param->mb == NULL) {
890                 result->error = -1;
891                 debug_print("no mb\n");
892                 return;
893         }
894         if (param->subscribe)
895                 r = mailimap_subscribe(param->imap, param->mb);
896         else
897                 r = mailimap_unsubscribe(param->imap, param->mb);
898         result->error = r;
899         debug_print("imap %ssubscribe run - end %d\n", param->subscribe?"":"un", r);
900 }
901
902 int imap_threaded_subscribe(Folder * folder, const char * mb,
903                        gboolean subscribe)
904 {
905         struct subscribe_param param;
906         struct subscribe_result result;
907         
908         debug_print("imap list - begin\n");
909         
910         param.imap = get_imap(folder);
911         param.mb = mb;
912         param.subscribe = subscribe;
913
914         threaded_run(folder, &param, &result, subscribe_run);
915         
916         return result.error;
917 }
918
919 struct login_param {
920         mailimap * imap;
921         const char * login;
922         const char * password;
923         const char * type;
924         const char * server;
925 };
926
927 struct login_result {
928         int error;
929 };
930
931 static void login_run(struct etpan_thread_op * op)
932 {
933         struct login_param * param;
934         struct login_result * result;
935         int r;
936 #ifdef DISABLE_LOG_DURING_LOGIN
937         int old_debug;
938 #endif
939         
940         param = op->param;
941         result = op->result;
942
943         CHECK_IMAP();
944
945 #ifdef DISABLE_LOG_DURING_LOGIN
946         old_debug = mailstream_debug;
947         mailstream_debug = 0;
948 #endif
949         if (!strcmp(param->type, "LOGIN"))
950                 r = mailimap_login(param->imap,
951                            param->login, param->password);
952         else if (!strcmp(param->type, "GSSAPI"))
953                 r = mailimap_authenticate(param->imap,
954                         param->type, param->server, NULL, NULL,
955                         param->login, param->login,
956                         param->password, NULL);
957         else 
958                 r = mailimap_authenticate(param->imap,
959                         param->type, NULL, NULL, NULL,
960                         param->login, param->login,
961                         param->password, NULL);
962 #ifdef DISABLE_LOG_DURING_LOGIN
963         mailstream_debug = old_debug;
964 #endif
965         
966         result->error = r;
967         if (param->imap->imap_response)
968                 imap_logger_cmd(0, param->imap->imap_response, strlen(param->imap->imap_response));
969         debug_print("imap login run - end %i\n", r);
970 }
971
972 int imap_threaded_login(Folder * folder,
973                         const char * login, const char * password,
974                         const char * type)
975 {
976         struct login_param param;
977         struct login_result result;
978         
979         debug_print("imap login - begin\n");
980         
981         param.imap = get_imap(folder);
982         param.login = login;
983         param.password = password;
984         param.type = type;
985         if (folder && folder->account)
986                 param.server = folder->account->recv_server;
987         else
988                 param.server = NULL;
989
990         threaded_run(folder, &param, &result, login_run);
991         
992         debug_print("imap login - end\n");
993         
994         return result.error;
995 }
996
997
998 struct status_param {
999         mailimap * imap;
1000         const char * mb;
1001         struct mailimap_status_att_list * status_att_list;
1002 };
1003
1004 struct status_result {
1005         int error;
1006         struct mailimap_mailbox_data_status * data_status;
1007 };
1008
1009 static void status_run(struct etpan_thread_op * op)
1010 {
1011         struct status_param * param;
1012         struct status_result * result;
1013         int r;
1014         
1015         param = op->param;
1016         result = op->result;
1017         
1018         CHECK_IMAP();
1019
1020         r = mailimap_status(param->imap, param->mb,
1021                             param->status_att_list,
1022                             &result->data_status);
1023         
1024         result->error = r;
1025         debug_print("imap status run - end %i\n", r);
1026 }
1027
1028 int imap_threaded_status(Folder * folder, const char * mb,
1029                          struct mailimap_mailbox_data_status ** data_status,
1030                          guint mask)
1031 {
1032         struct status_param param;
1033         struct status_result result;
1034         struct mailimap_status_att_list * status_att_list;
1035         
1036         debug_print("imap status - begin\n");
1037         
1038         status_att_list = mailimap_status_att_list_new_empty();
1039         if (mask & 1 << 0) {
1040                 mailimap_status_att_list_add(status_att_list,
1041                                      MAILIMAP_STATUS_ATT_MESSAGES);
1042         }
1043         if (mask & 1 << 1) {
1044                 mailimap_status_att_list_add(status_att_list,
1045                                      MAILIMAP_STATUS_ATT_RECENT);
1046         }
1047         if (mask & 1 << 2) {
1048                 mailimap_status_att_list_add(status_att_list,
1049                                      MAILIMAP_STATUS_ATT_UIDNEXT);
1050         }
1051         if (mask & 1 << 3) {
1052                 mailimap_status_att_list_add(status_att_list,
1053                                      MAILIMAP_STATUS_ATT_UIDVALIDITY);
1054         }
1055         if (mask & 1 << 4) {
1056                 mailimap_status_att_list_add(status_att_list,
1057                                      MAILIMAP_STATUS_ATT_UNSEEN);
1058         }
1059         param.imap = get_imap(folder);
1060         param.mb = mb;
1061         param.status_att_list = status_att_list;
1062         
1063         threaded_run(folder, &param, &result, status_run);
1064         
1065         debug_print("imap status - end\n");
1066         
1067         * data_status = result.data_status;
1068         
1069         mailimap_status_att_list_free(status_att_list);
1070         
1071         return result.error;
1072 }
1073
1074
1075
1076 struct noop_param {
1077         mailimap * imap;
1078 };
1079
1080 struct noop_result {
1081         int error;
1082 };
1083
1084 static void noop_run(struct etpan_thread_op * op)
1085 {
1086         struct noop_param * param;
1087         struct noop_result * result;
1088         int r;
1089         
1090         param = op->param;
1091         result = op->result;
1092
1093         CHECK_IMAP();
1094
1095         r = mailimap_noop(param->imap);
1096         
1097         result->error = r;
1098         debug_print("imap noop run - end %i\n", r);
1099 }
1100
1101 int imap_threaded_noop(Folder * folder, unsigned int * p_exists, 
1102                        unsigned int *p_recent, 
1103                        unsigned int *p_expunge,
1104                        unsigned int *p_unseen,
1105                        unsigned int *p_uidnext,
1106                        unsigned int *p_uidval)
1107 {
1108         struct noop_param param;
1109         struct noop_result result;
1110         mailimap * imap;
1111         
1112         debug_print("imap noop - begin\n");
1113         
1114         imap = get_imap(folder);
1115         param.imap = imap;
1116
1117         threaded_run(folder, &param, &result, noop_run);
1118         
1119         if (result.error == 0 && imap && imap->imap_selection_info != NULL) {
1120                 * p_exists = imap->imap_selection_info->sel_exists;
1121                 * p_recent = imap->imap_selection_info->sel_recent;
1122                 * p_unseen = imap->imap_selection_info->sel_unseen;
1123                 * p_uidnext = imap->imap_selection_info->sel_uidnext;
1124                 * p_uidval = imap->imap_selection_info->sel_uidvalidity;
1125         } else {
1126                 * p_exists = 0;
1127                 * p_recent = 0;
1128                 * p_unseen = 0;
1129                 * p_uidnext = 0;
1130                 * p_uidval = 0;
1131         }
1132         if (result.error == 0 && imap && imap->imap_response_info != NULL &&
1133             imap->imap_response_info->rsp_expunged != NULL) {
1134                 * p_expunge = clist_count(imap->imap_response_info->rsp_expunged);
1135         } else {
1136                 * p_expunge = 0;
1137         }       
1138         debug_print("imap noop - end [EXISTS %d RECENT %d EXPUNGE %d UNSEEN %d UIDNEXT %d UIDVAL %d]\n",
1139                 *p_exists, *p_recent, *p_expunge, *p_unseen,
1140                 *p_uidnext, *p_uidval);
1141         
1142         return result.error;
1143 }
1144
1145
1146 struct starttls_result {
1147         int error;
1148 };
1149
1150 static void starttls_run(struct etpan_thread_op * op)
1151 {
1152         struct connect_param * param;
1153         struct starttls_result * result;
1154         int r;
1155
1156         param = op->param;
1157         result = op->result;
1158
1159         CHECK_IMAP();
1160
1161         r = mailimap_starttls(param->imap);
1162         
1163         result->error = r;
1164         debug_print("imap starttls run - end %i\n", r);
1165         
1166         if (r == 0) {
1167                 mailimap *imap = param->imap;
1168                 mailstream_low *plain_low = NULL;
1169                 mailstream_low *tls_low = NULL;
1170                 int fd = -1;
1171                 
1172                 plain_low = mailstream_get_low(imap->imap_stream);
1173                 fd = mailstream_low_get_fd(plain_low);
1174                 if (fd == -1) {
1175                         debug_print("imap starttls run - can't get fd\n");
1176                         result->error = MAILIMAP_ERROR_STREAM;
1177                         return;
1178                 }
1179
1180                 tls_low = mailstream_low_tls_open_with_callback(fd, connect_ssl_context_cb, param->account);
1181                 if (tls_low == NULL) {
1182                         debug_print("imap starttls run - can't tls_open\n");
1183                         result->error = MAILIMAP_ERROR_STREAM;
1184                         return;
1185                 }
1186                 mailstream_low_free(plain_low);
1187                 mailstream_set_low(imap->imap_stream, tls_low);
1188         }
1189 }
1190
1191 int imap_threaded_starttls(Folder * folder, const gchar *host, int port)
1192 {
1193         struct connect_param param;
1194         struct starttls_result result;
1195         int cert_len;
1196         unsigned char *certificate;
1197         
1198         debug_print("imap starttls - begin\n");
1199         
1200         param.imap = get_imap(folder);
1201         param.server = host;
1202         param.port = port;
1203         param.account = folder->account;
1204
1205         threaded_run(folder, &param, &result, starttls_run);
1206         
1207         debug_print("imap starttls - end\n");
1208
1209         if (result.error == 0 && param.imap && !etpan_skip_ssl_cert_check) {
1210                 cert_len = (int)mailstream_ssl_get_certificate(param.imap->imap_stream, &certificate);
1211                 if (etpan_certificate_check(certificate, cert_len, &param) < 0)
1212                         result.error = MAILIMAP_ERROR_STREAM;
1213                 if (certificate) 
1214                         free(certificate); 
1215         }       
1216         return result.error;
1217 }
1218
1219
1220
1221 struct create_param {
1222         mailimap * imap;
1223         const char * mb;
1224 };
1225
1226 struct create_result {
1227         int error;
1228 };
1229
1230 static void create_run(struct etpan_thread_op * op)
1231 {
1232         struct create_param * param;
1233         struct create_result * result;
1234         int r;
1235         
1236         param = op->param;
1237         result = op->result;
1238
1239         CHECK_IMAP();
1240
1241         r = mailimap_create(param->imap, param->mb);
1242         
1243         result->error = r;
1244         debug_print("imap create run - end %i\n", r);
1245 }
1246
1247 int imap_threaded_create(Folder * folder, const char * mb)
1248 {
1249         struct create_param param;
1250         struct create_result result;
1251         
1252         debug_print("imap create - begin\n");
1253         
1254         param.imap = get_imap(folder);
1255         param.mb = mb;
1256         
1257         threaded_run(folder, &param, &result, create_run);
1258         
1259         debug_print("imap create - end\n");
1260         
1261         return result.error;
1262 }
1263
1264
1265
1266
1267 struct rename_param {
1268         mailimap * imap;
1269         const char * mb;
1270         const char * new_name;
1271 };
1272
1273 struct rename_result {
1274         int error;
1275 };
1276
1277 static void rename_run(struct etpan_thread_op * op)
1278 {
1279         struct rename_param * param;
1280         struct rename_result * result;
1281         int r;
1282         
1283         param = op->param;
1284         result = op->result;
1285
1286         CHECK_IMAP();
1287
1288         r = mailimap_rename(param->imap, param->mb, param->new_name);
1289         
1290         result->error = r;
1291         debug_print("imap rename run - end %i\n", r);
1292 }
1293
1294 int imap_threaded_rename(Folder * folder,
1295                          const char * mb, const char * new_name)
1296 {
1297         struct rename_param param;
1298         struct rename_result result;
1299         
1300         debug_print("imap rename - begin\n");
1301         
1302         param.imap = get_imap(folder);
1303         param.mb = mb;
1304         param.new_name = new_name;
1305         
1306         threaded_run(folder, &param, &result, rename_run);
1307         
1308         debug_print("imap rename - end\n");
1309         
1310         return result.error;
1311 }
1312
1313
1314
1315
1316 struct delete_param {
1317         mailimap * imap;
1318         const char * mb;
1319 };
1320
1321 struct delete_result {
1322         int error;
1323 };
1324
1325 static void delete_run(struct etpan_thread_op * op)
1326 {
1327         struct delete_param * param;
1328         struct delete_result * result;
1329         int r;
1330         
1331         param = op->param;
1332         result = op->result;
1333
1334         CHECK_IMAP();
1335
1336         r = mailimap_delete(param->imap, param->mb);
1337         
1338         result->error = r;
1339         debug_print("imap delete run - end %i\n", r);
1340 }
1341
1342 int imap_threaded_delete(Folder * folder, const char * mb)
1343 {
1344         struct delete_param param;
1345         struct delete_result result;
1346         
1347         debug_print("imap delete - begin\n");
1348         
1349         param.imap = get_imap(folder);
1350         param.mb = mb;
1351         
1352         threaded_run(folder, &param, &result, delete_run);
1353         
1354         debug_print("imap delete - end\n");
1355         
1356         return result.error;
1357 }
1358
1359
1360
1361 struct select_param {
1362         mailimap * imap;
1363         const char * mb;
1364 };
1365
1366 struct select_result {
1367         int error;
1368 };
1369
1370 static void select_run(struct etpan_thread_op * op)
1371 {
1372         struct select_param * param;
1373         struct select_result * result;
1374         int r;
1375         
1376         param = op->param;
1377         result = op->result;
1378
1379         CHECK_IMAP();
1380
1381         r = mailimap_select(param->imap, param->mb);
1382         
1383         result->error = r;
1384         debug_print("imap select run - end %i\n", r);
1385 }
1386
1387 int imap_threaded_select(Folder * folder, const char * mb,
1388                          gint * exists, gint * recent, gint * unseen,
1389                          guint32 * uid_validity,gint *can_create_flags,
1390                          GSList **ok_flags)
1391 {
1392         struct select_param param;
1393         struct select_result result;
1394         mailimap * imap;
1395
1396         debug_print("imap select - begin\n");
1397         
1398         imap = get_imap(folder);
1399         param.imap = imap;
1400         param.mb = mb;
1401         
1402         threaded_run(folder, &param, &result, select_run);
1403         
1404         if (result.error != MAILIMAP_NO_ERROR)
1405                 return result.error;
1406         
1407         if (!imap || imap->imap_selection_info == NULL)
1408                 return MAILIMAP_ERROR_PARSE;
1409         
1410         * exists = imap->imap_selection_info->sel_exists;
1411         * recent = imap->imap_selection_info->sel_recent;
1412         * unseen = imap->imap_selection_info->sel_unseen;
1413         * uid_validity = imap->imap_selection_info->sel_uidvalidity;
1414         * can_create_flags = FALSE;
1415
1416         if (imap->imap_selection_info->sel_perm_flags) {
1417                 GSList *t_flags = NULL;
1418                 clistiter *cur =
1419                         clist_begin(imap->imap_selection_info->sel_perm_flags);
1420                 for (; cur; cur = clist_next(cur)) {
1421                         struct mailimap_flag_perm *flag = (struct mailimap_flag_perm *)clist_content(cur);
1422                         if (flag->fl_type == MAILIMAP_FLAG_PERM_ALL)
1423                                 *can_create_flags = TRUE;
1424                         else if (flag->fl_flag && 
1425                                         flag->fl_flag->fl_type == 6 &&
1426                                         !strcmp(flag->fl_flag->fl_data.fl_extension, "*"))
1427                                 *can_create_flags = TRUE; 
1428                         if (ok_flags) {
1429                                 MsgPermFlags c_flag = 0;
1430                                 switch (flag->fl_flag->fl_type) {
1431                                 case MAILIMAP_FLAG_ANSWERED:
1432                                         c_flag = IMAP_FLAG_ANSWERED;
1433                                         break;
1434                                 case MAILIMAP_FLAG_FLAGGED:
1435                                         c_flag = IMAP_FLAG_FLAGGED;
1436                                         break;
1437                                 case MAILIMAP_FLAG_DELETED:
1438                                         c_flag = IMAP_FLAG_DELETED;
1439                                         break;
1440                                 case MAILIMAP_FLAG_DRAFT:
1441                                         c_flag = IMAP_FLAG_DRAFT;
1442                                         break;
1443                                 case MAILIMAP_FLAG_SEEN:
1444                                         c_flag = IMAP_FLAG_SEEN;
1445                                         break;
1446                                 case MAILIMAP_FLAG_KEYWORD:
1447                                         if (!strcasecmp(flag->fl_flag->fl_data.fl_keyword, "$Forwarded"))
1448                                                 c_flag = IMAP_FLAG_FORWARDED;
1449                                         break;
1450                                 default:
1451                                         break;
1452                                 }
1453                                 if (c_flag != 0) {
1454                                         t_flags = g_slist_prepend(t_flags, 
1455                                                 GUINT_TO_POINTER(c_flag));
1456                                 }
1457                         }
1458                 }
1459                 if (ok_flags)
1460                         *ok_flags = t_flags;
1461         }
1462         debug_print("imap select - end\n");
1463         
1464         return result.error;
1465 }
1466
1467 static void close_run(struct etpan_thread_op * op)
1468 {
1469         struct select_param * param;
1470         struct select_result * result;
1471         int r;
1472         
1473         param = op->param;
1474         result = op->result;
1475
1476         CHECK_IMAP();
1477
1478         r = mailimap_close(param->imap);
1479         
1480         result->error = r;
1481         debug_print("imap close run - end %i\n", r);
1482 }
1483
1484 int imap_threaded_close(Folder * folder)
1485 {
1486         struct select_param param;
1487         struct select_result result;
1488         mailimap * imap;
1489         
1490         debug_print("imap close - begin\n");
1491         
1492         imap = get_imap(folder);
1493         param.imap = imap;
1494         
1495         threaded_run(folder, &param, &result, close_run);
1496         
1497         if (result.error != MAILIMAP_NO_ERROR)
1498                 return result.error;
1499         
1500         debug_print("imap close - end\n");
1501         
1502         return result.error;
1503 }
1504
1505 struct examine_param {
1506         mailimap * imap;
1507         const char * mb;
1508 };
1509
1510 struct examine_result {
1511         int error;
1512 };
1513
1514 static void examine_run(struct etpan_thread_op * op)
1515 {
1516         struct examine_param * param;
1517         struct examine_result * result;
1518         int r;
1519         
1520         param = op->param;
1521         result = op->result;
1522
1523         CHECK_IMAP();
1524
1525         r = mailimap_examine(param->imap, param->mb);
1526         
1527         result->error = r;
1528         debug_print("imap examine run - end %i\n", r);
1529 }
1530
1531 int imap_threaded_examine(Folder * folder, const char * mb,
1532                           gint * exists, gint * recent, gint * unseen,
1533                           guint32 * uid_validity)
1534 {
1535         struct examine_param param;
1536         struct examine_result result;
1537         mailimap * imap;
1538         
1539         debug_print("imap examine - begin\n");
1540         
1541         imap = get_imap(folder);
1542         param.imap = imap;
1543         param.mb = mb;
1544         
1545         threaded_run(folder, &param, &result, examine_run);
1546         
1547         if (result.error != MAILIMAP_NO_ERROR)
1548                 return result.error;
1549         
1550         if (!imap || imap->imap_selection_info == NULL)
1551                 return MAILIMAP_ERROR_PARSE;
1552         
1553         * exists = imap->imap_selection_info->sel_exists;
1554         * recent = imap->imap_selection_info->sel_recent;
1555         * unseen = imap->imap_selection_info->sel_unseen;
1556         * uid_validity = imap->imap_selection_info->sel_uidvalidity;
1557         
1558         debug_print("imap examine - end\n");
1559         
1560         return result.error;
1561 }
1562
1563
1564
1565
1566 struct search_param {
1567         mailimap * imap;
1568         int type;
1569         struct mailimap_set * set;
1570 };
1571
1572 struct search_result {
1573         int error;
1574         clist * search_result;
1575 };
1576
1577 static struct mailimap_set_item *sc_mailimap_set_item_copy(struct mailimap_set_item *orig)
1578 {
1579         return mailimap_set_item_new(orig->set_first, orig->set_last);
1580 }
1581
1582 static struct mailimap_set *sc_mailimap_set_copy(struct mailimap_set *orig)
1583 {
1584         clist *list = orig ? orig->set_list : NULL;
1585         clist *newlist = clist_new();
1586         clistiter *cur;
1587         
1588         if (!orig)
1589                 return NULL;
1590         for (cur = clist_begin(list); cur; cur = clist_next(cur))
1591                 clist_append(newlist, 
1592                         sc_mailimap_set_item_copy(
1593                         (struct mailimap_set_item *)clist_content(cur)));
1594         return mailimap_set_new(newlist);
1595 }
1596
1597 static void search_run(struct etpan_thread_op * op)
1598 {
1599         struct search_param * param;
1600         struct search_result * result;
1601         int r;
1602         struct mailimap_search_key * key = NULL;
1603         struct mailimap_search_key * uid_key = NULL;
1604         struct mailimap_search_key * search_type_key;
1605         clist * search_result;
1606         
1607         param = op->param;
1608         result = op->result;
1609
1610         CHECK_IMAP();
1611
1612         /* we copy the mailimap_set because freeing the key is recursive */
1613         if (param->set != NULL) {
1614                 uid_key = mailimap_search_key_new_uid(sc_mailimap_set_copy(param->set));
1615         } else if (param->type == IMAP_SEARCH_TYPE_SIMPLE) {
1616                 uid_key = mailimap_search_key_new_all();
1617         }
1618         search_type_key = NULL;
1619         switch (param->type) {
1620         case IMAP_SEARCH_TYPE_SIMPLE:
1621                 search_type_key = NULL;
1622                 break;
1623                 
1624         case IMAP_SEARCH_TYPE_SEEN:
1625                 search_type_key = mailimap_search_key_new(MAILIMAP_SEARCH_KEY_SEEN,
1626                                                           NULL, NULL, NULL, NULL, NULL,
1627                                                           NULL, NULL, NULL, NULL, NULL,
1628                                                           NULL, NULL, NULL, NULL, 0,
1629                                                           NULL, NULL, NULL, NULL, NULL,
1630                                                           NULL, 0, NULL, NULL, NULL);
1631                 break;
1632                 
1633         case IMAP_SEARCH_TYPE_UNSEEN:
1634                 search_type_key = mailimap_search_key_new(MAILIMAP_SEARCH_KEY_UNSEEN,
1635                                                           NULL, NULL, NULL, NULL, NULL,
1636                                                           NULL, NULL, NULL, NULL, NULL,
1637                                                           NULL, NULL, NULL, NULL, 0,
1638                                                           NULL, NULL, NULL, NULL, NULL,
1639                                                           NULL, 0, NULL, NULL, NULL);
1640                 break;
1641                 
1642         case IMAP_SEARCH_TYPE_ANSWERED:
1643                 search_type_key = mailimap_search_key_new(MAILIMAP_SEARCH_KEY_ANSWERED,
1644                                                           NULL, NULL, NULL, NULL, NULL,
1645                                                           NULL, NULL, NULL, NULL, NULL,
1646                                                           NULL, NULL, NULL, NULL, 0,
1647                                                           NULL, NULL, NULL, NULL, NULL,
1648                                                           NULL, 0, NULL, NULL, NULL);
1649                 break;
1650                 
1651         case IMAP_SEARCH_TYPE_FLAGGED:
1652                 search_type_key = mailimap_search_key_new(MAILIMAP_SEARCH_KEY_FLAGGED,
1653                                                           NULL, NULL, NULL, NULL, NULL,
1654                                                           NULL, NULL, NULL, NULL, NULL,
1655                                                           NULL, NULL, NULL, NULL, 0,
1656                                                           NULL, NULL, NULL, NULL, NULL,
1657                                                           NULL, 0, NULL, NULL, NULL);
1658                 break;
1659         case IMAP_SEARCH_TYPE_DELETED:
1660                 search_type_key = mailimap_search_key_new(MAILIMAP_SEARCH_KEY_DELETED,
1661                                                           NULL, NULL, NULL, NULL, NULL,
1662                                                           NULL, NULL, NULL, NULL, NULL,
1663                                                           NULL, NULL, NULL, NULL, 0,
1664                                                           NULL, NULL, NULL, NULL, NULL,
1665                                                           NULL, 0, NULL, NULL, NULL);
1666                 break;
1667         case IMAP_SEARCH_TYPE_FORWARDED:
1668                 search_type_key = mailimap_search_key_new(MAILIMAP_SEARCH_KEY_KEYWORD,
1669                                                           NULL, NULL, NULL, NULL, NULL,
1670                                                           strdup("$Forwarded"), NULL, NULL, NULL, NULL,
1671                                                           NULL, NULL, NULL, NULL, 0,
1672                                                           NULL, NULL, NULL, NULL, NULL,
1673                                                           NULL, 0, NULL, NULL, NULL);
1674                 break;
1675         }
1676         
1677         if (search_type_key != NULL) {
1678                 if (param->set != NULL) {
1679                         key = mailimap_search_key_new_multiple_empty();
1680                         mailimap_search_key_multiple_add(key, search_type_key);
1681                         mailimap_search_key_multiple_add(key, uid_key);
1682                 } else {
1683                         key = search_type_key;
1684                 }
1685         } else if (uid_key != NULL) {
1686                 key = uid_key;
1687         }
1688         
1689         if (key == NULL) {
1690                 g_warning("no key!");
1691                 result = op->result;
1692                 result->error = -1;
1693                 result->search_result = NULL;
1694         } else {
1695                 mailstream_logger = imap_logger_uid;
1696
1697                 r = mailimap_uid_search(param->imap, NULL, key, &search_result);
1698
1699                 mailstream_logger = imap_logger_cmd;
1700
1701                 /* free the key (with the imapset) */
1702                 mailimap_search_key_free(key);
1703
1704                 result->error = r;
1705                 result->search_result = search_result;
1706         }
1707         debug_print("imap search run - end %i\n", result->error);
1708 }
1709
1710 int imap_threaded_search(Folder * folder, int search_type,
1711                          struct mailimap_set * set, clist ** search_result)
1712 {
1713         struct search_param param;
1714         struct search_result result;
1715         mailimap * imap;
1716         
1717         debug_print("imap search - begin\n");
1718
1719         imap = get_imap(folder);
1720         param.imap = imap;
1721         param.set = set;
1722         param.type = search_type;
1723         
1724         threaded_run(folder, &param, &result, search_run);
1725         
1726         if (result.error != MAILIMAP_NO_ERROR)
1727                 return result.error;
1728         
1729         debug_print("imap search - end\n");
1730         
1731         * search_result = result.search_result;
1732         
1733         return result.error;
1734 }
1735
1736
1737
1738 static int imap_get_msg_att_info(struct mailimap_msg_att * msg_att,
1739                                  uint32_t * puid,
1740                                  char ** pheaders,
1741                                  size_t * pref_size,
1742                                  struct mailimap_msg_att_dynamic ** patt_dyn);
1743
1744 static int
1745 result_to_uid_list(clist * fetch_result, carray ** result)
1746 {
1747         clistiter * cur;
1748         int r;
1749         int res;
1750         carray * tab;
1751         
1752         tab = carray_new(128);
1753         if (tab == NULL) {
1754                 res = MAILIMAP_ERROR_MEMORY;
1755                 goto err;
1756         }
1757         
1758         for(cur = clist_begin(fetch_result) ; cur != NULL ;
1759             cur = clist_next(cur)) {
1760                 struct mailimap_msg_att * msg_att;
1761                 uint32_t uid;
1762                 uint32_t * puid;
1763                 
1764                 msg_att = clist_content(cur);
1765                 
1766                 uid = 0;
1767                 imap_get_msg_att_info(msg_att, &uid, NULL, NULL, NULL);
1768                 
1769                 puid = malloc(sizeof(* puid));
1770                 if (puid == NULL) {
1771                         res = MAILIMAP_ERROR_MEMORY;
1772                         goto free_list;
1773                 }
1774                 * puid = uid;
1775                         
1776                 r = carray_add(tab, puid, NULL);
1777                 if (r < 0) {
1778                         free(puid);
1779                         res = MAILIMAP_ERROR_MEMORY;
1780                         goto free_list;
1781                 }
1782         }
1783                 
1784         * result = tab;
1785
1786         return MAILIMAP_NO_ERROR;
1787   
1788  free_list:
1789         imap_fetch_uid_list_free(tab);
1790  err:
1791         return res;
1792 }
1793
1794 static int imap_get_messages_list(mailimap * imap,
1795                                   uint32_t first_index,
1796                                   carray ** result)
1797 {
1798         carray * env_list;
1799         int r;
1800         struct mailimap_fetch_att * fetch_att;
1801         struct mailimap_fetch_type * fetch_type;
1802         struct mailimap_set * set;
1803         clist * fetch_result;
1804         int res;
1805         
1806         set = mailimap_set_new_interval(first_index, 0);
1807         if (set == NULL) {
1808                 res = MAILIMAP_ERROR_MEMORY;
1809                 goto err;
1810         }
1811
1812         fetch_type = mailimap_fetch_type_new_fetch_att_list_empty();
1813         if (fetch_type == NULL) {
1814                 res = MAILIMAP_ERROR_MEMORY;
1815                 goto free_set;
1816         }
1817
1818         fetch_att = mailimap_fetch_att_new_uid();
1819         if (fetch_att == NULL) {
1820                 res = MAILIMAP_ERROR_MEMORY;
1821                 goto free_fetch_type;
1822         }
1823
1824         r = mailimap_fetch_type_new_fetch_att_list_add(fetch_type, fetch_att);
1825         if (r != MAILIMAP_NO_ERROR) {
1826                 mailimap_fetch_att_free(fetch_att);
1827                 res = MAILIMAP_ERROR_MEMORY;
1828                 goto free_fetch_type;
1829         }
1830
1831         mailstream_logger = imap_logger_fetch;
1832         
1833         r = mailimap_uid_fetch(imap, set,
1834                                fetch_type, &fetch_result);
1835
1836         mailstream_logger = imap_logger_cmd;
1837         mailimap_fetch_type_free(fetch_type);
1838         mailimap_set_free(set);
1839
1840         if (r != MAILIMAP_NO_ERROR) {
1841                 res = r;
1842                 goto err;
1843         }
1844
1845         env_list = NULL;
1846         r = result_to_uid_list(fetch_result, &env_list);
1847         mailimap_fetch_list_free(fetch_result);
1848         
1849         * result = env_list;
1850
1851         return MAILIMAP_NO_ERROR;
1852
1853  free_fetch_type:
1854         mailimap_fetch_type_free(fetch_type);
1855  free_set:
1856         mailimap_set_free(set);
1857  err:
1858         return res;
1859 }
1860
1861
1862
1863
1864 struct fetch_uid_param {
1865         mailimap * imap;
1866         uint32_t first_index;
1867 };
1868
1869 struct fetch_uid_result {
1870         int error;
1871         carray * fetch_result;
1872 };
1873
1874 static void fetch_uid_run(struct etpan_thread_op * op)
1875 {
1876         struct fetch_uid_param * param;
1877         struct fetch_uid_result * result;
1878         carray * fetch_result;
1879         int r;
1880         
1881         param = op->param;
1882         result = op->result;
1883
1884         CHECK_IMAP();
1885
1886         fetch_result = NULL;
1887         mailstream_logger = imap_logger_noop;
1888         log_print(LOG_PROTOCOL, "IMAP4- [fetching UIDs...]\n");
1889
1890         r = imap_get_messages_list(param->imap, param->first_index,
1891                                    &fetch_result);
1892         
1893         mailstream_logger = imap_logger_cmd;
1894
1895         result->error = r;
1896         result->fetch_result = fetch_result;
1897         debug_print("imap fetch_uid run - end %i\n", r);
1898 }
1899
1900 int imap_threaded_fetch_uid(Folder * folder, uint32_t first_index,
1901                             carray ** fetch_result)
1902 {
1903         struct fetch_uid_param param;
1904         struct fetch_uid_result result;
1905         mailimap * imap;
1906         
1907         debug_print("imap fetch_uid - begin\n");
1908         
1909         imap = get_imap(folder);
1910         param.imap = imap;
1911         param.first_index = first_index;
1912         
1913         threaded_run(folder, &param, &result, fetch_uid_run);
1914         
1915         if (result.error != MAILIMAP_NO_ERROR)
1916                 return result.error;
1917         
1918         debug_print("imap fetch_uid - end\n");
1919         
1920         * fetch_result = result.fetch_result;
1921         
1922         return result.error;
1923 }
1924
1925
1926 void imap_fetch_uid_list_free(carray * uid_list)
1927 {
1928         unsigned int i;
1929         
1930         for(i = 0 ; i < carray_count(uid_list) ; i ++) {
1931                 uint32_t * puid;
1932                 
1933                 puid = carray_get(uid_list, i);
1934                 free(puid);
1935         }
1936         carray_free(uid_list);
1937 }
1938
1939
1940
1941
1942 static int imap_flags_to_flags(struct mailimap_msg_att_dynamic * att_dyn, GSList **tags);
1943
1944 static int
1945 result_to_uid_flags_list(clist * fetch_result, carray ** result)
1946 {
1947         clistiter * cur;
1948         int r;
1949         int res;
1950         carray * tab;
1951         GSList *tags = NULL;
1952
1953         tab = carray_new(128);
1954         if (tab == NULL) {
1955                 res = MAILIMAP_ERROR_MEMORY;
1956                 goto err;
1957         }
1958         
1959         for(cur = clist_begin(fetch_result) ; cur != NULL ;
1960             cur = clist_next(cur)) {
1961                 struct mailimap_msg_att * msg_att;
1962                 uint32_t uid;
1963                 uint32_t * puid;
1964                 struct mailimap_msg_att_dynamic * att_dyn;
1965                 int flags;
1966                 int * pflags;
1967                 
1968                 tags = NULL;
1969
1970                 msg_att = clist_content(cur);
1971                 
1972                 uid = 0;
1973                 att_dyn = NULL;
1974                 imap_get_msg_att_info(msg_att, &uid, NULL, NULL, &att_dyn);
1975                 if (uid == 0)
1976                         continue;
1977                 if (att_dyn == NULL)
1978                         continue;
1979                 
1980                 flags = imap_flags_to_flags(att_dyn, &tags);
1981                 
1982                 puid = malloc(sizeof(* puid));
1983                 if (puid == NULL) {
1984                         res = MAILIMAP_ERROR_MEMORY;
1985                         goto free_list;
1986                 }
1987                 * puid = uid;
1988                 
1989                 r = carray_add(tab, puid, NULL);
1990                 if (r < 0) {
1991                         free(puid);
1992                         res = MAILIMAP_ERROR_MEMORY;
1993                         goto free_list;
1994                 }
1995                 pflags = malloc(sizeof(* pflags));
1996                 if (pflags == NULL) {
1997                         res = MAILIMAP_ERROR_MEMORY;
1998                         goto free_list;
1999                 }
2000                 * pflags = flags;
2001                 r = carray_add(tab, pflags, NULL);
2002                 if (r < 0) {
2003                         free(pflags);
2004                         res = MAILIMAP_ERROR_MEMORY;
2005                         goto free_list;
2006                 }
2007                 r = carray_add(tab, tags, NULL);
2008                 if (r < 0) {
2009                         free(pflags);
2010                         res = MAILIMAP_ERROR_MEMORY;
2011                         goto free_list;
2012                 }
2013         }
2014                 
2015         * result = tab;
2016
2017         return MAILIMAP_NO_ERROR;
2018   
2019  free_list:
2020         imap_fetch_uid_flags_list_free(tab);
2021         slist_free_strings(tags);
2022         g_slist_free(tags);
2023  err:
2024         return res;
2025 }
2026
2027 static int imap_get_messages_flags_list(mailimap * imap,
2028                                         uint32_t first_index,
2029                                         carray ** result)
2030 {
2031         carray * env_list;
2032         int r;
2033         struct mailimap_fetch_att * fetch_att;
2034         struct mailimap_fetch_type * fetch_type;
2035         struct mailimap_set * set;
2036         clist * fetch_result;
2037         int res;
2038         
2039         set = mailimap_set_new_interval(first_index, 0);
2040         if (set == NULL) {
2041                 res = MAILIMAP_ERROR_MEMORY;
2042                 goto err;
2043         }
2044
2045         fetch_type = mailimap_fetch_type_new_fetch_att_list_empty();
2046         if (fetch_type == NULL) {
2047                 res = MAILIMAP_ERROR_MEMORY;
2048                 goto free_set;
2049         }
2050
2051         fetch_att = mailimap_fetch_att_new_flags();
2052         if (fetch_att == NULL) {
2053                 res = MAILIMAP_ERROR_MEMORY;
2054                 goto free_fetch_type;
2055         }
2056         
2057         r = mailimap_fetch_type_new_fetch_att_list_add(fetch_type, fetch_att);
2058         if (r != MAILIMAP_NO_ERROR) {
2059                 mailimap_fetch_att_free(fetch_att);
2060                 res = MAILIMAP_ERROR_MEMORY;
2061                 goto free_fetch_type;
2062         }
2063         
2064         fetch_att = mailimap_fetch_att_new_uid();
2065         if (fetch_att == NULL) {
2066                 res = MAILIMAP_ERROR_MEMORY;
2067                 goto free_fetch_type;
2068         }
2069
2070         r = mailimap_fetch_type_new_fetch_att_list_add(fetch_type, fetch_att);
2071         if (r != MAILIMAP_NO_ERROR) {
2072                 mailimap_fetch_att_free(fetch_att);
2073                 res = MAILIMAP_ERROR_MEMORY;
2074                 goto free_fetch_type;
2075         }
2076
2077         mailstream_logger = imap_logger_fetch;
2078         
2079         r = mailimap_uid_fetch(imap, set,
2080                                fetch_type, &fetch_result);
2081
2082         mailstream_logger = imap_logger_cmd;
2083         mailimap_fetch_type_free(fetch_type);
2084         mailimap_set_free(set);
2085
2086         if (r != MAILIMAP_NO_ERROR) {
2087                 res = r;
2088                 goto err;
2089         }
2090
2091         env_list = NULL;
2092         r = result_to_uid_flags_list(fetch_result, &env_list);
2093         mailimap_fetch_list_free(fetch_result);
2094         
2095         * result = env_list;
2096
2097         return MAILIMAP_NO_ERROR;
2098
2099  free_fetch_type:
2100         mailimap_fetch_type_free(fetch_type);
2101  free_set:
2102         mailimap_set_free(set);
2103  err:
2104         return res;
2105 }
2106
2107
2108
2109 static void fetch_uid_flags_run(struct etpan_thread_op * op)
2110 {
2111         struct fetch_uid_param * param;
2112         struct fetch_uid_result * result;
2113         carray * fetch_result;
2114         int r;
2115         
2116         param = op->param;
2117         result = op->result;
2118
2119         CHECK_IMAP();
2120
2121         fetch_result = NULL;
2122         r = imap_get_messages_flags_list(param->imap, param->first_index,
2123                                          &fetch_result);
2124         
2125         result->error = r;
2126         result->fetch_result = fetch_result;
2127         debug_print("imap fetch_uid run - end %i\n", r);
2128 }
2129
2130 int imap_threaded_fetch_uid_flags(Folder * folder, uint32_t first_index,
2131                                   carray ** fetch_result)
2132 {
2133         struct fetch_uid_param param;
2134         struct fetch_uid_result result;
2135         mailimap * imap;
2136         
2137         debug_print("imap fetch_uid - begin\n");
2138         
2139         imap = get_imap(folder);
2140         param.imap = imap;
2141         param.first_index = first_index;
2142         
2143         mailstream_logger = imap_logger_noop;
2144         log_print(LOG_PROTOCOL, "IMAP4- [fetching flags...]\n");
2145
2146         threaded_run(folder, &param, &result, fetch_uid_flags_run);
2147
2148         mailstream_logger = imap_logger_cmd;
2149
2150         
2151         if (result.error != MAILIMAP_NO_ERROR)
2152                 return result.error;
2153         
2154         debug_print("imap fetch_uid - end\n");
2155         
2156         * fetch_result = result.fetch_result;
2157         
2158         return result.error;
2159 }
2160
2161
2162 void imap_fetch_uid_flags_list_free(carray * uid_flags_list)
2163 {
2164         unsigned int i;
2165         
2166         for(i = 0 ; i < carray_count(uid_flags_list) ; i += 3) {
2167                 void * data;
2168                 
2169                 data = carray_get(uid_flags_list, i);
2170                 free(data);
2171                 data = carray_get(uid_flags_list, i + 1);
2172                 free(data);
2173         }
2174         carray_free(uid_flags_list);
2175 }
2176
2177
2178
2179 static int imap_fetch(mailimap * imap,
2180                       uint32_t msg_index,
2181                       char ** result,
2182                       size_t * result_len)
2183 {
2184         int r;
2185         struct mailimap_set * set;
2186         struct mailimap_fetch_att * fetch_att;
2187         struct mailimap_fetch_type * fetch_type;
2188         clist * fetch_result;
2189         struct mailimap_msg_att * msg_att;
2190         struct mailimap_msg_att_item * msg_att_item;
2191         char * text;
2192         size_t text_length;
2193         int res;
2194         clistiter * cur;
2195         struct mailimap_section * section;
2196
2197         set = mailimap_set_new_single(msg_index);
2198         if (set == NULL) {
2199                 res = MAILIMAP_ERROR_MEMORY;
2200                 goto err;
2201         }
2202
2203         section = mailimap_section_new(NULL);
2204         if (section == NULL) {
2205                 res = MAILIMAP_ERROR_MEMORY;
2206                 goto free_set;
2207         }
2208   
2209         fetch_att = mailimap_fetch_att_new_body_peek_section(section);
2210         if (fetch_att == NULL) {
2211                 mailimap_section_free(section);
2212                 res = MAILIMAP_ERROR_MEMORY;
2213                 goto free_set;
2214         }
2215   
2216         fetch_type = mailimap_fetch_type_new_fetch_att(fetch_att);
2217         if (fetch_type == NULL) {
2218                 res = MAILIMAP_ERROR_MEMORY;
2219                 goto free_fetch_att;
2220         }
2221
2222         mailstream_logger = imap_logger_fetch;
2223         
2224         r = mailimap_uid_fetch(imap, set,
2225                                fetch_type, &fetch_result);
2226   
2227         mailstream_logger = imap_logger_cmd;
2228         
2229         mailimap_fetch_type_free(fetch_type);
2230         mailimap_set_free(set);
2231   
2232         switch (r) {
2233         case MAILIMAP_NO_ERROR:
2234                 break;
2235         default:
2236                 return r;
2237         }
2238   
2239         if (clist_begin(fetch_result) == NULL) {
2240                 mailimap_fetch_list_free(fetch_result);
2241                 return MAILIMAP_ERROR_FETCH;
2242         }
2243
2244         msg_att = clist_begin(fetch_result)->data;
2245
2246         text = NULL;
2247         text_length = 0;
2248
2249         for(cur = clist_begin(msg_att->att_list) ; cur != NULL ;
2250             cur = clist_next(cur)) {
2251                 msg_att_item = clist_content(cur);
2252
2253                 if (msg_att_item->att_type == MAILIMAP_MSG_ATT_ITEM_STATIC) {
2254                         if (msg_att_item->att_data.att_static->att_type ==
2255                             MAILIMAP_MSG_ATT_BODY_SECTION) {
2256                                 text = msg_att_item->att_data.att_static->att_data.att_body_section->sec_body_part;
2257                                 /* detach */
2258                                 msg_att_item->att_data.att_static->att_data.att_body_section->sec_body_part = NULL;
2259                                 text_length =
2260                                         msg_att_item->att_data.att_static->att_data.att_body_section->sec_length;
2261                         }
2262                 }
2263         }
2264
2265         mailimap_fetch_list_free(fetch_result);
2266
2267         if (text == NULL)
2268                 return MAILIMAP_ERROR_FETCH;
2269
2270         * result = text;
2271         * result_len = text_length;
2272   
2273         return MAILIMAP_NO_ERROR;
2274
2275  free_fetch_att:
2276         mailimap_fetch_att_free(fetch_att);
2277  free_set:
2278         mailimap_set_free(set);
2279  err:
2280         return res;
2281 }
2282
2283 static int imap_fetch_header(mailimap * imap,
2284                              uint32_t msg_index,
2285                              char ** result,
2286                              size_t * result_len)
2287 {
2288   int r;
2289   struct mailimap_set * set;
2290   struct mailimap_fetch_att * fetch_att;
2291   struct mailimap_fetch_type * fetch_type;
2292   clist * fetch_result;
2293   struct mailimap_msg_att * msg_att;
2294   struct mailimap_msg_att_item * msg_att_item;
2295   char * text;
2296   size_t text_length;
2297   int res;
2298   clistiter * cur;
2299   struct mailimap_section * section;
2300   
2301   set = mailimap_set_new_single(msg_index);
2302   if (set == NULL) {
2303     res = MAILIMAP_ERROR_MEMORY;
2304     goto err;
2305   }
2306
2307   section = mailimap_section_new_header();
2308   if (section == NULL) {
2309     res = MAILIMAP_ERROR_MEMORY;
2310     goto free_set;
2311   }
2312   
2313   fetch_att = mailimap_fetch_att_new_body_peek_section(section);
2314   if (fetch_att == NULL) {
2315     mailimap_section_free(section);
2316     res = MAILIMAP_ERROR_MEMORY;
2317     goto free_set;
2318   }
2319   
2320   fetch_type = mailimap_fetch_type_new_fetch_att(fetch_att);
2321   if (fetch_type == NULL) {
2322     res = MAILIMAP_ERROR_MEMORY;
2323     goto free_fetch_att;
2324   }
2325
2326   mailstream_logger = imap_logger_fetch;
2327   
2328   r = mailimap_uid_fetch(imap, set, fetch_type, &fetch_result);
2329   
2330   mailstream_logger = imap_logger_cmd;
2331   mailimap_fetch_type_free(fetch_type);
2332   mailimap_set_free(set);
2333
2334   switch (r) {
2335   case MAILIMAP_NO_ERROR:
2336     break;
2337   default:
2338     return r;
2339   }
2340
2341   if (clist_begin(fetch_result) == NULL) {
2342     mailimap_fetch_list_free(fetch_result);
2343     return MAILIMAP_ERROR_FETCH;
2344   }
2345
2346   msg_att = clist_begin(fetch_result)->data;
2347
2348   text = NULL;
2349   text_length = 0;
2350
2351   for(cur = clist_begin(msg_att->att_list) ; cur != NULL ;
2352       cur = clist_next(cur)) {
2353     msg_att_item = clist_content(cur);
2354
2355     if (msg_att_item->att_type == MAILIMAP_MSG_ATT_ITEM_STATIC) {
2356       if (msg_att_item->att_data.att_static->att_type ==
2357           MAILIMAP_MSG_ATT_BODY_SECTION) {
2358         text = msg_att_item->att_data.att_static->att_data.att_body_section->sec_body_part;
2359         msg_att_item->att_data.att_static->att_data.att_body_section->sec_body_part = NULL;
2360         text_length =
2361           msg_att_item->att_data.att_static->att_data.att_body_section->sec_length;
2362       }
2363     }
2364   }
2365
2366   mailimap_fetch_list_free(fetch_result);
2367
2368   if (text == NULL)
2369     return MAILIMAP_ERROR_FETCH;
2370
2371   * result = text;
2372   * result_len = text_length;
2373
2374   return MAILIMAP_NO_ERROR;
2375
2376  free_fetch_att:
2377   mailimap_fetch_att_free(fetch_att);
2378  free_set:
2379   mailimap_set_free(set);
2380  err:
2381   return res;
2382 }
2383
2384
2385
2386 struct fetch_content_param {
2387         mailimap * imap;
2388         uint32_t msg_index;
2389         const char * filename;
2390         int with_body;
2391 };
2392
2393 struct fetch_content_result {
2394         int error;
2395 };
2396
2397 static void fetch_content_run(struct etpan_thread_op * op)
2398 {
2399         struct fetch_content_param * param;
2400         struct fetch_content_result * result;
2401         char * content;
2402         size_t content_size;
2403         int r;
2404         int fd;
2405         FILE * f;
2406         
2407         param = op->param;
2408         result = op->result;
2409
2410         CHECK_IMAP();
2411
2412         content = NULL;
2413         content_size = 0;
2414         if (param->with_body)
2415                 r = imap_fetch(param->imap, param->msg_index,
2416                                &content, &content_size);
2417         else
2418                 r = imap_fetch_header(param->imap, param->msg_index,
2419                                       &content, &content_size);
2420         
2421         result->error = r;
2422         
2423         if (r == MAILIMAP_NO_ERROR) {
2424                 fd = open(param->filename, O_RDWR | O_CREAT, 0600);
2425                 if (fd < 0) {
2426                         result->error = MAILIMAP_ERROR_FETCH;
2427                         goto free;
2428                 }
2429                 
2430                 f = fdopen(fd, "wb");
2431                 if (f == NULL) {
2432                         result->error = MAILIMAP_ERROR_FETCH;
2433                         goto close;
2434                 }
2435                 
2436                 r = fwrite(content, 1, content_size, f);
2437                 if (r < content_size) {
2438                         result->error = MAILIMAP_ERROR_FETCH;
2439                         goto fclose;
2440                 }
2441                 
2442                 r = fclose(f);
2443                 if (r == EOF) {
2444                         result->error = MAILIMAP_ERROR_FETCH;
2445                         goto unlink;
2446                 }
2447                 goto free;
2448                 
2449         fclose:
2450                 fclose(f);
2451                 goto unlink;
2452         close:
2453                 close(fd);
2454         unlink:
2455                 claws_unlink(param->filename);
2456         
2457         free:
2458                 /* mmap_string_unref is a simple free in libetpan
2459                  * when it has MMAP_UNAVAILABLE defined */
2460                 if (mmap_string_unref(content) != 0)
2461                         free(content);
2462         }
2463         
2464         debug_print("imap fetch_content run - end %i\n", result->error);
2465 }
2466
2467 int imap_threaded_fetch_content(Folder * folder, uint32_t msg_index,
2468                                 int with_body,
2469                                 const char * filename)
2470 {
2471         struct fetch_content_param param;
2472         struct fetch_content_result result;
2473         mailimap * imap;
2474         
2475         debug_print("imap fetch_content - begin\n");
2476         
2477         imap = get_imap(folder);
2478         param.imap = imap;
2479         param.msg_index = msg_index;
2480         param.filename = filename;
2481         param.with_body = with_body;
2482         
2483         threaded_run(folder, &param, &result, fetch_content_run);
2484         
2485         if (result.error != MAILIMAP_NO_ERROR)
2486                 return result.error;
2487         
2488         debug_print("imap fetch_content - end\n");
2489         
2490         return result.error;
2491 }
2492
2493
2494
2495 static int imap_flags_to_flags(struct mailimap_msg_att_dynamic * att_dyn, GSList **s_tags)
2496 {
2497         int flags;
2498         clist * flag_list;
2499         clistiter * cur;
2500         GSList *tags = NULL;
2501
2502         flags = MSG_UNREAD;
2503         
2504         flag_list = att_dyn->att_list;
2505         if (flag_list == NULL)
2506                 return flags;
2507         
2508         for(cur = clist_begin(flag_list) ; cur != NULL ;
2509             cur = clist_next(cur)) {
2510                 struct mailimap_flag_fetch * flag_fetch;
2511                         
2512                 flag_fetch = clist_content(cur);
2513                 if (flag_fetch->fl_type == MAILIMAP_FLAG_FETCH_RECENT)
2514                         flags |= MSG_NEW;
2515                 else {
2516                         switch (flag_fetch->fl_flag->fl_type) {
2517                         case MAILIMAP_FLAG_ANSWERED:
2518                                 flags |= MSG_REPLIED;
2519                                 break;
2520                         case MAILIMAP_FLAG_FLAGGED:
2521                                 flags |= MSG_MARKED;
2522                                 break;
2523                         case MAILIMAP_FLAG_DELETED:
2524                                 flags |= MSG_DELETED;
2525                                 break;
2526                         case MAILIMAP_FLAG_SEEN:
2527                                 flags &= ~MSG_UNREAD;
2528                                 flags &= ~MSG_NEW;
2529                                 break;
2530                         case MAILIMAP_FLAG_KEYWORD:
2531                                 if (!strcasecmp(flag_fetch->fl_flag->fl_data.fl_keyword, "$Forwarded"))
2532                                         flags |= MSG_FORWARDED;
2533                                 else if (s_tags)
2534                                         tags = g_slist_prepend(tags, g_strdup(flag_fetch->fl_flag->fl_data.fl_keyword));
2535                                 break;
2536                         }
2537                 }
2538         }
2539         if (s_tags)
2540                 *s_tags = tags;
2541         return flags;
2542 }
2543
2544 static int imap_get_msg_att_info(struct mailimap_msg_att * msg_att,
2545                                  uint32_t * puid,
2546                                  char ** pheaders,
2547                                  size_t * pref_size,
2548                                  struct mailimap_msg_att_dynamic ** patt_dyn)
2549 {
2550   clistiter * item_cur;
2551   uint32_t uid;
2552   char * headers;
2553   size_t ref_size;
2554   struct mailimap_msg_att_dynamic * att_dyn;
2555
2556   uid = 0;
2557   headers = NULL;
2558   ref_size = 0;
2559   att_dyn = NULL;
2560
2561   for(item_cur = clist_begin(msg_att->att_list) ; item_cur != NULL ;
2562       item_cur = clist_next(item_cur)) {
2563     struct mailimap_msg_att_item * item;
2564
2565     item = clist_content(item_cur);
2566       
2567     switch (item->att_type) {
2568     case MAILIMAP_MSG_ATT_ITEM_STATIC:
2569       switch (item->att_data.att_static->att_type) {
2570       case MAILIMAP_MSG_ATT_UID:
2571         uid = item->att_data.att_static->att_data.att_uid;
2572         break;
2573
2574       case MAILIMAP_MSG_ATT_BODY_SECTION:
2575         if (headers == NULL) {
2576           headers = item->att_data.att_static->att_data.att_body_section->sec_body_part;
2577         }
2578         break;
2579       case MAILIMAP_MSG_ATT_RFC822_SIZE:
2580               ref_size = item->att_data.att_static->att_data.att_rfc822_size;
2581               break;
2582       }
2583       break;
2584       
2585     case MAILIMAP_MSG_ATT_ITEM_DYNAMIC:
2586       if (att_dyn == NULL) {
2587         att_dyn = item->att_data.att_dyn;
2588       }
2589       break;
2590     }
2591   }
2592
2593   if (puid != NULL)
2594     * puid = uid;
2595   if (pheaders != NULL)
2596     * pheaders = headers;
2597   if (pref_size != NULL)
2598     * pref_size = ref_size;
2599   if (patt_dyn != NULL)
2600     * patt_dyn = att_dyn;
2601
2602   return MAIL_NO_ERROR;
2603 }
2604
2605 static struct imap_fetch_env_info *
2606 fetch_to_env_info(struct mailimap_msg_att * msg_att, GSList **tags)
2607 {
2608         struct imap_fetch_env_info * info;
2609         uint32_t uid;
2610         char * headers;
2611         size_t size;
2612         struct mailimap_msg_att_dynamic * att_dyn;
2613
2614         imap_get_msg_att_info(msg_att, &uid, &headers, &size,
2615                               &att_dyn);
2616         
2617         if (!headers)
2618                 return NULL;
2619         info = malloc(sizeof(* info));
2620         info->uid = uid;
2621         info->headers = strdup(headers);
2622         info->size = size;
2623         info->flags = imap_flags_to_flags(att_dyn, tags);
2624         
2625         return info;
2626 }
2627
2628 static int
2629 imap_fetch_result_to_envelop_list(clist * fetch_result,
2630                                   carray ** p_env_list)
2631 {
2632         clistiter * cur;
2633         unsigned int i;
2634         carray * env_list;
2635
2636         i = 0;
2637         env_list = carray_new(16);
2638   
2639         for(cur = clist_begin(fetch_result) ; cur != NULL ;
2640             cur = clist_next(cur)) {
2641                 struct mailimap_msg_att * msg_att;
2642                 struct imap_fetch_env_info * env_info;
2643                 GSList *tags = NULL;
2644
2645                 msg_att = clist_content(cur);
2646
2647                 env_info = fetch_to_env_info(msg_att, &tags);
2648                 if (!env_info)
2649                         return MAILIMAP_ERROR_MEMORY;
2650                 carray_add(env_list, env_info, NULL);
2651                 carray_add(env_list, tags, NULL);
2652         }
2653   
2654         * p_env_list = env_list;
2655   
2656         return MAIL_NO_ERROR;
2657 }
2658
2659 static int imap_add_envelope_fetch_att(struct mailimap_fetch_type * fetch_type)
2660 {
2661         struct mailimap_fetch_att * fetch_att;
2662         int r;
2663         char * header;
2664         clist * hdrlist;
2665         struct mailimap_header_list * imap_hdrlist;
2666         struct mailimap_section * section;
2667
2668         hdrlist = clist_new();
2669   
2670         header = strdup("Date");
2671         r = clist_append(hdrlist, header);
2672         header = strdup("From");
2673         r = clist_append(hdrlist, header);
2674         header = strdup("To");
2675         r = clist_append(hdrlist, header);
2676         header = strdup("Cc");
2677         r = clist_append(hdrlist, header);
2678         header = strdup("Subject");
2679         r = clist_append(hdrlist, header);
2680         header = strdup("Message-ID");
2681         r = clist_append(hdrlist, header);
2682         header = strdup("References");
2683         r = clist_append(hdrlist, header);
2684         header = strdup("In-Reply-To");
2685         r = clist_append(hdrlist, header);
2686   
2687         imap_hdrlist = mailimap_header_list_new(hdrlist);
2688         section = mailimap_section_new_header_fields(imap_hdrlist);
2689         fetch_att = mailimap_fetch_att_new_body_peek_section(section);
2690         mailimap_fetch_type_new_fetch_att_list_add(fetch_type, fetch_att);
2691   
2692         return MAIL_NO_ERROR;
2693 }
2694
2695 static int imap_add_header_fetch_att(struct mailimap_fetch_type * fetch_type)
2696 {
2697         struct mailimap_fetch_att * fetch_att;
2698         struct mailimap_section * section;
2699         
2700         section = mailimap_section_new_header();
2701         fetch_att = mailimap_fetch_att_new_body_peek_section(section);
2702         mailimap_fetch_type_new_fetch_att_list_add(fetch_type, fetch_att);
2703         
2704         return MAIL_NO_ERROR;
2705 }
2706
2707 static int
2708 imap_get_envelopes_list(mailimap * imap, struct mailimap_set * set,
2709                         carray ** p_env_list)
2710 {
2711         struct mailimap_fetch_att * fetch_att;
2712         struct mailimap_fetch_type * fetch_type;
2713         int res;
2714         clist * fetch_result;
2715         int r;
2716         carray * env_list = NULL;
2717         chashdatum key;
2718         chashdatum value;
2719         
2720         fetch_type = mailimap_fetch_type_new_fetch_att_list_empty();
2721   
2722         /* uid */
2723         fetch_att = mailimap_fetch_att_new_uid();
2724         r = mailimap_fetch_type_new_fetch_att_list_add(fetch_type, fetch_att);
2725   
2726         /* flags */
2727         fetch_att = mailimap_fetch_att_new_flags();
2728         r = mailimap_fetch_type_new_fetch_att_list_add(fetch_type, fetch_att);
2729   
2730         /* rfc822 size */
2731         fetch_att = mailimap_fetch_att_new_rfc822_size();
2732         r = mailimap_fetch_type_new_fetch_att_list_add(fetch_type, fetch_att);
2733   
2734         /* headers */
2735         key.data = &imap;
2736         key.len = sizeof(imap);
2737         r = chash_get(courier_workaround_hash, &key, &value);
2738         if (r < 0)
2739                 r = imap_add_envelope_fetch_att(fetch_type);
2740         else
2741                 r = imap_add_header_fetch_att(fetch_type);
2742         
2743         mailstream_logger = imap_logger_fetch;
2744         
2745         r = mailimap_uid_fetch(imap, set, fetch_type, &fetch_result);
2746         
2747         mailstream_logger = imap_logger_cmd;
2748         switch (r) {
2749         case MAILIMAP_NO_ERROR:
2750                 break;
2751         default:
2752                 mailimap_fetch_type_free(fetch_type);
2753                 debug_print("uid_fetch: %d\n", r);
2754                 return r;
2755         }
2756         
2757         if (clist_begin(fetch_result) == NULL) {
2758                 res = MAILIMAP_ERROR_FETCH;
2759                 debug_print("clist_begin = NULL\n");
2760                 goto err;
2761         }
2762         
2763         r = imap_fetch_result_to_envelop_list(fetch_result, &env_list);
2764         mailimap_fetch_list_free(fetch_result);
2765         
2766         if (r != MAILIMAP_NO_ERROR) {
2767                 mailimap_fetch_type_free(fetch_type);
2768                 res = MAILIMAP_ERROR_MEMORY;
2769                 debug_print("fetch_result_to_envelop_list: %d\n", res);
2770                 goto err;
2771         }
2772         
2773         mailimap_fetch_type_free(fetch_type);
2774         
2775         * p_env_list = env_list;
2776         
2777         return MAILIMAP_NO_ERROR;
2778   
2779  err:
2780         return res;
2781 }
2782
2783 struct fetch_env_param {
2784         mailimap * imap;
2785         struct mailimap_set * set;
2786 };
2787
2788 struct fetch_env_result {
2789         carray * fetch_env_result;
2790         int error;
2791 };
2792
2793 static void fetch_env_run(struct etpan_thread_op * op)
2794 {
2795         struct fetch_env_param * param;
2796         struct fetch_env_result * result;
2797         carray * env_list;
2798         int r;
2799         
2800         param = op->param;
2801         result = op->result;
2802
2803         CHECK_IMAP();
2804
2805         env_list = NULL;
2806         r = imap_get_envelopes_list(param->imap, param->set,
2807                                     &env_list);
2808         
2809         result->error = r;
2810         result->fetch_env_result = env_list;
2811         
2812         debug_print("imap fetch_env run - end %i\n", r);
2813 }
2814
2815 int imap_threaded_fetch_env(Folder * folder, struct mailimap_set * set,
2816                             carray ** p_env_list)
2817 {
2818         struct fetch_env_param param;
2819         struct fetch_env_result result;
2820         mailimap * imap;
2821         
2822         debug_print("imap fetch_env - begin\n");
2823         
2824         imap = get_imap(folder);
2825         param.imap = imap;
2826         param.set = set;
2827         
2828         threaded_run(folder, &param, &result, fetch_env_run);
2829         
2830         if (result.error != MAILIMAP_NO_ERROR) {
2831                 chashdatum key;
2832                 chashdatum value;
2833                 int r;
2834                 
2835                 key.data = &imap;
2836                 key.len = sizeof(imap);
2837                 r = chash_get(courier_workaround_hash, &key, &value);
2838                 if (r < 0) {
2839                         value.data = NULL;
2840                         value.len = 0;
2841                         chash_set(courier_workaround_hash, &key, &value, NULL);
2842                         
2843                         threaded_run(folder, &param, &result, fetch_env_run);
2844                 }
2845         }
2846         
2847         if (result.error != MAILIMAP_NO_ERROR)
2848                 return result.error;
2849         
2850         debug_print("imap fetch_env - end\n");
2851         
2852         * p_env_list = result.fetch_env_result;
2853         
2854         return result.error;
2855 }
2856
2857 void imap_fetch_env_free(carray * env_list)
2858 {
2859         unsigned int i;
2860         
2861         for(i = 0 ; i < carray_count(env_list) ; i += 2) {
2862                 struct imap_fetch_env_info * env_info;
2863                 
2864                 env_info = carray_get(env_list, i);
2865                 free(env_info->headers);
2866                 free(env_info);
2867         }
2868         carray_free(env_list);
2869 }
2870
2871
2872
2873
2874
2875 struct append_param {
2876         mailimap * imap;
2877         const char * mailbox;
2878         const char * filename;
2879         struct mailimap_flag_list * flag_list;
2880 };
2881
2882 struct append_result {
2883         int error;
2884         int uid;
2885 };
2886
2887 static void append_run(struct etpan_thread_op * op)
2888 {
2889         struct append_param * param;
2890         struct append_result * result;
2891         int r;
2892         char * data;
2893         size_t size;
2894 #ifndef G_OS_WIN32
2895         struct stat stat_buf;
2896         int fd;
2897 #endif
2898         guint32 uid = 0, val = 0;
2899         
2900         param = op->param;
2901         result = op->result;
2902         
2903         CHECK_IMAP();
2904
2905 #ifndef G_OS_WIN32
2906         r = stat(param->filename, &stat_buf);
2907         if (r < 0) {
2908                 result->error = MAILIMAP_ERROR_APPEND;
2909                 return;
2910         }
2911         size = stat_buf.st_size;
2912         
2913         fd = open(param->filename, O_RDONLY);
2914         if (fd < 0) {
2915                 result->error = MAILIMAP_ERROR_APPEND;
2916                 return;
2917         }
2918         
2919         data = mmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0);
2920         if (data == (void *) MAP_FAILED) {
2921                 close(fd);
2922                 result->error = MAILIMAP_ERROR_APPEND;
2923                 return;
2924         }
2925 #else
2926         data = file_read_to_str_no_recode(param->filename);
2927         if (data == NULL) {
2928                 result->error = MAILIMAP_ERROR_APPEND;
2929                 return;
2930         }
2931         size = strlen(data);
2932 #endif
2933         mailstream_logger = imap_logger_append;
2934         
2935         r = mailimap_uidplus_append(param->imap, param->mailbox,
2936                             param->flag_list, NULL,
2937                             data, size, &val, &uid);
2938
2939         mailstream_logger = imap_logger_cmd;
2940         
2941 #ifndef G_OS_WIN32
2942         munmap(data, size);
2943         close(fd);
2944 #else
2945         g_free(data);
2946 #endif
2947         
2948         result->error = r;
2949         result->uid = uid;
2950         debug_print("imap append run - end %i uid %d\n", r, uid);
2951 }
2952
2953 int imap_threaded_append(Folder * folder, const char * mailbox,
2954                          const char * filename,
2955                          struct mailimap_flag_list * flag_list,
2956                          int *uid)
2957 {
2958         struct append_param param;
2959         struct append_result result;
2960         mailimap * imap;
2961         
2962         debug_print("imap append - begin\n");
2963         
2964         imap = get_imap(folder);
2965         param.imap = imap;
2966         param.mailbox = mailbox;
2967         param.filename = filename;
2968         param.flag_list = flag_list;
2969         
2970         threaded_run(folder, &param, &result, append_run);
2971         
2972         if (result.error != MAILIMAP_NO_ERROR)
2973                 return result.error;
2974         
2975         debug_print("imap append - end\n");
2976         if (uid != NULL)
2977                 *uid = result.uid;
2978
2979         return result.error;
2980 }
2981
2982
2983
2984
2985 struct expunge_param {
2986         mailimap * imap;
2987 };
2988
2989 struct expunge_result {
2990         int error;
2991 };
2992
2993 static void expunge_run(struct etpan_thread_op * op)
2994 {
2995         struct expunge_param * param;
2996         struct expunge_result * result;
2997         int r;
2998         
2999         param = op->param;
3000         result = op->result;
3001
3002         CHECK_IMAP();
3003
3004         r = mailimap_expunge(param->imap);
3005         
3006         result->error = r;
3007         debug_print("imap expunge run - end %i\n", r);
3008 }
3009
3010 int imap_threaded_expunge(Folder * folder)
3011 {
3012         struct expunge_param param;
3013         struct expunge_result result;
3014         
3015         debug_print("imap expunge - begin\n");
3016         
3017         param.imap = get_imap(folder);
3018         
3019         threaded_run(folder, &param, &result, expunge_run);
3020         
3021         debug_print("imap expunge - end\n");
3022         
3023         return result.error;
3024 }
3025
3026
3027 struct copy_param {
3028         mailimap * imap;
3029         struct mailimap_set * set;
3030         const char * mb;
3031 };
3032
3033 struct copy_result {
3034         int error;
3035         struct mailimap_set *source;
3036         struct mailimap_set *dest;
3037 };
3038
3039 static void copy_run(struct etpan_thread_op * op)
3040 {
3041         struct copy_param * param;
3042         struct copy_result * result;
3043         int r;
3044         guint32 val;
3045         struct mailimap_set *source = NULL, *dest = NULL;
3046
3047         param = op->param;
3048         result = op->result;
3049
3050         CHECK_IMAP();
3051
3052         r = mailimap_uidplus_uid_copy(param->imap, param->set, param->mb,
3053                 &val, &source, &dest);
3054         
3055         result->error = r;
3056         if (r == 0) {
3057                 result->source = source;
3058                 result->dest = dest;
3059         } else {
3060                 result->source = NULL;
3061                 result->dest = NULL;
3062         }
3063         debug_print("imap copy run - end %i\n", r);
3064 }
3065
3066 int imap_threaded_copy(Folder * folder, struct mailimap_set * set,
3067                        const char * mb, struct mailimap_set **source,
3068                        struct mailimap_set **dest)
3069 {
3070         struct copy_param param;
3071         struct copy_result result;
3072         mailimap * imap;
3073         
3074         debug_print("imap copy - begin\n");
3075         
3076         imap = get_imap(folder);
3077         param.imap = imap;
3078         param.set = set;
3079         param.mb = mb;
3080         
3081         threaded_run(folder, &param, &result, copy_run);
3082         *source = NULL;
3083         *dest = NULL;
3084         
3085         if (result.error != MAILIMAP_NO_ERROR)
3086                 return result.error;
3087         
3088         *source = result.source;
3089         *dest = result.dest;
3090
3091         debug_print("imap copy - end\n");
3092         
3093         return result.error;
3094 }
3095
3096
3097
3098 struct store_param {
3099         mailimap * imap;
3100         struct mailimap_set * set;
3101         struct mailimap_store_att_flags * store_att_flags;
3102 };
3103
3104 struct store_result {
3105         int error;
3106 };
3107
3108 static void store_run(struct etpan_thread_op * op)
3109 {
3110         struct store_param * param;
3111         struct store_result * result;
3112         int r;
3113         
3114         param = op->param;
3115         result = op->result;
3116
3117         CHECK_IMAP();
3118
3119         r = mailimap_uid_store(param->imap, param->set,
3120                                param->store_att_flags);
3121         
3122         result->error = r;
3123         
3124         debug_print("imap store run - end %i\n", r);
3125 }
3126
3127 int imap_threaded_store(Folder * folder, struct mailimap_set * set,
3128                         struct mailimap_store_att_flags * store_att_flags)
3129 {
3130         struct store_param param;
3131         struct store_result result;
3132         mailimap * imap;
3133         
3134         debug_print("imap store - begin\n");
3135         
3136         imap = get_imap(folder);
3137         param.imap = imap;
3138         param.set = set;
3139         param.store_att_flags = store_att_flags;
3140         
3141         threaded_run(folder, &param, &result, store_run);
3142         
3143         if (result.error != MAILIMAP_NO_ERROR)
3144                 return result.error;
3145         
3146         debug_print("imap store - end\n");
3147         
3148         return result.error;
3149 }
3150
3151
3152 #define ENV_BUFFER_SIZE 512
3153 #ifndef G_OS_WIN32
3154 static void do_exec_command(int fd, const char * command,
3155                             const char * servername, uint16_t port)
3156 {
3157         int i, maxopen;
3158 #ifdef SOLARIS
3159         char env_buffer[ENV_BUFFER_SIZE];
3160 #endif
3161         
3162         if (fork() > 0) {
3163                 /* Fork again to become a child of init rather than
3164                    the etpan client. */
3165                 exit(0);
3166         }
3167   
3168         if (servername)
3169                 g_setenv("ETPANSERVER", servername, TRUE);
3170         else
3171                 g_unsetenv("ETPANSERVER");
3172   
3173         if (port) {
3174                 char porttext[20];
3175                 
3176                 snprintf(porttext, sizeof(porttext), "%d", port);
3177                 g_setenv("ETPANPORT", porttext, TRUE);
3178         }
3179         else {
3180                 g_unsetenv("ETPANPORT");
3181         }
3182                 
3183         /* Not a lot we can do if there's an error other than bail. */
3184         if (dup2(fd, 0) == -1)
3185                 exit(1);
3186         if (dup2(fd, 1) == -1)
3187                 exit(1);
3188   
3189         /* Should we close stderr and reopen /dev/null? */
3190   
3191         maxopen = sysconf(_SC_OPEN_MAX);
3192         for (i=3; i < maxopen; i++)
3193                 close(i);
3194   
3195 #ifdef TIOCNOTTY
3196         /* Detach from the controlling tty if we have one. Otherwise,
3197            SSH might do something stupid like trying to use it instead
3198            of running $SSH_ASKPASS. Doh. */
3199         fd = open("/dev/tty", O_RDONLY);
3200         if (fd != -1) {
3201                 ioctl(fd, TIOCNOTTY, NULL);
3202                 close(fd);
3203         }
3204 #endif /* TIOCNOTTY */
3205
3206         execl("/bin/sh", "/bin/sh", "-c", command, NULL);
3207   
3208         /* Eep. Shouldn't reach this */
3209         exit(1);
3210 }
3211
3212 static int subcommand_connect(const char *command,
3213                               const char *servername, uint16_t port)
3214 {
3215         /* SEB unsupported on Windows */
3216         int sockfds[2];
3217         pid_t childpid;
3218   
3219         if (socketpair(AF_UNIX, SOCK_STREAM, 0, sockfds))
3220                 return -1;
3221   
3222         childpid = fork();
3223         if (!childpid) {
3224                 do_exec_command(sockfds[1], command, servername, port);
3225         }
3226         else if (childpid == -1) {
3227                 close(sockfds[0]);
3228                 close(sockfds[1]);
3229                 return -1;
3230         }
3231   
3232         close(sockfds[1]);
3233   
3234         /* Reap child, leaving grandchild process to run */
3235         waitpid(childpid, NULL, 0);
3236   
3237         return sockfds[0];
3238 }
3239
3240 static int socket_connect_cmd(mailimap * imap, const char * command,
3241                        const char * server, int port)
3242 {
3243         int fd;
3244         mailstream * s;
3245         int r;
3246         
3247         fd = subcommand_connect(command, server, port);
3248         if (fd < 0)
3249                 return MAILIMAP_ERROR_STREAM;
3250         
3251         s = mailstream_socket_open(fd);
3252         if (s == NULL) {
3253                 close(fd);
3254                 return MAILIMAP_ERROR_STREAM;
3255         }
3256         
3257         r = mailimap_connect(imap, s);
3258         if (r != MAILIMAP_NO_ERROR_AUTHENTICATED
3259         &&  r != MAILIMAP_NO_ERROR_NON_AUTHENTICATED) {
3260                 mailstream_close(s);
3261                 if (imap)
3262                         imap->imap_stream = NULL;
3263                 return r;
3264         }
3265         
3266         return r;
3267 }
3268
3269 /* connect cmd */
3270
3271 struct connect_cmd_param {
3272         mailimap * imap;
3273         const char * command;
3274         const char * server;
3275         int port;
3276 };
3277
3278 struct connect_cmd_result {
3279         int error;
3280 };
3281
3282 static void connect_cmd_run(struct etpan_thread_op * op)
3283 {
3284         int r;
3285         struct connect_cmd_param * param;
3286         struct connect_cmd_result * result;
3287         
3288         param = op->param;
3289         result = op->result;
3290         
3291         CHECK_IMAP();
3292
3293         r = socket_connect_cmd(param->imap, param->command,
3294                                param->server, param->port);
3295         
3296         result->error = r;
3297 }
3298
3299
3300 int imap_threaded_connect_cmd(Folder * folder, const char * command,
3301                               const char * server, int port)
3302 {
3303         struct connect_cmd_param param;
3304         struct connect_cmd_result result;
3305         chashdatum key;
3306         chashdatum value;
3307         mailimap * imap, * oldimap;
3308         
3309         oldimap = get_imap(folder);
3310
3311         imap = mailimap_new(0, NULL);
3312         
3313         if (oldimap) {
3314                 debug_print("deleting old imap %p\n", oldimap);
3315                 delete_imap(folder, oldimap);
3316         }
3317
3318         key.data = &folder;
3319         key.len = sizeof(folder);
3320         value.data = imap;
3321         value.len = 0;
3322         chash_set(session_hash, &key, &value, NULL);
3323         
3324         param.imap = imap;
3325         param.command = command;
3326         param.server = server;
3327         param.port = port;
3328         
3329         threaded_run(folder, &param, &result, connect_cmd_run);
3330         
3331         debug_print("connect_cmd ok %i with imap %p\n", result.error, imap);
3332         
3333         return result.error;
3334 }
3335 #endif /* G_OS_WIN32 */
3336
3337 void imap_threaded_cancel(Folder * folder)
3338 {
3339         mailimap * imap;
3340         
3341         imap = get_imap(folder);
3342         if (imap->imap_stream != NULL)
3343                 mailstream_cancel(imap->imap_stream);
3344 }
3345
3346 #else
3347
3348 void imap_main_init(void)
3349 {
3350 }
3351 void imap_main_done(void)
3352 {
3353 }
3354 void imap_main_set_timeout(int sec)
3355 {
3356 }
3357
3358 void imap_threaded_cancel(Folder * folder);
3359 {
3360 }
3361
3362 #endif