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