lib-src/pop.c

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