src/pop.c

   1 /*
   2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
   3  * Copyright (C) 1999-2004 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 <glib.h>
  25 #include <stdio.h>
  26 #include <string.h>
  27 #include <stdarg.h>
  28 #include <ctype.h>
  29 #include <unistd.h>
  30 #include <time.h>
  31 #include <errno.h>
  32
  33 #include "intl.h"
  34 #include "pop.h"
  35 #include "md5.h"
  36 #include "prefs_account.h"
  37 #include "utils.h"
  38 #include "recv.h"
  39 #include "folder.h"
  40 #include "procmsg.h"
  41 #include "procheader.h"
  42 #include "msgcache.h"
  43 #include "partial_download.h"
  44 #include "log.h"
  45 #include "hooks.h"
  46
  47 static gint pop3_greeting_recv          (Pop3Session *session,
  48                                          const gchar *msg);
  49 static gint pop3_getauth_user_send      (Pop3Session *session);
  50 static gint pop3_getauth_pass_send      (Pop3Session *session);
  51 static gint pop3_getauth_apop_send      (Pop3Session *session);
  52 #if USE_OPENSSL
  53 static gint pop3_stls_send              (Pop3Session *session);
  54 static gint pop3_stls_recv              (Pop3Session *session);
  55 #endif
  56 static gint pop3_getrange_stat_send     (Pop3Session *session);
  57 static gint pop3_getrange_stat_recv     (Pop3Session *session,
  58                                          const gchar *msg);
  59 static gint pop3_getrange_last_send     (Pop3Session *session);
  60 static gint pop3_getrange_last_recv     (Pop3Session *session,
  61                                          const gchar *msg);
  62 static gint pop3_getrange_uidl_send     (Pop3Session *session);
  63 static gint pop3_getrange_uidl_recv     (Pop3Session *session,
  64                                          const gchar *data,
  65                                          guint        len);
  66 static gint pop3_getsize_list_send      (Pop3Session *session);
  67 static gint pop3_getsize_list_recv      (Pop3Session *session,
  68                                          const gchar *data,
  69                                          guint        len);
  70 static gint pop3_retr_send              (Pop3Session *session);
  71 static gint pop3_retr_recv              (Pop3Session *session,
  72                                          const gchar *data,
  73                                          guint        len);
  74 static gint pop3_delete_send            (Pop3Session *session);
  75 static gint pop3_delete_recv            (Pop3Session *session);
  76 static gint pop3_logout_send            (Pop3Session *session);
  77
  78 static void pop3_gen_send               (Pop3Session    *session,
  79                                          const gchar    *format, ...);
  80
  81 static void pop3_session_destroy        (Session        *session);
  82
  83 static gint pop3_write_msg_to_file      (const gchar    *file,
  84                                          const gchar    *data,
  85                                          guint           len,
  86                                          const gchar    *prefix);
  87
  88 static Pop3State pop3_lookup_next       (Pop3Session    *session);
  89 static Pop3ErrorValue pop3_ok           (Pop3Session    *session,
  90                                          const gchar    *msg);
  91
  92 static gint pop3_session_recv_msg               (Session        *session,
  93                                                  const gchar    *msg);
  94 static gint pop3_session_recv_data_finished     (Session        *session,
  95                                                  guchar         *data,
  96                                                  guint           len);
  97
  98 static gint pop3_greeting_recv(Pop3Session *session, const gchar *msg)
  99 {
 100         session->state = POP3_GREETING;
 101
 102         session->greeting = g_strdup(msg);
 103         return PS_SUCCESS;
 104 }
 105
 106 #if USE_OPENSSL
 107 static gint pop3_stls_send(Pop3Session *session)
 108 {
 109         session->state = POP3_STLS;
 110         pop3_gen_send(session, "STLS");
 111         return PS_SUCCESS;
 112 }
 113
 114 static gint pop3_stls_recv(Pop3Session *session)
 115 {
 116         if (session_start_tls(SESSION(session)) < 0) {
 117                 session->error_val = PS_SOCKET;
 118                 return -1;
 119         }
 120         return PS_SUCCESS;
 121 }
 122 #endif /* USE_OPENSSL */
 123
 124 static gint pop3_getauth_user_send(Pop3Session *session)
 125 {
 126         g_return_val_if_fail(session->user != NULL, -1);
 127
 128         session->state = POP3_GETAUTH_USER;
 129         pop3_gen_send(session, "USER %s", session->user);
 130         return PS_SUCCESS;
 131 }
 132
 133 static gint pop3_getauth_pass_send(Pop3Session *session)
 134 {
 135         g_return_val_if_fail(session->pass != NULL, -1);
 136
 137         session->state = POP3_GETAUTH_PASS;
 138         pop3_gen_send(session, "PASS %s", session->pass);
 139         return PS_SUCCESS;
 140 }
 141
 142 static gint pop3_getauth_apop_send(Pop3Session *session)
 143 {
 144         gchar *start, *end;
 145         gchar *apop_str;
 146         gchar md5sum[33];
 147
 148         g_return_val_if_fail(session->user != NULL, -1);
 149         g_return_val_if_fail(session->pass != NULL, -1);
 150
 151         session->state = POP3_GETAUTH_APOP;
 152
 153         if ((start = strchr(session->greeting, '<')) == NULL) {
 154                 log_warning(_("Required APOP timestamp not found "
 155                             "in greeting\n"));
 156                 session->error_val = PS_PROTOCOL;
 157                 return -1;
 158         }
 159
 160         if ((end = strchr(start, '>')) == NULL || end == start + 1) {
 161                 log_warning(_("Timestamp syntax error in greeting\n"));
 162                 session->error_val = PS_PROTOCOL;
 163                 return -1;
 164         }
 165
 166         *(end + 1) = '\0';
 167
 168         apop_str = g_strconcat(start, session->pass, NULL);
 169         md5_hex_digest(md5sum, apop_str);
 170         g_free(apop_str);
 171
 172         pop3_gen_send(session, "APOP %s %s", session->user, md5sum);
 173
 174         return PS_SUCCESS;
 175 }
 176
 177 static gint pop3_getrange_stat_send(Pop3Session *session)
 178 {
 179         session->state = POP3_GETRANGE_STAT;
 180         pop3_gen_send(session, "STAT");
 181         return PS_SUCCESS;
 182 }
 183
 184 static gint pop3_getrange_stat_recv(Pop3Session *session, const gchar *msg)
 185 {
 186         if (sscanf(msg, "%d %d", &session->count, &session->total_bytes) != 2) {
 187                 log_warning(_("POP3 protocol error\n"));
 188                 session->error_val = PS_PROTOCOL;
 189                 return -1;
 190         } else {
 191                 if (session->count == 0) {
 192                         session->uidl_is_valid = TRUE;
 193                 } else {
 194                         session->msg = g_new0(Pop3MsgInfo, session->count + 1);
 195                         session->cur_msg = 1;
 196                 }
 197         }
 198
 199         return PS_SUCCESS;
 200 }
 201
 202 static gint pop3_getrange_last_send(Pop3Session *session)
 203 {
 204         session->state = POP3_GETRANGE_LAST;
 205         pop3_gen_send(session, "LAST");
 206         return PS_SUCCESS;
 207 }
 208
 209 static gint pop3_getrange_last_recv(Pop3Session *session, const gchar *msg)
 210 {
 211         gint last;
 212
 213         if (sscanf(msg, "%d", &last) == 0) {
 214                 log_warning(_("POP3 protocol error\n"));
 215                 session->error_val = PS_PROTOCOL;
 216                 return -1;
 217         } else {
 218                 if (session->count > last) {
 219                         session->new_msg_exist = TRUE;
 220                         session->cur_msg = last + 1;
 221                 } else
 222                         session->cur_msg = 0;
 223         }
 224
 225         return PS_SUCCESS;
 226 }
 227
 228 static gint pop3_getrange_uidl_send(Pop3Session *session)
 229 {
 230         session->state = POP3_GETRANGE_UIDL;
 231         pop3_gen_send(session, "UIDL");
 232         return PS_SUCCESS;
 233 }
 234
 235 static gint pop3_getrange_uidl_recv(Pop3Session *session, const gchar *data,
 236                                     guint len)
 237 {
 238         gchar id[IDLEN + 1];
 239         gchar buf[POPBUFSIZE];
 240         gint buf_len;
 241         gint num;
 242         time_t recv_time;
 243         gint partial_recv;
 244         const gchar *p = data;
 245         const gchar *lastp = data + len;
 246         const gchar *newline;
 247
 248         while (p < lastp) {
 249                 if ((newline = memchr(p, '\r', lastp - p)) == NULL)
 250                         return -1;
 251                 buf_len = MIN(newline - p, sizeof(buf) - 1);
 252                 memcpy(buf, p, buf_len);
 253                 buf[buf_len] = '\0';
 254
 255                 p = newline + 1;
 256                 if (p < lastp && *p == '\n') p++;
 257
 258                 if (sscanf(buf, "%d %" Xstr(IDLEN) "s", &num, id) != 2)
 259                         return -1;
 260                 if (num <= 0 || num > session->count)
 261                         return -1;
 262
 263                 session->msg[num].uidl = g_strdup(id);
 264
 265                 recv_time = (time_t)g_hash_table_lookup(
 266                                         session->uidl_table, id);
 267                 session->msg[num].recv_time = recv_time;
 268
 269                 partial_recv = (gint)g_hash_table_lookup(
 270                                         session->partial_recv_table, id);
 271
 272                 if (!session->ac_prefs->getall && recv_time != RECV_TIME_NONE) {
 273                         session->msg[num].received =
 274                                 (partial_recv != POP3_MUST_COMPLETE_RECV);
 275                         session->msg[num].partial_recv = partial_recv;
 276
 277                 }
 278                 if (!session->new_msg_exist &&
 279                     (session->ac_prefs->getall || recv_time == RECV_TIME_NONE ||
 280                      session->ac_prefs->rmmail)) {
 281                         session->cur_msg = num;
 282                         session->new_msg_exist = TRUE;
 283                 }
 284         }
 285
 286         session->uidl_is_valid = TRUE;
 287         return PS_SUCCESS;
 288 }
 289
 290 static gint pop3_getsize_list_send(Pop3Session *session)
 291 {
 292         session->state = POP3_GETSIZE_LIST;
 293         pop3_gen_send(session, "LIST");
 294         return PS_SUCCESS;
 295 }
 296
 297 static gint pop3_getsize_list_recv(Pop3Session *session, const gchar *data,
 298                                    guint len)
 299 {
 300         gchar buf[POPBUFSIZE];
 301         gint buf_len;
 302         guint num, size;
 303         const gchar *p = data;
 304         const gchar *lastp = data + len;
 305         const gchar *newline;
 306
 307         while (p < lastp) {
 308                 if ((newline = memchr(p, '\r', lastp - p)) == NULL)
 309                         return -1;
 310                 buf_len = MIN(newline - p, sizeof(buf) - 1);
 311                 memcpy(buf, p, buf_len);
 312                 buf[buf_len] = '\0';
 313
 314                 p = newline + 1;
 315                 if (p < lastp && *p == '\n') p++;
 316
 317                 if (sscanf(buf, "%u %u", &num, &size) != 2) {
 318                         session->error_val = PS_PROTOCOL;
 319                         return -1;
 320                 }
 321
 322                 if (num > 0 && num <= session->count)
 323                         session->msg[num].size = size;
 324                 if (num > 0 && num < session->cur_msg)
 325                         session->cur_total_bytes += size;
 326         }
 327
 328         return PS_SUCCESS;
 329 }
 330
 331 static gint pop3_retr_send(Pop3Session *session)
 332 {
 333         session->state = POP3_RETR;
 334         pop3_gen_send(session, "RETR %d", session->cur_msg);
 335         return PS_SUCCESS;
 336 }
 337
 338 static gint pop3_retr_recv(Pop3Session *session, const gchar *data, guint len)
 339 {
 340         gchar *file;
 341         gint drop_ok;
 342         MailReceiveData mail_receive_data;
 343
 344         mail_receive_data.session = session;
 345         mail_receive_data.data = g_strndup(data, len);
 346         hooks_invoke(MAIL_RECEIVE_HOOKLIST, &mail_receive_data);
 347
 348         file = get_tmp_file();
 349         if (pop3_write_msg_to_file(file, mail_receive_data.data,
 350                 strlen(mail_receive_data.data), NULL) < 0) {
 351                 g_free(file);
 352                 g_free(mail_receive_data.data);
 353                 session->error_val = PS_IOERR;
 354                 return -1;
 355         }
 356         g_free(mail_receive_data.data);
 357
 358         if (session->msg[session->cur_msg].partial_recv
 359             == POP3_MUST_COMPLETE_RECV) {
 360                 gchar *old_file = partial_get_filename(
 361                                 session->ac_prefs->recv_server,
 362                                 session->ac_prefs->userid,
 363                                 session->msg[session->cur_msg].uidl);
 364
 365                 if (old_file) {
 366                         partial_delete_old(old_file);
 367                         g_free(old_file);
 368                 }
 369         }
 370
 371         /* drop_ok: 0: success 1: don't receive -1: error */
 372         drop_ok = session->drop_message(session, file);
 373
 374         g_free(file);
 375         if (drop_ok < 0) {
 376                 session->error_val = PS_IOERR;
 377                 return -1;
 378         }
 379
 380         session->cur_total_bytes += session->msg[session->cur_msg].size;
 381         session->cur_total_recv_bytes += session->msg[session->cur_msg].size;
 382         session->cur_total_num++;
 383
 384         session->msg[session->cur_msg].received = TRUE;
 385         session->msg[session->cur_msg].partial_recv = POP3_TOTALLY_RECEIVED;
 386
 387         session->msg[session->cur_msg].recv_time =
 388                 drop_ok == 1 ? RECV_TIME_KEEP : session->current_time;
 389
 390         return PS_SUCCESS;
 391 }
 392
 393 static gint pop3_top_send(Pop3Session *session, gint max_size)
 394 {
 395         gint num_lines = (max_size*1024)/82; /* consider lines to be 80 chars */
 396         session->state = POP3_TOP;
 397         pop3_gen_send(session, "TOP %d %d", session->cur_msg, num_lines);
 398         return PS_SUCCESS;
 399 }
 400
 401 static gint pop3_top_recv(Pop3Session *session, const gchar *data, guint len)
 402 {
 403         gchar *file;
 404         gint drop_ok;
 405         MailReceiveData mail_receive_data;
 406         gchar *partial_notice = NULL;
 407
 408         mail_receive_data.session = session;
 409         mail_receive_data.data = g_strndup(data, len);
 410         hooks_invoke(MAIL_RECEIVE_HOOKLIST, &mail_receive_data);
 411
 412         partial_notice = g_strdup_printf("SC-Marked-For-Download: 0\n"
 413                                          "SC-Partially-Retrieved: %s\n"
 414                                          "SC-Account-Server: %s\n"
 415                                          "SC-Account-Login: %s\n"
 416                                          "SC-Message-Size: %d",
 417                                          session->msg[session->cur_msg].uidl,
 418                                          session->ac_prefs->recv_server,
 419                                          session->ac_prefs->userid,
 420                                          session->msg[session->cur_msg].size);
 421         file = get_tmp_file();
 422         if (pop3_write_msg_to_file(file, mail_receive_data.data,
 423                 strlen(mail_receive_data.data), partial_notice) < 0) {
 424                 g_free(file);
 425                 g_free(mail_receive_data.data);
 426                 session->error_val = PS_IOERR;
 427                 g_free(partial_notice);
 428                 return -1;
 429         }
 430         g_free(mail_receive_data.data);
 431         g_free(partial_notice);
 432
 433         /* drop_ok: 0: success 1: don't receive -1: error */
 434         drop_ok = session->drop_message(session, file);
 435         g_free(file);
 436         if (drop_ok < 0) {
 437                 session->error_val = PS_IOERR;
 438                 return -1;
 439         }
 440
 441         session->cur_total_bytes += session->msg[session->cur_msg].size;
 442         session->cur_total_recv_bytes += session->msg[session->cur_msg].size;
 443         session->cur_total_num++;
 444
 445         session->msg[session->cur_msg].received = TRUE;
 446         session->msg[session->cur_msg].partial_recv = POP3_PARTIALLY_RECEIVED;
 447         session->msg[session->cur_msg].recv_time =
 448                 drop_ok == 1 ? RECV_TIME_KEEP : session->current_time;
 449
 450         return PS_SUCCESS;
 451 }
 452
 453 static gint pop3_delete_send(Pop3Session *session)
 454 {
 455         session->state = POP3_DELETE;
 456         pop3_gen_send(session, "DELE %d", session->cur_msg);
 457         return PS_SUCCESS;
 458 }
 459
 460 static gint pop3_delete_recv(Pop3Session *session)
 461 {
 462         session->msg[session->cur_msg].deleted = TRUE;
 463         return PS_SUCCESS;
 464 }
 465
 466 static gint pop3_logout_send(Pop3Session *session)
 467 {
 468         session->state = POP3_LOGOUT;
 469         pop3_gen_send(session, "QUIT");
 470         return PS_SUCCESS;
 471 }
 472
 473 static void pop3_gen_send(Pop3Session *session, const gchar *format, ...)
 474 {
 475         gchar buf[POPBUFSIZE + 1];
 476         va_list args;
 477
 478         va_start(args, format);
 479         g_vsnprintf(buf, sizeof(buf) - 2, format, args);
 480         va_end(args);
 481
 482         if (!strncasecmp(buf, "PASS ", 5))
 483                 log_print("POP3> PASS ********\n");
 484         else
 485                 log_print("POP3> %s\n", buf);
 486
 487         session_send_msg(SESSION(session), SESSION_MSG_NORMAL, buf);
 488 }
 489
 490 Session *pop3_session_new(PrefsAccount *account)
 491 {
 492         Pop3Session *session;
 493
 494         g_return_val_if_fail(account != NULL, NULL);
 495
 496         session = g_new0(Pop3Session, 1);
 497
 498         session_init(SESSION(session));
 499
 500         SESSION(session)->type = SESSION_POP3;
 501
 502         SESSION(session)->recv_msg = pop3_session_recv_msg;
 503         SESSION(session)->recv_data_finished = pop3_session_recv_data_finished;
 504         SESSION(session)->send_data_finished = NULL;
 505
 506         SESSION(session)->destroy = pop3_session_destroy;
 507
 508         session->state = POP3_READY;
 509         session->ac_prefs = account;
 510         session->pop_before_smtp = FALSE;
 511         pop3_get_uidl_table(account, session);
 512         session->current_time = time(NULL);
 513         session->error_val = PS_SUCCESS;
 514         session->error_msg = NULL;
 515
 516         return SESSION(session);
 517 }
 518
 519 static void pop3_session_destroy(Session *session)
 520 {
 521         Pop3Session *pop3_session = POP3_SESSION(session);
 522         gint n;
 523
 524         g_return_if_fail(session != NULL);
 525
 526         for (n = 1; n <= pop3_session->count; n++)
 527                 g_free(pop3_session->msg[n].uidl);
 528         g_free(pop3_session->msg);
 529
 530         if (pop3_session->uidl_table) {
 531                 hash_free_strings(pop3_session->uidl_table);
 532                 g_hash_table_destroy(pop3_session->uidl_table);
 533         }
 534
 535         if (pop3_session->partial_recv_table) {
 536                 hash_free_strings(pop3_session->partial_recv_table);
 537                 g_hash_table_destroy(pop3_session->partial_recv_table);
 538         }
 539
 540         g_free(pop3_session->greeting);
 541         g_free(pop3_session->user);
 542         g_free(pop3_session->pass);
 543         g_free(pop3_session->error_msg);
 544 }
 545
 546 void pop3_get_uidl_table(PrefsAccount *ac_prefs, Pop3Session *session)
 547 {
 548         GHashTable *table;
 549         GHashTable *partial_recv_table;
 550         gchar *path;
 551         FILE *fp;
 552         gchar buf[POPBUFSIZE];
 553         gchar uidl[POPBUFSIZE];
 554         time_t recv_time;
 555         time_t now;
 556         gint partial_recv;
 557
 558         table = g_hash_table_new(g_str_hash, g_str_equal);
 559         partial_recv_table = g_hash_table_new(g_str_hash, g_str_equal);
 560
 561         path = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
 562                            "uidl", G_DIR_SEPARATOR_S, ac_prefs->recv_server,
 563                            "-", ac_prefs->userid, NULL);
 564         if ((fp = fopen(path, "rb")) == NULL) {
 565                 if (ENOENT != errno) FILE_OP_ERROR(path, "fopen");
 566                 g_free(path);
 567                 path = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
 568                                    "uidl-", ac_prefs->recv_server,
 569                                    "-", ac_prefs->userid, NULL);
 570                 if ((fp = fopen(path, "rb")) == NULL) {
 571                         if (ENOENT != errno) FILE_OP_ERROR(path, "fopen");
 572                         g_free(path);
 573                         session->uidl_table = table;
 574                         session->partial_recv_table = partial_recv_table;
 575                         return;
 576                 }
 577         }
 578         g_free(path);
 579
 580         now = time(NULL);
 581
 582         while (fgets(buf, sizeof(buf), fp) != NULL) {
 583                 gchar tmp[POPBUFSIZE];
 584                 strretchomp(buf);
 585                 recv_time = RECV_TIME_NONE;
 586                 partial_recv = POP3_TOTALLY_RECEIVED;
 587
 588                 if (sscanf(buf, "%s\t%ld\t%s", uidl, &recv_time, &tmp) < 2) {
 589                         if (sscanf(buf, "%s", uidl) != 1)
 590                                 continue;
 591                         else {
 592                                 recv_time = now;
 593                         }
 594                 }
 595                 if (recv_time == RECV_TIME_NONE)
 596                         recv_time = RECV_TIME_RECEIVED;
 597                 g_hash_table_insert(table, g_strdup(uidl),
 598                                     GINT_TO_POINTER(recv_time));
 599                 if (strlen(tmp) == 1)
 600                         partial_recv = atoi(tmp); /* totally received ?*/
 601                 else
 602                         partial_recv = POP3_MUST_COMPLETE_RECV;
 603
 604                 g_hash_table_insert(partial_recv_table, g_strdup(uidl),
 605                                     GINT_TO_POINTER(partial_recv));
 606         }
 607
 608         fclose(fp);
 609         session->uidl_table = table;
 610         session->partial_recv_table = partial_recv_table;
 611
 612         return;
 613 }
 614
 615 gint pop3_write_uidl_list(Pop3Session *session)
 616 {
 617         gchar *path;
 618         FILE *fp;
 619         Pop3MsgInfo *msg;
 620         gint n;
 621
 622         if (!session->uidl_is_valid) return 0;
 623
 624         path = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
 625                            "uidl", G_DIR_SEPARATOR_S,
 626                            session->ac_prefs->recv_server,
 627                            "-", session->ac_prefs->userid, NULL);
 628         if ((fp = fopen(path, "wb")) == NULL) {
 629                 FILE_OP_ERROR(path, "fopen");
 630                 g_free(path);
 631                 return -1;
 632         }
 633
 634         for (n = 1; n <= session->count; n++) {
 635                 msg = &session->msg[n];
 636                 if (msg->uidl && msg->received && !msg->deleted) {
 637                         fprintf(fp, "%s\t%ld\t%d\n",
 638                                 msg->uidl, msg->recv_time, msg->partial_recv);
 639                 }
 640         }
 641
 642         if (fclose(fp) == EOF) FILE_OP_ERROR(path, "fclose");
 643         g_free(path);
 644
 645         return 0;
 646 }
 647
 648 static gint pop3_write_msg_to_file(const gchar *file, const gchar *data,
 649                                    guint len, const gchar *prefix)
 650 {
 651         FILE *fp;
 652         const gchar *prev, *cur;
 653
 654         g_return_val_if_fail(file != NULL, -1);
 655
 656         if ((fp = fopen(file, "wb")) == NULL) {
 657                 FILE_OP_ERROR(file, "fopen");
 658                 return -1;
 659         }
 660
 661         if (change_file_mode_rw(fp, file) < 0)
 662                 FILE_OP_ERROR(file, "chmod");
 663
 664         if (prefix != NULL) {
 665                 fprintf(fp, prefix);
 666                 fprintf(fp, "\n");
 667         }
 668
 669         /* +------------------+----------------+--------------------------+ *
 670          * ^data              ^prev            ^cur             data+len-1^ */
 671
 672         prev = data;
 673         while ((cur = memchr(prev, '\r', len - (prev - data))) != NULL) {
 674                 if ((cur > prev && fwrite(prev, cur - prev, 1, fp) < 1) ||
 675                     fputc('\n', fp) == EOF) {
 676                         FILE_OP_ERROR(file, "fwrite");
 677                         g_warning("can't write to file: %s\n", file);
 678                         fclose(fp);
 679                         unlink(file);
 680                         return -1;
 681                 }
 682
 683                 if (cur == data + len - 1) {
 684                         prev = cur + 1;
 685                         break;
 686                 }
 687
 688                 if (*(cur + 1) == '\n')
 689                         prev = cur + 2;
 690                 else
 691                         prev = cur + 1;
 692
 693                 if (prev - data < len - 1 && *prev == '.' && *(prev + 1) == '.')
 694                         prev++;
 695
 696                 if (prev - data >= len)
 697                         break;
 698         }
 699
 700         if (prev - data < len &&
 701             fwrite(prev, len - (prev - data), 1, fp) < 1) {
 702                 FILE_OP_ERROR(file, "fwrite");
 703                 g_warning("can't write to file: %s\n", file);
 704                 fclose(fp);
 705                 unlink(file);
 706                 return -1;
 707         }
 708         if (data[len - 1] != '\r' && data[len - 1] != '\n') {
 709                 if (fputc('\n', fp) == EOF) {
 710                         FILE_OP_ERROR(file, "fputc");
 711                         g_warning("can't write to file: %s\n", file);
 712                         fclose(fp);
 713                         unlink(file);
 714                         return -1;
 715                 }
 716         }
 717
 718         if (fclose(fp) == EOF) {
 719                 FILE_OP_ERROR(file, "fclose");
 720                 unlink(file);
 721                 return -1;
 722         }
 723
 724         return 0;
 725 }
 726
 727 static Pop3State pop3_lookup_next(Pop3Session *session)
 728 {
 729         Pop3MsgInfo *msg;
 730         PrefsAccount *ac = session->ac_prefs;
 731         gint size;
 732         gboolean size_limit_over;
 733
 734         for (;;) {
 735                 msg = &session->msg[session->cur_msg];
 736                 size = msg->size;
 737                 size_limit_over =
 738                     (ac->enable_size_limit &&
 739                      ac->size_limit > 0 &&
 740                      size > ac->size_limit * 1024);
 741
 742                 if (ac->rmmail &&
 743                     msg->recv_time != RECV_TIME_NONE &&
 744                     msg->recv_time != RECV_TIME_KEEP &&
 745                     msg->partial_recv == POP3_TOTALLY_RECEIVED &&
 746                     session->current_time - msg->recv_time >=
 747                     ac->msg_leave_time * 24 * 60 * 60) {
 748                         log_message
 749                                 (_("POP3: Deleting expired message "
 750                                    "%d\n"), session->cur_msg);
 751                         pop3_delete_send(session);
 752                         return POP3_DELETE;
 753                 }
 754
 755                 if (size_limit_over) {
 756                         if (!msg->received && msg->partial_recv !=
 757                             POP3_MUST_COMPLETE_RECV) {
 758                                 pop3_top_send(session, ac->size_limit);
 759                                 return POP3_TOP;
 760                         } else if (msg->partial_recv == POP3_MUST_COMPLETE_RECV)
 761                                 break;
 762
 763                         log_message
 764                                 (_("POP3: Skipping message %d (%d bytes)\n"),
 765                                    session->cur_msg, size);
 766                 }
 767
 768                 if (size == 0 || msg->received || size_limit_over) {
 769                         session->cur_total_bytes += size;
 770                         if (session->cur_msg == session->count) {
 771                                 pop3_logout_send(session);
 772                                 return POP3_LOGOUT;
 773                         } else
 774                                 session->cur_msg++;
 775                 } else
 776                         break;
 777         }
 778
 779         pop3_retr_send(session);
 780         return POP3_RETR;
 781 }
 782
 783 static Pop3ErrorValue pop3_ok(Pop3Session *session, const gchar *msg)
 784 {
 785         Pop3ErrorValue ok;
 786
 787         log_print("POP3< %s\n", msg);
 788
 789         if (!strncmp(msg, "+OK", 3))
 790                 ok = PS_SUCCESS;
 791         else if (!strncmp(msg, "-ERR", 4)) {
 792                 if (strstr(msg + 4, "lock") ||
 793                     strstr(msg + 4, "Lock") ||
 794                     strstr(msg + 4, "LOCK") ||
 795                     strstr(msg + 4, "wait")) {
 796                         log_warning(_("mailbox is locked\n"));
 797                         ok = PS_LOCKBUSY;
 798                 } else if (strcasestr(msg + 4, "timeout")) {
 799                         log_warning(_("session timeout\n"));
 800                         ok = PS_ERROR;
 801                 } else {
 802                         switch (session->state) {
 803 #if USE_OPENSSL
 804                         case POP3_STLS:
 805                                 log_warning(_("can't start TLS session\n"));
 806                                 ok = PS_ERROR;
 807                                 break;
 808 #endif
 809                         case POP3_GETAUTH_USER:
 810                         case POP3_GETAUTH_PASS:
 811                         case POP3_GETAUTH_APOP:
 812                                 log_warning(_("error occurred on authentication\n"));
 813                                 ok = PS_AUTHFAIL;
 814                                 break;
 815                         case POP3_GETRANGE_LAST:
 816                         case POP3_GETRANGE_UIDL:
 817                         case POP3_TOP:
 818                                 log_warning(_("command not supported\n"));
 819                                 ok = PS_NOTSUPPORTED;
 820                                 break;
 821
 822                         default:
 823                                 log_warning(_("error occurred on POP3 session\n"));
 824                                 ok = PS_ERROR;
 825                         }
 826                 }
 827
 828                 g_free(session->error_msg);
 829                 session->error_msg = g_strdup(msg);
 830                 fprintf(stderr, "POP3: %s\n", msg);
 831         } else
 832                 ok = PS_PROTOCOL;
 833
 834         session->error_val = ok;
 835         return ok;
 836 }
 837
 838 static gint pop3_session_recv_msg(Session *session, const gchar *msg)
 839 {
 840         Pop3Session *pop3_session = POP3_SESSION(session);
 841         Pop3ErrorValue val = PS_SUCCESS;
 842         const guchar *body;
 843
 844         body = msg;
 845         if (pop3_session->state != POP3_GETRANGE_UIDL_RECV &&
 846             pop3_session->state != POP3_GETSIZE_LIST_RECV) {
 847                 val = pop3_ok(pop3_session, msg);
 848                 if (val != PS_SUCCESS) {
 849                         if (val != PS_NOTSUPPORTED) {
 850                                 pop3_session->state = POP3_ERROR;
 851                                 return -1;
 852                         }
 853                 }
 854
 855                 if (*body == '+' || *body == '-')
 856                         body++;
 857                 while (isalpha(*body))
 858                         body++;
 859                 while (isspace(*body))
 860                         body++;
 861         }
 862
 863         switch (pop3_session->state) {
 864         case POP3_READY:
 865         case POP3_GREETING:
 866                 pop3_greeting_recv(pop3_session, body);
 867 #if USE_OPENSSL
 868                 if (pop3_session->ac_prefs->ssl_pop == SSL_STARTTLS)
 869                         pop3_stls_send(pop3_session);
 870                 else
 871 #endif
 872                 if (pop3_session->ac_prefs->protocol == A_APOP)
 873                         pop3_getauth_apop_send(pop3_session);
 874                 else
 875                         pop3_getauth_user_send(pop3_session);
 876                 break;
 877 #if USE_OPENSSL
 878         case POP3_STLS:
 879                 if (pop3_stls_recv(pop3_session) != PS_SUCCESS)
 880                         return -1;
 881                 if (pop3_session->ac_prefs->protocol == A_APOP)
 882                         pop3_getauth_apop_send(pop3_session);
 883                 else
 884                         pop3_getauth_user_send(pop3_session);
 885                 break;
 886 #endif
 887         case POP3_GETAUTH_USER:
 888                 pop3_getauth_pass_send(pop3_session);
 889                 break;
 890         case POP3_GETAUTH_PASS:
 891         case POP3_GETAUTH_APOP:
 892                 if (!pop3_session->pop_before_smtp)
 893                         pop3_getrange_stat_send(pop3_session);
 894                 else
 895                         pop3_logout_send(pop3_session);
 896                 break;
 897         case POP3_GETRANGE_STAT:
 898                 if (pop3_getrange_stat_recv(pop3_session, body) < 0)
 899                         return -1;
 900                 if (pop3_session->count > 0)
 901                         pop3_getrange_uidl_send(pop3_session);
 902                 else
 903                         pop3_logout_send(pop3_session);
 904                 break;
 905         case POP3_GETRANGE_LAST:
 906                 if (val == PS_NOTSUPPORTED)
 907                         pop3_session->error_val = PS_SUCCESS;
 908                 else if (pop3_getrange_last_recv(pop3_session, body) < 0)
 909                         return -1;
 910                 if (pop3_session->cur_msg > 0)
 911                         pop3_getsize_list_send(pop3_session);
 912                 else
 913                         pop3_logout_send(pop3_session);
 914                 break;
 915         case POP3_GETRANGE_UIDL:
 916                 if (val == PS_NOTSUPPORTED) {
 917                         pop3_session->error_val = PS_SUCCESS;
 918                         pop3_getrange_last_send(pop3_session);
 919                 } else {
 920                         pop3_session->state = POP3_GETRANGE_UIDL_RECV;
 921                         session_recv_data(session, 0, ".\r\n");
 922                 }
 923                 break;
 924         case POP3_GETSIZE_LIST:
 925                 pop3_session->state = POP3_GETSIZE_LIST_RECV;
 926                 session_recv_data(session, 0, ".\r\n");
 927                 break;
 928         case POP3_RETR:
 929                 pop3_session->state = POP3_RETR_RECV;
 930                 session_recv_data(session, 0, ".\r\n");
 931                 break;
 932         case POP3_TOP:
 933                 if (val == PS_NOTSUPPORTED) {
 934                         pop3_session->error_val = PS_SUCCESS;
 935                 } else {
 936                         pop3_session->state = POP3_TOP_RECV;
 937                         session_recv_data(session, 0, ".\r\n");
 938                 }
 939                 break;
 940         case POP3_DELETE:
 941                 pop3_delete_recv(pop3_session);
 942                 if (pop3_session->cur_msg == pop3_session->count)
 943                         pop3_logout_send(pop3_session);
 944                 else {
 945                         pop3_session->cur_msg++;
 946                         if (pop3_lookup_next(pop3_session) == POP3_ERROR)
 947                                 return -1;
 948                 }
 949                 break;
 950         case POP3_LOGOUT:
 951                 session_disconnect(session);
 952                 break;
 953         case POP3_ERROR:
 954         default:
 955                 return -1;
 956         }
 957
 958         return 0;
 959 }
 960
 961 static gint pop3_session_recv_data_finished(Session *session, guchar *data,
 962                                             guint len)
 963 {
 964         Pop3Session *pop3_session = POP3_SESSION(session);
 965         Pop3ErrorValue val = PS_SUCCESS;
 966
 967         switch (pop3_session->state) {
 968         case POP3_GETRANGE_UIDL_RECV:
 969                 val = pop3_getrange_uidl_recv(pop3_session, data, len);
 970                 if (val == PS_SUCCESS) {
 971                         if (pop3_session->new_msg_exist)
 972                                 pop3_getsize_list_send(pop3_session);
 973                         else
 974                                 pop3_logout_send(pop3_session);
 975                 } else
 976                         return -1;
 977                 break;
 978         case POP3_GETSIZE_LIST_RECV:
 979                 val = pop3_getsize_list_recv(pop3_session, data, len);
 980                 if (val == PS_SUCCESS) {
 981                         if (pop3_lookup_next(pop3_session) == POP3_ERROR)
 982                                 return -1;
 983                 } else
 984                         return -1;
 985                 break;
 986         case POP3_RETR_RECV:
 987                 if (pop3_retr_recv(pop3_session, data, len) < 0)
 988                         return -1;
 989
 990                 if (pop3_session->ac_prefs->rmmail &&
 991                     pop3_session->ac_prefs->msg_leave_time == 0 &&
 992                     pop3_session->msg[pop3_session->cur_msg].recv_time
 993                     != RECV_TIME_KEEP)
 994                         pop3_delete_send(pop3_session);
 995                 else if (pop3_session->cur_msg == pop3_session->count)
 996                         pop3_logout_send(pop3_session);
 997                 else {
 998                         pop3_session->cur_msg++;
 999                         if (pop3_lookup_next(pop3_session) == POP3_ERROR)
1000                                 return -1;
1001                 }
1002                 break;
1003         case POP3_TOP_RECV:
1004                 if (pop3_top_recv(pop3_session, data, len) < 0)
1005                         return -1;
1006
1007                 if (pop3_session->cur_msg == pop3_session->count)
1008                         pop3_logout_send(pop3_session);
1009                 else {
1010                         pop3_session->cur_msg++;
1011                         if (pop3_lookup_next(pop3_session) == POP3_ERROR)
1012                                 return -1;
1013                 }
1014                 break;
1015         case POP3_TOP:
1016                 log_warning(_("TOP command unsupported\n"));
1017                 if (pop3_session->cur_msg == pop3_session->count)
1018                         pop3_logout_send(pop3_session);
1019                 else {
1020                         pop3_session->cur_msg++;
1021                         if (pop3_lookup_next(pop3_session) == POP3_ERROR)
1022                                 return -1;
1023                 }
1024                 break;
1025         case POP3_ERROR:
1026         default:
1027                 return -1;
1028         }
1029
1030         return 0;
1031 }