src/pop.c

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