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