pop.c

   1 /*
   2  * Copyright notice from original mutt:
   3  * Copyright (C) 2000-2002 Vsevolod Volkov <vvv@mutt.org.ua>
   4  *
   5  * This file is part of mutt-ng, see http://www.muttng.org/.
   6  * It's licensed under the GNU General Public License,
   7  * please see the file GPL in the top level source directory.
   8  */
   9
  10 #include <lib-lib/lib-lib.h>
  11
  12 #include <sasl/sasl.h>
  13 #include <sasl/saslutil.h>
  14
  15 #include <lib-sys/mutt_socket.h>
  16 #include <lib-ui/lib-ui.h>
  17
  18 #include "crypt.h"
  19 #include "mutt.h"
  20 #include "mutt_sasl.h"
  21 #include "pop.h"
  22
  23 #define POP_PORT            110
  24 #define POP_SSL_PORT        995
  25 #define POP_CACHE_LEN        10
  26 /* maximal length of the server response (RFC1939) */
  27 #define POP_CMD_RESPONSE    512
  28
  29 enum {
  30     /* Status */
  31     POP_NONE = 0,
  32     POP_CONNECTED,
  33     POP_DISCONNECTED,
  34     POP_BYE
  35 };
  36
  37 typedef enum {
  38     POP_A_SUCCESS = 0,
  39     POP_A_SOCKET,
  40     POP_A_FAILURE,
  41     POP_A_UNAVAIL
  42 } pop_auth_res_t;
  43
  44 typedef struct {
  45   int index;
  46   char *path;
  47 } POP_CACHE;
  48
  49 typedef enum {
  50     /* pop_fetch_data uses pop_query_status and this return value */
  51     PFD_FUNCT_ERROR = -3,
  52     PQ_ERR = -2,
  53     PQ_NOT_CONNECTED = -1,
  54     PQ_OK = 0
  55 } pop_query_status;
  56
  57 typedef enum {
  58     CMD_NOT_AVAILABLE = 0,
  59     CMD_AVAILABLE,
  60     CMD_UNKNOWN /* unknown whether it is available or not */
  61 } cmd_status;
  62
  63 typedef struct {
  64     CONNECTION *conn;
  65
  66     unsigned status       : 2;
  67     unsigned capabilities : 1;
  68     unsigned use_stls     : 2;
  69     cmd_status cmd_capa   : 2;      /* optional command CAPA */
  70     cmd_status cmd_stls   : 2;      /* optional command STLS */
  71     cmd_status cmd_uidl   : 2;      /* optional command UIDL */
  72     cmd_status cmd_top    : 2;      /* optional command TOP  */
  73     cmd_status cmd_user   : 2;      /* optional command USER */
  74     unsigned resp_codes   : 1;      /* server supports extended response codes */
  75     unsigned expire       : 1;      /* expire is greater than 0 */
  76     unsigned clear_cache  : 1;
  77
  78     ssize_t size;
  79     time_t check_time;
  80     char *auth_list;              /* list of auth mechanisms */
  81     char *timestamp;
  82     char err_msg[POP_CMD_RESPONSE];
  83     POP_CACHE cache[POP_CACHE_LEN];
  84 } pop_data_t;
  85
  86 /* pop low level functions {{{ */
  87
  88 static void pop_error(pop_data_t *pop_data, const char *msg)
  89 {
  90     if (!m_strncmp(msg, "-ERR ", 5)) {
  91         const char *s = skipspaces(msg + 5);
  92         if (*s)
  93             msg = s;
  94     }
  95
  96     m_strcat(pop_data->err_msg, sizeof(pop_data->err_msg), msg);
  97     m_strrtrim(pop_data->err_msg);
  98 }
  99
 100 /*
 101  * Send data from buffer and receive answer to the same buffer
 102  *  0 - successful,
 103  * -1 - conection lost,
 104  * -2 - invalid command or execution error.
 105 */
 106 static pop_query_status _pop_query(pop_data_t *pop_data, char *buf, ssize_t buflen)
 107 {
 108     if (pop_data->status != POP_CONNECTED)
 109         return PQ_NOT_CONNECTED;
 110
 111     mutt_socket_write(pop_data->conn, buf);
 112     snprintf(pop_data->err_msg, sizeof(pop_data->err_msg), "%.*s: ",
 113              (int)(strpbrk(buf, " \r\n") - buf), buf);
 114
 115     if (mutt_socket_readln(buf, buflen, pop_data->conn) < 0) {
 116         pop_data->status = POP_DISCONNECTED;
 117         return PQ_NOT_CONNECTED;
 118     }
 119     if (!m_strncmp(buf, "+OK", 3))
 120         return PQ_OK;
 121
 122     pop_error(pop_data, buf);
 123     return PQ_ERR;
 124 }
 125 #define pop_query(pd, b, l, fmt, ...) \
 126     (snprintf(b, l, fmt "\r\n", ##__VA_ARGS__), _pop_query(pd, b, l))
 127
 128 /*
 129  * Open connection
 130  *  0 - successful,
 131  * -1 - conection lost,
 132  * -2 - invalid response.
 133 */
 134 static pop_query_status pop_connect(pop_data_t * pop_data)
 135 {
 136     char buf[LONG_STRING];
 137     const char *p, *q;
 138
 139     if (mutt_socket_open(pop_data->conn) < 0
 140     ||  mutt_socket_readln(buf, sizeof(buf), pop_data->conn) < 0)
 141     {
 142         mutt_error(_("Error connecting to server: %s"),
 143                    pop_data->conn->account.host);
 144         pop_data->status = POP_NONE;
 145         return PQ_NOT_CONNECTED;
 146     }
 147
 148     pop_data->status = POP_CONNECTED;
 149     if (m_strncmp(buf, "+OK", 3)) {
 150         pop_data->err_msg[0] = '\0';
 151         pop_error(pop_data, buf);
 152         mutt_error("%s", pop_data->err_msg);
 153         return PQ_ERR;
 154     }
 155
 156     p_delete(&pop_data->timestamp);
 157     if ((p = strchr(buf, '<')) && (q = strchr(p, '>'))) {
 158         pop_data->timestamp = p_dupstr(p, q + 1 - p);
 159     }
 160     return PQ_OK;
 161 }
 162
 163 static void pop_logout (CONTEXT * ctx)
 164 {
 165   pop_query_status ret = 0;
 166   char buf[LONG_STRING];
 167   pop_data_t *pop_data = (pop_data_t *) ctx->data;
 168
 169   if (pop_data->status == POP_CONNECTED) {
 170     mutt_message _("Closing connection to POP server...");
 171
 172     if (ctx->readonly) {
 173       ret = pop_query(pop_data, buf, sizeof(buf), "RSET");
 174     }
 175
 176     if (ret != PQ_NOT_CONNECTED) {
 177       pop_query(pop_data, buf, sizeof(buf), "QUIT");
 178     }
 179
 180     mutt_clear_error ();
 181   }
 182
 183   pop_data->status = POP_DISCONNECTED;
 184   return;
 185 }
 186
 187 /* }}} */
 188 /* Authentication {{{ */
 189
 190 static pop_auth_res_t pop_auth_sasl(pop_data_t *pop_data, const char *method)
 191 {
 192     sasl_conn_t *saslconn;
 193     sasl_interact_t *interaction = NULL;
 194
 195     char buf[LONG_STRING], inbuf[LONG_STRING];
 196     const char *mech, *pc = NULL;
 197     unsigned int len, olen;
 198     unsigned char client_start;
 199     int rc;
 200
 201     if (mutt_sasl_client_new(pop_data->conn, &saslconn) < 0) {
 202         return POP_A_FAILURE;
 203     }
 204
 205     if (!method)
 206         method = pop_data->auth_list;
 207
 208     for (;;) {
 209         rc = sasl_client_start(saslconn, method, &interaction, &pc, &olen,
 210                                &mech);
 211         if (rc != SASL_INTERACT)
 212             break;
 213         mutt_sasl_interact(interaction);
 214     }
 215
 216     if (rc != SASL_OK && rc != SASL_CONTINUE) {
 217         return POP_A_UNAVAIL;
 218     }
 219
 220     client_start = (olen > 0);
 221     mutt_message(_("Authenticating (SASL)..."));
 222     snprintf(buf, sizeof (buf), "AUTH %s", mech);
 223     olen = strlen (buf);
 224
 225     /* looping protocol */
 226     for (;;) {
 227         m_strcpy(buf + olen, sizeof(buf) - olen, "\r\n");
 228         mutt_socket_write(pop_data->conn, buf);
 229         if (mutt_socket_readln(inbuf, sizeof(inbuf), pop_data->conn) < 0) {
 230             sasl_dispose(&saslconn);
 231             pop_data->status = POP_DISCONNECTED;
 232             return POP_A_SOCKET;
 233         }
 234
 235         if (rc != SASL_CONTINUE)
 236             break;
 237
 238         if (!m_strncmp(inbuf, "+ ", 2)
 239         &&   sasl_decode64(inbuf, strlen(inbuf),
 240                            buf, sizeof(buf) - 1, &len) != SASL_OK)
 241         {
 242             goto bail;
 243         }
 244
 245         if (!client_start) {
 246             for (;;) {
 247                 rc = sasl_client_step(saslconn, buf, len, &interaction, &pc,
 248                                       &olen);
 249                 if (rc != SASL_INTERACT)
 250                     break;
 251                 mutt_sasl_interact(interaction);
 252             }
 253         } else {
 254             client_start = 0;
 255         }
 256
 257         if (rc != SASL_CONTINUE && (olen == 0 || rc != SASL_OK))
 258             break;
 259
 260         /* send out response, or line break if none needed */
 261         if (pc) {
 262             if (sasl_encode64(pc, olen, buf, sizeof(buf), &olen) != SASL_OK) {
 263                 goto bail;
 264             }
 265             p_delete((char **)&pc);
 266         }
 267     }
 268
 269     if (rc != SASL_OK)
 270         goto bail;
 271
 272     if (!m_strncmp(inbuf, "+OK", 3)) {
 273         mutt_sasl_setup_conn(pop_data->conn, saslconn);
 274         return POP_A_SUCCESS;
 275     }
 276
 277   bail:
 278     sasl_dispose(&saslconn);
 279     p_delete((char **)&pc);
 280
 281     /* terminate SASL session if the last responce is not +OK nor -ERR */
 282     if (!m_strncmp(inbuf, "+ ", 2)) {
 283         if (pop_query(pop_data, buf, sizeof(buf), "*") == PQ_NOT_CONNECTED)
 284             return POP_A_SOCKET;
 285     }
 286
 287     mutt_error(_("SASL authentication failed."));
 288     mutt_sleep(2);
 289
 290     return POP_A_FAILURE;
 291 }
 292
 293 static pop_auth_res_t pop_auth_apop(pop_data_t *pop_data, const char *method)
 294 {
 295     MD5_CTX mdContext;
 296     unsigned char digest[16];
 297     char hash[33];
 298     char buf[LONG_STRING];
 299     int i;
 300
 301     if (!pop_data->timestamp)
 302         return POP_A_UNAVAIL;
 303
 304     mutt_message _("Authenticating (APOP)...");
 305
 306     /* Compute the authentication hash to send to the server */
 307     MD5Init(&mdContext);
 308     MD5Update(&mdContext, (unsigned char *)pop_data->timestamp,
 309               strlen(pop_data->timestamp));
 310     MD5Update(&mdContext, (unsigned char *)pop_data->conn->account.pass,
 311               strlen(pop_data->conn->account.pass));
 312     MD5Final(digest, &mdContext);
 313
 314     for (i = 0; i < countof(digest); i++)
 315         sprintf(hash + 2 * i, "%02x", digest[i]);
 316
 317     switch (pop_query(pop_data, buf, sizeof(buf), "APOP %s %s",
 318                       pop_data->conn->account.user, hash))
 319     {
 320       case PQ_OK:
 321         return POP_A_SUCCESS;
 322       case PQ_NOT_CONNECTED:
 323         return POP_A_SOCKET;
 324       default:
 325         mutt_error("%s %s", _("APOP authentication failed."), pop_data->err_msg);
 326         mutt_sleep(2);
 327         return POP_A_FAILURE;
 328     }
 329 }
 330
 331 static pop_auth_res_t pop_auth_user(pop_data_t *pop_data, const char *method)
 332 {
 333     char buf[LONG_STRING];
 334     pop_query_status ret;
 335
 336     if (pop_data->cmd_user == CMD_NOT_AVAILABLE)
 337         return POP_A_UNAVAIL;
 338
 339     mutt_message _("Authenticating (USER)...");
 340     ret = pop_query(pop_data, buf, sizeof(buf), "USER %s",
 341                     pop_data->conn->account.user);
 342
 343     if (pop_data->cmd_user == CMD_UNKNOWN) {
 344         if (ret == PQ_OK)
 345             pop_data->cmd_user = CMD_AVAILABLE;
 346         if (ret == PQ_ERR)
 347             pop_data->cmd_user = CMD_NOT_AVAILABLE;
 348     }
 349
 350     if (ret == PQ_OK) {
 351         ret = pop_query(pop_data, buf, sizeof(buf), "PASS %s",
 352                         pop_data->conn->account.pass);
 353     }
 354
 355     switch (ret) {
 356       case PQ_OK:
 357         return POP_A_SUCCESS;
 358       case PQ_NOT_CONNECTED:
 359         return POP_A_SOCKET;
 360       default:
 361         mutt_error("%s %s", _("USER authentication failed."), pop_data->err_msg);
 362         mutt_sleep(2);
 363         return POP_A_FAILURE;
 364     }
 365 }
 366
 367 typedef struct {
 368     pop_auth_res_t (*do_auth)(pop_data_t *, const char *);
 369     const char *method;
 370 } pop_auth_t;
 371
 372 static pop_query_status pop_authenticate (pop_data_t * pop_data)
 373 {
 374     static pop_auth_t const pop_authenticators[] = {
 375         {pop_auth_sasl, NULL},
 376         {pop_auth_apop, "apop"},
 377         {pop_auth_user, "user"},
 378         {NULL, NULL}
 379     };
 380
 381     ACCOUNT *act = &pop_data->conn->account;
 382     const pop_auth_t *auth;
 383     int attempts = 0;
 384
 385     if (mutt_account_getuser(act) || !act->user[0]
 386     ||  mutt_account_getpass(act) || !act->pass[0])
 387     {
 388         return PFD_FUNCT_ERROR;
 389     }
 390
 391     if (!m_strisempty(PopAuthenticators)) {
 392         const char *p, *q;
 393         char buf[STRING];
 394
 395         for (p = PopAuthenticators; ; p = q) {
 396             while (*p == ':')
 397                 p++;
 398             if (!*p)
 399                 break;
 400
 401             q = strchrnul(p, ':');
 402             m_strncpy(buf, sizeof(buf), p, q - p);
 403
 404             for (auth = pop_authenticators; auth->do_auth; auth++) {
 405                 if (auth->method && ascii_strcasecmp(auth->method, buf))
 406                     continue;
 407
 408                 switch (auth->do_auth(pop_data, buf)) {
 409                   case POP_A_SUCCESS:
 410                     return PQ_OK;
 411                   case POP_A_SOCKET:
 412                     return PQ_NOT_CONNECTED;
 413                   case POP_A_UNAVAIL:
 414                     break;
 415                   case POP_A_FAILURE:
 416                     attempts++;
 417                     break;
 418                 }
 419                 mutt_socket_close(pop_data->conn);
 420             }
 421         }
 422     } else {
 423         for (auth = pop_authenticators; auth->do_auth; auth++) {
 424             switch (auth->do_auth(pop_data, auth->method)) {
 425               case POP_A_SUCCESS:
 426                 return PQ_OK;
 427               case POP_A_SOCKET:
 428                 return PQ_NOT_CONNECTED;
 429               case POP_A_UNAVAIL:
 430                 break;
 431               case POP_A_FAILURE:
 432                 attempts++;
 433                 break;
 434             }
 435             mutt_socket_close(pop_data->conn);
 436         }
 437     }
 438
 439     if (!attempts)
 440         mutt_error(_("No authenticators available"));
 441     return PQ_ERR;
 442 }
 443
 444 /* }}} */
 445
 446 /*
 447  * This function calls  funct(*line, *data)  for each received line,
 448  * funct(NULL, *data)  if  rewind(*data)  needs, exits when fail or done.
 449  * Returned codes:
 450  *  0 - successful,
 451  * -1 - conection lost,
 452  * -2 - invalid command or execution error,
 453  * -3 - error in funct(*line, *data)
 454  */
 455 static pop_query_status
 456 pop_fetch_data(pop_data_t *pop_data, const char *query, progress_t *bar,
 457                int (*funct)(char *, void *), void *data)
 458 {
 459     pop_query_status ret;
 460     char buf[LONG_STRING];
 461     buffer_t inbuf;
 462     ssize_t pos = 0;
 463
 464     buffer_init(&inbuf);
 465
 466     m_strcpy(buf, sizeof(buf), query);
 467     ret = _pop_query(pop_data, buf, sizeof(buf));
 468     if (ret != PQ_OK)
 469         return ret;
 470
 471     for (;;) {
 472         int dot = 0;
 473
 474         if (mutt_socket_readln2(&inbuf, pop_data->conn) < 0) {
 475             pop_data->status = POP_DISCONNECTED;
 476             ret = PQ_NOT_CONNECTED;
 477             break;
 478         }
 479
 480         if (bar) {
 481             mutt_progress_bar(bar, pos += inbuf.len);
 482         }
 483
 484         if (inbuf.data[0] == '.') {
 485             if (inbuf.data[1] != '.')
 486                 break;
 487             dot = 1;
 488         }
 489
 490         if (funct(inbuf.data + dot, data) < 0) {
 491             buffer_wipe(&inbuf);
 492             ret = PFD_FUNCT_ERROR;
 493             break;
 494         }
 495
 496         buffer_reset(&inbuf);
 497     }
 498
 499     buffer_wipe(&inbuf);
 500     return ret;
 501 }
 502
 503 static int fetch_capa (char *line, void *data)
 504 {
 505   pop_data_t *pop_data = (pop_data_t *) data;
 506   char *c;
 507
 508   if (!ascii_strncasecmp (line, "SASL", 4)) {
 509     p_delete(&pop_data->auth_list);
 510     c = vskipspaces(line + 4);
 511     pop_data->auth_list = m_strdup(c);
 512   }
 513
 514   else if (!ascii_strncasecmp (line, "STLS", 4))
 515     pop_data->cmd_stls = CMD_AVAILABLE;
 516
 517   else if (!ascii_strncasecmp (line, "UIDL", 4))
 518     pop_data->cmd_uidl = CMD_AVAILABLE;
 519
 520   else if (!ascii_strncasecmp (line, "TOP", 3))
 521     pop_data->cmd_top = CMD_AVAILABLE;
 522
 523   return 0;
 524 }
 525
 526 static int fetch_auth (char *line, void *data)
 527 {
 528   pop_data_t *pop_data = (pop_data_t *) data;
 529   ssize_t auth_list_len;
 530
 531   if (!pop_data->auth_list) {
 532     auth_list_len = m_strlen(line) + 1;
 533     pop_data->auth_list = p_new(char, auth_list_len);
 534   } else {
 535     auth_list_len = m_strlen(pop_data->auth_list) + m_strlen(line) + 2;
 536     p_realloc(&pop_data->auth_list, auth_list_len);
 537     m_strcat(pop_data->auth_list, auth_list_len, " ");
 538   }
 539   m_strcat(pop_data->auth_list, auth_list_len, line);
 540
 541   return 0;
 542 }
 543
 544 /*
 545  * Get capabilities
 546  *  0 - successful,
 547  * -1 - conection lost,
 548  * -2 - execution error.
 549 */
 550 static pop_query_status pop_capabilities(pop_data_t * pop_data, int mode)
 551 {
 552   /* don't check capabilities on reconnect */
 553   if (pop_data->capabilities)
 554     return 0;
 555
 556   /* init capabilities */
 557   if (mode == 0) {
 558     pop_data->cmd_capa   = CMD_NOT_AVAILABLE;
 559     pop_data->cmd_stls   = CMD_NOT_AVAILABLE;
 560     pop_data->cmd_uidl   = CMD_NOT_AVAILABLE;
 561     pop_data->cmd_top    = CMD_NOT_AVAILABLE;
 562     pop_data->cmd_user   = CMD_NOT_AVAILABLE;
 563     pop_data->resp_codes = 0;
 564     pop_data->expire     = 1;
 565     p_delete(&pop_data->auth_list);
 566   }
 567
 568   /* Execute CAPA command */
 569   if (mode == 0 || pop_data->cmd_capa != CMD_NOT_AVAILABLE) {
 570     switch (pop_fetch_data(pop_data, "CAPA\r\n", NULL, fetch_capa, pop_data)) {
 571     case PQ_OK:
 572       pop_data->cmd_capa = CMD_AVAILABLE;
 573       break;
 574     case PFD_FUNCT_ERROR:
 575     case PQ_ERR:
 576       pop_data->cmd_capa = CMD_NOT_AVAILABLE;
 577       break;
 578     case PQ_NOT_CONNECTED:
 579       return PQ_NOT_CONNECTED;
 580     }
 581   }
 582
 583   /* CAPA not supported, use defaults */
 584   if (mode == 0 && pop_data->cmd_capa == CMD_NOT_AVAILABLE) {
 585     pop_data->cmd_uidl = CMD_UNKNOWN;
 586     pop_data->cmd_top = CMD_UNKNOWN;
 587
 588     if (pop_fetch_data(pop_data, "AUTH\r\n", NULL, fetch_auth, pop_data) ==
 589         PQ_NOT_CONNECTED)
 590       return PQ_NOT_CONNECTED;
 591   }
 592
 593   /* Check capabilities */
 594   if (mode == 2) {
 595     const char *msg = NULL;
 596
 597     if (!pop_data->expire)
 598       msg = _("Unable to leave messages on server.");
 599     if (pop_data->cmd_top == CMD_NOT_AVAILABLE)
 600       msg = _("Command TOP is not supported by server.");
 601     if (pop_data->cmd_uidl == CMD_NOT_AVAILABLE)
 602       msg = _("Command UIDL is not supported by server.");
 603     if (msg && pop_data->cmd_capa != CMD_AVAILABLE) {
 604       mutt_error (msg);
 605       return PQ_ERR;
 606     }
 607     pop_data->capabilities = 1;
 608   }
 609
 610   return PQ_OK;
 611 }
 612
 613 /* given an POP mailbox name, return host, port, username and password */
 614 static int pop_parse_path (const char *path, ACCOUNT * act)
 615 {
 616   ciss_url_t url;
 617   char *c;
 618   int ret = -1;
 619
 620   /* Defaults */
 621   act->flags = 0;
 622   act->port = POP_PORT;
 623   act->type = M_ACCT_TYPE_POP;
 624
 625   c = m_strdup(path);
 626   url_parse_ciss (&url, c);
 627
 628   if (url.scheme == U_POP || url.scheme == U_POPS) {
 629     if (url.scheme == U_POPS) {
 630       act->has_ssl = 1;
 631       act->port = POP_SSL_PORT;
 632     }
 633
 634     if ((!url.path || !*url.path) && mutt_account_fromurl (act, &url) == 0)
 635       ret = 0;
 636   }
 637
 638   p_delete(&c);
 639   return ret;
 640 }
 641
 642 /*
 643  * Open connection and authenticate
 644  *  0 - successful,
 645  * -1 - conection lost,
 646  * -2 - invalid command or execution error,
 647  * -3 - authentication canceled.
 648 */
 649 static pop_query_status pop_open_connection (pop_data_t * pop_data)
 650 {
 651   pop_query_status ret;
 652   int n, size;
 653   char buf[LONG_STRING];
 654
 655   ret = pop_connect(pop_data);
 656   if (ret != PQ_OK) {
 657     mutt_sleep (2);
 658     return ret;
 659   }
 660
 661   ret = pop_capabilities (pop_data, 0);
 662   if (ret == PQ_NOT_CONNECTED)
 663     goto err_conn;
 664   if (ret == PQ_ERR) {
 665     mutt_sleep (2);
 666     return PQ_ERR;
 667   }
 668
 669   /* Attempt STLS if available and desired. */
 670   if (!pop_data->conn->ssf && (pop_data->cmd_stls || mod_ssl.force_tls)) {
 671     if (mod_ssl.force_tls)
 672       pop_data->use_stls = 2;
 673     if (pop_data->use_stls == 0) {
 674       pop_data->use_stls = 1;
 675       if (mod_ssl.starttls)
 676         pop_data->use_stls = 2;
 677     }
 678     if (pop_data->use_stls == 2) {
 679       ret = pop_query(pop_data, buf, sizeof(buf), "STLS");
 680       if (ret == PQ_NOT_CONNECTED)
 681         goto err_conn;
 682       if (ret != PQ_OK) {
 683         mutt_error ("%s", pop_data->err_msg);
 684         mutt_sleep (2);
 685       }
 686       else if (mutt_ssl_starttls (pop_data->conn))
 687       {
 688         mutt_error (_("Could not negotiate TLS connection"));
 689         mutt_sleep (2);
 690         return PQ_ERR;
 691       }
 692       else {
 693         /* recheck capabilities after STLS completes */
 694         ret = pop_capabilities (pop_data, 1);
 695         if (ret == PQ_NOT_CONNECTED)
 696           goto err_conn;
 697         if (ret == PQ_ERR) {
 698           mutt_sleep (2);
 699           return PQ_ERR;
 700         }
 701       }
 702     }
 703   }
 704
 705   if (mod_ssl.force_tls && !pop_data->conn->ssf) {
 706     mutt_error _("Encrypted connection unavailable");
 707     mutt_sleep (1);
 708     return -2;
 709   }
 710
 711   ret = pop_authenticate (pop_data);
 712   if (ret == PQ_NOT_CONNECTED)
 713     goto err_conn;
 714   if (ret == PFD_FUNCT_ERROR)
 715     mutt_clear_error ();
 716   if (ret != PQ_OK)
 717     return ret;
 718
 719   /* recheck capabilities after authentication */
 720   ret = pop_capabilities (pop_data, 2);
 721   if (ret == PQ_NOT_CONNECTED)
 722     goto err_conn;
 723   if (ret == PQ_ERR) {
 724     mutt_sleep (2);
 725     return PQ_ERR;
 726   }
 727
 728   /* get total size of mailbox */
 729   ret = pop_query(pop_data, buf, sizeof(buf), "STAT");
 730   if (ret == PQ_NOT_CONNECTED)
 731     goto err_conn;
 732   if (ret == PQ_ERR) {
 733     mutt_error ("%s", pop_data->err_msg);
 734     mutt_sleep (2);
 735     return ret;
 736   }
 737
 738   sscanf (buf, "+OK %u %u", &n, &size);
 739   pop_data->size = size;
 740   return PQ_OK;
 741
 742 err_conn:
 743   pop_data->status = POP_DISCONNECTED;
 744   mutt_error _("Server closed connection!");
 745
 746   mutt_sleep (2);
 747   return PQ_NOT_CONNECTED;
 748 }
 749
 750 /* find message with this UIDL and set refno */
 751 static int check_uidl (char *line, void *data)
 752 {
 753   int i, idx;
 754   CONTEXT *ctx = (CONTEXT *)data;
 755
 756   sscanf (line, "%u %s", &idx, line);
 757   for (i = 0; i < ctx->msgcount; i++) {
 758     if (!m_strcmp(ctx->hdrs[i]->data, line)) {
 759       ctx->hdrs[i]->refno = idx;
 760       break;
 761     }
 762   }
 763
 764   return 0;
 765 }
 766
 767 /* reconnect and verify indexes if connection was lost */
 768 static pop_query_status pop_reconnect (CONTEXT * ctx)
 769 {
 770   pop_query_status ret;
 771   pop_data_t *pop_data = (pop_data_t *) ctx->data;
 772   progress_t bar;
 773
 774   if (pop_data->status == POP_CONNECTED)
 775     return PQ_OK;
 776   if (pop_data->status == POP_BYE)
 777     return PQ_NOT_CONNECTED;
 778
 779   for (;;) {
 780     mutt_socket_close (pop_data->conn);
 781
 782     ret = pop_open_connection(pop_data);
 783     if (ret == PQ_OK) {
 784       int i;
 785
 786       bar.msg = _("Verifying message indexes...");
 787       bar.size = 0;
 788       mutt_progress_bar (&bar, 0);
 789
 790       for (i = 0; i < ctx->msgcount; i++)
 791         ctx->hdrs[i]->refno = -1;
 792
 793       ret = pop_fetch_data(pop_data, "UIDL\r\n", &bar, check_uidl, ctx);
 794       if (ret == PQ_ERR) {
 795         mutt_error ("%s", pop_data->err_msg);
 796         mutt_sleep (2);
 797       }
 798     }
 799     if (ret == PQ_OK)
 800       return PQ_OK;
 801
 802     pop_logout (ctx);
 803
 804     if (ret == PQ_ERR)
 805       return PQ_NOT_CONNECTED;
 806
 807     if (query_quadoption (OPT_POPRECONNECT,
 808                           _("Connection lost. Reconnect to POP server?")) !=
 809         M_YES)
 810       return PQ_NOT_CONNECTED;
 811   }
 812 }
 813
 814 /* write line to file */
 815 static int fetch_message (char *line, void *file)
 816 {
 817   FILE *f = (FILE *) file;
 818
 819   fputs (line, f);
 820   if (fputc ('\n', f) == EOF)
 821     return -1;
 822
 823   return 0;
 824 }
 825
 826 /*
 827  * Read header
 828  * returns:
 829  *  0 on success
 830  * -1 - conection lost,
 831  * -2 - invalid command or execution error,
 832  * -3 - error writing to tempfile
 833  */
 834 static pop_query_status pop_read_header (pop_data_t * pop_data, HEADER * h)
 835 {
 836   FILE *f;
 837   int idx;
 838   pop_query_status ret;
 839   long length;
 840   char buf[LONG_STRING];
 841
 842   f = tmpfile();
 843   if (!f) {
 844     mutt_error(_("Could not create temporary file"));
 845     return PFD_FUNCT_ERROR;
 846   }
 847
 848   ret = pop_query(pop_data, buf, sizeof(buf), "LIST %d", h->refno);
 849   if (ret == PQ_OK) {
 850     sscanf (buf, "+OK %d %ld", &idx, &length);
 851
 852     snprintf (buf, sizeof (buf), "TOP %d 0\r\n", h->refno);
 853     ret = pop_fetch_data(pop_data, buf, NULL, fetch_message, f);
 854
 855     if (pop_data->cmd_top == CMD_UNKNOWN) {
 856       if (ret == PQ_OK) {
 857         pop_data->cmd_top = CMD_AVAILABLE;
 858       }
 859
 860       if (ret == PQ_ERR) {
 861         pop_data->cmd_top = CMD_NOT_AVAILABLE;
 862         snprintf (pop_data->err_msg, sizeof (pop_data->err_msg),
 863                   _("Command TOP is not supported by server."));
 864       }
 865     }
 866   }
 867
 868   switch (ret) {
 869   case PQ_OK:
 870     {
 871       rewind (f);
 872       h->env = mutt_read_rfc822_header (f, h, 0, 0);
 873       h->content->length = length - h->content->offset + 1;
 874       rewind (f);
 875       while (!feof (f)) {
 876         h->content->length--;
 877         fgets (buf, sizeof (buf), f);
 878       }
 879       break;
 880     }
 881   case PQ_ERR:
 882     {
 883       mutt_error ("%s", pop_data->err_msg);
 884       break;
 885     }
 886   case PFD_FUNCT_ERROR:
 887     {
 888       mutt_error _("Can't write header to temporary file!");
 889
 890       break;
 891     }
 892   case PQ_NOT_CONNECTED:
 893     {
 894       mutt_error _("Can't fetch header: Not connected!");
 895       break;
 896     }
 897   }
 898
 899   m_fclose(&f);
 900   return ret;
 901 }
 902
 903 /* parse UIDL */
 904 static int fetch_uidl (char *line, void *data)
 905 {
 906   int i, idx;
 907   CONTEXT *ctx = (CONTEXT *) data;
 908   pop_data_t *pop_data = (pop_data_t *) ctx->data;
 909
 910   sscanf (line, "%d %s", &idx, line);
 911   for (i = 0; i < ctx->msgcount; i++)
 912     if (!m_strcmp(line, ctx->hdrs[i]->data))
 913       break;
 914
 915   if (i == ctx->msgcount) {
 916     if (i >= ctx->hdrmax)
 917       mx_alloc_memory (ctx);
 918
 919     ctx->msgcount++;
 920     ctx->hdrs[i] = header_new();
 921     ctx->hdrs[i]->data = m_strdup(line);
 922   }
 923   else if (ctx->hdrs[i]->index != idx - 1)
 924     pop_data->clear_cache = 1;
 925
 926   ctx->hdrs[i]->refno = idx;
 927   ctx->hdrs[i]->index = idx - 1;
 928
 929   return 0;
 930 }
 931
 932 /*
 933  * Read headers
 934  * returns:
 935  *  0 on success
 936  * -1 - conection lost,
 937  * -2 - invalid command or execution error,
 938  * -3 - error writing to tempfile
 939  */
 940 static int pop_fetch_headers (CONTEXT * ctx)
 941 {
 942   int i, old_count, new_count;
 943   pop_query_status ret;
 944   pop_data_t *pop_data = (pop_data_t *) ctx->data;
 945
 946   time (&pop_data->check_time);
 947   pop_data->clear_cache = 0;
 948
 949   for (i = 0; i < ctx->msgcount; i++)
 950     ctx->hdrs[i]->refno = -1;
 951
 952   old_count = ctx->msgcount;
 953   ret = pop_fetch_data(pop_data, "UIDL\r\n", NULL, fetch_uidl, ctx);
 954   new_count = ctx->msgcount;
 955   ctx->msgcount = old_count;
 956
 957   if (pop_data->cmd_uidl == CMD_UNKNOWN) {
 958     if (ret == PQ_OK) {
 959       pop_data->cmd_uidl = CMD_AVAILABLE;
 960     }
 961
 962     if (ret == PQ_ERR && pop_data->cmd_uidl == CMD_UNKNOWN) {
 963       pop_data->cmd_uidl = CMD_NOT_AVAILABLE;
 964
 965       snprintf (pop_data->err_msg, sizeof (pop_data->err_msg),
 966                 _("Command UIDL is not supported by server."));
 967     }
 968   }
 969
 970   if (ret == PQ_OK) {
 971     for (i = 0; i < old_count; i++)
 972       if (ctx->hdrs[i]->refno == -1)
 973         ctx->hdrs[i]->deleted = 1;
 974
 975     for (i = old_count; i < new_count; i++) {
 976       mutt_message (_("Fetching message headers... [%d/%d]"),
 977                     i + 1 - old_count, new_count - old_count);
 978
 979       ret = pop_read_header (pop_data, ctx->hdrs[i]);
 980       if (ret != PQ_OK)
 981         break;
 982
 983       ctx->msgcount++;
 984     }
 985
 986     if (i > old_count)
 987       mx_update_context (ctx, i - old_count);
 988   }
 989
 990   if (ret != PQ_OK) {
 991     for (i = ctx->msgcount; i < new_count; i++)
 992       header_delete(&ctx->hdrs[i]);
 993     return ret;
 994   }
 995
 996   mutt_clear_error ();
 997   return (new_count - old_count);
 998 }
 999
1000 /* delete all cached messages */
1001 static void pop_clear_cache (pop_data_t * pop_data)
1002 {
1003   int i;
1004
1005   if (!pop_data->clear_cache)
1006     return;
1007
1008   for (i = 0; i < POP_CACHE_LEN; i++) {
1009     if (pop_data->cache[i].path) {
1010       unlink (pop_data->cache[i].path);
1011       p_delete(&pop_data->cache[i].path);
1012     }
1013   }
1014 }
1015
1016 /* pop_mx functions {{{ */
1017
1018 static int pop_is_magic(const char* path, struct stat* st)
1019 {
1020     url_scheme_t s = url_check_scheme(NONULL(path));
1021     return s == U_POP || s == U_POPS ? M_POP : -1;
1022 }
1023
1024 static int pop_open_mailbox (CONTEXT * ctx)
1025 {
1026   int ret;
1027   char buf[LONG_STRING];
1028   CONNECTION *conn;
1029   ACCOUNT act;
1030   pop_data_t *pop_data;
1031   ciss_url_t url;
1032
1033   if (pop_parse_path (ctx->path, &act)) {
1034     mutt_error (_("%s is an invalid POP path"), ctx->path);
1035     mutt_sleep (2);
1036     return -1;
1037   }
1038
1039   mutt_account_tourl (&act, &url);
1040   url.path = NULL;
1041   url_ciss_tostring (&url, buf, sizeof (buf), 0);
1042   conn = mutt_conn_find (NULL, &act);
1043   if (!conn)
1044     return -1;
1045
1046   p_delete(&ctx->path);
1047   ctx->path = m_strdup(buf);
1048
1049   pop_data = p_new(pop_data_t, 1);
1050   pop_data->conn = conn;
1051   ctx->data = pop_data;
1052
1053   if (pop_open_connection(pop_data) != PQ_OK)
1054     return -1;
1055
1056   conn->data = pop_data;
1057
1058   for (;;) {
1059     if (pop_reconnect (ctx) != PQ_OK)
1060       return -1;
1061
1062     mutt_message _("Fetching list of messages...");
1063     ctx->size = pop_data->size;
1064     ret = pop_fetch_headers (ctx);
1065
1066     if (ret >= 0)
1067       return 0;
1068
1069     if (ret < -1) {
1070       mutt_sleep (2);
1071       return -1;
1072     }
1073   }
1074 }
1075
1076 static int pop_acl_check(CONTEXT *ctx, int bit)
1077 {
1078     switch (bit) {
1079       case ACL_DELETE:    /* (un)deletion */
1080       case ACL_SEEN:      /* mark as read */
1081         return 1;
1082       case ACL_INSERT:    /* editing messages */
1083       case ACL_WRITE:     /* change importance */
1084       default:
1085         return 0;
1086     }
1087 }
1088
1089 static int pop_check_mailbox(CONTEXT * ctx, int *index_hint, int unused)
1090 {
1091   int ret;
1092   pop_data_t *pop_data = (pop_data_t *) ctx->data;
1093
1094   if ((pop_data->check_time + PopCheckTimeout) > time (NULL))
1095     return 0;
1096
1097   pop_logout (ctx);
1098
1099   mutt_socket_close (pop_data->conn);
1100
1101   if (pop_open_connection (pop_data) < 0)
1102     return -1;
1103
1104   mutt_message _("Checking for new messages...");
1105   ctx->size = pop_data->size;
1106   ret = pop_fetch_headers (ctx);
1107   pop_clear_cache (pop_data);
1108
1109   if (ret < 0)
1110     return -1;
1111
1112   if (ret > 0)
1113     return M_NEW_MAIL;
1114
1115   return 0;
1116 }
1117
1118 static void pop_close_mailbox (CONTEXT * ctx)
1119 {
1120   pop_data_t *pop_data = (pop_data_t *) ctx->data;
1121
1122   if (!pop_data)
1123     return;
1124
1125   pop_logout (ctx);
1126
1127   if (pop_data->status != POP_NONE)
1128     mutt_socket_close (pop_data->conn);
1129
1130   pop_data->status = POP_NONE;
1131
1132   pop_data->clear_cache = 1;
1133   pop_clear_cache (pop_data);
1134
1135   if (!pop_data->conn->data)
1136     mutt_socket_free (pop_data->conn);
1137
1138   return;
1139 }
1140
1141 static int pop_sync_mailbox(CONTEXT * ctx, int unused, int *index_hint)
1142 {
1143   int i;
1144   pop_query_status ret;
1145   char buf[LONG_STRING];
1146   pop_data_t *pop_data = (pop_data_t *) ctx->data;
1147
1148   pop_data->check_time = 0;
1149
1150   for (;;) {
1151     if (pop_reconnect (ctx) != PQ_OK)
1152       return PQ_NOT_CONNECTED;
1153
1154     mutt_message (_("Marking %d messages deleted..."), ctx->deleted);
1155
1156     for (i = 0, ret = 0; ret == 0 && i < ctx->msgcount; i++) {
1157       if (ctx->hdrs[i]->deleted) {
1158         ret = pop_query(pop_data, buf, sizeof(buf), "DELE %d",
1159                         ctx->hdrs[i]->refno);
1160       }
1161     }
1162
1163     if (ret == PQ_OK) {
1164       ret = pop_query(pop_data, buf, sizeof(buf), "QUIT");
1165     }
1166
1167     if (ret == PQ_OK) {
1168       pop_data->clear_cache = 1;
1169       pop_clear_cache (pop_data);
1170       pop_data->status = POP_DISCONNECTED;
1171       return PQ_OK;
1172     }
1173
1174     if (ret == PQ_ERR) {
1175       mutt_error ("%s", pop_data->err_msg);
1176       mutt_sleep (2);
1177       return PQ_NOT_CONNECTED;
1178     }
1179   }
1180 }
1181
1182 /* }}} */
1183
1184 mx_t const pop_mx = {
1185     M_POP,
1186     0,
1187     pop_is_magic,
1188     NULL,
1189     NULL,
1190     pop_open_mailbox,
1191     NULL,
1192     pop_acl_check,
1193     pop_check_mailbox,
1194     pop_close_mailbox,
1195     pop_sync_mailbox,
1196     NULL,
1197 };
1198
1199 /* public API {{{ */
1200
1201 void pop_fetch_mail (void)
1202 {
1203   char buffer[LONG_STRING];
1204   char msgbuf[STRING];
1205   char *url, *p;
1206   int i, delanswer, last = 0, msgs, bytes, rset = 0;
1207   pop_query_status ret;
1208   CONNECTION *conn;
1209   CONTEXT ctx;
1210   MESSAGE *msg = NULL;
1211   ACCOUNT act;
1212   pop_data_t *pop_data;
1213   ssize_t plen;
1214
1215   if (m_strisempty(PopHost)) {
1216     mutt_error _("POP host is not defined.");
1217     return;
1218   }
1219
1220   plen = m_strlen(PopHost) + 7;
1221   url  = p = p_new(char, plen);
1222   if (url_check_scheme (PopHost) == U_UNKNOWN) {
1223       snprintf(p, plen, "pop://%s", PopHost);
1224   } else {
1225       m_strcpy(p, plen, PopHost);
1226   }
1227
1228   ret = pop_parse_path (url, &act);
1229   p_delete(&url);
1230   if (ret) {
1231     mutt_error (_("%s is an invalid POP path"), PopHost);
1232     return;
1233   }
1234
1235   conn = mutt_conn_find (NULL, &act);
1236   if (!conn)
1237     return;
1238
1239   pop_data = p_new(pop_data_t, 1);
1240   pop_data->conn = conn;
1241
1242   if (pop_open_connection (pop_data) < 0) {
1243     mutt_socket_free (pop_data->conn);
1244     p_delete(&pop_data);
1245     return;
1246   }
1247
1248   conn->data = pop_data;
1249
1250   mutt_message _("Checking for new messages...");
1251
1252   /* find out how many messages are in the mailbox. */
1253   ret = pop_query(pop_data, buffer, sizeof(buffer), "STAT");
1254   if (ret == PQ_NOT_CONNECTED)
1255     goto fail;
1256   if (ret == PQ_ERR) {
1257     mutt_error ("%s", pop_data->err_msg);
1258     goto finish;
1259   }
1260
1261   sscanf (buffer, "+OK %d %d", &msgs, &bytes);
1262
1263   /* only get unread messages */
1264   if (msgs > 0 && option (OPTPOPLAST)) {
1265     ret = pop_query(pop_data, buffer, sizeof(buffer), "LAST");
1266     if (ret == PQ_NOT_CONNECTED)
1267       goto fail;
1268     if (ret == PQ_OK)
1269       sscanf (buffer, "+OK %d", &last);
1270   }
1271
1272   if (msgs <= last) {
1273     mutt_message _("No new mail in POP mailbox.");
1274
1275     goto finish;
1276   }
1277
1278   if (mx_open_mailbox (NONULL (Spoolfile), M_APPEND, &ctx) == NULL)
1279     goto finish;
1280
1281   delanswer =
1282     query_quadoption (OPT_POPDELETE, _("Delete messages from server?"));
1283
1284   snprintf (msgbuf, sizeof (msgbuf), _("Reading new messages (%d bytes)..."),
1285             bytes);
1286   mutt_message ("%s", msgbuf);
1287
1288   for (i = last + 1; i <= msgs; i++) {
1289     if ((msg = mx_open_new_message (&ctx, NULL, M_ADD_FROM)) == NULL)
1290       ret = -3;
1291     else {
1292       snprintf (buffer, sizeof (buffer), "RETR %d\r\n", i);
1293       ret = pop_fetch_data(pop_data, buffer, NULL, fetch_message, msg->fp);
1294       if (ret == PFD_FUNCT_ERROR)
1295         rset = 1;
1296
1297       if (ret == PQ_OK && mx_commit_message (msg, &ctx) != 0) {
1298         rset = 1;
1299         ret = PFD_FUNCT_ERROR;
1300       }
1301
1302       mx_close_message (&msg);
1303     }
1304
1305     if (ret == PQ_OK && delanswer == M_YES) {
1306       ret = pop_query(pop_data, buffer, sizeof(buffer), "DELE %d", i);
1307     }
1308
1309     if (ret == PQ_NOT_CONNECTED) {
1310       mx_close_mailbox (&ctx, NULL);
1311       goto fail;
1312     }
1313     if (ret == PQ_ERR) {
1314       mutt_error ("%s", pop_data->err_msg);
1315       break;
1316     }
1317     if (ret == -3) { /* this is -3 when ret != 0, because it will keep the value from before *gna* */
1318       mutt_error _("Error while writing mailbox!");
1319
1320       break;
1321     }
1322
1323     mutt_message (_("%s [%d of %d messages read]"), msgbuf, i - last,
1324                   msgs - last);
1325   }
1326
1327   mx_close_mailbox (&ctx, NULL);
1328
1329   if (rset) {
1330     /* make sure no messages get deleted */
1331     if (pop_query(pop_data, buffer, sizeof(buffer), "RSET") ==
1332         PQ_NOT_CONNECTED)
1333       goto fail;
1334   }
1335
1336 finish:
1337   if (pop_query(pop_data, buffer, sizeof(buffer), "QUIT") == PQ_NOT_CONNECTED)
1338     goto fail;
1339   mutt_socket_close (conn);
1340   p_delete(&pop_data);
1341   return;
1342
1343 fail:
1344   mutt_error _("Server closed connection!");
1345   mutt_socket_close (conn);
1346   p_delete(&pop_data);
1347 }
1348
1349 /* fetch message from POP server */
1350 int pop_fetch_message (MESSAGE * msg, CONTEXT * ctx, int msgno)
1351 {
1352   int ret;
1353   void *uidl;
1354   char buf[LONG_STRING];
1355   char path[_POSIX_PATH_MAX];
1356   progress_t bar;
1357   pop_data_t *pop_data = (pop_data_t *) ctx->data;
1358   POP_CACHE *cache;
1359   HEADER *h = ctx->hdrs[msgno];
1360
1361   /* see if we already have the message in our cache */
1362   cache = &pop_data->cache[h->index % POP_CACHE_LEN];
1363
1364   if (cache->path) {
1365     if (cache->index == h->index) {
1366       /* yes, so just return a pointer to the message */
1367       msg->fp = fopen (cache->path, "r");
1368       if (msg->fp)
1369         return 0;
1370
1371       mutt_perror (cache->path);
1372       mutt_sleep (2);
1373       return -1;
1374     }
1375     else {
1376       /* clear the previous entry */
1377       unlink (cache->path);
1378       p_delete(&cache->path);
1379     }
1380   }
1381
1382   for (;;) {
1383     if (pop_reconnect (ctx) != PQ_OK)
1384       return -1;
1385
1386     /* verify that massage index is correct */
1387     if (h->refno < 0) {
1388       mutt_error
1389         _("The message index is incorrect. Try reopening the mailbox.");
1390       mutt_sleep (2);
1391       return -1;
1392     }
1393
1394     bar.size = h->content->length + h->content->offset - 1;
1395     bar.msg = _("Fetching message...");
1396     mutt_progress_bar (&bar, 0);
1397
1398     msg->fp = m_tempfile(path, sizeof(path), NONULL(mod_core.tmpdir), NULL);
1399     if (!msg->fp) {
1400       mutt_error(_("Could not create temporary file"));
1401       mutt_sleep(2);
1402       return -1;
1403     }
1404
1405     snprintf(buf, sizeof(buf), "RETR %d\r\n", h->refno);
1406     ret = pop_fetch_data(pop_data, buf, &bar, fetch_message, msg->fp);
1407     if (ret == PQ_OK)
1408       break;
1409
1410     m_fclose(&msg->fp);
1411     unlink (path);
1412
1413     if (ret == PQ_ERR) {
1414       mutt_error ("%s", pop_data->err_msg);
1415       mutt_sleep (2);
1416       return -1;
1417     }
1418
1419     if (ret == PFD_FUNCT_ERROR) {
1420       mutt_error _("Can't write message to temporary file!");
1421
1422       mutt_sleep (2);
1423       return -1;
1424     }
1425   }
1426
1427   /* Update the header information.  Previously, we only downloaded a
1428    * portion of the headers, those required for the main display.
1429    */
1430   cache->index = h->index;
1431   cache->path = m_strdup(path);
1432   rewind (msg->fp);
1433   uidl = h->data;
1434   envelope_delete(&h->env);
1435   h->env = mutt_read_rfc822_header (msg->fp, h, 0, 0);
1436   h->data = uidl;
1437   h->lines = 0;
1438   fgets (buf, sizeof (buf), msg->fp);
1439   while (!feof (msg->fp)) {
1440     ctx->hdrs[msgno]->lines++;
1441     fgets (buf, sizeof (buf), msg->fp);
1442   }
1443
1444   h->content->length = ftello (msg->fp) - h->content->offset;
1445
1446   /* This needs to be done in case this is a multipart message */
1447   h->security = crypt_query (h->content);
1448
1449   mutt_clear_error ();
1450   rewind (msg->fp);
1451
1452   return 0;
1453 }
1454
1455 /* }}} */