src/news.c

   1 /*
   2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
   3  * Copyright (C) 1999-2002 Hiroyuki Yamamoto
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18  */
  19
  20 #ifdef HAVE_CONFIG_H
  21 #  include "config.h"
  22 #endif
  23
  24 #include "defs.h"
  25
  26 #include <glib.h>
  27 #include <stdio.h>
  28 #include <string.h>
  29 #include <stdlib.h>
  30 #include <dirent.h>
  31 #include <unistd.h>
  32 #include <time.h>
  33
  34 #include "intl.h"
  35 #include "news.h"
  36 #include "nntp.h"
  37 #include "socket.h"
  38 #include "recv.h"
  39 #include "procmsg.h"
  40 #include "procheader.h"
  41 #include "folder.h"
  42 #include "session.h"
  43 #include "statusbar.h"
  44 #include "codeconv.h"
  45 #include "utils.h"
  46 #include "prefs_common.h"
  47 #include "prefs_account.h"
  48 #include "inputdialog.h"
  49 #include "alertpanel.h"
  50
  51 #define NNTP_PORT       119
  52 #if USE_SSL
  53 #include "ssl.h"
  54 #define NNTPS_PORT 563
  55 #endif
  56
  57 static void news_folder_init             (Folder        *folder,
  58                                           const gchar   *name,
  59                                           const gchar   *path);
  60
  61 #if USE_SSL
  62 static Session *news_session_new         (const gchar   *server,
  63                                           gushort        port,
  64                                           const gchar   *userid,
  65                                           const gchar   *passwd, SSLType ssl_type);
  66 #else
  67 static Session *news_session_new         (const gchar   *server,
  68                                           gushort        port,
  69                                           const gchar   *userid,
  70                                           const gchar   *passwd);
  71 #endif
  72
  73 static gint news_get_article_cmd         (NNTPSession   *session,
  74                                           const gchar   *cmd,
  75                                           gint           num,
  76                                           gchar         *filename);
  77 static gint news_get_article             (NNTPSession   *session,
  78                                           gint           num,
  79                                           gchar         *filename);
  80 static gint news_get_header              (NNTPSession   *session,
  81                                           gint           num,
  82                                           gchar         *filename);
  83
  84 static gint news_select_group            (NNTPSession   *session,
  85                                           const gchar   *group,
  86                                           gint          *num,
  87                                           gint          *first,
  88                                           gint          *last);
  89 static GSList *news_get_uncached_articles(NNTPSession   *session,
  90                                           FolderItem    *item,
  91                                           gint           cache_last,
  92                                           gint          *rfirst,
  93                                           gint          *rlast);
  94 static MsgInfo *news_parse_xover         (const gchar   *xover_str);
  95 static gchar *news_parse_xhdr            (const gchar   *xhdr_str,
  96                                           MsgInfo       *msginfo);
  97 static GSList *news_delete_old_articles  (GSList        *alist,
  98                                           FolderItem    *item,
  99                                           gint           first);
 100 static void news_delete_all_articles     (FolderItem    *item);
 101
 102 static gint news_remove_msg              (Folder        *folder,
 103                                           FolderItem    *item,
 104                                           gint           num);
 105
 106 Folder *news_folder_new(const gchar *name, const gchar *path)
 107 {
 108         Folder *folder;
 109
 110         folder = (Folder *)g_new0(NewsFolder, 1);
 111         news_folder_init(folder, name, path);
 112
 113         return folder;
 114 }
 115
 116 void news_folder_destroy(NewsFolder *folder)
 117 {
 118         folder_remote_folder_destroy(REMOTE_FOLDER(folder));
 119 }
 120
 121 static void news_folder_init(Folder *folder, const gchar *name,
 122                              const gchar *path)
 123 {
 124         folder_remote_folder_init(folder, name, path);
 125
 126         folder->type = F_NEWS;
 127
 128         folder->get_msg_list = news_get_article_list;
 129         folder->fetch_msg    = news_fetch_msg;
 130         folder->scan         = news_scan_group;
 131         folder->remove_msg   = news_remove_msg;
 132 }
 133
 134 #if USE_SSL
 135 static Session *news_session_new(const gchar *server, gushort port,
 136                                  const gchar *userid, const gchar *passwd, SSLType ssl_type)
 137 #else
 138 static Session *news_session_new(const gchar *server, gushort port,
 139                                  const gchar *userid, const gchar *passwd)
 140 #endif
 141 {
 142         gchar buf[NNTPBUFSIZE];
 143         NNTPSession *session;
 144         NNTPSockInfo *nntp_sock;
 145
 146         g_return_val_if_fail(server != NULL, NULL);
 147
 148         log_message(_("creating NNTP connection to %s:%d ...\n"), server, port);
 149
 150         if (userid && passwd)
 151 #if USE_SSL
 152                 nntp_sock = nntp_open_auth(server, port, buf, userid, passwd, ssl_type);
 153 #else
 154                 nntp_sock = nntp_open_auth(server, port, buf, userid, passwd);
 155 #endif
 156         else
 157 #if USE_SSL
 158                 nntp_sock = nntp_open(server, port, buf, ssl_type);
 159 #else
 160                 nntp_sock = nntp_open(server, port, buf);
 161 #endif
 162
 163         if (nntp_sock == NULL)
 164                 return NULL;
 165
 166         session = g_new(NNTPSession, 1);
 167         SESSION(session)->type             = SESSION_NEWS;
 168         SESSION(session)->server           = g_strdup(server);
 169         session->nntp_sock                 = nntp_sock;
 170         SESSION(session)->sock             = nntp_sock->sock;
 171         SESSION(session)->connected        = TRUE;
 172         SESSION(session)->phase            = SESSION_READY;
 173         SESSION(session)->last_access_time = time(NULL);
 174         SESSION(session)->data             = NULL;
 175         session->group = NULL;
 176
 177         return SESSION(session);
 178 }
 179
 180 void news_session_destroy(NNTPSession *session)
 181 {
 182         nntp_close(session->nntp_sock);
 183         session->nntp_sock = NULL;
 184         SESSION(session)->sock = NULL;
 185
 186         g_free(session->group);
 187 }
 188
 189 static Session *news_session_new_for_folder(Folder *folder)
 190 {
 191         Session *session;
 192         PrefsAccount *ac;
 193         const gchar *userid = NULL;
 194         gchar *passwd = NULL;
 195         int port;
 196
 197         g_return_val_if_fail(folder != NULL, NULL);
 198         g_return_val_if_fail(folder->account != NULL, NULL);
 199
 200         ac = folder->account;
 201
 202 #if USE_SSL
 203         if (ac->set_nntpport) {
 204                  port = ac->nntpport;
 205         } else {
 206                  port = ac->ssl_nntp ? NNTPS_PORT : NNTP_PORT;
 207         }
 208 #else
 209         port = ac->set_nntpport ? ac->nntpport : NNTP_PORT;
 210 #endif
 211         if (ac->use_nntp_auth && ac->userid && ac->userid[0]) {
 212                 userid = ac->userid;
 213                 if (ac->passwd && ac->passwd[0])
 214                         passwd = g_strdup(ac->passwd);
 215                 else
 216                         passwd = input_dialog_query_password(ac->nntp_server,
 217                                                              userid);
 218         }
 219
 220 #if USE_SSL
 221         session = news_session_new(ac->nntp_server,
 222                                    port,
 223                                    userid, passwd, ac->ssl_nntp);
 224 #else
 225         session = news_session_new(ac->nntp_server,
 226                                    port,
 227                                    userid, passwd);
 228 #endif
 229         g_free(passwd);
 230
 231         return session;
 232 }
 233
 234 NNTPSession *news_session_get(Folder *folder)
 235 {
 236         RemoteFolder *rfolder = REMOTE_FOLDER(folder);
 237
 238         g_return_val_if_fail(folder != NULL, NULL);
 239         g_return_val_if_fail(folder->type == F_NEWS, NULL);
 240         g_return_val_if_fail(folder->account != NULL, NULL);
 241
 242         if (!rfolder->session) {
 243                 rfolder->session = news_session_new_for_folder(folder);
 244                 statusbar_pop_all();
 245                 return NNTP_SESSION(rfolder->session);
 246         }
 247
 248         if (time(NULL) - rfolder->session->last_access_time < SESSION_TIMEOUT) {
 249                 rfolder->session->last_access_time = time(NULL);
 250                 statusbar_pop_all();
 251                 return NNTP_SESSION(rfolder->session);
 252         }
 253
 254         if (nntp_mode(NNTP_SESSION(rfolder->session)->nntp_sock, FALSE)
 255             != NN_SUCCESS) {
 256                 log_warning(_("NNTP connection to %s:%d has been"
 257                               " disconnected. Reconnecting...\n"),
 258                             folder->account->nntp_server,
 259                             folder->account->set_nntpport ?
 260                             folder->account->nntpport : NNTP_PORT);
 261                 session_destroy(rfolder->session);
 262                 rfolder->session = news_session_new_for_folder(folder);
 263         }
 264
 265         if (rfolder->session)
 266                 rfolder->session->last_access_time = time(NULL);
 267         statusbar_pop_all();
 268         return NNTP_SESSION(rfolder->session);
 269 }
 270
 271 GSList *news_get_article_list(Folder *folder, FolderItem *item,
 272                               gboolean use_cache)
 273 {
 274         GSList *alist;
 275         NNTPSession *session;
 276
 277         g_return_val_if_fail(folder != NULL, NULL);
 278         g_return_val_if_fail(item != NULL, NULL);
 279         g_return_val_if_fail(folder->type == F_NEWS, NULL);
 280
 281         session = news_session_get(folder);
 282
 283         if (!session) {
 284                 alist = procmsg_read_cache(item, FALSE);
 285                 item->last_num = procmsg_get_last_num_in_cache(alist);
 286         } else if (use_cache) {
 287                 GSList *newlist;
 288                 gint cache_last;
 289                 gint first, last;
 290
 291                 alist = procmsg_read_cache(item, FALSE);
 292
 293                 cache_last = procmsg_get_last_num_in_cache(alist);
 294                 newlist = news_get_uncached_articles
 295                         (session, item, cache_last, &first, &last);
 296                 alist = news_delete_old_articles(alist, item, first);
 297
 298                 alist = g_slist_concat(alist, newlist);
 299                 item->last_num = last;
 300         } else {
 301                 gint last;
 302
 303                 alist = news_get_uncached_articles
 304                         (session, item, 0, NULL, &last);
 305                 news_delete_all_articles(item);
 306                 item->last_num = last;
 307         }
 308
 309         procmsg_set_flags(alist, item);
 310
 311         statusbar_pop_all();
 312
 313         return alist;
 314 }
 315
 316 gchar *news_fetch_msg(Folder *folder, FolderItem *item, gint num)
 317 {
 318         gchar *path, *filename;
 319         NNTPSession *session;
 320         gint ok;
 321
 322         g_return_val_if_fail(folder != NULL, NULL);
 323         g_return_val_if_fail(item != NULL, NULL);
 324
 325         path = folder_item_get_path(item);
 326         if (!is_dir_exist(path))
 327                 make_dir_hier(path);
 328         filename = g_strconcat(path, G_DIR_SEPARATOR_S, itos(num), NULL);
 329         g_free(path);
 330
 331         if (is_file_exist(filename)) {
 332                 debug_print(_("article %d has been already cached.\n"), num);
 333                 return filename;
 334         }
 335
 336         session = news_session_get(folder);
 337         if (!session) {
 338                 g_free(filename);
 339                 return NULL;
 340         }
 341
 342         ok = news_select_group(session, item->path, NULL, NULL, NULL);
 343         statusbar_pop_all();
 344         if (ok != NN_SUCCESS) {
 345                 g_warning(_("can't select group %s\n"), item->path);
 346                 g_free(filename);
 347                 return NULL;
 348         }
 349
 350         debug_print(_("getting article %d...\n"), num);
 351         ok = news_get_article(NNTP_SESSION(REMOTE_FOLDER(folder)->session),
 352                               num, filename);
 353         statusbar_pop_all();
 354         if (ok < 0) {
 355                 g_warning(_("can't read article %d\n"), num);
 356                 g_free(filename);
 357                 return NULL;
 358         }
 359
 360         return filename;
 361 }
 362
 363 gint news_scan_group(Folder *folder, FolderItem *item)
 364 {
 365         NNTPSession *session;
 366         gint num = 0, first = 0, last = 0;
 367         gint new = 0, unread = 0, total = 0;
 368         gint min = 0, max = 0;
 369         gchar *path;
 370         gint ok;
 371
 372         g_return_val_if_fail(folder != NULL, -1);
 373         g_return_val_if_fail(item != NULL, -1);
 374
 375         session = news_session_get(folder);
 376         if (!session) return -1;
 377
 378         ok = news_select_group(session, item->path, &num, &first, &last);
 379         if (ok != NN_SUCCESS) {
 380                 log_warning(_("can't set group: %s\n"), item->path);
 381                 return -1;
 382         }
 383
 384         if (num == 0) {
 385                 item->new = item->unread = item->total = item->last_num = 0;
 386                 return 0;
 387         }
 388
 389         path = folder_item_get_path(item);
 390         if (path && is_dir_exist(path)) {
 391                 procmsg_get_mark_sum(path, &new, &unread, &total, &min, &max,
 392                                      first);
 393         }
 394         g_free(path);
 395
 396         if (max < first || last < min)
 397                 new = unread = total = num;
 398         else {
 399                 if (min < first)
 400                         min = first;
 401                 else if (first < min) {
 402                         num -= min - first;
 403                         first = min;
 404                 }
 405
 406                 if (last < max)
 407                         max = last;
 408                 else if (max < last) {
 409                         new += last - max;
 410                         unread += last - max;
 411                 }
 412
 413                 if (new > num) new = num;
 414                 if (unread > num) unread = num;
 415         }
 416
 417         item->new = new;
 418         item->unread = unread;
 419         item->total = num;
 420         item->last_num = last;
 421
 422         return 0;
 423 }
 424
 425 static NewsGroupInfo *news_group_info_new(const gchar *name,
 426                                           gint first, gint last, gchar type)
 427 {
 428         NewsGroupInfo *ginfo;
 429
 430         ginfo = g_new(NewsGroupInfo, 1);
 431         ginfo->name = g_strdup(name);
 432         ginfo->first = first;
 433         ginfo->last = last;
 434         ginfo->type = type;
 435
 436         return ginfo;
 437 }
 438
 439 static void news_group_info_free(NewsGroupInfo *ginfo)
 440 {
 441         g_free(ginfo->name);
 442         g_free(ginfo);
 443 }
 444
 445 static gint news_group_info_compare(NewsGroupInfo *ginfo1,
 446                                     NewsGroupInfo *ginfo2)
 447 {
 448         return g_strcasecmp(ginfo1->name, ginfo2->name);
 449 }
 450
 451 GSList *news_get_group_list(Folder *folder)
 452 {
 453         gchar *path, *filename;
 454         FILE *fp;
 455         GSList *list = NULL;
 456         GSList *last = NULL;
 457         gchar buf[NNTPBUFSIZE];
 458
 459         g_return_val_if_fail(folder != NULL, NULL);
 460         g_return_val_if_fail(folder->type == F_NEWS, NULL);
 461
 462         path = folder_item_get_path(FOLDER_ITEM(folder->node->data));
 463         if (!is_dir_exist(path))
 464                 make_dir_hier(path);
 465         filename = g_strconcat(path, G_DIR_SEPARATOR_S, NEWSGROUP_LIST, NULL);
 466         g_free(path);
 467
 468         if ((fp = fopen(filename, "rb")) == NULL) {
 469                 NNTPSession *session;
 470
 471                 session = news_session_get(folder);
 472                 if (!session) {
 473                         g_free(filename);
 474                         return NULL;
 475                 }
 476
 477                 if (nntp_list(session->nntp_sock) != NN_SUCCESS) {
 478                         g_free(filename);
 479                         statusbar_pop_all();
 480                         return NULL;
 481                 }
 482                 statusbar_pop_all();
 483                 if (recv_write_to_file(SESSION(session)->sock, filename) < 0) {
 484                         log_warning(_("can't retrieve newsgroup list\n"));
 485                         session_destroy(SESSION(session));
 486                         REMOTE_FOLDER(folder)->session = NULL;
 487                         g_free(filename);
 488                         return NULL;
 489                 }
 490
 491                 if ((fp = fopen(filename, "rb")) == NULL) {
 492                         FILE_OP_ERROR(filename, "fopen");
 493                         g_free(filename);
 494                         return NULL;
 495                 }
 496         }
 497
 498         while (fgets(buf, sizeof(buf), fp) != NULL) {
 499                 gchar *p = buf;
 500                 gchar *name;
 501                 gint last_num;
 502                 gint first_num;
 503                 gchar type;
 504                 NewsGroupInfo *ginfo;
 505
 506                 p = strchr(p, ' ');
 507                 if (!p) continue;
 508                 *p = '\0';
 509                 p++;
 510                 name = buf;
 511
 512                 if (sscanf(p, "%d %d %c", &last_num, &first_num, &type) < 3)
 513                         continue;
 514
 515                 ginfo = news_group_info_new(name, first_num, last_num, type);
 516
 517                 if (!last)
 518                         last = list = g_slist_append(NULL, ginfo);
 519                 else {
 520                         last = g_slist_append(last, ginfo);
 521                         last = last->next;
 522                 }
 523         }
 524
 525         fclose(fp);
 526         g_free(filename);
 527
 528         list = g_slist_sort(list, (GCompareFunc)news_group_info_compare);
 529
 530         statusbar_pop_all();
 531
 532         return list;
 533 }
 534
 535 void news_group_list_free(GSList *group_list)
 536 {
 537         GSList *cur;
 538
 539         if (!group_list) return;
 540
 541         for (cur = group_list; cur != NULL; cur = cur->next)
 542                 news_group_info_free((NewsGroupInfo *)cur->data);
 543         g_slist_free(group_list);
 544 }
 545
 546 void news_remove_group_list_cache(Folder *folder)
 547 {
 548         gchar *path, *filename;
 549
 550         g_return_if_fail(folder != NULL);
 551         g_return_if_fail(folder->type == F_NEWS);
 552
 553         path = folder_item_get_path(FOLDER_ITEM(folder->node->data));
 554         filename = g_strconcat(path, G_DIR_SEPARATOR_S, NEWSGROUP_LIST, NULL);
 555         g_free(path);
 556
 557         if (is_file_exist(filename)) {
 558                 if (remove(filename) < 0)
 559                         FILE_OP_ERROR(filename, "remove");
 560         }
 561         g_free(filename);
 562 }
 563
 564 gint news_post(Folder *folder, const gchar *file)
 565 {
 566         NNTPSession *session;
 567         FILE *fp;
 568         gint ok;
 569
 570         g_return_val_if_fail(folder != NULL, -1);
 571         g_return_val_if_fail(folder->type == F_NEWS, -1);
 572         g_return_val_if_fail(file != NULL, -1);
 573
 574         session = news_session_get(folder);
 575         if (!session) return -1;
 576
 577         if ((fp = fopen(file, "rb")) == NULL) {
 578                 FILE_OP_ERROR(file, "fopen");
 579                 return -1;
 580         }
 581
 582         ok = nntp_post(session->nntp_sock, fp);
 583         if (ok != NN_SUCCESS) {
 584                 log_warning(_("can't post article.\n"));
 585                 return -1;
 586         }
 587
 588         fclose(fp);
 589
 590         statusbar_pop_all();
 591
 592         return 0;
 593 }
 594
 595 static gint news_get_article_cmd(NNTPSession *session, const gchar *cmd,
 596                                  gint num, gchar *filename)
 597 {
 598         gchar *msgid;
 599
 600         if (nntp_get_article(session->nntp_sock, cmd, num, &msgid)
 601             != NN_SUCCESS)
 602                 return -1;
 603
 604         debug_print("Message-Id = %s, num = %d\n", msgid, num);
 605         g_free(msgid);
 606
 607         if (recv_write_to_file(session->nntp_sock->sock, filename) < 0) {
 608                 log_warning(_("can't retrieve article %d\n"), num);
 609                 return -1;
 610         }
 611
 612         return 0;
 613 }
 614
 615 static gint news_remove_msg(Folder *folder, FolderItem *item, gint num)
 616 {
 617         MsgInfo * msginfo;
 618         gchar * filename;
 619         MsgFlags msgflags = { 0, 0 };
 620         gint r;
 621
 622         filename = folder_item_fetch_msg(item, num);
 623         if (filename == NULL)
 624                 return -1;
 625
 626         msginfo = procheader_parse(filename, msgflags, FALSE, FALSE);
 627         if (msginfo == NULL)
 628                 return -1;
 629
 630         r = news_cancel_article(folder, msginfo);
 631
 632         procmsg_msginfo_free(msginfo);
 633
 634         return r;
 635 }
 636
 637 static gint news_get_article(NNTPSession *session, gint num, gchar *filename)
 638 {
 639         return news_get_article_cmd(session, "ARTICLE", num, filename);
 640 }
 641
 642 static gint news_get_header(NNTPSession *session, gint num, gchar *filename)
 643 {
 644         return news_get_article_cmd(session, "HEAD", num, filename);
 645 }
 646
 647 /**
 648  * news_select_group:
 649  * @session: Active NNTP session.
 650  * @group: Newsgroup name.
 651  * @num: Estimated number of articles.
 652  * @first: First article number.
 653  * @last: Last article number.
 654  *
 655  * Select newsgroup @group with the GROUP command if it is not already
 656  * selected in @session, or article numbers need to be returned.
 657  *
 658  * Return value: NNTP result code.
 659  **/
 660 static gint news_select_group(NNTPSession *session, const gchar *group,
 661                               gint *num, gint *first, gint *last)
 662 {
 663         gint ok;
 664         gint num_, first_, last_;
 665
 666         if (!num || !first || !last) {
 667                 if (session->group && g_strcasecmp(session->group, group) == 0)
 668                         return NN_SUCCESS;
 669                 num = &num_;
 670                 first = &first_;
 671                 last = &last_;
 672         }
 673
 674         g_free(session->group);
 675         session->group = NULL;
 676
 677         ok = nntp_group(session->nntp_sock, group, num, first, last);
 678         if (ok == NN_SUCCESS)
 679                 session->group = g_strdup(group);
 680
 681         return ok;
 682 }
 683
 684 static GSList *news_get_uncached_articles(NNTPSession *session,
 685                                           FolderItem *item, gint cache_last,
 686                                           gint *rfirst, gint *rlast)
 687 {
 688         gint ok;
 689         gint num = 0, first = 0, last = 0, begin = 0, end = 0;
 690         gchar buf[NNTPBUFSIZE];
 691         GSList *newlist = NULL;
 692         GSList *llast = NULL;
 693         MsgInfo *msginfo;
 694
 695         if (rfirst) *rfirst = 0;
 696         if (rlast)  *rlast  = 0;
 697
 698         g_return_val_if_fail(session != NULL, NULL);
 699         g_return_val_if_fail(item != NULL, NULL);
 700         g_return_val_if_fail(item->folder != NULL, NULL);
 701         g_return_val_if_fail(item->folder->type == F_NEWS, NULL);
 702
 703         ok = news_select_group(session, item->path, &num, &first, &last);
 704         if (ok != NN_SUCCESS) {
 705                 log_warning(_("can't set group: %s\n"), item->path);
 706                 return NULL;
 707         }
 708
 709         /* calculate getting overview range */
 710         if (first > last) {
 711                 log_warning(_("invalid article range: %d - %d\n"),
 712                             first, last);
 713                 return NULL;
 714         }
 715         if (cache_last < first)
 716                 begin = first;
 717         else if (last < cache_last)
 718                 begin = first;
 719         else if (last == cache_last) {
 720                 debug_print(_("no new articles.\n"));
 721                 return NULL;
 722         } else
 723                 begin = cache_last + 1;
 724         end = last;
 725
 726         if (rfirst) *rfirst = first;
 727         if (rlast)  *rlast  = last;
 728
 729         if (prefs_common.max_articles > 0 &&
 730             end - begin + 1 > prefs_common.max_articles)
 731                 begin = end - prefs_common.max_articles + 1;
 732
 733         log_message(_("getting xover %d - %d in %s...\n"),
 734                     begin, end, item->path);
 735         if (nntp_xover(session->nntp_sock, begin, end) != NN_SUCCESS) {
 736                 log_warning(_("can't get xover\n"));
 737                 return NULL;
 738         }
 739
 740         for (;;) {
 741                 if (sock_gets(SESSION(session)->sock, buf, sizeof(buf)) < 0) {
 742                         log_warning(_("error occurred while getting xover.\n"));
 743                         return newlist;
 744                 }
 745
 746                 if (buf[0] == '.' && buf[1] == '\r') break;
 747
 748                 msginfo = news_parse_xover(buf);
 749                 if (!msginfo) {
 750                         log_warning(_("invalid xover line: %s\n"), buf);
 751                         continue;
 752                 }
 753
 754                 msginfo->folder = item;
 755                 msginfo->flags.perm_flags = MSG_NEW|MSG_UNREAD;
 756                 msginfo->flags.tmp_flags = MSG_NEWS;
 757                 msginfo->newsgroups = g_strdup(item->path);
 758
 759                 if (!newlist)
 760                         llast = newlist = g_slist_append(newlist, msginfo);
 761                 else {
 762                         llast = g_slist_append(llast, msginfo);
 763                         llast = llast->next;
 764                 }
 765         }
 766
 767         if (nntp_xhdr(session->nntp_sock, "to", begin, end) != NN_SUCCESS) {
 768                 log_warning(_("can't get xhdr\n"));
 769                 return newlist;
 770         }
 771
 772         llast = newlist;
 773
 774         for (;;) {
 775                 if (sock_gets(SESSION(session)->sock, buf, sizeof(buf)) < 0) {
 776                         log_warning(_("error occurred while getting xhdr.\n"));
 777                         return newlist;
 778                 }
 779
 780                 if (buf[0] == '.' && buf[1] == '\r') break;
 781                 if (!llast) {
 782                         g_warning("llast == NULL\n");
 783                         continue;
 784                 }
 785
 786                 msginfo = (MsgInfo *)llast->data;
 787                 msginfo->to = news_parse_xhdr(buf, msginfo);
 788
 789                 llast = llast->next;
 790         }
 791
 792         if (nntp_xhdr(session->nntp_sock, "cc", begin, end) != NN_SUCCESS) {
 793                 log_warning(_("can't get xhdr\n"));
 794                 return newlist;
 795         }
 796
 797         llast = newlist;
 798
 799         for (;;) {
 800                 if (sock_gets(SESSION(session)->sock, buf, sizeof(buf)) < 0) {
 801                         log_warning(_("error occurred while getting xhdr.\n"));
 802                         return newlist;
 803                 }
 804
 805                 if (buf[0] == '.' && buf[1] == '\r') break;
 806                 if (!llast) {
 807                         g_warning("llast == NULL\n");
 808                         continue;
 809                 }
 810
 811                 msginfo = (MsgInfo *)llast->data;
 812                 msginfo->cc = news_parse_xhdr(buf, msginfo);
 813
 814                 llast = llast->next;
 815         }
 816
 817         return newlist;
 818 }
 819
 820 #define PARSE_ONE_PARAM(p, srcp) \
 821 { \
 822         p = strchr(srcp, '\t'); \
 823         if (!p) return NULL; \
 824         else \
 825                 *p++ = '\0'; \
 826 }
 827
 828 static MsgInfo *news_parse_xover(const gchar *xover_str)
 829 {
 830         MsgInfo *msginfo;
 831         gchar buf[NNTPBUFSIZE];
 832         gchar *subject, *sender, *size, *line, *date, *msgid, *ref, *tmp, *xref;
 833         gchar *p;
 834         gint num, size_int, line_int;
 835         gchar *xover_buf;
 836
 837         Xstrdup_a(xover_buf, xover_str, return NULL);
 838
 839         PARSE_ONE_PARAM(subject, xover_buf);
 840         PARSE_ONE_PARAM(sender, subject);
 841         PARSE_ONE_PARAM(date, sender);
 842         PARSE_ONE_PARAM(msgid, date);
 843         PARSE_ONE_PARAM(ref, msgid);
 844         PARSE_ONE_PARAM(size, ref);
 845         PARSE_ONE_PARAM(line, size);
 846         PARSE_ONE_PARAM(xref, line);
 847
 848         tmp = strchr(xref, '\t');
 849         if (!tmp) tmp = strchr(line, '\r');
 850         if (!tmp) tmp = strchr(line, '\n');
 851         if (tmp) *tmp = '\0';
 852
 853         num = atoi(xover_str);
 854         size_int = atoi(size);
 855         line_int = atoi(line);
 856
 857         /* set MsgInfo */
 858         msginfo = g_new0(MsgInfo, 1);
 859         msginfo->msgnum = num;
 860         msginfo->size = size_int;
 861
 862         msginfo->date = g_strdup(date);
 863         msginfo->date_t = procheader_date_parse(NULL, date, 0);
 864
 865         conv_unmime_header(buf, sizeof(buf), sender, NULL);
 866         msginfo->from = g_strdup(buf);
 867         msginfo->fromname = procheader_get_fromname(buf);
 868
 869         conv_unmime_header(buf, sizeof(buf), subject, NULL);
 870         msginfo->subject = g_strdup(buf);
 871
 872         extract_parenthesis(msgid, '<', '>');
 873         remove_space(msgid);
 874         if (*msgid != '\0')
 875                 msginfo->msgid = g_strdup(msgid);
 876
 877         msginfo->references = g_strdup(ref);
 878         eliminate_parenthesis(ref, '(', ')');
 879         if ((p = strrchr(ref, '<')) != NULL) {
 880                 extract_parenthesis(p, '<', '>');
 881                 remove_space(p);
 882                 if (*p != '\0')
 883                         msginfo->inreplyto = g_strdup(p);
 884         }
 885
 886         msginfo->xref = g_strdup(xref);
 887         p = msginfo->xref+strlen(msginfo->xref) - 1;
 888         while (*p == '\r' || *p == '\n') {
 889                 *p = '\0';
 890                 p--;
 891         }
 892
 893         return msginfo;
 894 }
 895
 896 static gchar *news_parse_xhdr(const gchar *xhdr_str, MsgInfo *msginfo)
 897 {
 898         gchar *p;
 899         gchar *tmp;
 900         gint num;
 901
 902         p = strchr(xhdr_str, ' ');
 903         if (!p)
 904                 return NULL;
 905         else
 906                 p++;
 907
 908         num = atoi(xhdr_str);
 909         if (msginfo->msgnum != num) return NULL;
 910
 911         tmp = strchr(p, '\r');
 912         if (!tmp) tmp = strchr(p, '\n');
 913
 914         if (tmp)
 915                 return g_strndup(p, tmp - p);
 916         else
 917                 return g_strdup(p);
 918 }
 919
 920 static GSList *news_delete_old_articles(GSList *alist, FolderItem *item,
 921                                         gint first)
 922 {
 923         GSList *cur, *next;
 924         MsgInfo *msginfo;
 925         gchar *dir;
 926
 927         g_return_val_if_fail(item != NULL, alist);
 928         g_return_val_if_fail(item->folder != NULL, alist);
 929         g_return_val_if_fail(item->folder->type == F_NEWS, alist);
 930
 931         if (first < 2) return alist;
 932
 933         debug_print(_("Deleting cached articles 1 - %d ... "), first - 1);
 934
 935         dir = folder_item_get_path(item);
 936         remove_numbered_files(dir, 1, first - 1);
 937         g_free(dir);
 938
 939         for (cur = alist; cur != NULL; ) {
 940                 next = cur->next;
 941
 942                 msginfo = (MsgInfo *)cur->data;
 943                 if (msginfo && msginfo->msgnum < first) {
 944                         procmsg_msginfo_free(msginfo);
 945                         alist = g_slist_remove(alist, msginfo);
 946                 }
 947
 948                 cur = next;
 949         }
 950
 951         return alist;
 952 }
 953
 954 static void news_delete_all_articles(FolderItem *item)
 955 {
 956         gchar *dir;
 957
 958         g_return_if_fail(item != NULL);
 959         g_return_if_fail(item->folder != NULL);
 960         g_return_if_fail(item->folder->type == F_NEWS);
 961
 962         debug_print(_("\tDeleting all cached articles... "));
 963
 964         dir = folder_item_get_path(item);
 965         remove_all_numbered_files(dir);
 966         g_free(dir);
 967
 968         debug_print(_("done.\n"));
 969 }
 970
 971 gint news_cancel_article(Folder * folder, MsgInfo * msginfo)
 972 {
 973         gchar * tmp;
 974         FILE * tmpfp;
 975         gchar buf[BUFFSIZE];
 976
 977         tmp = g_strdup_printf("%s%ctmp%d", g_get_tmp_dir(),
 978                               G_DIR_SEPARATOR, (gint)msginfo);
 979         if (tmp == NULL)
 980                 return -1;
 981
 982         if ((tmpfp = fopen(tmp, "wb")) == NULL) {
 983                 FILE_OP_ERROR(tmp, "fopen");
 984                 return -1;
 985         }
 986         if (change_file_mode_rw(tmpfp, tmp) < 0) {
 987                 FILE_OP_ERROR(tmp, "chmod");
 988                 g_warning(_("can't change file mode\n"));
 989         }
 990
 991         fprintf(tmpfp, "From: %s\r\n", msginfo->from);
 992         fprintf(tmpfp, "Newsgroups: %s\r\n", msginfo->newsgroups);
 993         fprintf(tmpfp, "Subject: cmsg cancel <%s>\r\n", msginfo->msgid);
 994         fprintf(tmpfp, "Control: cancel <%s>\r\n", msginfo->msgid);
 995         fprintf(tmpfp, "Approved: %s\r\n", msginfo->from);
 996         fprintf(tmpfp, "X-Cancelled-by: %s\r\n", msginfo->from);
 997         get_rfc822_date(buf, sizeof(buf));
 998         fprintf(tmpfp, "Date: %s\r\n", buf);
 999         fprintf(tmpfp, "\r\n");
1000         fprintf(tmpfp, "removed with sylpheed\r\n");
1001
1002         fclose(tmpfp);
1003
1004         news_post(folder, tmp);
1005         remove(tmp);
1006
1007         g_free(tmp);
1008
1009         return 0;
1010 }