lib-src/pop.c

   1 /* pop.c: client routines for talking to a POP3-protocol post-office server
   2
   3 Copyright (C) 1991, 1993, 1996-1997, 1999, 2001-2014 Free Software
   4 Foundation, Inc.
   5
   6 Author: Jonathan Kamens <jik@security.ov.com>
   7
   8 This file is part of GNU Emacs.
   9
  10 GNU Emacs is free software: you can redistribute it and/or modify
  11 it under the terms of the GNU General Public License as published by
  12 the Free Software Foundation, either version 3 of the License, or
  13 (at your option) any later version.
  14
  15 GNU Emacs is distributed in the hope that it will be useful,
  16 but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 GNU General Public License for more details.
  19
  20 You should have received a copy of the GNU General Public License
  21 along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
  22
  23
  24 #include <config.h>
  25
  26 #ifdef MAIL_USE_POP
  27
  28 #include <sys/types.h>
  29 #ifdef WINDOWSNT
  30 #include "ntlib.h"
  31 #include <winsock.h>
  32 #undef SOCKET_ERROR
  33 #define RECV(s,buf,len,flags) recv (s,buf,len,flags)
  34 #define SEND(s,buf,len,flags) send (s,buf,len,flags)
  35 #define CLOSESOCKET(s) closesocket (s)
  36 #else
  37 #include <netinet/in.h>
  38 #include <sys/socket.h>
  39 #define RECV(s,buf,len,flags) read (s,buf,len)
  40 #define SEND(s,buf,len,flags) write (s,buf,len)
  41 #define CLOSESOCKET(s) close (s)
  42 #endif
  43 #include <pop.h>
  44
  45 #ifdef sun
  46 #include <malloc.h>
  47 #endif /* sun */
  48
  49 #ifdef HESIOD
  50 #include <hesiod.h>
  51 /*
  52  * It really shouldn't be necessary to put this declaration here, but
  53  * the version of hesiod.h that Athena has installed in release 7.2
  54  * doesn't declare this function; I don't know if the 7.3 version of
  55  * hesiod.h does.
  56  */
  57 extern struct servent *hes_getservbyname (/* char *, char * */);
  58 #endif
  59
  60 #include <pwd.h>
  61 #include <netdb.h>
  62 #include <errno.h>
  63 #include <stdio.h>
  64 #include <string.h>
  65 #include <unistd.h>
  66
  67 #ifdef KERBEROS
  68 # ifdef HAVE_KRB5_H
  69 #  include <krb5.h>
  70 # endif
  71 # ifdef HAVE_KRB_H
  72 #  include <krb.h>
  73 # else
  74 #  ifdef HAVE_KERBEROSIV_KRB_H
  75 #   include <kerberosIV/krb.h>
  76 #  else
  77 #   ifdef HAVE_KERBEROS_KRB_H
  78 #    include <kerberos/krb.h>
  79 #   endif
  80 #  endif
  81 # endif
  82 # ifdef HAVE_COM_ERR_H
  83 #  include <com_err.h>
  84 # endif
  85 #endif /* KERBEROS */
  86
  87 #include <min-max.h>
  88
  89 #ifdef KERBEROS
  90 #ifndef KERBEROS5
  91 extern int krb_sendauth (/* long, int, KTEXT, char *, char *, char *,
  92                             u_long, MSG_DAT *, CREDENTIALS *, Key_schedule,
  93                             struct sockaddr_in *, struct sockaddr_in *,
  94                             char * */);
  95 extern char *krb_realmofhost (/* char * */);
  96 #endif /* ! KERBEROS5 */
  97 #endif /* KERBEROS */
  98
  99 #ifndef WINDOWSNT
 100 #ifndef HAVE_H_ERRNO
 101 extern int h_errno;
 102 #endif
 103 #endif
 104
 105 static int socket_connection (char *, int);
 106 static int pop_getline (popserver, char **);
 107 static int sendline (popserver, const char *);
 108 static int fullwrite (int, char *, int);
 109 static int getok (popserver);
 110 #if 0
 111 static int gettermination (popserver);
 112 #endif
 113 static void pop_trash (popserver);
 114 static char *find_crlf (char *, int);
 115
 116 #define ERROR_MAX 160           /* a pretty arbitrary size, but needs
 117                                    to be bigger than the original
 118                                    value of 80 */
 119 #define POP_PORT 110
 120 #define POP_SERVICE "pop3"      /* we don't want the POP2 port! */
 121 #ifdef KERBEROS
 122 #define KPOP_PORT 1109
 123 #define KPOP_SERVICE "kpop"     /* never used: look for 20060515 to see why */
 124 #endif
 125
 126 char pop_error[ERROR_MAX];
 127 bool pop_debug = false;
 128
 129 /*
 130  * Function: pop_open (char *host, char *username, char *password,
 131  *                     int flags)
 132  *
 133  * Purpose: Establishes a connection with a post-office server, and
 134  *      completes the authorization portion of the session.
 135  *
 136  * Arguments:
 137  *      host    The server host with which the connection should be
 138  *              established.  Optional.  If omitted, internal
 139  *              heuristics will be used to determine the server host,
 140  *              if possible.
 141  *      username
 142  *              The username of the mail-drop to access.  Optional.
 143  *              If omitted, internal heuristics will be used to
 144  *              determine the username, if possible.
 145  *      password
 146  *              The password to use for authorization.  If omitted,
 147  *              internal heuristics will be used to determine the
 148  *              password, if possible.
 149  *      flags   A bit mask containing flags controlling certain
 150  *              functions of the routine.  Valid flags are defined in
 151  *              the file pop.h
 152  *
 153  * Return value: Upon successful establishment of a connection, a
 154  *      non-null popserver will be returned.  Otherwise, null will be
 155  *      returned, and the string variable pop_error will contain an
 156  *      explanation of the error.
 157  */
 158 popserver
 159 pop_open (char *host, char *username, char *password, int flags)
 160 {
 161   int sock;
 162   popserver server;
 163
 164   /* Determine the user name */
 165   if (! username)
 166     {
 167       username = getenv ("USER");
 168       if (! (username && *username))
 169         {
 170           username = getlogin ();
 171           if (! (username && *username))
 172             {
 173               struct passwd *passwd;
 174               passwd = getpwuid (getuid ());
 175               if (passwd && passwd->pw_name && *passwd->pw_name)
 176                 {
 177                   username = passwd->pw_name;
 178                 }
 179               else
 180                 {
 181                   strcpy (pop_error, "Could not determine username");
 182                   return (0);
 183                 }
 184             }
 185         }
 186     }
 187
 188   /*
 189    *  Determine the mail host.
 190    */
 191
 192   if (! host)
 193     {
 194       host = getenv ("MAILHOST");
 195     }
 196
 197 #ifdef HESIOD
 198   if ((! host) && (! (flags & POP_NO_HESIOD)))
 199     {
 200       struct hes_postoffice *office;
 201       office = hes_getmailhost (username);
 202       if (office && office->po_type && (! strcmp (office->po_type, "POP"))
 203           && office->po_name && *office->po_name && office->po_host
 204           && *office->po_host)
 205         {
 206           host = office->po_host;
 207           username = office->po_name;
 208         }
 209     }
 210 #endif
 211
 212 #ifdef MAILHOST
 213   if (! host)
 214     {
 215       host = MAILHOST;
 216     }
 217 #endif
 218
 219   if (! host)
 220     {
 221       strcpy (pop_error, "Could not determine POP server");
 222       return (0);
 223     }
 224
 225   /* Determine the password */
 226 #ifdef KERBEROS
 227 #define DONT_NEED_PASSWORD (! (flags & POP_NO_KERBEROS))
 228 #else
 229 #define DONT_NEED_PASSWORD 0
 230 #endif
 231
 232   if ((! password) && (! DONT_NEED_PASSWORD))
 233     {
 234       if (! (flags & POP_NO_GETPASS))
 235         {
 236           password = getpass ("Enter POP password:");
 237         }
 238       if (! password)
 239         {
 240           strcpy (pop_error, "Could not determine POP password");
 241           return (0);
 242         }
 243     }
 244   if (password)                 /* always true, detected 20060515 */
 245     flags |= POP_NO_KERBEROS;
 246   else
 247     password = username;        /* dead code, detected 20060515 */
 248   /** "kpop" service is  never used: look for 20060515 to see why **/
 249
 250   sock = socket_connection (host, flags);
 251   if (sock == -1)
 252     return (0);
 253
 254   server = (popserver) malloc (sizeof (struct _popserver));
 255   if (! server)
 256     {
 257       strcpy (pop_error, "Out of memory in pop_open");
 258       return (0);
 259     }
 260   server->buffer = (char *) malloc (GETLINE_MIN);
 261   if (! server->buffer)
 262     {
 263       strcpy (pop_error, "Out of memory in pop_open");
 264       free ((char *) server);
 265       return (0);
 266     }
 267
 268   server->file = sock;
 269   server->data = 0;
 270   server->buffer_index = 0;
 271   server->buffer_size = GETLINE_MIN;
 272   server->in_multi = false;
 273   server->trash_started = false;
 274
 275   if (getok (server))
 276     return (0);
 277
 278   /*
 279    * I really shouldn't use the pop_error variable like this, but....
 280    */
 281   if (strlen (username) > ERROR_MAX - 6)
 282     {
 283       pop_close (server);
 284       strcpy (pop_error,
 285               "Username too long; recompile pop.c with larger ERROR_MAX");
 286       return (0);
 287     }
 288   sprintf (pop_error, "USER %s", username);
 289
 290   if (sendline (server, pop_error) || getok (server))
 291     {
 292       return (0);
 293     }
 294
 295   if (strlen (password) > ERROR_MAX - 6)
 296     {
 297       pop_close (server);
 298       strcpy (pop_error,
 299               "Password too long; recompile pop.c with larger ERROR_MAX");
 300       return (0);
 301     }
 302   sprintf (pop_error, "PASS %s", password);
 303
 304   if (sendline (server, pop_error) || getok (server))
 305     {
 306       return (0);
 307     }
 308
 309   return (server);
 310 }
 311
 312 /*
 313  * Function: pop_stat
 314  *
 315  * Purpose: Issue the STAT command to the server and return (in the
 316  *      value parameters) the number of messages in the maildrop and
 317  *      the total size of the maildrop.
 318  *
 319  * Return value: 0 on success, or non-zero with an error in pop_error
 320  *      in failure.
 321  *
 322  * Side effects: On failure, may make further operations on the
 323  *      connection impossible.
 324  */
 325 int
 326 pop_stat (popserver server, int *count, int *size)
 327 {
 328   char *fromserver;
 329   char *end_ptr;
 330
 331   if (server->in_multi)
 332     {
 333       strcpy (pop_error, "In multi-line query in pop_stat");
 334       return (-1);
 335     }
 336
 337   if (sendline (server, "STAT") || (pop_getline (server, &fromserver) < 0))
 338     return (-1);
 339
 340   if (strncmp (fromserver, "+OK ", 4))
 341     {
 342       if (0 == strncmp (fromserver, "-ERR", 4))
 343         snprintf (pop_error, ERROR_MAX, "%s", fromserver);
 344       else
 345         {
 346           strcpy (pop_error,
 347                   "Unexpected response from POP server in pop_stat");
 348           pop_trash (server);
 349         }
 350       return (-1);
 351     }
 352
 353   errno = 0;
 354   *count = strtol (&fromserver[4], &end_ptr, 10);
 355   /* Check validity of string-to-integer conversion. */
 356   if (fromserver + 4 == end_ptr || *end_ptr != ' ' || errno)
 357     {
 358       strcpy (pop_error, "Unexpected response from POP server in pop_stat");
 359       pop_trash (server);
 360       return (-1);
 361     }
 362
 363   fromserver = end_ptr;
 364
 365   errno = 0;
 366   *size = strtol (fromserver + 1, &end_ptr, 10);
 367   if (fromserver + 1 == end_ptr || errno)
 368     {
 369       strcpy (pop_error, "Unexpected response from POP server in pop_stat");
 370       pop_trash (server);
 371       return (-1);
 372     }
 373
 374   return (0);
 375 }
 376
 377 /*
 378  * Function: pop_list
 379  *
 380  * Purpose: Performs the POP "list" command and returns (in value
 381  *      parameters) two malloc'd zero-terminated arrays -- one of
 382  *      message IDs, and a parallel one of sizes.
 383  *
 384  * Arguments:
 385  *      server  The pop connection to talk to.
 386  *      message The number of the one message about which to get
 387  *              information, or 0 to get information about all
 388  *              messages.
 389  *
 390  * Return value: 0 on success, non-zero with error in pop_error on
 391  *      failure.
 392  *
 393  * Side effects: On failure, may make further operations on the
 394  *      connection impossible.
 395  */
 396 int
 397 pop_list (popserver server, int message, int **IDs, int **sizes)
 398 {
 399   int how_many, i;
 400   char *fromserver;
 401
 402   if (server->in_multi)
 403     {
 404       strcpy (pop_error, "In multi-line query in pop_list");
 405       return (-1);
 406     }
 407
 408   if (message)
 409     how_many = 1;
 410   else
 411     {
 412       int count, size;
 413       if (pop_stat (server, &count, &size))
 414         return (-1);
 415       how_many = count;
 416     }
 417
 418   *IDs = (int *) malloc ((how_many + 1) * sizeof (int));
 419   *sizes = (int *) malloc ((how_many + 1) * sizeof (int));
 420   if (! (*IDs && *sizes))
 421     {
 422       strcpy (pop_error, "Out of memory in pop_list");
 423       return (-1);
 424     }
 425
 426   if (message)
 427     {
 428       sprintf (pop_error, "LIST %d", message);
 429       if (sendline (server, pop_error))
 430         {
 431           free ((char *) *IDs);
 432           free ((char *) *sizes);
 433           return (-1);
 434         }
 435       if (pop_getline (server, &fromserver) < 0)
 436         {
 437           free ((char *) *IDs);
 438           free ((char *) *sizes);
 439           return (-1);
 440         }
 441       if (strncmp (fromserver, "+OK ", 4))
 442         {
 443           if (! strncmp (fromserver, "-ERR", 4))
 444             snprintf (pop_error, ERROR_MAX, "%s", fromserver);
 445           else
 446             {
 447               strcpy (pop_error,
 448                       "Unexpected response from server in pop_list");
 449               pop_trash (server);
 450             }
 451           free ((char *) *IDs);
 452           free ((char *) *sizes);
 453           return (-1);
 454         }
 455       (*IDs)[0] = atoi (&fromserver[4]);
 456       fromserver = strchr (&fromserver[4], ' ');
 457       if (! fromserver)
 458         {
 459           strcpy (pop_error,
 460                   "Badly formatted response from server in pop_list");
 461           pop_trash (server);
 462           free ((char *) *IDs);
 463           free ((char *) *sizes);
 464           return (-1);
 465         }
 466       (*sizes)[0] = atoi (fromserver);
 467       (*IDs)[1] = (*sizes)[1] = 0;
 468       return (0);
 469     }
 470   else
 471     {
 472       if (pop_multi_first (server, "LIST", &fromserver))
 473         {
 474           free ((char *) *IDs);
 475           free ((char *) *sizes);
 476           return (-1);
 477         }
 478       for (i = 0; i < how_many; i++)
 479         {
 480           if (pop_multi_next (server, &fromserver) <= 0)
 481             {
 482               free ((char *) *IDs);
 483               free ((char *) *sizes);
 484               return (-1);
 485             }
 486           (*IDs)[i] = atoi (fromserver);
 487           fromserver = strchr (fromserver, ' ');
 488           if (! fromserver)
 489             {
 490               strcpy (pop_error,
 491                       "Badly formatted response from server in pop_list");
 492               free ((char *) *IDs);
 493               free ((char *) *sizes);
 494               pop_trash (server);
 495               return (-1);
 496             }
 497           (*sizes)[i] = atoi (fromserver);
 498         }
 499       if (pop_multi_next (server, &fromserver) < 0)
 500         {
 501           free ((char *) *IDs);
 502           free ((char *) *sizes);
 503           return (-1);
 504         }
 505       else if (fromserver)
 506         {
 507           strcpy (pop_error,
 508                   "Too many response lines from server in pop_list");
 509           free ((char *) *IDs);
 510           free ((char *) *sizes);
 511           return (-1);
 512         }
 513       (*IDs)[i] = (*sizes)[i] = 0;
 514       return (0);
 515     }
 516 }
 517
 518 /*
 519  * Function: pop_retrieve
 520  *
 521  * Purpose: Retrieve a specified message from the maildrop.
 522  *
 523  * Arguments:
 524  *      server  The server to retrieve from.
 525  *      message The message number to retrieve.
 526  *      markfrom
 527  *              If true, then mark the string "From " at the beginning
 528  *              of lines with '>'.
 529  *      msg_buf Output parameter to which a buffer containing the
 530  *              message is assigned.
 531  *
 532  * Return value: The number of bytes in msg_buf, which may contain
 533  *      embedded nulls, not including its final null, or -1 on error
 534  *      with pop_error set.
 535  *
 536  * Side effects: May kill connection on error.
 537  */
 538 int
 539 pop_retrieve (popserver server, int message, int markfrom, char **msg_buf)
 540 {
 541   int *IDs, *sizes, bufsize, fromcount = 0, cp = 0;
 542   char *ptr, *fromserver;
 543   int ret;
 544
 545   if (server->in_multi)
 546     {
 547       strcpy (pop_error, "In multi-line query in pop_retrieve");
 548       return (-1);
 549     }
 550
 551   if (pop_list (server, message, &IDs, &sizes))
 552     return (-1);
 553
 554   if (pop_retrieve_first (server, message, &fromserver))
 555     {
 556       return (-1);
 557     }
 558
 559   /*
 560    * The "5" below is an arbitrary constant -- I assume that if
 561    * there are "From" lines in the text to be marked, there
 562    * probably won't be more than 5 of them.  If there are, I
 563    * allocate more space for them below.
 564    */
 565   bufsize = sizes[0] + (markfrom ? 5 : 0);
 566   ptr = (char *)malloc (bufsize);
 567   free ((char *) IDs);
 568   free ((char *) sizes);
 569
 570   if (! ptr)
 571     {
 572       strcpy (pop_error, "Out of memory in pop_retrieve");
 573       pop_retrieve_flush (server);
 574       return (-1);
 575     }
 576
 577   while ((ret = pop_retrieve_next (server, &fromserver)) >= 0)
 578     {
 579       if (! fromserver)
 580         {
 581           ptr[cp] = '\0';
 582           *msg_buf = ptr;
 583           return (cp);
 584         }
 585       if (markfrom && fromserver[0] == 'F' && fromserver[1] == 'r' &&
 586           fromserver[2] == 'o' && fromserver[3] == 'm' &&
 587           fromserver[4] == ' ')
 588         {
 589           if (++fromcount == 5)
 590             {
 591               bufsize += 5;
 592               ptr = (char *)realloc (ptr, bufsize);
 593               if (! ptr)
 594                 {
 595                   strcpy (pop_error, "Out of memory in pop_retrieve");
 596                   pop_retrieve_flush (server);
 597                   return (-1);
 598                 }
 599               fromcount = 0;
 600             }
 601           ptr[cp++] = '>';
 602         }
 603       memcpy (&ptr[cp], fromserver, ret);
 604       cp += ret;
 605       ptr[cp++] = '\n';
 606     }
 607
 608   free (ptr);
 609   return (-1);
 610 }
 611
 612 int
 613 pop_retrieve_first (popserver server, int message, char **response)
 614 {
 615   sprintf (pop_error, "RETR %d", message);
 616   return (pop_multi_first (server, pop_error, response));
 617 }
 618
 619 /*
 620   Returns a negative number on error, 0 to indicate that the data has
 621   all been read (i.e., the server has returned a "." termination
 622   line), or a positive number indicating the number of bytes in the
 623   returned buffer (which is null-terminated and may contain embedded
 624   nulls, but the returned bytecount doesn't include the final null).
 625   */
 626
 627 int
 628 pop_retrieve_next (popserver server, char **line)
 629 {
 630   return (pop_multi_next (server, line));
 631 }
 632
 633 int
 634 pop_retrieve_flush (popserver server)
 635 {
 636   return (pop_multi_flush (server));
 637 }
 638
 639 int
 640 pop_top_first (popserver server, int message, int lines, char **response)
 641 {
 642   sprintf (pop_error, "TOP %d %d", message, lines);
 643   return (pop_multi_first (server, pop_error, response));
 644 }
 645
 646 /*
 647   Returns a negative number on error, 0 to indicate that the data has
 648   all been read (i.e., the server has returned a "." termination
 649   line), or a positive number indicating the number of bytes in the
 650   returned buffer (which is null-terminated and may contain embedded
 651   nulls, but the returned bytecount doesn't include the final null).
 652   */
 653
 654 int
 655 pop_top_next (popserver server, char **line)
 656 {
 657   return (pop_multi_next (server, line));
 658 }
 659
 660 int
 661 pop_top_flush (popserver server)
 662 {
 663   return (pop_multi_flush (server));
 664 }
 665
 666 int
 667 pop_multi_first (popserver server, const char *command, char **response)
 668 {
 669   if (server->in_multi)
 670     {
 671       strcpy (pop_error,
 672               "Already in multi-line query in pop_multi_first");
 673       return (-1);
 674     }
 675
 676   if (sendline (server, command) || (pop_getline (server, response) < 0))
 677     {
 678       return (-1);
 679     }
 680
 681   if (0 == strncmp (*response, "-ERR", 4))
 682     {
 683       snprintf (pop_error, ERROR_MAX, "%s", *response);
 684       return (-1);
 685     }
 686   else if (0 == strncmp (*response, "+OK", 3))
 687     {
 688       for (*response += 3; **response == ' '; (*response)++) /* empty */;
 689       server->in_multi = true;
 690       return (0);
 691     }
 692   else
 693     {
 694       strcpy (pop_error,
 695               "Unexpected response from server in pop_multi_first");
 696       return (-1);
 697     }
 698 }
 699
 700 /*
 701   Read the next line of data from SERVER and place a pointer to it
 702   into LINE.  Return -1 on error, 0 if there are no more lines to read
 703   (i.e., the server has returned a line containing only "."), or a
 704   positive number indicating the number of bytes in the LINE buffer
 705   (not including the final null).  The data in that buffer may contain
 706   embedded nulls, but does not contain the final CRLF. When returning
 707   0, LINE is set to null. */
 708
 709 int
 710 pop_multi_next (popserver server, char **line)
 711 {
 712   char *fromserver;
 713   int ret;
 714
 715   if (! server->in_multi)
 716     {
 717       strcpy (pop_error, "Not in multi-line query in pop_multi_next");
 718       return (-1);
 719     }
 720
 721   if ((ret = pop_getline (server, &fromserver)) < 0)
 722     {
 723       return (-1);
 724     }
 725
 726   if (fromserver[0] == '.')
 727     {
 728       if (! fromserver[1])
 729         {
 730           *line = 0;
 731           server->in_multi = false;
 732           return (0);
 733         }
 734       else
 735         {
 736           *line = fromserver + 1;
 737           return (ret - 1);
 738         }
 739     }
 740   else
 741     {
 742       *line = fromserver;
 743       return (ret);
 744     }
 745 }
 746
 747 int
 748 pop_multi_flush (popserver server)
 749 {
 750   char *line;
 751   int ret;
 752
 753   if (! server->in_multi)
 754     {
 755       return (0);
 756     }
 757
 758   while ((ret = pop_multi_next (server, &line)))
 759     {
 760       if (ret < 0)
 761         return (-1);
 762     }
 763
 764   return (0);
 765 }
 766
 767 /* Function: pop_delete
 768  *
 769  * Purpose: Delete a specified message.
 770  *
 771  * Arguments:
 772  *      server  Server from which to delete the message.
 773  *      message Message to delete.
 774  *
 775  * Return value: 0 on success, non-zero with error in pop_error
 776  *      otherwise.
 777  */
 778 int
 779 pop_delete (popserver server, int message)
 780 {
 781   if (server->in_multi)
 782     {
 783       strcpy (pop_error, "In multi-line query in pop_delete");
 784       return (-1);
 785     }
 786
 787   sprintf (pop_error, "DELE %d", message);
 788
 789   if (sendline (server, pop_error) || getok (server))
 790     return (-1);
 791
 792   return (0);
 793 }
 794
 795 /*
 796  * Function: pop_noop
 797  *
 798  * Purpose: Send a noop command to the server.
 799  *
 800  * Argument:
 801  *      server  The server to send to.
 802  *
 803  * Return value: 0 on success, non-zero with error in pop_error
 804  *      otherwise.
 805  *
 806  * Side effects: Closes connection on error.
 807  */
 808 int
 809 pop_noop (popserver server)
 810 {
 811   if (server->in_multi)
 812     {
 813       strcpy (pop_error, "In multi-line query in pop_noop");
 814       return (-1);
 815     }
 816
 817   if (sendline (server, "NOOP") || getok (server))
 818     return (-1);
 819
 820   return (0);
 821 }
 822
 823 /*
 824  * Function: pop_last
 825  *
 826  * Purpose: Find out the highest seen message from the server.
 827  *
 828  * Arguments:
 829  *      server  The server.
 830  *
 831  * Return value: If successful, the highest seen message, which is
 832  *      greater than or equal to 0.  Otherwise, a negative number with
 833  *      the error explained in pop_error.
 834  *
 835  * Side effects: Closes the connection on error.
 836  */
 837 int
 838 pop_last (popserver server)
 839 {
 840   char *fromserver;
 841
 842   if (server->in_multi)
 843     {
 844       strcpy (pop_error, "In multi-line query in pop_last");
 845       return (-1);
 846     }
 847
 848   if (sendline (server, "LAST"))
 849     return (-1);
 850
 851   if (pop_getline (server, &fromserver) < 0)
 852     return (-1);
 853
 854   if (! strncmp (fromserver, "-ERR", 4))
 855     {
 856       snprintf (pop_error, ERROR_MAX, "%s", fromserver);
 857       return (-1);
 858     }
 859   else if (strncmp (fromserver, "+OK ", 4))
 860     {
 861       strcpy (pop_error, "Unexpected response from server in pop_last");
 862       pop_trash (server);
 863       return (-1);
 864     }
 865   else
 866     {
 867       char *end_ptr;
 868       int count;
 869       errno = 0;
 870       count = strtol (&fromserver[4], &end_ptr, 10);
 871       if (fromserver + 4 == end_ptr || errno)
 872         {
 873           strcpy (pop_error, "Unexpected response from server in pop_last");
 874           pop_trash (server);
 875           return (-1);
 876         }
 877       return count;
 878     }
 879 }
 880
 881 /*
 882  * Function: pop_reset
 883  *
 884  * Purpose: Reset the server to its initial connect state
 885  *
 886  * Arguments:
 887  *      server  The server.
 888  *
 889  * Return value: 0 for success, non-0 with error in pop_error
 890  *      otherwise.
 891  *
 892  * Side effects: Closes the connection on error.
 893  */
 894 int
 895 pop_reset (popserver server)
 896 {
 897   if (pop_retrieve_flush (server))
 898     {
 899       return (-1);
 900     }
 901
 902   if (sendline (server, "RSET") || getok (server))
 903     return (-1);
 904
 905   return (0);
 906 }
 907
 908 /*
 909  * Function: pop_quit
 910  *
 911  * Purpose: Quit the connection to the server,
 912  *
 913  * Arguments:
 914  *      server  The server to quit.
 915  *
 916  * Return value: 0 for success, non-zero otherwise with error in
 917  *      pop_error.
 918  *
 919  * Side Effects: The popserver passed in is unusable after this
 920  *      function is called, even if an error occurs.
 921  */
 922 int
 923 pop_quit (popserver server)
 924 {
 925   int ret = 0;
 926
 927   if (server->file >= 0)
 928     {
 929       if (pop_retrieve_flush (server))
 930         {
 931           ret = -1;
 932         }
 933
 934       if (sendline (server, "QUIT") || getok (server))
 935         {
 936           ret = -1;
 937         }
 938
 939       close (server->file);
 940     }
 941
 942   free (server->buffer);
 943   free ((char *) server);
 944
 945   return (ret);
 946 }
 947
 948 #ifdef WINDOWSNT
 949 static int have_winsock = 0;
 950 #endif
 951
 952 /*
 953  * Function: socket_connection
 954  *
 955  * Purpose: Opens the network connection with the mail host, without
 956  *      doing any sort of I/O with it or anything.
 957  *
 958  * Arguments:
 959  *      host    The host to which to connect.
 960  *      flags   Option flags.
 961  *
 962  * Return value: A file descriptor indicating the connection, or -1
 963  *      indicating failure, in which case an error has been copied
 964  *      into pop_error.
 965  */
 966 static int
 967 socket_connection (char *host, int flags)
 968 {
 969 #ifdef HAVE_GETADDRINFO
 970   struct addrinfo *res, *it;
 971   struct addrinfo hints;
 972   int ret;
 973 #else /* !HAVE_GETADDRINFO */
 974   struct hostent *hostent;
 975 #endif
 976   struct servent *servent;
 977   struct sockaddr_in addr;
 978   char found_port = 0;
 979   const char *service;
 980   int sock;
 981   char *realhost;
 982 #ifdef KERBEROS
 983 #ifdef KERBEROS5
 984   krb5_error_code rem;
 985   krb5_context kcontext = 0;
 986   krb5_auth_context auth_context = 0;
 987   krb5_ccache ccdef;
 988   krb5_principal client, server;
 989   krb5_error *err_ret;
 990   register char *cp;
 991 #else
 992   KTEXT ticket;
 993   MSG_DAT msg_data;
 994   CREDENTIALS cred;
 995   Key_schedule schedule;
 996   int rem;
 997 #endif /* KERBEROS5 */
 998 #endif /* KERBEROS */
 999
1000   int try_count = 0;
1001   int connect_ok;
1002
1003 #ifdef WINDOWSNT
1004   {
1005     WSADATA winsockData;
1006     if (WSAStartup (0x101, &winsockData) == 0)
1007       have_winsock = 1;
1008   }
1009 #endif
1010
1011   memset (&addr, 0, sizeof (addr));
1012   addr.sin_family = AF_INET;
1013
1014   /** "kpop" service is  never used: look for 20060515 to see why **/
1015 #ifdef KERBEROS
1016   service = (flags & POP_NO_KERBEROS) ? POP_SERVICE : KPOP_SERVICE;
1017 #else
1018   service = POP_SERVICE;
1019 #endif
1020
1021 #ifdef HESIOD
1022   if (! (flags & POP_NO_HESIOD))
1023     {
1024       servent = hes_getservbyname (service, "tcp");
1025       if (servent)
1026         {
1027           addr.sin_port = servent->s_port;
1028           found_port = 1;
1029         }
1030     }
1031 #endif
1032   if (! found_port)
1033     {
1034       servent = getservbyname (service, "tcp");
1035       if (servent)
1036         {
1037           addr.sin_port = servent->s_port;
1038         }
1039       else
1040         {
1041   /** "kpop" service is  never used: look for 20060515 to see why **/
1042 #ifdef KERBEROS
1043           addr.sin_port = htons ((flags & POP_NO_KERBEROS) ?
1044                                 POP_PORT : KPOP_PORT);
1045 #else
1046           addr.sin_port = htons (POP_PORT);
1047 #endif
1048         }
1049     }
1050
1051 #define POP_SOCKET_ERROR "Could not create socket for POP connection: "
1052
1053   sock = socket (PF_INET, SOCK_STREAM, 0);
1054   if (sock < 0)
1055     {
1056       snprintf (pop_error, ERROR_MAX, "%s%s",
1057                 POP_SOCKET_ERROR, strerror (errno));
1058       return (-1);
1059
1060     }
1061
1062 #ifdef HAVE_GETADDRINFO
1063   memset (&hints, 0, sizeof (hints));
1064   hints.ai_socktype = SOCK_STREAM;
1065   hints.ai_flags = AI_CANONNAME;
1066   hints.ai_family = AF_INET;
1067   do
1068     {
1069       ret = getaddrinfo (host, service, &hints, &res);
1070       try_count++;
1071       if (ret != 0 && (ret != EAI_AGAIN || try_count == 5))
1072         {
1073           strcpy (pop_error, "Could not determine POP server's address");
1074           return (-1);
1075         }
1076     } while (ret != 0);
1077
1078   for (it = res; it; it = it->ai_next)
1079     if (it->ai_addrlen == sizeof addr)
1080       {
1081         struct sockaddr_in *in_a = (struct sockaddr_in *) it->ai_addr;
1082         addr.sin_addr = in_a->sin_addr;
1083         if (! connect (sock, (struct sockaddr *) &addr, sizeof addr))
1084           break;
1085       }
1086   connect_ok = it != NULL;
1087   if (connect_ok)
1088     {
1089       realhost = alloca (strlen (it->ai_canonname) + 1);
1090       strcpy (realhost, it->ai_canonname);
1091     }
1092   freeaddrinfo (res);
1093
1094 #else /* !HAVE_GETADDRINFO */
1095   do
1096     {
1097       hostent = gethostbyname (host);
1098       try_count++;
1099       if ((! hostent) && ((h_errno != TRY_AGAIN) || (try_count == 5)))
1100         {
1101           strcpy (pop_error, "Could not determine POP server's address");
1102           return (-1);
1103         }
1104     } while (! hostent);
1105
1106   while (*hostent->h_addr_list)
1107     {
1108       memcpy (&addr.sin_addr, *hostent->h_addr_list, hostent->h_length);
1109       if (! connect (sock, (struct sockaddr *) &addr, sizeof (addr)))
1110         break;
1111       hostent->h_addr_list++;
1112     }
1113   connect_ok = *hostent->h_addr_list != NULL;
1114   if (! connect_ok)
1115     {
1116       realhost = alloca (strlen (hostent->h_name) + 1);
1117       strcpy (realhost, hostent->h_name);
1118     }
1119
1120 #endif /* !HAVE_GETADDRINFO */
1121
1122 #define CONNECT_ERROR "Could not connect to POP server: "
1123
1124   if (! connect_ok)
1125     {
1126       CLOSESOCKET (sock);
1127       snprintf (pop_error, ERROR_MAX, "%s%s", CONNECT_ERROR, strerror (errno));
1128       return (-1);
1129
1130     }
1131
1132 #ifdef KERBEROS
1133
1134 #define KRB_ERROR "Kerberos error connecting to POP server: "
1135   if (! (flags & POP_NO_KERBEROS))
1136     {
1137 #ifdef KERBEROS5
1138       if ((rem = krb5_init_context (&kcontext)))
1139         {
1140         krb5error:
1141           if (auth_context)
1142             krb5_auth_con_free (kcontext, auth_context);
1143           if (kcontext)
1144             krb5_free_context (kcontext);
1145           snprintf (pop_error, ERROR_MAX, "%s%s",
1146                     KRB_ERROR, error_message (rem));
1147           CLOSESOCKET (sock);
1148           return (-1);
1149         }
1150
1151       if ((rem = krb5_auth_con_init (kcontext, &auth_context)))
1152         goto krb5error;
1153
1154       if (rem = krb5_cc_default (kcontext, &ccdef))
1155         goto krb5error;
1156
1157       if (rem = krb5_cc_get_principal (kcontext, ccdef, &client))
1158         goto krb5error;
1159
1160       for (cp = realhost; *cp; cp++)
1161         {
1162           if (isupper (*cp))
1163             {
1164               *cp = tolower (*cp);
1165             }
1166         }
1167
1168       if (rem = krb5_sname_to_principal (kcontext, realhost,
1169                                          POP_SERVICE, FALSE, &server))
1170         goto krb5error;
1171
1172       rem = krb5_sendauth (kcontext, &auth_context,
1173                            (krb5_pointer) &sock, "KPOPV1.0", client, server,
1174                           AP_OPTS_MUTUAL_REQUIRED,
1175                           0,    /* no checksum */
1176                           0,    /* no creds, use ccache instead */
1177                           ccdef,
1178                           &err_ret,
1179                           0,    /* don't need subsession key */
1180                           0);   /* don't need reply */
1181       krb5_free_principal (kcontext, server);
1182       if (rem)
1183         {
1184           int pop_error_len = snprintf (pop_error, ERROR_MAX, "%s%s",
1185                                         KRB_ERROR, error_message (rem));
1186 #if defined HAVE_KRB5_ERROR_TEXT
1187           if (err_ret && err_ret->text.length)
1188             {
1189               int errlen = err_ret->text.length;
1190               snprintf (pop_error + pop_error_len, ERROR_MAX - pop_error_len,
1191                         " [server says '.*%s']", errlen, err_ret->text.data);
1192             }
1193 #elif defined HAVE_KRB5_ERROR_E_TEXT
1194           if (err_ret && err_ret->e_text && **err_ret->e_text)
1195             snprintf (pop_error + pop_error_len, ERROR_MAX - pop_error_len,
1196                       " [server says '%s']", *err_ret->e_text);
1197 #endif
1198           if (err_ret)
1199             krb5_free_error (kcontext, err_ret);
1200           krb5_auth_con_free (kcontext, auth_context);
1201           krb5_free_context (kcontext);
1202
1203           CLOSESOCKET (sock);
1204           return (-1);
1205         }
1206 #else  /* ! KERBEROS5 */
1207       ticket = (KTEXT) malloc (sizeof (KTEXT_ST));
1208       rem = krb_sendauth (0L, sock, ticket, "pop", realhost,
1209                           (char *) krb_realmofhost (realhost),
1210                           (unsigned long) 0, &msg_data, &cred, schedule,
1211                           (struct sockaddr_in *) 0,
1212                           (struct sockaddr_in *) 0,
1213                           "KPOPV0.1");
1214       free ((char *) ticket);
1215       if (rem != KSUCCESS)
1216         {
1217           snprintf (pop_error, ERROR_MAX, "%s%s", KRB_ERROR, krb_err_txt[rem]);
1218           CLOSESOCKET (sock);
1219           return (-1);
1220         }
1221 #endif /* KERBEROS5 */
1222     }
1223 #endif /* KERBEROS */
1224
1225   return (sock);
1226 } /* socket_connection */
1227
1228 /*
1229  * Function: pop_getline
1230  *
1231  * Purpose: Get a line of text from the connection and return a
1232  *      pointer to it.  The carriage return and linefeed at the end of
1233  *      the line are stripped, but periods at the beginnings of lines
1234  *      are NOT dealt with in any special way.
1235  *
1236  * Arguments:
1237  *      server  The server from which to get the line of text.
1238  *
1239  * Returns: The number of characters in the line, which is returned in
1240  *      LINE, not including the final null.  A return value of 0
1241  *      indicates a blank line.  A negative return value indicates an
1242  *      error (in which case the contents of LINE are undefined.  In
1243  *      case of error, an error message is copied into pop_error.
1244  *
1245  * Notes: The line returned is overwritten with each call to pop_getline.
1246  *
1247  * Side effects: Closes the connection on error.
1248  *
1249  * THE RETURNED LINE MAY CONTAIN EMBEDDED NULLS!
1250  */
1251 static int
1252 pop_getline (popserver server, char **line)
1253 {
1254 #define GETLINE_ERROR "Error reading from server: "
1255
1256   int ret;
1257   int search_offset = 0;
1258
1259   if (server->data)
1260     {
1261       char *cp = find_crlf (server->buffer + server->buffer_index,
1262                             server->data);
1263       if (cp)
1264         {
1265           int found;
1266           int data_used;
1267
1268           found = server->buffer_index;
1269           data_used = (cp + 2) - server->buffer - found;
1270
1271           *cp = '\0';           /* terminate the string to be returned */
1272           server->data -= data_used;
1273           server->buffer_index += data_used;
1274
1275           if (pop_debug)
1276             /* Embedded nulls will truncate this output prematurely,
1277                but that's OK because it's just for debugging anyway. */
1278             fprintf (stderr, "<<< %s\n", server->buffer + found);
1279           *line = server->buffer + found;
1280           return (data_used - 2);
1281         }
1282       else
1283         {
1284           memmove (server->buffer, server->buffer + server->buffer_index,
1285                    server->data);
1286           /* Record the fact that we've searched the data already in
1287              the buffer for a CRLF, so that when we search below, we
1288              don't have to search the same data twice.  There's a "-
1289              1" here to account for the fact that the last character
1290              of the data we have may be the CR of a CRLF pair, of
1291              which we haven't read the second half yet, so we may have
1292              to search it again when we read more data. */
1293           search_offset = server->data - 1;
1294           server->buffer_index = 0;
1295         }
1296     }
1297   else
1298     {
1299       server->buffer_index = 0;
1300     }
1301
1302   while (1)
1303     {
1304       /* There's a "- 1" here to leave room for the null that we put
1305          at the end of the read data below.  We put the null there so
1306          that find_crlf knows where to stop when we call it. */
1307       if (server->data == server->buffer_size - 1)
1308         {
1309           server->buffer_size += GETLINE_INCR;
1310           server->buffer = (char *)realloc (server->buffer, server->buffer_size);
1311           if (! server->buffer)
1312             {
1313               strcpy (pop_error, "Out of memory in pop_getline");
1314               pop_trash (server);
1315               return (-1);
1316             }
1317         }
1318       ret = RECV (server->file, server->buffer + server->data,
1319                   server->buffer_size - server->data - 1, 0);
1320       if (ret < 0)
1321         {
1322           snprintf (pop_error, ERROR_MAX, "%s%s",
1323                     GETLINE_ERROR, strerror (errno));
1324           pop_trash (server);
1325           return (-1);
1326         }
1327       else if (ret == 0)
1328         {
1329           strcpy (pop_error, "Unexpected EOF from server in pop_getline");
1330           pop_trash (server);
1331           return (-1);
1332         }
1333       else
1334         {
1335           char *cp;
1336           server->data += ret;
1337           server->buffer[server->data] = '\0';
1338
1339           cp = find_crlf (server->buffer + search_offset,
1340                           server->data - search_offset);
1341           if (cp)
1342             {
1343               int data_used = (cp + 2) - server->buffer;
1344               *cp = '\0';
1345               server->data -= data_used;
1346               server->buffer_index = data_used;
1347
1348               if (pop_debug)
1349                 fprintf (stderr, "<<< %s\n", server->buffer);
1350               *line = server->buffer;
1351               return (data_used - 2);
1352             }
1353           /* As above, the "- 1" here is to account for the fact that
1354              we may have read a CR without its accompanying LF. */
1355           search_offset += ret - 1;
1356         }
1357     }
1358
1359   /* NOTREACHED */
1360 }
1361
1362 /*
1363  * Function: sendline
1364  *
1365  * Purpose: Sends a line of text to the POP server.  The line of text
1366  *      passed into this function should NOT have the carriage return
1367  *      and linefeed on the end of it.  Periods at beginnings of lines
1368  *      will NOT be treated specially by this function.
1369  *
1370  * Arguments:
1371  *      server  The server to which to send the text.
1372  *      line    The line of text to send.
1373  *
1374  * Return value: Upon successful completion, a value of 0 will be
1375  *      returned.  Otherwise, a non-zero value will be returned, and
1376  *      an error will be copied into pop_error.
1377  *
1378  * Side effects: Closes the connection on error.
1379  */
1380 static int
1381 sendline (popserver server, const char *line)
1382 {
1383 #define SENDLINE_ERROR "Error writing to POP server: "
1384   int ret;
1385   char *buf;
1386
1387   /* Combine the string and the CR-LF into one buffer.  Otherwise, two
1388      reasonable network stack optimizations, Nagle's algorithm and
1389      delayed acks, combine to delay us a fraction of a second on every
1390      message we send.  (Movemail writes line without \r\n, client
1391      kernel sends packet, server kernel delays the ack to see if it
1392      can combine it with data, movemail writes \r\n, client kernel
1393      waits because it has unacked data already in its outgoing queue,
1394      client kernel eventually times out and sends.)
1395
1396      This can be something like 0.2s per command, which can add up
1397      over a few dozen messages, and is a big chunk of the time we
1398      spend fetching mail from a server close by.  */
1399   buf = alloca (strlen (line) + 3);
1400   strcpy (buf, line);
1401   strcat (buf, "\r\n");
1402   ret = fullwrite (server->file, buf, strlen (buf));
1403
1404   if (ret < 0)
1405     {
1406       pop_trash (server);
1407       snprintf (pop_error, ERROR_MAX, "%s%s", SENDLINE_ERROR, strerror (errno));
1408       return (ret);
1409     }
1410
1411   if (pop_debug)
1412     fprintf (stderr, ">>> %s\n", line);
1413
1414   return (0);
1415 }
1416
1417 /*
1418  * Procedure: fullwrite
1419  *
1420  * Purpose: Just like write, but keeps trying until the entire string
1421  *      has been written.
1422  *
1423  * Return value: Same as write.  Pop_error is not set.
1424  */
1425 static int
1426 fullwrite (int fd, char *buf, int nbytes)
1427 {
1428   char *cp;
1429   int ret = 0;
1430
1431   cp = buf;
1432   while (nbytes && ((ret = SEND (fd, cp, nbytes, 0)) > 0))
1433     {
1434       cp += ret;
1435       nbytes -= ret;
1436     }
1437
1438   return (ret);
1439 }
1440
1441 /*
1442  * Procedure getok
1443  *
1444  * Purpose: Reads a line from the server.  If the return indicator is
1445  *      positive, return with a zero exit status.  If not, return with
1446  *      a negative exit status.
1447  *
1448  * Arguments:
1449  *      server  The server to read from.
1450  *
1451  * Returns: 0 for success, else for failure and puts error in pop_error.
1452  *
1453  * Side effects: On failure, may make the connection unusable.
1454  */
1455 static int
1456 getok (popserver server)
1457 {
1458   char *fromline;
1459
1460   if (pop_getline (server, &fromline) < 0)
1461     {
1462       return (-1);
1463     }
1464
1465   if (! strncmp (fromline, "+OK", 3))
1466     return (0);
1467   else if (! strncmp (fromline, "-ERR", 4))
1468     {
1469       snprintf (pop_error, ERROR_MAX, "%s", fromline);
1470       return (-1);
1471     }
1472   else
1473     {
1474       strcpy (pop_error,
1475               "Unexpected response from server; expecting +OK or -ERR");
1476       pop_trash (server);
1477       return (-1);
1478     }
1479 }
1480
1481 #if 0
1482 /*
1483  * Function: gettermination
1484  *
1485  * Purpose: Gets the next line and verifies that it is a termination
1486  *      line (nothing but a dot).
1487  *
1488  * Return value: 0 on success, non-zero with pop_error set on error.
1489  *
1490  * Side effects: Closes the connection on error.
1491  */
1492 static int
1493 gettermination (server)
1494      popserver server;
1495 {
1496   char *fromserver;
1497
1498   if (pop_getline (server, &fromserver) < 0)
1499     return (-1);
1500
1501   if (strcmp (fromserver, "."))
1502     {
1503       strcpy (pop_error,
1504               "Unexpected response from server in gettermination");
1505       pop_trash (server);
1506       return (-1);
1507     }
1508
1509   return (0);
1510 }
1511 #endif
1512
1513 /*
1514  * Function pop_close
1515  *
1516  * Purpose: Close a pop connection, sending a "RSET" command to try to
1517  *      preserve any changes that were made and a "QUIT" command to
1518  *      try to get the server to quit, but ignoring any responses that
1519  *      are received.
1520  *
1521  * Side effects: The server is unusable after this function returns.
1522  *      Changes made to the maildrop since the session was started (or
1523  *      since the last pop_reset) may be lost.
1524  */
1525 void
1526 pop_close (popserver server)
1527 {
1528   pop_trash (server);
1529   free ((char *) server);
1530
1531   return;
1532 }
1533
1534 /*
1535  * Function: pop_trash
1536  *
1537  * Purpose: Like pop_close or pop_quit, but doesn't deallocate the
1538  *      memory associated with the server.  It is valid to call
1539  *      pop_close or pop_quit after this function has been called.
1540  */
1541 static void
1542 pop_trash (popserver server)
1543 {
1544   if (server->file >= 0)
1545     {
1546       /* avoid recursion; sendline can call pop_trash */
1547       if (server->trash_started)
1548         return;
1549       server->trash_started = true;
1550
1551       sendline (server, "RSET");
1552       sendline (server, "QUIT");
1553
1554       CLOSESOCKET (server->file);
1555       server->file = -1;
1556       if (server->buffer)
1557         {
1558           free (server->buffer);
1559           server->buffer = 0;
1560         }
1561     }
1562
1563 #ifdef WINDOWSNT
1564   if (have_winsock)
1565     WSACleanup ();
1566 #endif
1567 }
1568
1569 /* Return a pointer to the first CRLF in IN_STRING, which can contain
1570    embedded nulls and has LEN characters in it not including the final
1571    null, or 0 if it does not contain one.  */
1572
1573 static char *
1574 find_crlf (char *in_string, int len)
1575 {
1576   while (len--)
1577     {
1578       if (*in_string == '\r')
1579         {
1580           if (*++in_string == '\n')
1581             return (in_string - 1);
1582         }
1583       else
1584         in_string++;
1585     }
1586   return (0);
1587 }
1588
1589 #endif /* MAIL_USE_POP */