Clear statusbar's progressbar in case of NNTP xhdr/xover failure.
[claws.git] / src / etpan / nntp-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 "nntp-thread.h"
29 #include "news.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 "ssl_certificate.h"
47 #include "socket.h"
48 #include "remotefolder.h"
49 #include "main.h"
50 #include "account.h"
51 #include "statusbar.h"
52
53 #define DISABLE_LOG_DURING_LOGIN
54
55 #define NNTP_BATCH_SIZE 5000
56
57 static struct etpan_thread_manager * thread_manager = NULL;
58 static chash * nntp_hash = NULL;
59 static chash * session_hash = NULL;
60 static guint thread_manager_signal = 0;
61 static GIOChannel * io_channel = NULL;
62
63 static void nntp_logger(int direction, const char * str, size_t size) 
64 {
65         gchar *buf;
66         gchar **lines;
67         int i = 0;
68
69         if (size > 256) {
70                 log_print(LOG_PROTOCOL, "NNTP%c [data - %zd bytes]\n", direction?'>':'<', size);
71                 return;
72         }
73         buf = malloc(size+1);
74         memset(buf, 0, size+1);
75         strncpy(buf, str, size);
76         buf[size] = '\0';
77
78         if (!strncmp(buf, "<<<<<<<", 7) 
79         ||  !strncmp(buf, ">>>>>>>", 7)) {
80                 free(buf);
81                 return;
82         }
83         while (strstr(buf, "\r"))
84                 *strstr(buf, "\r") = ' ';
85         while (strlen(buf) > 0 && buf[strlen(buf)-1] == '\n')
86                 buf[strlen(buf)-1] = '\0';
87
88         lines = g_strsplit(buf, "\n", -1);
89
90         while (lines[i] && *lines[i]) {
91                 log_print(LOG_PROTOCOL, "NNTP%c %s\n", direction?'>':'<', lines[i]);
92                 i++;
93         }
94         g_strfreev(lines);
95         free(buf);
96 }
97
98 static void delete_nntp(Folder *folder, newsnntp *nntp)
99 {
100         chashdatum key;
101
102         key.data = &folder;
103         key.len = sizeof(folder);
104         chash_delete(session_hash, &key, NULL);
105         
106         key.data = &nntp;
107         key.len = sizeof(nntp);
108         if (nntp && nntp->nntp_stream) {
109                 /* we don't want libetpan to logout */
110                 mailstream_close(nntp->nntp_stream);
111                 nntp->nntp_stream = NULL;
112         }
113         debug_print("removing newsnntp %p\n", nntp);
114         newsnntp_free(nntp);    
115 }
116
117 static gboolean thread_manager_event(GIOChannel * source,
118     GIOCondition condition,
119     gpointer data)
120 {
121 #ifdef G_OS_WIN32
122         gsize bytes_read;
123         gchar ch;
124         
125         if (condition & G_IO_IN)
126                 g_io_channel_read_chars(source, &ch, 1, &bytes_read, NULL);
127 #endif
128         etpan_thread_manager_loop(thread_manager);
129         
130         return TRUE;
131 }
132
133 #define ETPAN_DEFAULT_NETWORK_TIMEOUT 60
134 extern gboolean etpan_skip_ssl_cert_check;
135
136 void nntp_main_init(gboolean skip_ssl_cert_check)
137 {
138         int fd_thread_manager;
139         
140         etpan_skip_ssl_cert_check = skip_ssl_cert_check;
141         
142         nntp_hash = chash_new(CHASH_COPYKEY, CHASH_DEFAULTSIZE);
143         session_hash = chash_new(CHASH_COPYKEY, CHASH_DEFAULTSIZE);
144         
145         thread_manager = etpan_thread_manager_new();
146         
147         fd_thread_manager = etpan_thread_manager_get_fd(thread_manager);
148         
149 #ifndef G_OS_WIN32
150         io_channel = g_io_channel_unix_new(fd_thread_manager);
151 #else
152         io_channel = g_io_channel_win32_new_fd(fd_thread_manager);
153 #endif
154         
155         thread_manager_signal = g_io_add_watch_full(io_channel, 0, G_IO_IN,
156                                                     thread_manager_event,
157                                                     (gpointer) NULL,
158                                                     NULL);
159 }
160
161 void nntp_main_done(gboolean have_connectivity)
162 {
163         nntp_disconnect_all(have_connectivity);
164         etpan_thread_manager_stop(thread_manager);
165 #if defined(__NetBSD__) || defined(__OpenBSD__) || defined(__FreeBSD__)
166         return;
167 #endif
168         etpan_thread_manager_join(thread_manager);
169         
170         g_source_remove(thread_manager_signal);
171         g_io_channel_unref(io_channel);
172         
173         etpan_thread_manager_free(thread_manager);
174         
175         chash_free(session_hash);
176         chash_free(nntp_hash);
177 }
178
179 void nntp_init(Folder * folder)
180 {
181         struct etpan_thread * thread;
182         chashdatum key;
183         chashdatum value;
184         
185         thread = etpan_thread_manager_get_thread(thread_manager);
186         
187         key.data = &folder;
188         key.len = sizeof(folder);
189         value.data = thread;
190         value.len = 0;
191         
192         chash_set(nntp_hash, &key, &value, NULL);
193 }
194
195 void nntp_done(Folder * folder)
196 {
197         struct etpan_thread * thread;
198         chashdatum key;
199         chashdatum value;
200         int r;
201         
202         key.data = &folder;
203         key.len = sizeof(folder);
204         
205         r = chash_get(nntp_hash, &key, &value);
206         if (r < 0)
207                 return;
208         
209         thread = value.data;
210         
211         etpan_thread_unbind(thread);
212         
213         chash_delete(nntp_hash, &key, NULL);
214         
215         debug_print("remove thread\n");
216 }
217
218 static struct etpan_thread * get_thread(Folder * folder)
219 {
220         struct etpan_thread * thread;
221         chashdatum key;
222         chashdatum value;
223         int r;
224
225         key.data = &folder;
226         key.len = sizeof(folder);
227
228         r = chash_get(nntp_hash, &key, &value);
229         if (r < 0)
230                 return NULL;
231
232         thread = value.data;
233
234         return thread;
235 }
236
237 static newsnntp * get_nntp(Folder * folder)
238 {
239         newsnntp * nntp;
240         chashdatum key;
241         chashdatum value;
242         int r;
243         
244         key.data = &folder;
245         key.len = sizeof(folder);
246         
247         r = chash_get(session_hash, &key, &value);
248         if (r < 0)
249                 return NULL;
250         
251         nntp = value.data;
252         debug_print("found nntp %p\n", nntp);
253         return nntp;
254 }
255
256
257 static void generic_cb(int cancelled, void * result, void * callback_data)
258 {
259         struct etpan_thread_op * op;
260         
261         op = (struct etpan_thread_op *) callback_data;
262
263         debug_print("generic_cb\n");
264         op->finished = 1;
265 }
266
267 static void threaded_run(Folder * folder, void * param, void * result,
268                          void (* func)(struct etpan_thread_op * ))
269 {
270         struct etpan_thread_op * op;
271         struct etpan_thread * thread;
272         void (*previous_stream_logger)(int direction,
273                 const char * str, size_t size);
274
275         nntp_folder_ref(folder);
276
277         op = etpan_thread_op_new();
278         
279         op->nntp = get_nntp(folder);
280         op->param = param;
281         op->result = result;
282
283         op->run = func;
284         op->callback = generic_cb;
285         op->callback_data = op;
286         
287         previous_stream_logger = mailstream_logger;
288         mailstream_logger = nntp_logger;
289
290         thread = get_thread(folder);
291         etpan_thread_op_schedule(thread, op);
292         
293         while (!op->finished) {
294                 gtk_main_iteration();
295         }
296         
297         mailstream_logger = previous_stream_logger;
298
299         etpan_thread_op_free(op);
300
301         nntp_folder_unref(folder);
302 }
303
304
305 /* connect */
306
307 struct connect_param {
308         newsnntp * nntp;
309         PrefsAccount *account;
310         const char * server;
311         int port;
312 };
313
314 struct connect_result {
315         int error;
316 };
317
318 #define CHECK_NNTP() {                                          \
319         if (!param->nntp) {                                     \
320                 result->error = NEWSNNTP_ERROR_BAD_STATE;       \
321                 return;                                         \
322         }                                                       \
323 }
324
325 static void connect_run(struct etpan_thread_op * op)
326 {
327         int r;
328         struct connect_param * param;
329         struct connect_result * result;
330         
331         param = op->param;
332         result = op->result;
333         
334         CHECK_NNTP();
335
336         r = newsnntp_socket_connect(param->nntp,
337                                     param->server, param->port);
338         
339         result->error = r;
340 }
341
342
343 int nntp_threaded_connect(Folder * folder, const char * server, int port)
344 {
345         struct connect_param param;
346         struct connect_result result;
347         chashdatum key;
348         chashdatum value;
349         newsnntp * nntp, * oldnntp;
350         
351         oldnntp = get_nntp(folder);
352
353         nntp = newsnntp_new(0, NULL);
354         
355         if (oldnntp) {
356                 debug_print("deleting old nntp %p\n", oldnntp);
357                 delete_nntp(folder, oldnntp);
358         }
359         
360         key.data = &folder;
361         key.len = sizeof(folder);
362         value.data = nntp;
363         value.len = 0;
364         chash_set(session_hash, &key, &value, NULL);
365         
366         param.nntp = nntp;
367         param.server = server;
368         param.port = port;
369         
370         refresh_resolvers();
371         threaded_run(folder, &param, &result, connect_run);
372         
373         debug_print("connect ok %i with nntp %p\n", result.error, nntp);
374         
375         return result.error;
376 }
377 #ifdef USE_GNUTLS
378 static void connect_ssl_run(struct etpan_thread_op * op)
379 {
380         int r;
381         struct connect_param * param;
382         struct connect_result * result;
383         
384         param = op->param;
385         result = op->result;
386         
387         CHECK_NNTP();
388
389         r = newsnntp_ssl_connect_with_callback(param->nntp,
390                                  param->server, param->port,
391                                  etpan_connect_ssl_context_cb, param->account);
392         result->error = r;
393 }
394
395 int nntp_threaded_connect_ssl(Folder * folder, const char * server, int port)
396 {
397         struct connect_param param;
398         struct connect_result result;
399         chashdatum key;
400         chashdatum value;
401         newsnntp * nntp, * oldnntp;
402         gboolean accept_if_valid = FALSE;
403
404         oldnntp = get_nntp(folder);
405
406         nntp = newsnntp_new(0, NULL);
407
408         if (oldnntp) {
409                 debug_print("deleting old nntp %p\n", oldnntp);
410                 delete_nntp(folder, oldnntp);
411         }
412
413         key.data = &folder;
414         key.len = sizeof(folder);
415         value.data = nntp;
416         value.len = 0;
417         chash_set(session_hash, &key, &value, NULL);
418
419         param.nntp = nntp;
420         param.server = server;
421         param.port = port;
422         param.account = folder->account;
423
424         if (folder->account)
425                 accept_if_valid = folder->account->ssl_certs_auto_accept;
426
427         refresh_resolvers();
428         threaded_run(folder, &param, &result, connect_ssl_run);
429
430         if (result.error == NEWSNNTP_NO_ERROR && !etpan_skip_ssl_cert_check) {
431                 if (etpan_certificate_check(nntp->nntp_stream, server, port,
432                                             accept_if_valid) != TRUE)
433                         return -1;
434         }
435         debug_print("connect %d with nntp %p\n", result.error, nntp);
436         
437         return result.error;
438 }
439 #endif
440
441 void nntp_threaded_disconnect(Folder * folder)
442 {
443         newsnntp * nntp;
444         
445         nntp = get_nntp(folder);
446         if (nntp == NULL) {
447                 debug_print("was disconnected\n");
448                 return;
449         }
450         
451         debug_print("deleting old nntp %p\n", nntp);
452         delete_nntp(folder, nntp);
453         
454         debug_print("disconnect ok\n");
455 }
456
457 void nntp_threaded_cancel(Folder * folder)
458 {
459         newsnntp * nntp;
460         
461         nntp = get_nntp(folder);
462         if (nntp->nntp_stream != NULL)
463                 mailstream_cancel(nntp->nntp_stream);
464 }
465
466
467 struct login_param {
468         newsnntp * nntp;
469         const char * login;
470         const char * password;
471 };
472
473 struct login_result {
474         int error;
475 };
476
477 static void login_run(struct etpan_thread_op * op)
478 {
479         struct login_param * param;
480         struct login_result * result;
481         int r;
482 #ifdef DISABLE_LOG_DURING_LOGIN
483         int old_debug;
484 #endif
485         
486         param = op->param;
487         result = op->result;
488
489         CHECK_NNTP();
490
491 #ifdef DISABLE_LOG_DURING_LOGIN
492         old_debug = mailstream_debug;
493         mailstream_debug = 0;
494 #endif
495
496         r = newsnntp_authinfo_username(param->nntp, param->login);
497         /* libetpan returning NO_ERROR means it received resp.code 281:
498            in this case auth. is already successful, no password is needed. */
499         if (r == NEWSNNTP_WARNING_REQUEST_AUTHORIZATION_PASSWORD) {
500                 r = newsnntp_authinfo_password(param->nntp, param->password);
501         }
502         
503
504
505 #ifdef DISABLE_LOG_DURING_LOGIN
506         mailstream_debug = old_debug;
507 #endif
508         
509         result->error = r;
510         if (param->nntp->nntp_response)
511                 nntp_logger(0, param->nntp->nntp_response, strlen(param->nntp->nntp_response));
512
513         debug_print("nntp login run - end %i\n", r);
514 }
515
516 int nntp_threaded_login(Folder * folder, const char * login, const char * password)
517 {
518         struct login_param param;
519         struct login_result result;
520         
521         debug_print("nntp login - begin\n");
522         
523         param.nntp = get_nntp(folder);
524         param.login = login;
525         param.password = password;
526
527         threaded_run(folder, &param, &result, login_run);
528         
529         debug_print("nntp login - end\n");
530         
531         return result.error;
532 }
533
534 struct date_param {
535         newsnntp * nntp;
536         struct tm * lt;
537 };
538
539 struct date_result {
540         int error;
541 };
542
543 static void date_run(struct etpan_thread_op * op)
544 {
545         struct date_param * param;
546         struct date_result * result;
547         int r;
548         
549         param = op->param;
550         result = op->result;
551
552         CHECK_NNTP();
553
554         r = newsnntp_date(param->nntp, param->lt);
555         
556         result->error = r;
557         debug_print("nntp date run - end %i\n", r);
558 }
559
560 int nntp_threaded_date(Folder * folder, struct tm *lt)
561 {
562         struct date_param param;
563         struct date_result result;
564         
565         debug_print("nntp date - begin\n");
566         
567         param.nntp = get_nntp(folder);
568         param.lt = lt;
569
570         threaded_run(folder, &param, &result, date_run);
571         
572         debug_print("nntp date - end\n");
573         
574         return result.error;
575 }
576
577 struct list_param {
578         newsnntp * nntp;
579         clist **grouplist;
580 };
581
582 struct list_result {
583         int error;
584 };
585
586 static void list_run(struct etpan_thread_op * op)
587 {
588         struct list_param * param;
589         struct list_result * result;
590         int r;
591         
592         param = op->param;
593         result = op->result;
594
595         CHECK_NNTP();
596
597         r = newsnntp_list(param->nntp, param->grouplist);
598         
599         result->error = r;
600         debug_print("nntp list run - end %i\n", r);
601 }
602
603 int nntp_threaded_list(Folder * folder, clist **grouplist)
604 {
605         struct list_param param;
606         struct list_result result;
607         
608         debug_print("nntp list - begin\n");
609         
610         param.nntp = get_nntp(folder);
611         param.grouplist = grouplist;
612
613         threaded_run(folder, &param, &result, list_run);
614         
615         debug_print("nntp list - end\n");
616         
617         return result.error;
618 }
619
620 struct post_param {
621         newsnntp * nntp;
622         char *contents;
623         size_t len;
624 };
625
626 struct post_result {
627         int error;
628 };
629
630 static void post_run(struct etpan_thread_op * op)
631 {
632         struct post_param * param;
633         struct post_result * result;
634         int r;
635         
636         param = op->param;
637         result = op->result;
638
639         CHECK_NNTP();
640
641         r = newsnntp_post(param->nntp, param->contents, param->len);
642         
643         result->error = r;
644         debug_print("nntp post run - end %i\n", r);
645 }
646
647 int nntp_threaded_post(Folder * folder, char *contents, size_t len)
648 {
649         struct post_param param;
650         struct post_result result;
651         
652         debug_print("nntp post - begin\n");
653         
654         param.nntp = get_nntp(folder);
655         param.contents = contents;
656         param.len = len;
657
658         threaded_run(folder, &param, &result, post_run);
659         
660         debug_print("nntp post - end\n");
661         
662         return result.error;
663 }
664
665 struct article_param {
666         newsnntp * nntp;
667         guint32 num;
668         char **contents;
669         size_t *len;
670 };
671
672 struct article_result {
673         int error;
674 };
675
676 static void article_run(struct etpan_thread_op * op)
677 {
678         struct article_param * param;
679         struct article_result * result;
680         int r;
681         
682         param = op->param;
683         result = op->result;
684
685         CHECK_NNTP();
686
687         r = newsnntp_article(param->nntp, param->num, param->contents, param->len);
688         
689         result->error = r;
690         debug_print("nntp article run - end %i\n", r);
691 }
692
693 int nntp_threaded_article(Folder * folder, guint32 num, char **contents, size_t *len)
694 {
695         struct article_param param;
696         struct article_result result;
697         
698         debug_print("nntp article - begin\n");
699         
700         param.nntp = get_nntp(folder);
701         param.num = num;
702         param.contents = contents;
703         param.len = len;
704
705         threaded_run(folder, &param, &result, article_run);
706         
707         debug_print("nntp article - end\n");
708         
709         return result.error;
710 }
711
712 struct group_param {
713         newsnntp * nntp;
714         const char *group;
715         struct newsnntp_group_info **info;
716 };
717
718 struct group_result {
719         int error;
720 };
721
722 static void group_run(struct etpan_thread_op * op)
723 {
724         struct group_param * param;
725         struct group_result * result;
726         int r;
727         
728         param = op->param;
729         result = op->result;
730
731         CHECK_NNTP();
732
733         r = newsnntp_group(param->nntp, param->group, param->info);
734         
735         result->error = r;
736         debug_print("nntp group run - end %i\n", r);
737 }
738
739 int nntp_threaded_group(Folder * folder, const char *group, struct newsnntp_group_info **info)
740 {
741         struct group_param param;
742         struct group_result result;
743         
744         debug_print("nntp group - begin\n");
745         
746         param.nntp = get_nntp(folder);
747         param.group = group;
748         param.info = info;
749
750         threaded_run(folder, &param, &result, group_run);
751         
752         debug_print("nntp group - end\n");
753         
754         return result.error;
755 }
756
757 struct mode_reader_param {
758         newsnntp * nntp;
759 };
760
761 struct mode_reader_result {
762         int error;
763 };
764
765 static void mode_reader_run(struct etpan_thread_op * op)
766 {
767         struct mode_reader_param * param;
768         struct mode_reader_result * result;
769         int r;
770         
771         param = op->param;
772         result = op->result;
773
774         CHECK_NNTP();
775
776         r = newsnntp_mode_reader(param->nntp);
777         
778         result->error = r;
779         debug_print("nntp mode_reader run - end %i\n", r);
780 }
781
782 int nntp_threaded_mode_reader(Folder * folder)
783 {
784         struct mode_reader_param param;
785         struct mode_reader_result result;
786         
787         debug_print("nntp mode_reader - begin\n");
788         
789         param.nntp = get_nntp(folder);
790
791         threaded_run(folder, &param, &result, mode_reader_run);
792         
793         debug_print("nntp mode_reader - end\n");
794         
795         return result.error;
796 }
797
798 struct xover_param {
799         newsnntp * nntp;
800         guint32 beg;
801         guint32 end;
802         struct newsnntp_xover_resp_item **result;
803         clist **msglist;
804 };
805
806 struct xover_result {
807         int error;
808 };
809
810 static void xover_run(struct etpan_thread_op * op)
811 {
812         struct xover_param * param;
813         struct xover_result * result;
814         int r;
815         
816         param = op->param;
817         result = op->result;
818
819         CHECK_NNTP();
820         
821         if (param->result) {
822                 r = newsnntp_xover_single(param->nntp, param->beg, param->result);
823         } else {
824                 r = newsnntp_xover_range(param->nntp, param->beg, param->end, param->msglist);
825         }
826         
827         result->error = r;
828         debug_print("nntp xover run %d-%d - end %i\n",
829                         param->beg, param->end, r);
830 }
831
832 int nntp_threaded_xover(Folder * folder, guint32 beg, guint32 end, struct newsnntp_xover_resp_item **single_result, clist **multiple_result)
833 {
834         struct xover_param param;
835         struct xover_result result;
836         clist *l = NULL, *h = NULL;
837         guint32 cbeg = 0, cend = 0;
838
839         debug_print("nntp xover - begin (%d-%d)\n", beg, end);
840
841         h = clist_new();
842
843         /* Request the overview in batches of NNTP_BATCH_SIZE, to prevent
844          * long stalls or libetpan choking on too large server response,
845          * and to allow updating any progress indicators while we work. */
846         cbeg = beg;
847         while (cbeg <= end && cend <= end) {
848                 cend = cbeg + (NNTP_BATCH_SIZE - 1);
849                 if (cend > end)
850                         cend = end;
851
852                 statusbar_progress_all(cbeg - beg, end - beg, 1);
853                 GTK_EVENTS_FLUSH();
854
855                 param.nntp = get_nntp(folder);
856                 param.beg = cbeg;
857                 param.end = cend;
858                 param.result = single_result;
859                 param.msglist = &l;
860
861                 threaded_run(folder, &param, &result, xover_run);
862
863                 /* Handle errors */
864                 if (result.error != NEWSNNTP_NO_ERROR) {
865                         log_warning(LOG_PROTOCOL, _("couldn't get xover range\n"));
866                         debug_print("couldn't get xover for %d-%d\n", cbeg, cend);
867                         if (l != NULL)
868                                 newsnntp_xover_resp_list_free(l);
869                         newsnntp_xover_resp_list_free(h);
870                         statusbar_progress_all(0, 0, 0);
871                         return result.error;
872                 }
873
874                 /* Append the new data (l) to list of results (h). */
875                 if (l != NULL) {
876                         debug_print("total items so far %d, items this batch %d\n",
877                                         clist_count(h), clist_count(l));
878                         clist_concat(h, l);
879                         clist_free(l);
880                         l = NULL;
881                 }
882
883                 cbeg += NNTP_BATCH_SIZE;
884         }
885
886         statusbar_progress_all(0, 0, 0);
887         
888         debug_print("nntp xover - end\n");
889
890         *multiple_result = h;
891
892         return result.error;
893 }
894
895 struct xhdr_param {
896         newsnntp * nntp;
897         const char *header;
898         guint32 beg;
899         guint32 end;
900         clist **hdrlist;
901 };
902
903 struct xhdr_result {
904         int error;
905 };
906
907 static void xhdr_run(struct etpan_thread_op * op)
908 {
909         struct xhdr_param * param;
910         struct xhdr_result * result;
911         int r;
912         
913         param = op->param;
914         result = op->result;
915
916         CHECK_NNTP();
917         
918         if (param->beg == param->end) {
919                 r = newsnntp_xhdr_single(param->nntp, param->header, param->beg, param->hdrlist);
920         } else {
921                 r = newsnntp_xhdr_range(param->nntp, param->header, param->beg, param->end, param->hdrlist);
922         }
923         
924         result->error = r;
925         debug_print("nntp xhdr '%s %d-%d' run - end %i\n",
926                         param->header, param->beg, param->end, r);
927 }
928
929 int nntp_threaded_xhdr(Folder * folder, const char *header, guint32 beg, guint32 end, clist **hdrlist)
930 {
931         struct xhdr_param param;
932         struct xhdr_result result;
933         clist *l = NULL;
934         clist *h = *hdrlist;
935         guint32 cbeg = 0, cend = 0;
936
937         debug_print("nntp xhdr %s - begin (%d-%d)\n", header, beg, end);
938
939         if (h == NULL)
940                 h = clist_new();
941
942         /* Request the headers in batches of NNTP_BATCH_SIZE, to prevent
943          * long stalls or libetpan choking on too large server response,
944          * and to allow updating any progress indicators while we work. */
945         cbeg = beg;
946         while (cbeg <= end && cend <= end) {
947                 cend = cbeg + NNTP_BATCH_SIZE - 1;
948                 if (cend > end)
949                         cend = end;
950
951                 statusbar_progress_all(cbeg - beg, end - beg, 1);
952                 GTK_EVENTS_FLUSH();
953
954                 param.nntp = get_nntp(folder);
955                 param.header = header;
956                 param.beg = cbeg;
957                 param.end = cend;
958                 param.hdrlist = &l;
959
960                 threaded_run(folder, &param, &result, xhdr_run);
961
962                 /* Handle errors */
963                 if (result.error != NEWSNNTP_NO_ERROR) {
964                         log_warning(LOG_PROTOCOL, _("couldn't get xhdr range\n"));
965                         debug_print("couldn't get xhdr %s %d-%d\n",     header, cbeg, cend);
966                         if (l != NULL)
967                                 newsnntp_xhdr_free(l);
968                         newsnntp_xhdr_free(h);
969                         statusbar_progress_all(0, 0, 0);
970                         return result.error;
971                 }
972
973                 /* Append the new data (l) to list of results (h). */
974                 if (l != NULL) {
975                         debug_print("total items so far %d, items this batch %d\n",
976                                         clist_count(h), clist_count(l));
977                         clist_concat(h, l);
978                         clist_free(l);
979                         l = NULL;
980                 }
981
982                 cbeg += NNTP_BATCH_SIZE;
983         }
984
985         statusbar_progress_all(0, 0, 0);
986         
987         debug_print("nntp xhdr %s - end (%d-%d)\n", header, beg, end);
988
989         *hdrlist = h;
990
991         return result.error;
992 }
993
994 void nntp_main_set_timeout(int sec)
995 {
996         mailstream_network_delay.tv_sec = sec;
997         mailstream_network_delay.tv_usec = 0;
998 }
999
1000 #else
1001
1002 void nntp_main_init(void)
1003 {
1004 }
1005 void nntp_main_done(gboolean have_connectivity)
1006 {
1007 }
1008 void nntp_main_set_timeout(int sec)
1009 {
1010 }
1011
1012 void nntp_threaded_cancel(Folder * folder);
1013 {
1014 }
1015
1016 #endif