diplodocus.org Git - nmh/blob - uip/popsbr.c

   1 /*
   2  * popsbr.c -- POP client subroutines
   3  *
   4  * This code is Copyright (c) 2002, by the authors of nmh.  See the
   5  * COPYRIGHT file in the root directory of the nmh distribution for
   6  * complete copyright information.
   7  */
   8
   9 #include <h/mh.h>
  10 #include <h/utils.h>
  11
  12 #ifdef CYRUS_SASL
  13 # include <sasl/sasl.h>
  14 # include <sasl/saslutil.h>
  15 #endif /* CYRUS_SASL */
  16
  17 #include <h/popsbr.h>
  18 #include <h/signals.h>
  19 #include <signal.h>
  20 #include <errno.h>
  21
  22 #define TRM     "."
  23 #define TRMLEN  (sizeof TRM - 1)
  24
  25 static int poprint = 0;
  26 static int pophack = 0;
  27
  28 char response[BUFSIZ];
  29
  30 static FILE *input;
  31 static FILE *output;
  32
  33 #ifdef CYRUS_SASL
  34 static sasl_conn_t *conn;       /* SASL connection state */
  35 static int sasl_complete = 0;   /* Has sasl authentication succeeded? */
  36 static int maxoutbuf;           /* Maximum output buffer size */
  37 static sasl_ssf_t sasl_ssf = 0; /* Security strength factor */
  38 static int sasl_get_user(void *, int, const char **, unsigned *);
  39 static int sasl_get_pass(sasl_conn_t *, void *, int, sasl_secret_t **);
  40 struct pass_context {
  41     char *user;
  42     char *host;
  43 };
  44
  45 static sasl_callback_t callbacks[] = {
  46     { SASL_CB_USER, sasl_get_user, NULL },
  47 #define POP_SASL_CB_N_USER 0
  48     { SASL_CB_PASS, sasl_get_pass, NULL },
  49 #define POP_SASL_CB_N_PASS 1
  50     { SASL_CB_LOG, NULL, NULL },
  51     { SASL_CB_LIST_END, NULL, NULL },
  52
  53 #define SASL_BUFFER_SIZE 262144
  54 };
  55 #else /* CYRUS_SASL */
  56 # define sasl_fgetc fgetc
  57 #endif /* CYRUS_SASL */
  58
  59 /*
  60  * static prototypes
  61  */
  62
  63 static int command(const char *, ...);
  64 static int multiline(void);
  65
  66 #ifdef CYRUS_SASL
  67 static int pop_auth_sasl(char *, char *, char *);
  68 static int sasl_fgetc(FILE *);
  69 #endif /* CYRUS_SASL */
  70
  71 static int traverse (int (*)(char *), const char *, ...);
  72 static int vcommand(const char *, va_list);
  73 static int sasl_getline (char *, int, FILE *);
  74 static int putline (char *, FILE *);
  75
  76
  77 #ifdef CYRUS_SASL
  78 /*
  79  * This function implements the AUTH command for various SASL mechanisms
  80  *
  81  * We do the whole SASL dialog here.  If this completes, then we've
  82  * authenticated successfully and have (possibly) negotiated a security
  83  * layer.
  84  */
  85
  86 int
  87 pop_auth_sasl(char *user, char *host, char *mech)
  88 {
  89     int result, status, sasl_capability = 0;
  90     unsigned int buflen, outlen;
  91     char server_mechs[256], *buf, outbuf[BUFSIZ];
  92     const char *chosen_mech;
  93     sasl_security_properties_t secprops;
  94     struct pass_context p_context;
  95     sasl_ssf_t *ssf;
  96     int *moutbuf;
  97
  98     /*
  99      * First off, we're going to send the CAPA command to see if we can
 100      * even support the AUTH command, and if we do, then we'll get a
 101      * list of mechanisms the server supports.  If we don't support
 102      * the CAPA command, then it's unlikely that we will support
 103      * SASL
 104      */
 105
 106     if (command("CAPA") == NOTOK) {
 107         snprintf(response, sizeof(response),
 108                  "The POP CAPA command failed; POP server does not "
 109                  "support SASL");
 110         return NOTOK;
 111     }
 112
 113     while ((status = multiline()) != DONE)
 114         switch (status) {
 115         case NOTOK:
 116             return NOTOK;
 117             break;
 118         case DONE:      /* Shouldn't be possible, but just in case */
 119             break;
 120         case OK:
 121             if (strncasecmp(response, "SASL ", 5) == 0) {
 122                 /*
 123                  * We've seen the SASL capability.  Grab the mech list
 124                  */
 125                 sasl_capability++;
 126                 strncpy(server_mechs, response + 5, sizeof(server_mechs));
 127             }
 128             break;
 129         }
 130
 131     if (!sasl_capability) {
 132         snprintf(response, sizeof(response), "POP server does not support "
 133                  "SASL");
 134         return NOTOK;
 135     }
 136
 137     /*
 138      * If we received a preferred mechanism, see if the server supports it.
 139      */
 140
 141     if (mech && stringdex(mech, server_mechs) == -1) {
 142         snprintf(response, sizeof(response), "Requested SASL mech \"%s\" is "
 143                  "not in list of supported mechanisms:\n%s",
 144                  mech, server_mechs);
 145         return NOTOK;
 146     }
 147
 148     /*
 149      * Start the SASL process.  First off, initialize the SASL library.
 150      */
 151
 152     callbacks[POP_SASL_CB_N_USER].context = user;
 153     p_context.user = user;
 154     p_context.host = host;
 155     callbacks[POP_SASL_CB_N_PASS].context = &p_context;
 156
 157     result = sasl_client_init(callbacks);
 158
 159     if (result != SASL_OK) {
 160         snprintf(response, sizeof(response), "SASL library initialization "
 161                  "failed: %s", sasl_errstring(result, NULL, NULL));
 162         return NOTOK;
 163     }
 164
 165     result = sasl_client_new("pop", host, NULL, NULL, NULL, 0, &conn);
 166
 167     if (result != SASL_OK) {
 168         snprintf(response, sizeof(response), "SASL client initialization "
 169                  "failed: %s", sasl_errstring(result, NULL, NULL));
 170         return NOTOK;
 171     }
 172
 173     /*
 174      * Initialize the security properties
 175      */
 176
 177     memset(&secprops, 0, sizeof(secprops));
 178     secprops.maxbufsize = SASL_BUFFER_SIZE;
 179     secprops.max_ssf = UINT_MAX;
 180
 181     result = sasl_setprop(conn, SASL_SEC_PROPS, &secprops);
 182
 183     if (result != SASL_OK) {
 184         snprintf(response, sizeof(response), "SASL security property "
 185                  "initialization failed: %s", sasl_errdetail(conn));
 186         return NOTOK;
 187     }
 188
 189     /*
 190      * Start the actual protocol.  Feed the mech list into the library
 191      * and get out a possible initial challenge
 192      */
 193
 194     result = sasl_client_start(conn,
 195                                (const char *) (mech ? mech : server_mechs),
 196                                NULL, (const char **) &buf,
 197                                &buflen, &chosen_mech);
 198
 199     if (result != SASL_OK && result != SASL_CONTINUE) {
 200         snprintf(response, sizeof(response), "SASL client start failed: %s",
 201                  sasl_errdetail(conn));
 202         return NOTOK;
 203     }
 204
 205     if (buflen) {
 206         status = sasl_encode64(buf, buflen, outbuf, sizeof(outbuf), NULL);
 207         if (status != SASL_OK) {
 208             snprintf(response, sizeof(response), "SASL base64 encode "
 209                      "failed: %s", sasl_errstring(status, NULL, NULL));
 210             return NOTOK;
 211         }
 212
 213         status = command("AUTH %s %s", chosen_mech, outbuf);
 214     } else
 215         status = command("AUTH %s", chosen_mech);
 216
 217     while (result == SASL_CONTINUE) {
 218         if (status == NOTOK)
 219             return NOTOK;
 220
 221         /*
 222          * If we get a "+OK" prefix to our response, then we should
 223          * exit out of this exchange now (because authenticated should
 224          * have succeeded)
 225          */
 226
 227         if (strncmp(response, "+OK", 3) == 0)
 228             break;
 229
 230         /*
 231          * Otherwise, make sure the server challenge is correctly formatted
 232          */
 233
 234         if (strncmp(response, "+ ", 2) != 0) {
 235             command("*");
 236             snprintf(response, sizeof(response),
 237                      "Malformed authentication message from server");
 238             return NOTOK;
 239         }
 240
 241         result = sasl_decode64(response + 2, strlen(response + 2),
 242                                outbuf, sizeof(outbuf), &outlen);
 243
 244         if (result != SASL_OK) {
 245             command("*");
 246             snprintf(response, sizeof(response), "SASL base64 decode "
 247                      "failed: %s", sasl_errstring(result, NULL, NULL));
 248             return NOTOK;
 249         }
 250
 251         result = sasl_client_step(conn, outbuf, outlen, NULL,
 252                                   (const char **) &buf, &buflen);
 253
 254         if (result != SASL_OK && result != SASL_CONTINUE) {
 255             command("*");
 256             snprintf(response, sizeof(response), "SASL client negotiaton "
 257                      "failed: %s", sasl_errdetail(conn));
 258             return NOTOK;
 259         }
 260
 261         status = sasl_encode64(buf, buflen, outbuf, sizeof(outbuf), NULL);
 262
 263         if (status != SASL_OK) {
 264             command("*");
 265             snprintf(response, sizeof(response), "SASL base64 encode "
 266                      "failed: %s", sasl_errstring(status, NULL, NULL));
 267             return NOTOK;
 268         }
 269
 270         status = command(outbuf);
 271     }
 272
 273     /*
 274      * If we didn't get a positive final response, then error out
 275      * (that probably means we failed an authorization check).
 276      */
 277
 278     if (status != OK)
 279         return NOTOK;
 280
 281     /*
 282      * We _should_ be okay now.  Get a few properties now that negotiation
 283      * has completed.
 284      */
 285
 286     result = sasl_getprop(conn, SASL_MAXOUTBUF, (const void **) &moutbuf);
 287
 288     if (result != SASL_OK) {
 289         snprintf(response, sizeof(response), "Cannot retrieve SASL negotiated "
 290                  "output buffer size: %s", sasl_errdetail(conn));
 291         return NOTOK;
 292     }
 293
 294     maxoutbuf = *moutbuf;
 295
 296     result = sasl_getprop(conn, SASL_SSF, (const void **) &ssf);
 297
 298     sasl_ssf = *ssf;
 299
 300     if (result != SASL_OK) {
 301         snprintf(response, sizeof(response), "Cannot retrieve SASL negotiated "
 302                  "security strength factor: %s", sasl_errdetail(conn));
 303         return NOTOK;
 304     }
 305
 306     /*
 307      * Limit this to what we can deal with.  Shouldn't matter much because
 308      * this is only outgoing data (which should be small)
 309      */
 310
 311     if (maxoutbuf == 0 || maxoutbuf > BUFSIZ)
 312         maxoutbuf = BUFSIZ;
 313
 314     sasl_complete = 1;
 315
 316     return status;
 317 }
 318
 319 /*
 320  * Callback to return the userid sent down via the user parameter
 321  */
 322
 323 static int
 324 sasl_get_user(void *context, int id, const char **result, unsigned *len)
 325 {
 326     char *user = (char *) context;
 327
 328     if (! result || id != SASL_CB_USER)
 329         return SASL_BADPARAM;
 330
 331     *result = user;
 332     if (len)
 333         *len = strlen(user);
 334
 335     return SASL_OK;
 336 }
 337
 338 /*
 339  * Callback to return the password (we call ruserpass, which can get it
 340  * out of the .netrc
 341  */
 342
 343 static int
 344 sasl_get_pass(sasl_conn_t *conn, void *context, int id, sasl_secret_t **psecret)
 345 {
 346     NMH_UNUSED (conn);
 347
 348     struct pass_context *p_context = (struct pass_context *) context;
 349     char *pass = NULL;
 350     int len;
 351
 352     if (! psecret || id != SASL_CB_PASS)
 353         return SASL_BADPARAM;
 354
 355     ruserpass(p_context->user, &(p_context->host), &pass);
 356
 357     len = strlen(pass);
 358
 359     *psecret = (sasl_secret_t *) mh_xmalloc(sizeof(sasl_secret_t) + len);
 360
 361     (*psecret)->len = len;
 362     strcpy((char *) (*psecret)->data, pass);
 363
 364     return SASL_OK;
 365 }
 366 #endif /* CYRUS_SASL */
 367
 368
 369 /*
 370  * Split string containing proxy command into an array of arguments
 371  * suitable for passing to exec. Returned array must be freed. Shouldn't
 372  * be possible to call this with host set to NULL.
 373  */
 374 char **
 375 parse_proxy(char *proxy, char *host)
 376 {
 377     char **pargv, **p;
 378     int pargc = 2;
 379     int hlen = strlen(host);
 380     int plen = 1;
 381     unsigned char *cur, *pro;
 382     char *c;
 383
 384     /* skip any initial space */
 385     for (pro = (unsigned char *) proxy; isspace(*pro); pro++)
 386         continue;
 387
 388     /* calculate required size for argument array */
 389     for (cur = pro; *cur; cur++) {
 390         if (isspace(*cur) && cur[1] && !isspace(cur[1]))
 391             plen++, pargc++;
 392         else if (*cur == '%' && cur[1] == 'h') {
 393             plen += hlen;
 394             cur++;
 395         } else if (!isspace(*cur))
 396             plen++;
 397     }
 398
 399    /* put together list of arguments */
 400     p = pargv = mh_xmalloc(pargc * sizeof(char *));
 401     c = *pargv = mh_xmalloc(plen * sizeof(char));
 402     for (cur = pro; *cur; cur++) {
 403         if (isspace(*cur) && cur[1] && !isspace(cur[1])) {
 404             *c++ = '\0';
 405             *++p = c;
 406         } else if (*cur == '%' && cur[1] == 'h') {
 407             strcpy (c, host);
 408             c += hlen;
 409             cur++;
 410         } else if (!isspace(*cur))
 411             *c++ = *cur;
 412     }
 413     *++p = NULL;
 414     return pargv;
 415 }
 416
 417 int
 418 pop_init (char *host, char *port, char *user, char *pass, char *proxy,
 419           int snoop, int sasl, char *mech)
 420 {
 421 #ifndef CYRUS_SASL
 422     NMH_UNUSED (sasl);
 423     NMH_UNUSED (mech);
 424 #endif /* ! CYRUS_SASL */
 425
 426     int fd1, fd2;
 427     char buffer[BUFSIZ];
 428
 429     if (proxy && *proxy) {
 430        int pid;
 431        int inpipe[2];     /* for reading from the server */
 432        int outpipe[2];    /* for sending to the server */
 433
 434        /* first give up any root priviledges we may have for rpop */
 435        setuid(getuid());
 436
 437        pipe(inpipe);
 438        pipe(outpipe);
 439
 440        pid=fork();
 441        if (pid==0) {
 442            char **argv;
 443
 444            /* in child */
 445            close(0);
 446            close(1);
 447            dup2(outpipe[0],0);  /* connect read end of connection */
 448            dup2(inpipe[1], 1);  /* connect write end of connection */
 449            if(inpipe[0]>1) close(inpipe[0]);
 450            if(inpipe[1]>1) close(inpipe[1]);
 451            if(outpipe[0]>1) close(outpipe[0]);
 452            if(outpipe[1]>1) close(outpipe[1]);
 453
 454            /* run the proxy command */
 455            argv=parse_proxy(proxy, host);
 456            execvp(argv[0],argv);
 457
 458            perror(argv[0]);
 459            close(0);
 460            close(1);
 461            free(*argv);
 462            free(argv);
 463            exit(10);
 464        }
 465
 466        /* okay in the parent we do some stuff */
 467        close(inpipe[1]);  /* child uses this */
 468        close(outpipe[0]); /* child uses this */
 469
 470        /* we read on fd1 */
 471        fd1=inpipe[0];
 472        /* and write on fd2 */
 473        fd2=outpipe[1];
 474
 475     } else {
 476
 477         if ((fd1 = client (host, port ? port : "pop3", response,
 478                            sizeof(response), snoop)) == NOTOK) {
 479             return NOTOK;
 480         }
 481
 482         if ((fd2 = dup (fd1)) == NOTOK) {
 483             char *s;
 484
 485             if ((s = strerror(errno)))
 486                 snprintf (response, sizeof(response),
 487                     "unable to dup connection descriptor: %s", s);
 488             else
 489                 snprintf (response, sizeof(response),
 490                     "unable to dup connection descriptor: unknown error");
 491             close (fd1);
 492             return NOTOK;
 493         }
 494     }
 495     if (pop_set (fd1, fd2, snoop) == NOTOK)
 496         return NOTOK;
 497
 498     SIGNAL (SIGPIPE, SIG_IGN);
 499
 500     switch (sasl_getline (response, sizeof response, input)) {
 501         case OK:
 502             if (poprint)
 503                 fprintf (stderr, "<--- %s\n", response);
 504             if (*response == '+') {
 505 #  ifdef CYRUS_SASL
 506                 if (sasl) {
 507                     if (pop_auth_sasl(user, host, mech) != NOTOK)
 508                         return OK;
 509                 } else
 510 #  endif /* CYRUS_SASL */
 511                 if (command ("USER %s", user) != NOTOK
 512                     && command ("%s %s", (pophack++, "PASS"),
 513                                         pass) != NOTOK)
 514                 return OK;
 515             }
 516             strncpy (buffer, response, sizeof(buffer));
 517             command ("QUIT");
 518             strncpy (response, buffer, sizeof(response));
 519                                 /* and fall */
 520
 521         case NOTOK:
 522         case DONE:
 523             if (poprint)
 524                 fprintf (stderr, "%s\n", response);
 525             fclose (input);
 526             fclose (output);
 527             return NOTOK;
 528     }
 529
 530     return NOTOK;       /* NOTREACHED */
 531 }
 532
 533 int
 534 pop_set (int in, int out, int snoop)
 535 {
 536
 537     if ((input = fdopen (in, "r")) == NULL
 538             || (output = fdopen (out, "w")) == NULL) {
 539         strncpy (response, "fdopen failed on connection descriptor", sizeof(response));
 540         if (input)
 541             fclose (input);
 542         else
 543             close (in);
 544         close (out);
 545         return NOTOK;
 546     }
 547
 548     poprint = snoop;
 549
 550     return OK;
 551 }
 552
 553
 554 int
 555 pop_fd (char *in, int inlen, char *out, int outlen)
 556 {
 557     snprintf (in, inlen, "%d", fileno (input));
 558     snprintf (out, outlen, "%d", fileno (output));
 559     return OK;
 560 }
 561
 562
 563 /*
 564  * Find out number of messages available
 565  * and their total size.
 566  */
 567
 568 int
 569 pop_stat (int *nmsgs, int *nbytes)
 570 {
 571
 572     if (command ("STAT") == NOTOK)
 573         return NOTOK;
 574
 575     *nmsgs = *nbytes = 0;
 576     sscanf (response, "+OK %d %d", nmsgs, nbytes);
 577
 578     return OK;
 579 }
 580
 581
 582 int
 583 pop_list (int msgno, int *nmsgs, int *msgs, int *bytes)
 584 {
 585     int i;
 586     int *ids = NULL;
 587
 588     if (msgno) {
 589         if (command ("LIST %d", msgno) == NOTOK)
 590             return NOTOK;
 591         *msgs = *bytes = 0;
 592         if (ids) {
 593             *ids = 0;
 594             sscanf (response, "+OK %d %d %d", msgs, bytes, ids);
 595         }
 596         else
 597             sscanf (response, "+OK %d %d", msgs, bytes);
 598         return OK;
 599     }
 600
 601     if (command ("LIST") == NOTOK)
 602         return NOTOK;
 603
 604     for (i = 0; i < *nmsgs; i++)
 605         switch (multiline ()) {
 606             case NOTOK:
 607                 return NOTOK;
 608             case DONE:
 609                 *nmsgs = ++i;
 610                 return OK;
 611             case OK:
 612                 *msgs = *bytes = 0;
 613                 if (ids) {
 614                     *ids = 0;
 615                     sscanf (response, "%d %d %d",
 616                             msgs++, bytes++, ids++);
 617                 }
 618                 else
 619                     sscanf (response, "%d %d", msgs++, bytes++);
 620                 break;
 621         }
 622     for (;;)
 623         switch (multiline ()) {
 624             case NOTOK:
 625                 return NOTOK;
 626             case DONE:
 627                 return OK;
 628             case OK:
 629                 break;
 630         }
 631 }
 632
 633
 634 int
 635 pop_retr (int msgno, int (*action)(char *))
 636 {
 637     return traverse (action, "RETR %d", msgno);
 638 }
 639
 640
 641 static int
 642 traverse (int (*action)(char *), const char *fmt, ...)
 643 {
 644     int result;
 645     va_list ap;
 646     char buffer[sizeof(response)];
 647
 648     va_start(ap, fmt);
 649     result = vcommand (fmt, ap);
 650     va_end(ap);
 651
 652     if (result == NOTOK)
 653         return NOTOK;
 654     strncpy (buffer, response, sizeof(buffer));
 655
 656     for (;;)
 657         switch (multiline ()) {
 658             case NOTOK:
 659                 return NOTOK;
 660
 661             case DONE:
 662                 strncpy (response, buffer, sizeof(response));
 663                 return OK;
 664
 665             case OK:
 666                 (*action) (response);
 667                 break;
 668         }
 669 }
 670
 671
 672 int
 673 pop_dele (int msgno)
 674 {
 675     return command ("DELE %d", msgno);
 676 }
 677
 678
 679 int
 680 pop_noop (void)
 681 {
 682     return command ("NOOP");
 683 }
 684
 685
 686 int
 687 pop_rset (void)
 688 {
 689     return command ("RSET");
 690 }
 691
 692
 693 int
 694 pop_top (int msgno, int lines, int (*action)(char *))
 695 {
 696     return traverse (action, "TOP %d %d", msgno, lines);
 697 }
 698
 699
 700 int
 701 pop_quit (void)
 702 {
 703     int i;
 704
 705     i = command ("QUIT");
 706     pop_done ();
 707
 708     return i;
 709 }
 710
 711
 712 int
 713 pop_done (void)
 714 {
 715 #ifdef CYRUS_SASL
 716     if (conn)
 717         sasl_dispose(&conn);
 718 #endif /* CYRUS_SASL */
 719     fclose (input);
 720     fclose (output);
 721
 722     return OK;
 723 }
 724
 725
 726 int
 727 command(const char *fmt, ...)
 728 {
 729     va_list ap;
 730     int result;
 731
 732     va_start(ap, fmt);
 733     result = vcommand(fmt, ap);
 734     va_end(ap);
 735
 736     return result;
 737 }
 738
 739
 740 static int
 741 vcommand (const char *fmt, va_list ap)
 742 {
 743     char *cp, buffer[BUFSIZ];
 744
 745     vsnprintf (buffer, sizeof(buffer), fmt, ap);
 746     if (poprint) {
 747 #ifdef CYRUS_SASL
 748         if (sasl_ssf)
 749             fprintf(stderr, "(encrypted) ");
 750 #endif /* CYRUS_SASL */
 751         if (pophack) {
 752             if ((cp = strchr (buffer, ' ')))
 753                 *cp = 0;
 754             fprintf (stderr, "---> %s ********\n", buffer);
 755             if (cp)
 756                 *cp = ' ';
 757             pophack = 0;
 758         }
 759         else
 760             fprintf (stderr, "---> %s\n", buffer);
 761     }
 762
 763     if (putline (buffer, output) == NOTOK)
 764         return NOTOK;
 765
 766 #ifdef CYRUS_SASL
 767     if (poprint && sasl_ssf)
 768         fprintf(stderr, "(decrypted) ");
 769 #endif /* CYRUS_SASL */
 770
 771     switch (sasl_getline (response, sizeof response, input)) {
 772         case OK:
 773             if (poprint)
 774                 fprintf (stderr, "<--- %s\n", response);
 775             return (*response == '+' ? OK : NOTOK);
 776
 777         case NOTOK:
 778         case DONE:
 779             if (poprint)
 780                 fprintf (stderr, "%s\n", response);
 781             return NOTOK;
 782     }
 783
 784     return NOTOK;       /* NOTREACHED */
 785 }
 786
 787
 788 int
 789 multiline (void)
 790 {
 791     char buffer[BUFSIZ + TRMLEN];
 792
 793     if (sasl_getline (buffer, sizeof buffer, input) != OK)
 794         return NOTOK;
 795 #ifdef DEBUG
 796     if (poprint) {
 797 #ifdef CYRUS_SASL
 798         if (sasl_ssf)
 799             fprintf(stderr, "(decrypted) ");
 800 #endif /* CYRUS_SASL */
 801         fprintf (stderr, "<--- %s\n", response);
 802     }
 803 #endif /* DEBUG */
 804     if (strncmp (buffer, TRM, TRMLEN) == 0) {
 805         if (buffer[TRMLEN] == 0)
 806             return DONE;
 807         else
 808             strncpy (response, buffer + TRMLEN, sizeof(response));
 809     }
 810     else
 811         strncpy (response, buffer, sizeof(response));
 812
 813     return OK;
 814 }
 815
 816 /*
 817  * Note that these functions have been modified to deal with layer encryption
 818  * in the SASL case
 819  */
 820
 821 static int
 822 sasl_getline (char *s, int n, FILE *iop)
 823 {
 824     int c = -2;
 825     char *p;
 826
 827     p = s;
 828     while (--n > 0 && (c = sasl_fgetc (iop)) != EOF && c != -2)
 829         if ((*p++ = c) == '\n')
 830             break;
 831     if (c == -2)
 832         return NOTOK;
 833     if (ferror (iop) && c != EOF) {
 834         strncpy (response, "error on connection", sizeof(response));
 835         return NOTOK;
 836     }
 837     if (c == EOF && p == s) {
 838         strncpy (response, "connection closed by foreign host", sizeof(response));
 839         return DONE;
 840     }
 841     *p = 0;
 842     if (*--p == '\n')
 843         *p = 0;
 844     if (*--p == '\r')
 845         *p = 0;
 846
 847     return OK;
 848 }
 849
 850
 851 static int
 852 putline (char *s, FILE *iop)
 853 {
 854 #ifdef CYRUS_SASL
 855     char outbuf[BUFSIZ], *buf;
 856     int result;
 857     unsigned int buflen;
 858
 859     if (!sasl_complete) {
 860 #endif /* CYRUS_SASL */
 861         fprintf (iop, "%s\r\n", s);
 862 #ifdef CYRUS_SASL
 863     } else {
 864         /*
 865          * Build an output buffer, encrypt it using sasl_encode, and
 866          * squirt out the results.
 867          */
 868         strncpy(outbuf, s, sizeof(outbuf) - 3);
 869         outbuf[sizeof(outbuf) - 3] = '\0';   /* Just in case */
 870         strcat(outbuf, "\r\n");
 871
 872         result = sasl_encode(conn, outbuf, strlen(outbuf),
 873                              (const char **) &buf, &buflen);
 874
 875         if (result != SASL_OK) {
 876             snprintf(response, sizeof(response), "SASL encoding error: %s",
 877                      sasl_errdetail(conn));
 878             return NOTOK;
 879         }
 880
 881         fwrite(buf, buflen, 1, iop);
 882     }
 883 #endif /* CYRUS_SASL */
 884
 885     fflush (iop);
 886     if (ferror (iop)) {
 887         strncpy (response, "lost connection", sizeof(response));
 888         return NOTOK;
 889     }
 890
 891     return OK;
 892 }
 893
 894 #ifdef CYRUS_SASL
 895 /*
 896  * Okay, our little fgetc replacement.  Hopefully this is a little more
 897  * efficient than the last one.
 898  */
 899 static int
 900 sasl_fgetc(FILE *f)
 901 {
 902     static unsigned char *buffer = NULL, *ptr;
 903     static unsigned int size = 0;
 904     static int cnt = 0;
 905     unsigned int retbufsize = 0;
 906     int cc, result;
 907     char *retbuf, tmpbuf[SASL_BUFFER_SIZE];
 908
 909     /*
 910      * If we have some leftover data, return that
 911      */
 912
 913     if (cnt) {
 914         cnt--;
 915         return (int) *ptr++;
 916     }
 917
 918     /*
 919      * Otherwise, fill our buffer until we have some data to return.
 920      */
 921
 922     while (retbufsize == 0) {
 923
 924         cc = read(fileno(f), tmpbuf, sizeof(tmpbuf));
 925
 926         if (cc == 0)
 927             return EOF;
 928
 929         if (cc < 0) {
 930             snprintf(response, sizeof(response), "Error during read from "
 931                      "network: %s", strerror(errno));
 932             return -2;
 933         }
 934
 935         /*
 936          * We're not allowed to call sasl_decode until sasl_complete is
 937          * true, so we do these gyrations ...
 938          */
 939
 940         if (!sasl_complete) {
 941
 942             retbuf = tmpbuf;
 943             retbufsize = cc;
 944
 945         } else {
 946
 947             result = sasl_decode(conn, tmpbuf, cc,
 948                                  (const char **) &retbuf, &retbufsize);
 949
 950             if (result != SASL_OK) {
 951                 snprintf(response, sizeof(response), "Error during SASL "
 952                          "decoding: %s", sasl_errdetail(conn));
 953                 return -2;
 954             }
 955         }
 956     }
 957
 958     if (retbufsize > size) {
 959         buffer = mh_xrealloc(buffer, retbufsize);
 960         size = retbufsize;
 961     }
 962
 963     memcpy(buffer, retbuf, retbufsize);
 964     ptr = buffer + 1;
 965     cnt = retbufsize - 1;
 966
 967     return (int) buffer[0];
 968 }
 969 #endif /* CYRUS_SASL */