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