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-2012
   4   Free Software 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 int pop_debug = 0;
 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 = 0;
 273   server->trash_started = 0;
 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 = 1;
 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 = 0;
 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   if (ret == 0)
1079     {
1080       it = res;
1081       while (it)
1082         {
1083           if (it->ai_addrlen == sizeof (addr))
1084             {
1085               struct sockaddr_in *in_a = (struct sockaddr_in *) it->ai_addr;
1086               memcpy (&addr.sin_addr, &in_a->sin_addr, sizeof (addr.sin_addr));
1087               if (! connect (sock, (struct sockaddr *) &addr, sizeof (addr)))
1088                 break;
1089             }
1090           it = it->ai_next;
1091         }
1092       connect_ok = it != NULL;
1093       if (connect_ok)
1094         {
1095           realhost = alloca (strlen (it->ai_canonname) + 1);
1096           strcpy (realhost, it->ai_canonname);
1097         }
1098       freeaddrinfo (res);
1099     }
1100 #else /* !HAVE_GETADDRINFO */
1101   do
1102     {
1103       hostent = gethostbyname (host);
1104       try_count++;
1105       if ((! hostent) && ((h_errno != TRY_AGAIN) || (try_count == 5)))
1106         {
1107           strcpy (pop_error, "Could not determine POP server's address");
1108           return (-1);
1109         }
1110     } while (! hostent);
1111
1112   while (*hostent->h_addr_list)
1113     {
1114       memcpy (&addr.sin_addr, *hostent->h_addr_list, hostent->h_length);
1115       if (! connect (sock, (struct sockaddr *) &addr, sizeof (addr)))
1116         break;
1117       hostent->h_addr_list++;
1118     }
1119   connect_ok = *hostent->h_addr_list != NULL;
1120   if (! connect_ok)
1121     {
1122       realhost = alloca (strlen (hostent->h_name) + 1);
1123       strcpy (realhost, hostent->h_name);
1124     }
1125
1126 #endif /* !HAVE_GETADDRINFO */
1127
1128 #define CONNECT_ERROR "Could not connect to POP server: "
1129
1130   if (! connect_ok)
1131     {
1132       CLOSESOCKET (sock);
1133       snprintf (pop_error, ERROR_MAX, "%s%s", CONNECT_ERROR, strerror (errno));
1134       return (-1);
1135
1136     }
1137
1138 #ifdef KERBEROS
1139
1140 #define KRB_ERROR "Kerberos error connecting to POP server: "
1141   if (! (flags & POP_NO_KERBEROS))
1142     {
1143 #ifdef KERBEROS5
1144       if ((rem = krb5_init_context (&kcontext)))
1145         {
1146         krb5error:
1147           if (auth_context)
1148             krb5_auth_con_free (kcontext, auth_context);
1149           if (kcontext)
1150             krb5_free_context (kcontext);
1151           snprintf (pop_error, ERROR_MAX, "%s%s",
1152                     KRB_ERROR, error_message (rem));
1153           CLOSESOCKET (sock);
1154           return (-1);
1155         }
1156
1157       if ((rem = krb5_auth_con_init (kcontext, &auth_context)))
1158         goto krb5error;
1159
1160       if (rem = krb5_cc_default (kcontext, &ccdef))
1161         goto krb5error;
1162
1163       if (rem = krb5_cc_get_principal (kcontext, ccdef, &client))
1164         goto krb5error;
1165
1166       for (cp = realhost; *cp; cp++)
1167         {
1168           if (isupper (*cp))
1169             {
1170               *cp = tolower (*cp);
1171             }
1172         }
1173
1174       if (rem = krb5_sname_to_principal (kcontext, realhost,
1175                                          POP_SERVICE, FALSE, &server))
1176         goto krb5error;
1177
1178       rem = krb5_sendauth (kcontext, &auth_context,
1179                            (krb5_pointer) &sock, "KPOPV1.0", client, server,
1180                           AP_OPTS_MUTUAL_REQUIRED,
1181                           0,    /* no checksum */
1182                           0,    /* no creds, use ccache instead */
1183                           ccdef,
1184                           &err_ret,
1185                           0,    /* don't need subsession key */
1186                           0);   /* don't need reply */
1187       krb5_free_principal (kcontext, server);
1188       if (rem)
1189         {
1190           int pop_error_len = snprintf (pop_error, ERROR_MAX, "%s%s",
1191                                         KRB_ERROR, error_message (rem));
1192 #if defined HAVE_KRB5_ERROR_TEXT
1193           if (err_ret && err_ret->text.length)
1194             {
1195               int errlen = err_ret->text.length;
1196               snprintf (pop_error + pop_error_len, ERROR_MAX - pop_error_len,
1197                         " [server says '.*%s']", errlen, err_ret->text.data);
1198             }
1199 #elif defined HAVE_KRB5_ERROR_E_TEXT
1200           if (err_ret && err_ret->e_text && **err_ret->e_text)
1201             snprintf (pop_error + pop_error_len, ERRMAX - pop_error_len,
1202                       " [server says '%s']", *err_ret->e_text);
1203 #endif
1204           if (err_ret)
1205             krb5_free_error (kcontext, err_ret);
1206           krb5_auth_con_free (kcontext, auth_context);
1207           krb5_free_context (kcontext);
1208
1209           CLOSESOCKET (sock);
1210           return (-1);
1211         }
1212 #else  /* ! KERBEROS5 */
1213       ticket = (KTEXT) malloc (sizeof (KTEXT_ST));
1214       rem = krb_sendauth (0L, sock, ticket, "pop", realhost,
1215                           (char *) krb_realmofhost (realhost),
1216                           (unsigned long) 0, &msg_data, &cred, schedule,
1217                           (struct sockaddr_in *) 0,
1218                           (struct sockaddr_in *) 0,
1219                           "KPOPV0.1");
1220       free ((char *) ticket);
1221       if (rem != KSUCCESS)
1222         {
1223           snprintf (pop_error, ERROR_MAX, "%s%s", KRB_ERROR, krb_err_txt[rem]);
1224           CLOSESOCKET (sock);
1225           return (-1);
1226         }
1227 #endif /* KERBEROS5 */
1228     }
1229 #endif /* KERBEROS */
1230
1231   return (sock);
1232 } /* socket_connection */
1233
1234 /*
1235  * Function: pop_getline
1236  *
1237  * Purpose: Get a line of text from the connection and return a
1238  *      pointer to it.  The carriage return and linefeed at the end of
1239  *      the line are stripped, but periods at the beginnings of lines
1240  *      are NOT dealt with in any special way.
1241  *
1242  * Arguments:
1243  *      server  The server from which to get the line of text.
1244  *
1245  * Returns: The number of characters in the line, which is returned in
1246  *      LINE, not including the final null.  A return value of 0
1247  *      indicates a blank line.  A negative return value indicates an
1248  *      error (in which case the contents of LINE are undefined.  In
1249  *      case of error, an error message is copied into pop_error.
1250  *
1251  * Notes: The line returned is overwritten with each call to pop_getline.
1252  *
1253  * Side effects: Closes the connection on error.
1254  *
1255  * THE RETURNED LINE MAY CONTAIN EMBEDDED NULLS!
1256  */
1257 static int
1258 pop_getline (popserver server, char **line)
1259 {
1260 #define GETLINE_ERROR "Error reading from server: "
1261
1262   int ret;
1263   int search_offset = 0;
1264
1265   if (server->data)
1266     {
1267       char *cp = find_crlf (server->buffer + server->buffer_index,
1268                             server->data);
1269       if (cp)
1270         {
1271           int found;
1272           int data_used;
1273
1274           found = server->buffer_index;
1275           data_used = (cp + 2) - server->buffer - found;
1276
1277           *cp = '\0';           /* terminate the string to be returned */
1278           server->data -= data_used;
1279           server->buffer_index += data_used;
1280
1281           if (pop_debug)
1282             /* Embedded nulls will truncate this output prematurely,
1283                but that's OK because it's just for debugging anyway. */
1284             fprintf (stderr, "<<< %s\n", server->buffer + found);
1285           *line = server->buffer + found;
1286           return (data_used - 2);
1287         }
1288       else
1289         {
1290           memmove (server->buffer, server->buffer + server->buffer_index,
1291                    server->data);
1292           /* Record the fact that we've searched the data already in
1293              the buffer for a CRLF, so that when we search below, we
1294              don't have to search the same data twice.  There's a "-
1295              1" here to account for the fact that the last character
1296              of the data we have may be the CR of a CRLF pair, of
1297              which we haven't read the second half yet, so we may have
1298              to search it again when we read more data. */
1299           search_offset = server->data - 1;
1300           server->buffer_index = 0;
1301         }
1302     }
1303   else
1304     {
1305       server->buffer_index = 0;
1306     }
1307
1308   while (1)
1309     {
1310       /* There's a "- 1" here to leave room for the null that we put
1311          at the end of the read data below.  We put the null there so
1312          that find_crlf knows where to stop when we call it. */
1313       if (server->data == server->buffer_size - 1)
1314         {
1315           server->buffer_size += GETLINE_INCR;
1316           server->buffer = (char *)realloc (server->buffer, server->buffer_size);
1317           if (! server->buffer)
1318             {
1319               strcpy (pop_error, "Out of memory in pop_getline");
1320               pop_trash (server);
1321               return (-1);
1322             }
1323         }
1324       ret = RECV (server->file, server->buffer + server->data,
1325                   server->buffer_size - server->data - 1, 0);
1326       if (ret < 0)
1327         {
1328           snprintf (pop_error, ERROR_MAX, "%s%s",
1329                     GETLINE_ERROR, strerror (errno));
1330           pop_trash (server);
1331           return (-1);
1332         }
1333       else if (ret == 0)
1334         {
1335           strcpy (pop_error, "Unexpected EOF from server in pop_getline");
1336           pop_trash (server);
1337           return (-1);
1338         }
1339       else
1340         {
1341           char *cp;
1342           server->data += ret;
1343           server->buffer[server->data] = '\0';
1344
1345           cp = find_crlf (server->buffer + search_offset,
1346                           server->data - search_offset);
1347           if (cp)
1348             {
1349               int data_used = (cp + 2) - server->buffer;
1350               *cp = '\0';
1351               server->data -= data_used;
1352               server->buffer_index = data_used;
1353
1354               if (pop_debug)
1355                 fprintf (stderr, "<<< %s\n", server->buffer);
1356               *line = server->buffer;
1357               return (data_used - 2);
1358             }
1359           /* As above, the "- 1" here is to account for the fact that
1360              we may have read a CR without its accompanying LF. */
1361           search_offset += ret - 1;
1362         }
1363     }
1364
1365   /* NOTREACHED */
1366 }
1367
1368 /*
1369  * Function: sendline
1370  *
1371  * Purpose: Sends a line of text to the POP server.  The line of text
1372  *      passed into this function should NOT have the carriage return
1373  *      and linefeed on the end of it.  Periods at beginnings of lines
1374  *      will NOT be treated specially by this function.
1375  *
1376  * Arguments:
1377  *      server  The server to which to send the text.
1378  *      line    The line of text to send.
1379  *
1380  * Return value: Upon successful completion, a value of 0 will be
1381  *      returned.  Otherwise, a non-zero value will be returned, and
1382  *      an error will be copied into pop_error.
1383  *
1384  * Side effects: Closes the connection on error.
1385  */
1386 static int
1387 sendline (popserver server, const char *line)
1388 {
1389 #define SENDLINE_ERROR "Error writing to POP server: "
1390   int ret;
1391   char *buf;
1392
1393   /* Combine the string and the CR-LF into one buffer.  Otherwise, two
1394      reasonable network stack optimizations, Nagle's algorithm and
1395      delayed acks, combine to delay us a fraction of a second on every
1396      message we send.  (Movemail writes line without \r\n, client
1397      kernel sends packet, server kernel delays the ack to see if it
1398      can combine it with data, movemail writes \r\n, client kernel
1399      waits because it has unacked data already in its outgoing queue,
1400      client kernel eventually times out and sends.)
1401
1402      This can be something like 0.2s per command, which can add up
1403      over a few dozen messages, and is a big chunk of the time we
1404      spend fetching mail from a server close by.  */
1405   buf = alloca (strlen (line) + 3);
1406   strcpy (buf, line);
1407   strcat (buf, "\r\n");
1408   ret = fullwrite (server->file, buf, strlen (buf));
1409
1410   if (ret < 0)
1411     {
1412       pop_trash (server);
1413       snprintf (pop_error, ERROR_MAX, "%s%s", SENDLINE_ERROR, strerror (errno));
1414       return (ret);
1415     }
1416
1417   if (pop_debug)
1418     fprintf (stderr, ">>> %s\n", line);
1419
1420   return (0);
1421 }
1422
1423 /*
1424  * Procedure: fullwrite
1425  *
1426  * Purpose: Just like write, but keeps trying until the entire string
1427  *      has been written.
1428  *
1429  * Return value: Same as write.  Pop_error is not set.
1430  */
1431 static int
1432 fullwrite (int fd, char *buf, int nbytes)
1433 {
1434   char *cp;
1435   int ret = 0;
1436
1437   cp = buf;
1438   while (nbytes && ((ret = SEND (fd, cp, nbytes, 0)) > 0))
1439     {
1440       cp += ret;
1441       nbytes -= ret;
1442     }
1443
1444   return (ret);
1445 }
1446
1447 /*
1448  * Procedure getok
1449  *
1450  * Purpose: Reads a line from the server.  If the return indicator is
1451  *      positive, return with a zero exit status.  If not, return with
1452  *      a negative exit status.
1453  *
1454  * Arguments:
1455  *      server  The server to read from.
1456  *
1457  * Returns: 0 for success, else for failure and puts error in pop_error.
1458  *
1459  * Side effects: On failure, may make the connection unusable.
1460  */
1461 static int
1462 getok (popserver server)
1463 {
1464   char *fromline;
1465
1466   if (pop_getline (server, &fromline) < 0)
1467     {
1468       return (-1);
1469     }
1470
1471   if (! strncmp (fromline, "+OK", 3))
1472     return (0);
1473   else if (! strncmp (fromline, "-ERR", 4))
1474     {
1475       snprintf (pop_error, ERROR_MAX, "%s", fromline);
1476       return (-1);
1477     }
1478   else
1479     {
1480       strcpy (pop_error,
1481               "Unexpected response from server; expecting +OK or -ERR");
1482       pop_trash (server);
1483       return (-1);
1484     }
1485 }
1486
1487 #if 0
1488 /*
1489  * Function: gettermination
1490  *
1491  * Purpose: Gets the next line and verifies that it is a termination
1492  *      line (nothing but a dot).
1493  *
1494  * Return value: 0 on success, non-zero with pop_error set on error.
1495  *
1496  * Side effects: Closes the connection on error.
1497  */
1498 static int
1499 gettermination (server)
1500      popserver server;
1501 {
1502   char *fromserver;
1503
1504   if (pop_getline (server, &fromserver) < 0)
1505     return (-1);
1506
1507   if (strcmp (fromserver, "."))
1508     {
1509       strcpy (pop_error,
1510               "Unexpected response from server in gettermination");
1511       pop_trash (server);
1512       return (-1);
1513     }
1514
1515   return (0);
1516 }
1517 #endif
1518
1519 /*
1520  * Function pop_close
1521  *
1522  * Purpose: Close a pop connection, sending a "RSET" command to try to
1523  *      preserve any changes that were made and a "QUIT" command to
1524  *      try to get the server to quit, but ignoring any responses that
1525  *      are received.
1526  *
1527  * Side effects: The server is unusable after this function returns.
1528  *      Changes made to the maildrop since the session was started (or
1529  *      since the last pop_reset) may be lost.
1530  */
1531 void
1532 pop_close (popserver server)
1533 {
1534   pop_trash (server);
1535   free ((char *) server);
1536
1537   return;
1538 }
1539
1540 /*
1541  * Function: pop_trash
1542  *
1543  * Purpose: Like pop_close or pop_quit, but doesn't deallocate the
1544  *      memory associated with the server.  It is valid to call
1545  *      pop_close or pop_quit after this function has been called.
1546  */
1547 static void
1548 pop_trash (popserver server)
1549 {
1550   if (server->file >= 0)
1551     {
1552       /* avoid recursion; sendline can call pop_trash */
1553       if (server->trash_started)
1554         return;
1555       server->trash_started = 1;
1556
1557       sendline (server, "RSET");
1558       sendline (server, "QUIT");
1559
1560       CLOSESOCKET (server->file);
1561       server->file = -1;
1562       if (server->buffer)
1563         {
1564           free (server->buffer);
1565           server->buffer = 0;
1566         }
1567     }
1568
1569 #ifdef WINDOWSNT
1570   if (have_winsock)
1571     WSACleanup ();
1572 #endif
1573 }
1574
1575 /* Return a pointer to the first CRLF in IN_STRING, which can contain
1576    embedded nulls and has LEN characters in it not including the final
1577    null, or 0 if it does not contain one.  */
1578
1579 static char *
1580 find_crlf (char *in_string, int len)
1581 {
1582   while (len--)
1583     {
1584       if (*in_string == '\r')
1585         {
1586           if (*++in_string == '\n')
1587             return (in_string - 1);
1588         }
1589       else
1590         in_string++;
1591     }
1592   return (0);
1593 }
1594
1595 #endif /* MAIL_USE_POP */