lib-src/pop.c

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