Pileus Git - ~andy/fetchmail/blob - driver.c

   1 /*
   2  * driver.c -- generic driver for mail fetch method protocols
   3  *
   4  * Copyright 1997 by Eric S. Raymond
   5  * For license terms, see the file COPYING in this directory.
   6  */
   7
   8 #include  "config.h"
   9 #include  <stdio.h>
  10 #include  <setjmp.h>
  11 #include  <errno.h>
  12 #include  <string.h>
  13 #ifdef HAVE_MEMORY_H
  14 #include  <memory.h>
  15 #endif /* HAVE_MEMORY_H */
  16 #if defined(STDC_HEADERS)
  17 #include  <stdlib.h>
  18 #include  <limits.h>
  19 #endif
  20 #if defined(HAVE_UNISTD_H)
  21 #include <unistd.h>
  22 #endif
  23 #if defined(HAVE_SYS_ITIMER_H)
  24 #include <sys/itimer.h>
  25 #endif
  26 #include  <signal.h>
  27 #ifdef HAVE_SYS_WAIT_H
  28 #include <sys/wait.h>
  29 #endif
  30
  31 #ifdef HAVE_SYS_SOCKET_H
  32 #include <sys/socket.h>
  33 #endif
  34 #ifdef HAVE_NET_SOCKET_H
  35 #include <net/socket.h>
  36 #endif
  37 #include <netdb.h>
  38 #ifdef HAVE_PKG_hesiod
  39 #include <hesiod.h>
  40 #endif
  41
  42 #include <langinfo.h>
  43
  44 #include "kerberos.h"
  45 #ifdef KERBEROS_V4
  46 #include <netinet/in.h>
  47 #endif /* KERBEROS_V4 */
  48
  49 #include "i18n.h"
  50 #include "socket.h"
  51
  52 #include "fetchmail.h"
  53 #include "getaddrinfo.h"
  54 #include "tunable.h"
  55
  56 /* throw types for runtime errors */
  57 #define THROW_TIMEOUT   1               /* server timed out */
  58 #define THROW_SIGPIPE   2               /* SIGPIPE on stream socket */
  59
  60 /* magic values for the message length array */
  61 #define MSGLEN_UNKNOWN  0               /* length unknown (0 is impossible) */
  62 #define MSGLEN_INVALID  -1              /* length passed back is invalid */
  63 #define MSGLEN_TOOLARGE -2              /* message is too large */
  64 #define MSGLEN_OLD      -3              /* message is old */
  65
  66 int pass;               /* how many times have we re-polled? */
  67 int stage;              /* where are we? */
  68 int phase;              /* where are we, for error-logging purposes? */
  69 int batchcount;         /* count of messages sent in current batch */
  70 flag peek_capable;      /* can we peek for better error recovery? */
  71 int mailserver_socket_temp = -1;        /* socket to free if connect timeout */
  72
  73 struct addrinfo *ai0, *ai1;     /* clean these up after signal */
  74
  75 static volatile int timeoutcount = 0;   /* count consecutive timeouts */
  76 static volatile int idletimeout = 0;    /* timeout occured in idle stage? */
  77
  78 static sigjmp_buf       restart;
  79
  80 int is_idletimeout(void)
  81 /* last timeout occured in idle stage? */
  82 {
  83     return idletimeout;
  84 }
  85
  86 void resetidletimeout(void)
  87 {
  88     idletimeout = 0;
  89 }
  90
  91 void set_timeout(int timeleft)
  92 /* reset the nonresponse-timeout */
  93 {
  94 #if !defined(__EMX__) && !defined(__BEOS__)
  95     struct itimerval ntimeout;
  96
  97     if (timeleft == 0)
  98         timeoutcount = 0;
  99
 100     ntimeout.it_interval.tv_sec = ntimeout.it_interval.tv_usec = 0;
 101     ntimeout.it_value.tv_sec  = timeleft;
 102     ntimeout.it_value.tv_usec = 0;
 103     setitimer(ITIMER_REAL, &ntimeout, (struct itimerval *)NULL);
 104 #endif
 105 }
 106
 107 static RETSIGTYPE timeout_handler (int signal)
 108 /* handle SIGALRM signal indicating a server timeout */
 109 {
 110     (void)signal;
 111     if(stage != STAGE_IDLE) {
 112         timeoutcount++;
 113         siglongjmp(restart, THROW_TIMEOUT);
 114     } else
 115         idletimeout = 1;
 116 }
 117
 118 static RETSIGTYPE sigpipe_handler (int signal)
 119 /* handle SIGPIPE signal indicating a broken stream socket */
 120 {
 121     (void)signal;
 122     siglongjmp(restart, THROW_SIGPIPE);
 123 }
 124
 125 #define CLEANUP_TIMEOUT 60 /* maximum timeout during cleanup */
 126
 127 static int cleanupSockClose (int fd)
 128 /* close sockets in maximum CLEANUP_TIMEOUT seconds during cleanup */
 129 {
 130     int scerror;
 131     SIGHANDLERTYPE alrmsave;
 132     alrmsave = set_signal_handler(SIGALRM, null_signal_handler);
 133     set_timeout(CLEANUP_TIMEOUT);
 134     scerror = SockClose(fd);
 135     set_timeout(0);
 136     set_signal_handler(SIGALRM, alrmsave);
 137     return (scerror);
 138 }
 139
 140 #ifdef KERBEROS_V4
 141 static int kerberos_auth(socket, canonical, principal)
 142 /* authenticate to the server host using Kerberos V4 */
 143 int socket;             /* socket to server host */
 144 char *canonical;        /* server name */
 145 char *principal;
 146 {
 147     KTEXT ticket;
 148     MSG_DAT msg_data;
 149     CREDENTIALS cred;
 150     Key_schedule schedule;
 151     int rem;
 152     char * prin_copy = (char *) NULL;
 153     char * prin = (char *) NULL;
 154     char * inst = (char *) NULL;
 155     char * realm = (char *) NULL;
 156
 157     if (principal != (char *)NULL && *principal)
 158     {
 159         char *cp;
 160         prin = prin_copy = xstrdup(principal);
 161         for (cp = prin_copy; *cp && *cp != '.'; ++cp)
 162             ;
 163         if (*cp)
 164         {
 165             *cp++ = '\0';
 166             inst = cp;
 167             while (*cp && *cp != '@')
 168                 ++cp;
 169             if (*cp)
 170             {
 171                 *cp++ = '\0';
 172                 realm = cp;
 173             }
 174         }
 175     }
 176
 177     ticket = xmalloc(sizeof (KTEXT_ST));
 178     rem = (krb_sendauth (0L, socket, ticket,
 179                          prin ? prin : "pop",
 180                          inst ? inst : canonical,
 181                          realm ? realm : ((char *) (krb_realmofhost (canonical))),
 182                          ((unsigned long) 0),
 183                          (&msg_data),
 184                          (&cred),
 185                          (schedule),
 186                          ((struct sockaddr_in *) 0),
 187                          ((struct sockaddr_in *) 0),
 188                          "KPOPV0.1"));
 189     free(ticket);
 190     if (prin_copy)
 191     {
 192         free(prin_copy);
 193     }
 194     if (rem != KSUCCESS)
 195     {
 196         report(stderr, GT_("kerberos error %s\n"), (krb_get_err_text (rem)));
 197         return (PS_AUTHFAIL);
 198     }
 199     return (0);
 200 }
 201 #endif /* KERBEROS_V4 */
 202
 203 #ifdef KERBEROS_V5
 204 static int kerberos5_auth(socket, canonical)
 205 /* authenticate to the server host using Kerberos V5 */
 206 int socket;             /* socket to server host */
 207 const char *canonical;  /* server name */
 208 {
 209     krb5_error_code retval;
 210     krb5_context context;
 211     krb5_ccache ccdef;
 212     krb5_principal client = NULL, server = NULL;
 213     krb5_error *err_ret = NULL;
 214
 215     krb5_auth_context auth_context = NULL;
 216
 217     krb5_init_context(&context);
 218     krb5_auth_con_init(context, &auth_context);
 219
 220     if ((retval = krb5_cc_default(context, &ccdef))) {
 221         report(stderr, "krb5_cc_default: %s\n", error_message(retval));
 222         return(PS_ERROR);
 223     }
 224
 225     if ((retval = krb5_cc_get_principal(context, ccdef, &client))) {
 226         report(stderr, "krb5_cc_get_principal: %s\n", error_message(retval));
 227         return(PS_ERROR);
 228     }
 229
 230     if ((retval = krb5_sname_to_principal(context, canonical, "pop",
 231            KRB5_NT_UNKNOWN,
 232            &server))) {
 233         report(stderr, "krb5_sname_to_principal: %s\n", error_message(retval));
 234         return(PS_ERROR);
 235     }
 236
 237     retval = krb5_sendauth(context, &auth_context, (krb5_pointer) &socket,
 238          "KPOPV1.0", client, server,
 239          AP_OPTS_MUTUAL_REQUIRED,
 240          NULL,  /* no data to checksum */
 241          0,   /* no creds, use ccache instead */
 242          ccdef,
 243          &err_ret, 0,
 244
 245          NULL); /* don't need reply */
 246
 247     krb5_free_principal(context, server);
 248     krb5_free_principal(context, client);
 249     krb5_auth_con_free(context, auth_context);
 250
 251     if (retval) {
 252 #ifdef HEIMDAL
 253       if (err_ret && err_ret->e_text) {
 254           report(stderr, GT_("krb5_sendauth: %s [server says '%*s'] \n"),
 255                  error_message(retval),
 256                  err_ret->e_text);
 257 #else
 258       if (err_ret && err_ret->text.length) {
 259           report(stderr, GT_("krb5_sendauth: %s [server says '%*s'] \n"),
 260                  error_message(retval),
 261                  err_ret->text.length,
 262                  err_ret->text.data);
 263 #endif
 264           krb5_free_error(context, err_ret);
 265       } else
 266           report(stderr, "krb5_sendauth: %s\n", error_message(retval));
 267       return(PS_ERROR);
 268     }
 269
 270     return 0;
 271 }
 272 #endif /* KERBEROS_V5 */
 273
 274 static void clean_skipped_list(struct idlist **skipped_list)
 275 /* struct "idlist" contains no "prev" ptr; we must remove unused items first */
 276 {
 277     struct idlist *current=NULL, *prev=NULL, *tmp=NULL, *head=NULL;
 278     prev = current = head = *skipped_list;
 279
 280     if (!head)
 281         return;
 282     do
 283     {
 284         /* if item has no reference, remove it */
 285         if (current && current->val.status.mark == 0)
 286         {
 287             if (current == head) /* remove first item (head) */
 288             {
 289                 head = current->next;
 290                 if (current->id) free(current->id);
 291                 free(current);
 292                 prev = current = head;
 293             }
 294             else /* remove middle/last item */
 295             {
 296                 tmp = current->next;
 297                 prev->next = tmp;
 298                 if (current->id) free(current->id);
 299                 free(current);
 300                 current = tmp;
 301             }
 302         }
 303         else /* skip this item */
 304         {
 305             prev = current;
 306             current = current->next;
 307         }
 308     } while(current);
 309
 310     *skipped_list = head;
 311 }
 312
 313 static void send_size_warnings(struct query *ctl)
 314 /* send warning mail with skipped msg; reset msg count when user notified */
 315 {
 316     int size, nbr;
 317     int msg_to_send = FALSE;
 318     struct idlist *head=NULL, *current=NULL;
 319     int max_warning_poll_count;
 320
 321     head = ctl->skipped;
 322     if (!head)
 323         return;
 324
 325     /* don't start a notification message unless we need to */
 326     for (current = head; current; current = current->next)
 327         if (current->val.status.num == 0 && current->val.status.mark)
 328             msg_to_send = TRUE;
 329     if (!msg_to_send)
 330         return;
 331
 332     /*
 333      * There's no good way to recover if we can't send notification mail,
 334      * but it's not a disaster, either, since the skipped mail will not
 335      * be deleted.
 336      */
 337     if (open_warning_by_mail(ctl))
 338         return;
 339     stuff_warning(iana_charset, ctl,
 340            GT_("Subject: Fetchmail oversized-messages warning"));
 341     stuff_warning(NULL, ctl, "%s", "");
 342     if (ctl->limitflush)
 343         stuff_warning(NULL, ctl,
 344                 GT_("The following oversized messages were deleted on server %s account %s:"),
 345                 ctl->server.pollname, ctl->remotename);
 346     else
 347         stuff_warning(NULL, ctl,
 348                 GT_("The following oversized messages remain on server %s account %s:"),
 349                 ctl->server.pollname, ctl->remotename);
 350
 351     stuff_warning(NULL, ctl, "%s", "");
 352
 353     if (run.poll_interval == 0)
 354         max_warning_poll_count = 0;
 355     else
 356         max_warning_poll_count = ctl->warnings/run.poll_interval;
 357
 358     /* parse list of skipped msg, adding items to the mail */
 359     for (current = head; current; current = current->next)
 360     {
 361         if (current->val.status.num == 0 && current->val.status.mark)
 362         {
 363             nbr = current->val.status.mark;
 364             size = atoi(current->id);
 365             if (ctl->limitflush)
 366                 stuff_warning(NULL, ctl,
 367                         GT_("  %d msg %d octets long deleted by fetchmail."),
 368                         nbr, size);
 369             else
 370                 stuff_warning(NULL, ctl,
 371                         GT_("  %d msg %d octets long skipped by fetchmail."),
 372                         nbr, size);
 373         }
 374         current->val.status.num++;
 375         current->val.status.mark = 0;
 376
 377         if (current->val.status.num >= max_warning_poll_count)
 378             current->val.status.num = 0;
 379     }
 380
 381     stuff_warning(NULL, ctl, "%s", "");
 382
 383     close_warning_by_mail(ctl, (struct msgblk *)NULL);
 384 }
 385
 386 static void mark_oversized(struct query *ctl, int size)
 387 /* mark a message oversized */
 388 {
 389     struct idlist *current=NULL, *tmp=NULL;
 390     char sizestr[32];
 391     int cnt;
 392
 393     /* convert size to string */
 394     snprintf(sizestr, sizeof(sizestr), "%d", size);
 395
 396     /* build a list of skipped messages
 397      * val.id = size of msg (string cnvt)
 398      * val.status.num = warning_poll_count
 399      * val.status.mask = nbr of msg this size
 400      */
 401
 402     current = ctl->skipped;
 403
 404     /* initialise warning_poll_count to the
 405      * current value so that all new msg will
 406      * be included in the next mail
 407      */
 408     cnt = current ? current->val.status.num : 0;
 409
 410     /* if entry exists, increment the count */
 411     if (current && (tmp = str_in_list(&current, sizestr, FALSE)))
 412     {
 413         tmp->val.status.mark++;
 414     }
 415     /* otherwise, create a new entry */
 416     /* initialise with current poll count */
 417     else
 418     {
 419         tmp = save_str(&ctl->skipped, sizestr, 1);
 420         tmp->val.status.num = cnt;
 421     }
 422 }
 423
 424 static int fetch_messages(int mailserver_socket, struct query *ctl,
 425                           int count, int **msgsizes, int maxfetch,
 426                           int *fetches, int *dispatches, int *deletions)
 427 /* fetch messages in lockstep mode */
 428 {
 429     flag force_retrieval;
 430     int num, firstnum = 1, lastnum = 0, err, len;
 431     int fetchsizelimit = ctl->fetchsizelimit;
 432     int msgsize;
 433     int initialfetches = *fetches;
 434
 435     if (ctl->server.base_protocol->getpartialsizes && NUM_NONZERO(fetchsizelimit))
 436     {
 437         /* for POP3, we can get the size of one mail only! Unfortunately, this
 438          * protocol specific test cannot be done elsewhere as the protocol
 439          * could be "auto". */
 440         switch (ctl->server.protocol)
 441         {
 442             case P_POP3: case P_APOP: case P_RPOP:
 443             fetchsizelimit = 1;
 444         }
 445
 446         /* Time to allocate memory to store the sizes */
 447         xfree(*msgsizes);
 448         *msgsizes = (int *)xmalloc(sizeof(int) * fetchsizelimit);
 449     }
 450
 451     /*
 452      * What forces this code is that in POP2 and
 453      * IMAP2bis you can't fetch a message without
 454      * having it marked `seen'.  In POP3 and IMAP4, on the
 455      * other hand, you can (peek_capable is set by
 456      * each driver module to convey this; it's not a
 457      * method constant because of the difference between
 458      * IMAP2bis and IMAP4, and because POP3 doesn't  peek
 459      * if fetchall is on).
 460      *
 461      * The result of being unable to peek is that if there's
 462      * any kind of transient error (DNS lookup failure, or
 463      * sendmail refusing delivery due to process-table limits)
 464      * the message will be marked "seen" on the server without
 465      * having been delivered.  This is not a big problem if
 466      * fetchmail is running in foreground, because the user
 467      * will see a "skipped" message when it next runs and get
 468      * clued in.
 469      *
 470      * But in daemon mode this leads to the message
 471      * being silently ignored forever.  This is not
 472      * acceptable.
 473      *
 474      * We compensate for this by checking the error
 475      * count from the previous pass and forcing all
 476      * messages to be considered new if it's nonzero.
 477      */
 478     force_retrieval = !peek_capable && (ctl->errcount > 0);
 479
 480     for (num = 1; num <= count; num++)
 481     {
 482         flag suppress_delete = FALSE;
 483         flag suppress_forward = FALSE;
 484         flag suppress_readbody = FALSE;
 485         flag retained = FALSE;
 486         int msgcode = MSGLEN_UNKNOWN;
 487
 488         /* check if the message is old
 489          * Note: the size of the message may not be known here */
 490         if (ctl->fetchall || force_retrieval)
 491             ;
 492         else if (ctl->server.base_protocol->is_old && (ctl->server.base_protocol->is_old)(mailserver_socket,ctl,num))
 493             msgcode = MSGLEN_OLD;
 494         if (msgcode == MSGLEN_OLD)
 495         {
 496                 /* To avoid flooding the syslog when using --keep,
 497                  * report "Skipped message" only when:
 498                  *  1) --verbose is on, or
 499                  *  2) fetchmail does not use syslog
 500                  */
 501             if (   (outlevel >= O_VERBOSE) ||
 502                    (outlevel > O_SILENT && !run.use_syslog)
 503                )
 504             {
 505                 report_build(stdout,
 506                              GT_("skipping message %s@%s:%d"),
 507                              ctl->remotename, ctl->server.truename, num);
 508             }
 509
 510             goto flagthemail;
 511         }
 512
 513         if (ctl->server.base_protocol->getpartialsizes && NUM_NONZERO(fetchsizelimit) &&
 514             lastnum < num)
 515         {
 516             /* Instead of getting the sizes of all mails at the start, we get
 517              * the sizes in blocks of fetchsizelimit. This leads to better
 518              * performance when there are too many mails (say, 10000) in
 519              * the mailbox and either we are not getting all the mails at
 520              * one go (--fetchlimit 100) or there is a frequent socket
 521              * error while just getting the sizes of all mails! */
 522
 523             int i;
 524             int oldstage = stage;
 525             firstnum = num;
 526             lastnum = num + fetchsizelimit - 1;
 527             if (lastnum > count)
 528                 lastnum = count;
 529             for (i = 0; i < fetchsizelimit; i++)
 530                 (*msgsizes)[i] = 0;
 531
 532             stage = STAGE_GETSIZES;
 533             err = (ctl->server.base_protocol->getpartialsizes)(mailserver_socket, num, lastnum, *msgsizes);
 534             if (err != 0) {
 535                 return err;
 536             }
 537             stage = oldstage;
 538         }
 539
 540         msgsize = *msgsizes ? (*msgsizes)[num-firstnum] : 0;
 541
 542         /* check if the message is oversized */
 543         if (NUM_NONZERO(ctl->limit) && (msgsize > ctl->limit))
 544             msgcode = MSGLEN_TOOLARGE;
 545 /*      else if (msgsize == 512)
 546             msgcode = MSGLEN_OLD;  (hmh) sample code to skip message */
 547
 548         if (msgcode < 0)
 549         {
 550             if (msgcode == MSGLEN_TOOLARGE)
 551             {
 552                 mark_oversized(ctl, msgsize);
 553                 if (!ctl->limitflush)
 554                     suppress_delete = TRUE;
 555             }
 556             if (outlevel > O_SILENT)
 557             {
 558                 /* old messages are already handled above */
 559                 report_build(stdout,
 560                              GT_("skipping message %s@%s:%d (%d octets)"),
 561                              ctl->remotename, ctl->server.truename, num,
 562                              msgsize);
 563                 switch (msgcode)
 564                 {
 565                 case MSGLEN_INVALID:
 566                     /*
 567                      * Invalid lengths are produced by Post Office/NT's
 568                      * annoying habit of randomly prepending bogus
 569                      * LIST items of length -1.  Patrick Audley
 570                      * <paudley@pobox.com> tells us: LIST shows a
 571                      * size of -1, RETR and TOP return "-ERR
 572                      * System error - couldn't open message", and
 573                      * DELE succeeds but doesn't actually delete
 574                      * the message.
 575                      */
 576                     report_build(stdout, GT_(" (length -1)"));
 577                     break;
 578                 case MSGLEN_TOOLARGE:
 579                     report_build(stdout, GT_(" (oversized)"));
 580                     break;
 581                 }
 582             }
 583         }
 584         else
 585         {
 586             flag wholesize = !ctl->server.base_protocol->fetch_body;
 587             flag separatefetchbody = (ctl->server.base_protocol->fetch_body) ? TRUE : FALSE;
 588
 589             /* request a message */
 590             err = (ctl->server.base_protocol->fetch_headers)(mailserver_socket,ctl,num, &len);
 591             if (err == PS_TRANSIENT)    /* server is probably Exchange */
 592             {
 593                 report(stdout,
 594                              GT_("couldn't fetch headers, message %s@%s:%d (%d octets)\n"),
 595                              ctl->remotename, ctl->server.truename, num,
 596                              msgsize);
 597                 continue;
 598             }
 599             else if (err != 0)
 600                 return(err);
 601
 602             /* -1 means we didn't see a size in the response */
 603             if (len == -1)
 604             {
 605                 len = msgsize;
 606                 wholesize = TRUE;
 607             }
 608
 609             if (outlevel > O_SILENT)
 610             {
 611                 report_build(stdout, GT_("reading message %s@%s:%d of %d"),
 612                              ctl->remotename, ctl->server.truename,
 613                              num, count);
 614
 615                 if (len > 0)
 616                     report_build(stdout, wholesize ? GT_(" (%d octets)")
 617                                  : GT_(" (%d header octets)"), len);
 618                 if (outlevel >= O_VERBOSE)
 619                     report_complete(stdout, "\n");
 620             }
 621
 622             /*
 623              * Read the message headers and ship them to the
 624              * output sink.
 625              */
 626             err = readheaders(mailserver_socket, len, msgsize,
 627                              ctl, num,
 628                              /* pass the suppress_readbody flag only if the underlying
 629                               * protocol does not fetch the body separately */
 630                              separatefetchbody ? 0 : &suppress_readbody);
 631             if (err == PS_RETAINED)
 632                 suppress_forward = suppress_delete = retained = TRUE;
 633             else if (err == PS_TRANSIENT)
 634                 suppress_delete = suppress_forward = TRUE;
 635             else if (err == PS_REFUSED)
 636                 suppress_forward = TRUE;
 637             else if (err == PS_TRUNCATED)
 638                 suppress_readbody = TRUE;
 639             else if (err)
 640                 return(err);
 641
 642             /* tell server we got it OK and resynchronize */
 643             if (separatefetchbody && ctl->server.base_protocol->trail)
 644             {
 645                 if (outlevel >= O_VERBOSE && !is_a_file(1) && !run.use_syslog)
 646                 {
 647                     fputc('\n', stdout);
 648                     fflush(stdout);
 649                 }
 650
 651                 if ((err = (ctl->server.base_protocol->trail)(mailserver_socket, ctl, tag)))
 652                     return(err);
 653             }
 654
 655             /* do not read the body which is not being forwarded only if
 656              * the underlying protocol allows the body to be fetched
 657              * separately */
 658             if (separatefetchbody && suppress_forward)
 659                 suppress_readbody = TRUE;
 660
 661             /*
 662              * If we're using IMAP4 or something else that
 663              * can fetch headers separately from bodies,
 664              * it's time to request the body now.  This
 665              * fetch may be skipped if we got an anti-spam
 666              * or other PS_REFUSED error response during
 667              * readheaders.
 668              */
 669             if (!suppress_readbody)
 670             {
 671                 if (separatefetchbody)
 672                 {
 673                     len = -1;
 674                     if ((err=(ctl->server.base_protocol->fetch_body)(mailserver_socket,ctl,num,&len)))
 675                         return(err);
 676                     /*
 677                      * Work around a bug in Novell's
 678                      * broken GroupWise IMAP server;
 679                      * its body FETCH response is missing
 680                      * the required length for the data
 681                      * string.  This violates RFC2060.
 682                      */
 683                     if (len == -1)
 684                         len = msgsize - msgblk.msglen;
 685                     if (outlevel > O_SILENT && !wholesize)
 686                         report_build(stdout,
 687                                         GT_(" (%d body octets)"), len);
 688                 }
 689
 690                 /* process the body now */
 691                 err = readbody(mailserver_socket,
 692                               ctl,
 693                               !suppress_forward,
 694                               len);
 695                 if (err == PS_TRANSIENT)
 696                     suppress_delete = suppress_forward = TRUE;
 697                 else if (err)
 698                     return(err);
 699
 700                 /* tell server we got it OK and resynchronize */
 701                 if (ctl->server.base_protocol->trail)
 702                 {
 703                     if (outlevel >= O_VERBOSE && !is_a_file(1) && !run.use_syslog)
 704                     {
 705                         fputc('\n', stdout);
 706                         fflush(stdout);
 707                     }
 708
 709                     err = (ctl->server.base_protocol->trail)(mailserver_socket, ctl, tag);
 710                     if (err != 0)
 711                         return(err);
 712                 }
 713             }
 714
 715             /* count # messages forwarded on this pass */
 716             if (!suppress_forward)
 717                 (*dispatches)++;
 718
 719             /*
 720              * Check to see if the numbers matched?
 721              *
 722              * Yes, some servers foo this up horribly.
 723              * All IMAP servers seem to get it right, and
 724              * so does Eudora QPOP at least in 2.xx
 725              * versions.
 726              *
 727              * Microsoft Exchange gets it completely
 728              * wrong, reporting compressed rather than
 729              * actual sizes (so the actual length of
 730              * message is longer than the reported size).
 731              * Another fine example of Microsoft brain death!
 732              *
 733              * Some older POP servers, like the old UCB
 734              * POP server and the pre-QPOP QUALCOMM
 735              * versions, report a longer size in the LIST
 736              * response than actually gets shipped up.
 737              * It's unclear what is going on here, as the
 738              * QUALCOMM server (at least) seems to be
 739              * reporting the on-disk size correctly.
 740              *
 741              * qmail-pop3d also goofs up message sizes and does not
 742              * count the line end characters properly.
 743              */
 744             if (msgblk.msglen != msgsize)
 745             {
 746                 if (outlevel >= O_DEBUG)
 747                     report(stdout,
 748                            GT_("message %s@%s:%d was not the expected length (%d actual != %d expected)\n"),
 749                            ctl->remotename, ctl->server.truename, num,
 750                            msgblk.msglen, msgsize);
 751             }
 752
 753             /* end-of-message processing starts here */
 754             if (!close_sink(ctl, &msgblk, !suppress_forward))
 755             {
 756                 ctl->errcount++;
 757                 suppress_delete = TRUE;
 758             }
 759             if (!retained)
 760                 (*fetches)++;
 761         }
 762
 763 flagthemail:
 764         /*
 765          * At this point in flow of control, either
 766          * we've bombed on a protocol error or had
 767          * delivery refused by the SMTP server
 768          * (unlikely -- I've never seen it) or we've
 769          * seen `accepted for delivery' and the
 770          * message is shipped.  It's safe to mark the
 771          * message seen and delete it on the server
 772          * now.
 773          */
 774
 775         /* maybe we delete this message now? */
 776         if (retained)
 777         {
 778             if (outlevel > O_SILENT)
 779                 report_complete(stdout, GT_(" retained\n"));
 780         }
 781         else if (ctl->server.base_protocol->delete_msg
 782                  && !suppress_delete
 783                  && ((msgcode >= 0 && !ctl->keep)
 784                      || (msgcode == MSGLEN_OLD && ctl->flush)
 785                      || (msgcode == MSGLEN_TOOLARGE && ctl->limitflush)))
 786         {
 787             (*deletions)++;
 788             if (outlevel > O_SILENT)
 789                 report_complete(stdout, GT_(" flushed\n"));
 790             err = (ctl->server.base_protocol->delete_msg)(mailserver_socket, ctl, num);
 791             if (err != 0)
 792                 return(err);
 793         }
 794         else
 795         {
 796             if (   (outlevel >= O_VERBOSE) ||
 797                         /* To avoid flooding the syslog when using --keep,
 798                          * report "Skipped message" only when:
 799                          *  1) --verbose is on, or
 800                          *  2) fetchmail does not use syslog, or
 801                          *  3) the message was skipped for some other
 802                          *     reason than just being old.
 803                          */
 804                    (outlevel > O_SILENT && (!run.use_syslog || msgcode != MSGLEN_OLD))
 805                )
 806             report_complete(stdout, GT_(" not flushed\n"));
 807
 808             /* maybe we mark this message as seen now? */
 809             if (ctl->server.base_protocol->mark_seen
 810                 && !suppress_delete
 811                 && (msgcode >= 0 && ctl->keep))
 812             {
 813                 err = (ctl->server.base_protocol->mark_seen)(mailserver_socket, ctl, num);
 814                 if (err != 0)
 815                     return(err);
 816             }
 817         }
 818
 819         /* perhaps this as many as we're ready to handle */
 820         if (maxfetch && maxfetch <= *fetches && num < count)
 821         {
 822             int remcount = count - (*fetches - initialfetches);
 823             report(stdout,
 824                    ngettext("fetchlimit %d reached; %d message left on server %s account %s\n",
 825                             "fetchlimit %d reached; %d messages left on server %s account %s\n", remcount),
 826                    maxfetch, remcount, ctl->server.truename, ctl->remotename);
 827             return(PS_MAXFETCH);
 828         }
 829     } /* for (num = 1; num <= count; num++) */
 830
 831     return(PS_SUCCESS);
 832 }
 833
 834 /* retrieve messages from server using given protocol method table */
 835 static int do_session(
 836         /* parsed options with merged-in defaults */
 837         struct query *ctl,
 838         /* protocol method table */
 839         const struct method *proto,
 840         /* maximum number of messages to fetch */
 841         const int maxfetch)
 842 {
 843     static int *msgsizes;
 844     volatile int err, mailserver_socket = -1;   /* pacifies -Wall */
 845     int tmperr;
 846     int deletions = 0, js;
 847     const char *msg;
 848     SIGHANDLERTYPE pipesave;
 849     SIGHANDLERTYPE alrmsave;
 850
 851     ctl->server.base_protocol = proto;
 852
 853     msgsizes = NULL;
 854     pass = 0;
 855     err = 0;
 856     init_transact(proto);
 857
 858     /* set up the server-nonresponse timeout */
 859     alrmsave = set_signal_handler(SIGALRM, timeout_handler);
 860     mytimeout = ctl->server.timeout;
 861
 862     /* set up the broken-pipe timeout */
 863     pipesave = set_signal_handler(SIGPIPE, sigpipe_handler);
 864
 865     if ((js = sigsetjmp(restart,1)))
 866     {
 867         /* exception caught */
 868         sigset_t        allsigs;
 869
 870         sigfillset(&allsigs);
 871         sigprocmask(SIG_UNBLOCK, &allsigs, NULL);
 872
 873         if (ai0) {
 874             freeaddrinfo(ai0); ai0 = NULL;
 875         }
 876
 877         if (ai1) {
 878             freeaddrinfo(ai1); ai1 = NULL;
 879         }
 880
 881         if (js == THROW_SIGPIPE)
 882         {
 883             set_signal_handler(SIGPIPE, SIG_IGN);
 884             report(stdout,
 885                    GT_("SIGPIPE thrown from an MDA or a stream socket error\n"));
 886             wait(0);
 887         }
 888         else if (js == THROW_TIMEOUT)
 889         {
 890             if (phase == OPEN_WAIT)
 891                 report(stdout,
 892                        GT_("timeout after %d seconds waiting to connect to server %s.\n"),
 893                        ctl->server.timeout, ctl->server.pollname);
 894             else if (phase == SERVER_WAIT)
 895                 report(stdout,
 896                        GT_("timeout after %d seconds waiting for server %s.\n"),
 897                        ctl->server.timeout, ctl->server.pollname);
 898             else if (phase == FORWARDING_WAIT)
 899                 report(stdout,
 900                        GT_("timeout after %d seconds waiting for %s.\n"),
 901                        ctl->server.timeout,
 902                        ctl->mda ? "MDA" : "SMTP");
 903             else if (phase == LISTENER_WAIT)
 904                 report(stdout,
 905                        GT_("timeout after %d seconds waiting for listener to respond.\n"), ctl->server.timeout);
 906             else
 907                 report(stdout,
 908                        GT_("timeout after %d seconds.\n"), ctl->server.timeout);
 909
 910             /*
 911              * If we've exceeded our threshold for consecutive timeouts,
 912              * try to notify the user, then mark the connection wedged.
 913              * Don't do this if the connection can idle, though; idle
 914              * timeouts just mean the frequency of mail is low.
 915              */
 916             if (timeoutcount > MAX_TIMEOUTS
 917                 && !open_warning_by_mail(ctl))
 918             {
 919                 stuff_warning(iana_charset, ctl,
 920                               GT_("Subject: fetchmail sees repeated timeouts"));
 921                 stuff_warning(NULL, ctl, "%s", "");
 922                 stuff_warning(NULL, ctl,
 923                               GT_("Fetchmail saw more than %d timeouts while attempting to get mail from %s@%s.\n"),
 924                               MAX_TIMEOUTS,
 925                               ctl->remotename, ctl->server.truename);
 926                 stuff_warning(NULL, ctl,
 927     GT_("This could mean that your mailserver is stuck, or that your SMTP\n" \
 928     "server is wedged, or that your mailbox file on the server has been\n" \
 929     "corrupted by a server error.  You can run `fetchmail -v -v' to\n" \
 930     "diagnose the problem.\n\n" \
 931     "Fetchmail won't poll this mailbox again until you restart it.\n"));
 932                 close_warning_by_mail(ctl, (struct msgblk *)NULL);
 933                 ctl->wedged = TRUE;
 934             }
 935         }
 936
 937         err = PS_SOCKET;
 938         goto cleanUp;
 939     }
 940     else
 941     {
 942         /* setjmp returned zero -> normal operation */
 943         char buf[MSGBUFSIZE+1], *realhost;
 944         int count, newm, bytes;
 945         int fetches, dispatches, oldphase;
 946         struct idlist *idp;
 947
 948         /* execute pre-initialization command, if any */
 949         if (ctl->preconnect && (err = system(ctl->preconnect)))
 950         {
 951             report(stderr,
 952                    GT_("pre-connection command failed with status %d\n"), err);
 953             err = PS_SYNTAX;
 954             goto closeUp;
 955         }
 956
 957         /* open a socket to the mail server */
 958         oldphase = phase;
 959         phase = OPEN_WAIT;
 960         set_timeout(mytimeout);
 961
 962 #ifdef HAVE_PKG_hesiod
 963         /* If either the pollname or vianame are "hesiod" we want to
 964            lookup the user's hesiod pobox host */
 965         if (!strcasecmp(ctl->server.queryname, "hesiod")) {
 966             struct hes_postoffice *hes_p;
 967             hes_p = hes_getmailhost(ctl->remotename);
 968             if (hes_p != NULL && strcmp(hes_p->po_type, "POP") == 0) {
 969                  free(ctl->server.queryname);
 970                  ctl->server.queryname = xstrdup(hes_p->po_host);
 971                  if (ctl->server.via)
 972                      free(ctl->server.via);
 973                  ctl->server.via = xstrdup(hes_p->po_host);
 974             } else {
 975                  report(stderr,
 976                         GT_("couldn't find HESIOD pobox for %s\n"),
 977                         ctl->remotename);
 978             }
 979         }
 980 #endif /* HESIOD */
 981
 982         /*
 983          * Canonicalize the server truename for later use.  This also
 984          * functions as a probe for whether the mailserver is accessible.
 985          * We try it on each poll cycle until we get a result.  This way,
 986          * fetchmail won't fail if started up when the network is inaccessible.
 987          */
 988         if (ctl->server.dns && !ctl->server.trueaddr)
 989         {
 990             if (ctl->server.lead_server)
 991             {
 992                 char    *leadname = ctl->server.lead_server->truename;
 993
 994                 /* prevent core dump from ill-formed or duplicate entry */
 995                 if (!leadname)
 996                 {
 997                     report(stderr, GT_("Lead server has no name.\n"));
 998                     err = PS_DNS;
 999                     set_timeout(0);
1000                     phase = oldphase;
1001                     goto closeUp;
1002                 }
1003
1004                 xfree(ctl->server.truename);
1005                 ctl->server.truename = xstrdup(leadname);
1006             }
1007             else
1008             {
1009                 struct addrinfo hints, *res;
1010                 int error;
1011
1012                 memset(&hints, 0, sizeof(hints));
1013                 hints.ai_socktype = SOCK_STREAM;
1014                 hints.ai_family = AF_UNSPEC;
1015                 hints.ai_flags = AI_CANONNAME;
1016
1017                 error = getaddrinfo(ctl->server.queryname, NULL, &hints, &res);
1018                 if (error)
1019                 {
1020                     report(stderr,
1021                            GT_("couldn't find canonical DNS name of %s (%s)\n"),
1022                            ctl->server.pollname, ctl->server.queryname);
1023                     err = PS_DNS;
1024                     set_timeout(0);
1025                     phase = oldphase;
1026                     goto closeUp;
1027                 }
1028                 else
1029                 {
1030                     xfree(ctl->server.truename);
1031                     /* Older FreeBSD versions return NULL in ai_canonname
1032                      * if they cannot canonicalize, rather than copying
1033                      * the queryname here, as IEEE Std 1003.1-2001
1034                      * requires. Work around NULL. */
1035                     if (res->ai_canonname != NULL) {
1036                         ctl->server.truename = xstrdup(res->ai_canonname);
1037                     } else {
1038                         ctl->server.truename = xstrdup(ctl->server.queryname);
1039                     }
1040                     ctl->server.trueaddr = (struct sockaddr *)xmalloc(res->ai_addrlen);
1041                     ctl->server.trueaddr_len = res->ai_addrlen;
1042                     memcpy(ctl->server.trueaddr, res->ai_addr, res->ai_addrlen);
1043                     freeaddrinfo(res);
1044                 }
1045             }
1046         }
1047
1048         realhost = ctl->server.via ? ctl->server.via : ctl->server.pollname;
1049
1050         /* allow time for the port to be set up if we have a plugin */
1051         if (ctl->server.plugin)
1052             (void)sleep(1);
1053         if ((mailserver_socket = SockOpen(realhost,
1054                              ctl->server.service ? ctl->server.service : ( ctl->use_ssl ? ctl->server.base_protocol->sslservice : ctl->server.base_protocol->service ),
1055                              ctl->server.plugin, &ai0)) == -1)
1056         {
1057             char        errbuf[BUFSIZ];
1058             int err_no = errno;
1059             /*
1060              * Avoid generating a bogus error every poll cycle when we're
1061              * in daemon mode but the connection to the outside world
1062              * is down.
1063              */
1064             if (!((err_no == EHOSTUNREACH || err_no == ENETUNREACH)
1065                   && run.poll_interval))
1066             {
1067                 report_build(stderr, GT_("%s connection to %s failed"),
1068                              ctl->server.base_protocol->name, ctl->server.pollname);
1069                     strlcpy(errbuf, strerror(err_no), sizeof(errbuf));
1070                 report_complete(stderr, ": %s\n", errbuf);
1071
1072 #ifdef __UNUSED__
1073                 /*
1074                  * Don't use this.  It was an attempt to address Debian bug
1075                  * #47143 (Notify user by mail when pop server nonexistent).
1076                  * Trouble is, that doesn't work; you trip over the case
1077                  * where your SLIP or PPP link is down...
1078                  */
1079                 /* warn the system administrator */
1080                 if (open_warning_by_mail(ctl) == 0)
1081                 {
1082                     stuff_warning(iana_charset, ctl,
1083                          GT_("Subject: Fetchmail unreachable-server warning."));
1084                     stuff_warning(NULL, ctl, "");
1085                     stuff_warning(NULL, ctl, GT_("Fetchmail could not reach the mail server %s:"),
1086                                   ctl->server.pollname);
1087                     stuff_warning(NULL, ctl, errbuf, ctl->server.pollname);
1088                     close_warning_by_mail(ctl, (struct msgblk *)NULL);
1089                 }
1090 #endif
1091             }
1092             err = PS_SOCKET;
1093             set_timeout(0);
1094             phase = oldphase;
1095             goto closeUp;
1096         }
1097
1098 #ifdef SSL_ENABLE
1099         /* Save the socket opened. Useful if Fetchmail hangs on SSLOpen
1100          * because the socket can be closed.
1101          */
1102         mailserver_socket_temp = mailserver_socket;
1103         set_timeout(mytimeout);
1104
1105         /* perform initial SSL handshake on open connection */
1106         /* Note:  We pass the realhost name over for certificate
1107                 verification.  We may want to make this configurable */
1108         if (ctl->use_ssl && SSLOpen(mailserver_socket,ctl->sslcert,ctl->sslkey,ctl->sslproto,ctl->sslcertck,
1109             ctl->sslcertpath,ctl->sslfingerprint,realhost,ctl->server.pollname) == -1)
1110         {
1111             report(stderr, GT_("SSL connection failed.\n"));
1112             err = PS_SOCKET;
1113             goto cleanUp;
1114         }
1115
1116         /* Fetchmail didn't hang on SSLOpen,
1117          * then no need to set mailserver_socket_temp
1118          */
1119         mailserver_socket_temp = -1;
1120 #endif
1121
1122         /* A timeout is still defined before SSLOpen,
1123          * then Fetchmail hanging on SSLOpen is handled.
1124          */
1125         set_timeout(0);
1126         phase = oldphase;
1127 #ifdef KERBEROS_V4
1128         if (ctl->server.authenticate == A_KERBEROS_V4 && (strcasecmp(proto->name,"IMAP") != 0))
1129         {
1130             set_timeout(mytimeout);
1131             err = kerberos_auth(mailserver_socket, ctl->server.truename,
1132                                ctl->server.principal);
1133             set_timeout(0);
1134             if (err != 0)
1135                 goto cleanUp;
1136         }
1137 #endif /* KERBEROS_V4 */
1138
1139 #ifdef KERBEROS_V5
1140         if (ctl->server.authenticate == A_KERBEROS_V5)
1141         {
1142             set_timeout(mytimeout);
1143             err = kerberos5_auth(mailserver_socket, ctl->server.truename);
1144             set_timeout(0);
1145             if (err != 0)
1146                 goto cleanUp;
1147         }
1148 #endif /* KERBEROS_V5 */
1149
1150         /* accept greeting message from mail server */
1151         err = (ctl->server.base_protocol->parse_response)(mailserver_socket, buf);
1152         if (err != 0)
1153             goto cleanUp;
1154
1155         /* try to get authorized to fetch mail */
1156         stage = STAGE_GETAUTH;
1157         if (ctl->server.base_protocol->getauth)
1158         {
1159             err = (ctl->server.base_protocol->getauth)(mailserver_socket, ctl, buf);
1160
1161             if (err != 0)
1162             {
1163                 if (err == PS_LOCKBUSY)
1164                     report(stderr, GT_("Lock-busy error on %s@%s\n"),
1165                           ctl->remotename,
1166                           ctl->server.truename);
1167                 else if (err == PS_SERVBUSY)
1168                     report(stderr, GT_("Server busy error on %s@%s\n"),
1169                           ctl->remotename,
1170                           ctl->server.truename);
1171                 else if (err == PS_AUTHFAIL)
1172                 {
1173                     report(stderr, GT_("Authorization failure on %s@%s%s\n"),
1174                            ctl->remotename,
1175                            ctl->server.truename,
1176                            (ctl->wehaveauthed ? GT_(" (previously authorized)") : "")
1177                         );
1178
1179                     /*
1180                      * If we're running in background, try to mail the
1181                      * calling user a heads-up about the authentication
1182                      * failure once it looks like this isn't a fluke
1183                      * due to the server being temporarily inaccessible.
1184                      * When we get third succesive failure, we notify the user
1185                      * but only if we haven't already managed to get
1186                      * authorization.  After that, once we get authorization
1187                      * we let the user know service is restored.
1188                      */
1189                     if (run.poll_interval
1190                         && !ctl->wehavesentauthnote
1191                         && ((ctl->wehaveauthed && ++ctl->authfailcount >= 10)
1192                             || (!ctl->wehaveauthed && ++ctl->authfailcount >= 3))
1193                         && !open_warning_by_mail(ctl))
1194                     {
1195                         ctl->wehavesentauthnote = 1;
1196                         stuff_warning(iana_charset, ctl,
1197                                       GT_("Subject: fetchmail authentication failed on %s@%s"),
1198                             ctl->remotename, ctl->server.truename);
1199                         stuff_warning(NULL, ctl, "%s", "");
1200                         stuff_warning(NULL, ctl,
1201                                       GT_("Fetchmail could not get mail from %s@%s.\n"),
1202                                       ctl->remotename,
1203                                       ctl->server.truename);
1204                         if (ctl->wehaveauthed) {
1205                             stuff_warning(NULL, ctl, GT_("\
1206 The attempt to get authorization failed.\n\
1207 Since we have already succeeded in getting authorization for this\n\
1208 connection, this is probably another failure mode (such as busy server)\n\
1209 that fetchmail cannot distinguish because the server didn't send a useful\n\
1210 error message."));
1211                             stuff_warning(NULL, ctl, GT_("\
1212 \n\
1213 However, if you HAVE changed your account details since starting the\n\
1214 fetchmail daemon, you need to stop the daemon, change your configuration\n\
1215 of fetchmail, and then restart the daemon.\n\
1216 \n\
1217 The fetchmail daemon will continue running and attempt to connect\n\
1218 at each cycle.  No future notifications will be sent until service\n\
1219 is restored."));
1220                         } else {
1221                             stuff_warning(NULL, ctl, GT_("\
1222 The attempt to get authorization failed.\n\
1223 This probably means your password is invalid, but some servers have\n\
1224 other failure modes that fetchmail cannot distinguish from this\n\
1225 because they don't send useful error messages on login failure.\n\
1226 \n\
1227 The fetchmail daemon will continue running and attempt to connect\n\
1228 at each cycle.  No future notifications will be sent until service\n\
1229 is restored."));
1230                         }
1231                         close_warning_by_mail(ctl, (struct msgblk *)NULL);
1232                     }
1233                 }
1234                 else if (err == PS_REPOLL)
1235                 {
1236                   if (outlevel >= O_VERBOSE)
1237                     report(stderr, GT_("Repoll immediately on %s@%s\n"),
1238                            ctl->remotename,
1239                            ctl->server.truename);
1240                 }
1241                 else
1242                     report(stderr, GT_("Unknown login or authentication error on %s@%s\n"),
1243                            ctl->remotename,
1244                            ctl->server.truename);
1245
1246                 goto cleanUp;
1247             }
1248             else
1249             {
1250                 /*
1251                  * This connection has given us authorization at least once.
1252                  *
1253                  * There are dodgy server (clubinternet.fr for example) that
1254                  * give spurious authorization failures on patently good
1255                  * account/password details, then 5 minutes later let you in!
1256                  *
1257                  * This is meant to build in some tolerance of such nasty bits
1258                  * of work.
1259                  */
1260                 ctl->wehaveauthed = 1;
1261                 /*if (ctl->authfailcount >= 3)*/
1262                 if (ctl->wehavesentauthnote)
1263                 {
1264                     ctl->wehavesentauthnote = 0;
1265                     report(stderr,
1266                            GT_("Authorization OK on %s@%s\n"),
1267                            ctl->remotename,
1268                            ctl->server.truename);
1269                     if (!open_warning_by_mail(ctl))
1270                     {
1271                         stuff_warning(iana_charset, ctl,
1272                               GT_("Subject: fetchmail authentication OK on %s@%s"),
1273                                       ctl->remotename, ctl->server.truename);
1274                         stuff_warning(NULL, ctl, "%s", "");
1275                         stuff_warning(NULL, ctl,
1276                               GT_("Fetchmail was able to log into %s@%s.\n"),
1277                                       ctl->remotename,
1278                                       ctl->server.truename);
1279                         stuff_warning(NULL, ctl,
1280                                       GT_("Service has been restored.\n"));
1281                         close_warning_by_mail(ctl, (struct msgblk *)NULL);
1282
1283                     }
1284                 }
1285                 /*
1286                  * Reporting only after the first three
1287                  * consecutive failures, or ten consecutive
1288                  * failures after we have managed to get
1289                  * authorization.
1290                  */
1291                 ctl->authfailcount = 0;
1292             }
1293         }
1294
1295         ctl->errcount = fetches = 0;
1296
1297         /* now iterate over each folder selected */
1298         for (idp = ctl->mailboxes; idp; idp = idp->next)
1299         {
1300             ctl->folder = idp->id;
1301             pass = 0;
1302             do {
1303                 dispatches = 0;
1304                 ++pass;
1305
1306                 /* reset timeout, in case we did an IDLE */
1307                 mytimeout = ctl->server.timeout;
1308
1309                 if (outlevel >= O_DEBUG)
1310                 {
1311                     if (idp->id)
1312                         report(stdout, GT_("selecting or re-polling folder %s\n"), idp->id);
1313                     else
1314                         report(stdout, GT_("selecting or re-polling default folder\n"));
1315                 }
1316
1317                 /* compute # of messages and number of new messages waiting */
1318                 stage = STAGE_GETRANGE;
1319                 err = (ctl->server.base_protocol->getrange)(mailserver_socket, ctl, idp->id, &count, &newm, &bytes);
1320                 if (err != 0)
1321                     goto cleanUp;
1322
1323                 /* show user how many messages we downloaded */
1324                 if (idp->id)
1325                     (void) snprintf(buf, sizeof(buf),
1326                                    GT_("%s at %s (folder %s)"),
1327                                    ctl->remotename, ctl->server.pollname, idp->id);
1328                 else
1329                     (void) snprintf(buf, sizeof(buf), GT_("%s at %s"),
1330                                    ctl->remotename, ctl->server.pollname);
1331                 if (outlevel > O_SILENT)
1332                 {
1333                     if (count == -1)            /* only used for ETRN */
1334                         report(stdout, GT_("Polling %s\n"), ctl->server.truename);
1335                     else if (count != 0)
1336                     {
1337                         if (newm != -1 && (count - newm) > 0)
1338                             report_build(stdout, ngettext("%d message (%d %s) for %s", "%d messages (%d %s) for %s", (unsigned long)count),
1339                                   count,
1340                                   count - newm,
1341                                   ngettext("seen", "seen", (unsigned long)count-newm),
1342                                   buf);
1343                         else
1344                             report_build(stdout, ngettext("%d message for %s",
1345                                                           "%d messages for %s",
1346                                                           count),
1347                                   count, buf);
1348                         if (bytes == -1)
1349                             report_complete(stdout, ".\n");
1350                         else
1351                             report_complete(stdout, GT_(" (%d octets).\n"), bytes);
1352                     }
1353                     else
1354                     {
1355                         /* these are pointless in normal daemon mode */
1356                         if (pass == 1 && (run.poll_interval == 0 || outlevel >= O_VERBOSE))
1357                             report(stdout, GT_("No mail for %s\n"), buf);
1358                     }
1359                 }
1360
1361                 /* very important, this is where we leave the do loop */
1362                 if (count == 0)
1363                     break;
1364
1365                 if (check_only)
1366                 {
1367                     if (newm == -1 || ctl->fetchall)
1368                         newm = count;
1369                     fetches = newm;     /* set error status correctly */
1370                     /*
1371                      * There used to be a `goto noerror' here, but this
1372                      * prevented checking of multiple folders.  This
1373                      * comment is a reminder in case I introduced some
1374                      * subtle bug by removing it...
1375                      */
1376                 }
1377                 else if (count > 0)
1378                 {
1379                     int         i;
1380
1381                     /*
1382                      * Don't trust the message count passed by the server.
1383                      * Without this check, it might be possible to do a
1384                      * DNS-spoofing attack that would pass back a ridiculous
1385                      * count, and allocate a malloc area that would overlap
1386                      * a portion of the stack.
1387                      */
1388                     if ((unsigned)count > INT_MAX/sizeof(int))
1389                     {
1390                         report(stderr, GT_("bogus message count!"));
1391                         err = PS_PROTOCOL;
1392                         goto cleanUp;
1393                     }
1394
1395                     /*
1396                      * We need the size of each message before it's
1397                      * loaded in order to pass it to the ESMTP SIZE
1398                      * option.  If the protocol has a getsizes method,
1399                      * we presume this means it doesn't get reliable
1400                      * sizes from message fetch responses.
1401                      *
1402                      * If the protocol supports getting sizes of subset of
1403                      * messages, we skip this step now.
1404                      */
1405                     if (proto->getsizes &&
1406                         !(proto->getpartialsizes && NUM_NONZERO(ctl->fetchsizelimit)))
1407                     {
1408                         xfree(msgsizes);
1409                         msgsizes = (int *)xmalloc(sizeof(int) * count);
1410                         for (i = 0; i < count; i++)
1411                             msgsizes[i] = 0;
1412
1413                         stage = STAGE_GETSIZES;
1414                         err = (proto->getsizes)(mailserver_socket, count, msgsizes);
1415                         if (err != 0)
1416                             goto cleanUp;
1417
1418                         if (bytes == -1)
1419                         {
1420                             bytes = 0;
1421                             for (i = 0; i < count; i++)
1422                                 bytes += msgsizes[i];
1423                         }
1424                     }
1425
1426                     /* read, forward, and delete messages */
1427                     stage = STAGE_FETCH;
1428
1429                     /* fetch in lockstep mode */
1430                     err = fetch_messages(mailserver_socket, ctl,
1431                                          count, &msgsizes,
1432                                          maxfetch,
1433                                          &fetches, &dispatches, &deletions);
1434                     if (err != PS_SUCCESS && err != PS_MAXFETCH)
1435                         goto cleanUp;
1436
1437                     if (!check_only && ctl->skipped
1438                         && run.poll_interval > 0 && !nodetach)
1439                     {
1440                         clean_skipped_list(&ctl->skipped);
1441                         send_size_warnings(ctl);
1442                     }
1443                 }
1444
1445                 /* end-of-mailbox processing before we repoll or switch to another one */
1446                 if (ctl->server.base_protocol->end_mailbox_poll)
1447                 {
1448                     err = (ctl->server.base_protocol->end_mailbox_poll)(mailserver_socket, ctl);
1449                     if (err)
1450                         goto cleanUp;
1451                 }
1452                 /* Return now if we have reached the fetchlimit */
1453                 if (maxfetch && maxfetch <= fetches)
1454                     goto no_error;
1455             } while
1456                   /*
1457                    * Only repoll if we either had some actual forwards
1458                    * or are idling for new mails and had no errors.
1459                    * Otherwise it is far too easy to get into infinite loops.
1460                    */
1461                   (ctl->server.base_protocol->retry && (dispatches || ctl->idle) && !ctl->errcount);
1462         }
1463
1464         /* XXX: From this point onwards, preserve err unless a new error has occurred */
1465
1466     no_error:
1467         /* PS_SUCCESS, PS_MAXFETCH: ordinary termination with no errors -- officially log out */
1468         stage = STAGE_LOGOUT;
1469         tmperr = (ctl->server.base_protocol->logout_cmd)(mailserver_socket, ctl);
1470         if (tmperr != PS_SUCCESS)
1471             err = tmperr;
1472         /*
1473          * Hmmmm...arguably this would be incorrect if we had fetches but
1474          * no dispatches (due to oversized messages, etc.)
1475          */
1476         else if (err == PS_SUCCESS && fetches == 0)
1477             err = PS_NOMAIL;
1478         /*
1479          * Close all SMTP delivery sockets.  For optimum performance
1480          * we'd like to hold them open til end of run, but (1) this
1481          * loses if our poll interval is longer than the MTA's
1482          * inactivity timeout, and (2) some MTAs (like smail) don't
1483          * deliver after each message, but rather queue up mail and
1484          * wait to actually deliver it until the input socket is
1485          * closed.
1486          *
1487          * don't send QUIT for ODMR case because we're acting as a
1488          * proxy between the SMTP server and client.
1489          */
1490         smtp_close(ctl, ctl->server.protocol != P_ODMR);
1491         cleanupSockClose(mailserver_socket);
1492         goto closeUp;
1493
1494     cleanUp:
1495         /* we only get here on error */
1496         if (err != 0 && err != PS_SOCKET && err != PS_REPOLL)
1497         {
1498             stage = STAGE_LOGOUT;
1499             (ctl->server.base_protocol->logout_cmd)(mailserver_socket, ctl);
1500         }
1501
1502         /* try to clean up all streams */
1503         release_sink(ctl);
1504         /*
1505          * Sending SMTP QUIT on signal is theoretically nice, but led
1506          * to a subtle bug.  If fetchmail was terminated by signal
1507          * while it was shipping message text, it would hang forever
1508          * waiting for a command acknowledge.  In theory we could
1509          * enable the QUIT only outside of the message send.  In
1510          * practice, we don't care.  All mailservers hang up on a
1511          * dropped TCP/IP connection anyway.
1512          */
1513         smtp_close(ctl, 0);
1514         if (mailserver_socket != -1) {
1515             cleanupSockClose(mailserver_socket);
1516             mailserver_socket = -1;
1517         }
1518         /* If there was a connect timeout, the socket should be closed.
1519          * mailserver_socket_temp contains the socket to close.
1520          */
1521         if (mailserver_socket_temp != -1) {
1522             cleanupSockClose(mailserver_socket_temp);
1523             mailserver_socket_temp = -1;
1524         }
1525     }
1526
1527     /* no report on PS_AUTHFAIL */
1528     msg = NULL;
1529     switch (err)
1530     {
1531     case PS_SOCKET:
1532         msg = GT_("socket");
1533         break;
1534     case PS_SYNTAX:
1535         msg = GT_("missing or bad RFC822 header");
1536         break;
1537     case PS_IOERR:
1538         msg = GT_("MDA");
1539         break;
1540     case PS_ERROR:
1541         msg = GT_("client/server synchronization");
1542         break;
1543     case PS_PROTOCOL:
1544         msg = GT_("client/server protocol");
1545         break;
1546     case PS_LOCKBUSY:
1547         msg = GT_("lock busy on server");
1548         break;
1549     case PS_SMTP:
1550         msg = GT_("SMTP transaction");
1551         break;
1552     case PS_DNS:
1553         msg = GT_("DNS lookup");
1554         break;
1555     case PS_UNDEFINED:
1556         msg = GT_("undefined");
1557         break;
1558     }
1559     if (msg) {
1560         if (phase == FORWARDING_WAIT || phase == LISTENER_WAIT
1561                 || err == PS_SMTP)
1562             report(stderr, GT_("%s error while fetching from %s@%s and delivering to SMTP host %s\n"),
1563                     msg, ctl->remotename, ctl->server.pollname,
1564                     ctl->smtphost ? ctl->smtphost : GT_("unknown"));
1565         else
1566             report(stderr, GT_("%s error while fetching from %s@%s\n"),
1567                     msg, ctl->remotename, ctl->server.pollname);
1568     }
1569
1570 closeUp:
1571     xfree(msgsizes);
1572     ctl->folder = NULL;
1573
1574     /* execute wrapup command, if any */
1575     if (ctl->postconnect && (tmperr = system(ctl->postconnect)))
1576     {
1577         report(stderr, GT_("post-connection command failed with status %d\n"), tmperr);
1578         if (err == PS_SUCCESS)
1579             err = PS_SYNTAX;
1580     }
1581
1582     set_timeout(0); /* cancel any pending alarm */
1583     set_signal_handler(SIGALRM, alrmsave);
1584     set_signal_handler(SIGPIPE, pipesave);
1585     return(err);
1586 }
1587
1588 /** retrieve messages from server using given protocol method table */
1589 int do_protocol(struct query *ctl /** parsed options with merged-in defaults */,
1590                 const struct method *proto /** protocol method table */)
1591 {
1592     int err;
1593
1594 #ifndef KERBEROS_V4
1595     if (ctl->server.authenticate == A_KERBEROS_V4)
1596     {
1597         report(stderr, GT_("Kerberos V4 support not linked.\n"));
1598         return(PS_ERROR);
1599     }
1600 #endif /* KERBEROS_V4 */
1601
1602 #ifndef KERBEROS_V5
1603     if (ctl->server.authenticate == A_KERBEROS_V5)
1604     {
1605         report(stderr, GT_("Kerberos V5 support not linked.\n"));
1606         return(PS_ERROR);
1607     }
1608 #endif /* KERBEROS_V5 */
1609
1610     /* lacking methods, there are some options that may fail */
1611     if (!proto->is_old)
1612     {
1613         /* check for unsupported options */
1614         if (ctl->flush) {
1615             report(stderr,
1616                     GT_("Option --flush is not supported with %s\n"),
1617                     proto->name);
1618             return(PS_SYNTAX);
1619         }
1620         else if (ctl->fetchall) {
1621             report(stderr,
1622                     GT_("Option --all is not supported with %s\n"),
1623                     proto->name);
1624             return(PS_SYNTAX);
1625         }
1626     }
1627     if (!(proto->getsizes || proto->getpartialsizes)
1628             && NUM_SPECIFIED(ctl->limit))
1629     {
1630         report(stderr,
1631                 GT_("Option --limit is not supported with %s\n"),
1632                 proto->name);
1633         return(PS_SYNTAX);
1634     }
1635
1636     /*
1637      * If no expunge limit or we do expunges within the driver,
1638      * then just do one session, passing in any fetchlimit.
1639      */
1640     if ((ctl->keep && !ctl->flush) ||
1641         proto->retry || !NUM_SPECIFIED(ctl->expunge))
1642         return(do_session(ctl, proto, NUM_VALUE_OUT(ctl->fetchlimit)));
1643     /*
1644      * There's an expunge limit, and it isn't handled in the driver itself.
1645      * OK; do multiple sessions, each fetching a limited # of messages.
1646      * Stop if the total count of retrieved messages exceeds ctl->fetchlimit
1647      * (if it was nonzero).
1648      */
1649     else
1650     {
1651         int totalcount = 0;
1652         int lockouts   = 0;
1653         int expunge    = NUM_VALUE_OUT(ctl->expunge);
1654         int fetchlimit = NUM_VALUE_OUT(ctl->fetchlimit);
1655
1656         do {
1657             if (fetchlimit > 0 && (expunge == 0 || expunge > fetchlimit - totalcount))
1658                 expunge = fetchlimit - totalcount;
1659             err = do_session(ctl, proto, expunge);
1660             totalcount += expunge;
1661             if (NUM_SPECIFIED(ctl->fetchlimit) && totalcount >= fetchlimit)
1662                 break;
1663             if (err != PS_LOCKBUSY)
1664                 lockouts = 0;
1665             else if (lockouts >= MAX_LOCKOUTS)
1666                 break;
1667             else /* err == PS_LOCKBUSY */
1668             {
1669                 /*
1670                  * Allow time for the server lock to release.  if we
1671                  * don't do this, we'll often hit a locked-mailbox
1672                  * condition and fail.
1673                  */
1674                 lockouts++;
1675                 sleep(3);
1676             }
1677         } while
1678             (err == PS_MAXFETCH || err == PS_LOCKBUSY);
1679
1680         return(err);
1681     }
1682 }
1683
1684
1685 /* driver.c ends here */