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     int fd1, fd2;
 422     char buffer[BUFSIZ];
 423
 424     if (proxy && *proxy) {
 425        int pid;
 426        int inpipe[2];     /* for reading from the server */
 427        int outpipe[2];    /* for sending to the server */
 428
 429        /* first give up any root priviledges we may have for rpop */
 430        setuid(getuid());
 431
 432        pipe(inpipe);
 433        pipe(outpipe);
 434
 435        pid=fork();
 436        if (pid==0) {
 437            char **argv;
 438
 439            /* in child */
 440            close(0);
 441            close(1);
 442            dup2(outpipe[0],0);  /* connect read end of connection */
 443            dup2(inpipe[1], 1);  /* connect write end of connection */
 444            if(inpipe[0]>1) close(inpipe[0]);
 445            if(inpipe[1]>1) close(inpipe[1]);
 446            if(outpipe[0]>1) close(outpipe[0]);
 447            if(outpipe[1]>1) close(outpipe[1]);
 448
 449            /* run the proxy command */
 450            argv=parse_proxy(proxy, host);
 451            execvp(argv[0],argv);
 452
 453            perror(argv[0]);
 454            close(0);
 455            close(1);
 456            free(*argv);
 457            free(argv);
 458            exit(10);
 459        }
 460
 461        /* okay in the parent we do some stuff */
 462        close(inpipe[1]);  /* child uses this */
 463        close(outpipe[0]); /* child uses this */
 464
 465        /* we read on fd1 */
 466        fd1=inpipe[0];
 467        /* and write on fd2 */
 468        fd2=outpipe[1];
 469
 470     } else {
 471
 472         if ((fd1 = client (host, port ? port : "pop3", response,
 473                            sizeof(response), snoop)) == NOTOK) {
 474             return NOTOK;
 475         }
 476
 477         if ((fd2 = dup (fd1)) == NOTOK) {
 478             char *s;
 479
 480             if ((s = strerror(errno)))
 481                 snprintf (response, sizeof(response),
 482                     "unable to dup connection descriptor: %s", s);
 483             else
 484                 snprintf (response, sizeof(response),
 485                     "unable to dup connection descriptor: unknown error");
 486             close (fd1);
 487             return NOTOK;
 488         }
 489     }
 490     if (pop_set (fd1, fd2, snoop) == NOTOK)
 491         return NOTOK;
 492
 493     SIGNAL (SIGPIPE, SIG_IGN);
 494
 495     switch (sasl_getline (response, sizeof response, input)) {
 496         case OK:
 497             if (poprint)
 498                 fprintf (stderr, "<--- %s\n", response);
 499             if (*response == '+') {
 500 #  ifdef CYRUS_SASL
 501                 if (sasl) {
 502                     if (pop_auth_sasl(user, host, mech) != NOTOK)
 503                         return OK;
 504                 } else
 505 #  endif /* CYRUS_SASL */
 506                 if (command ("USER %s", user) != NOTOK
 507                     && command ("%s %s", (pophack++, "PASS"),
 508                                         pass) != NOTOK)
 509                 return OK;
 510             }
 511             strncpy (buffer, response, sizeof(buffer));
 512             command ("QUIT");
 513             strncpy (response, buffer, sizeof(response));
 514                                 /* and fall */
 515
 516         case NOTOK:
 517         case DONE:
 518             if (poprint)
 519                 fprintf (stderr, "%s\n", response);
 520             fclose (input);
 521             fclose (output);
 522             return NOTOK;
 523     }
 524
 525     return NOTOK;       /* NOTREACHED */
 526 }
 527
 528 int
 529 pop_set (int in, int out, int snoop)
 530 {
 531
 532     if ((input = fdopen (in, "r")) == NULL
 533             || (output = fdopen (out, "w")) == NULL) {
 534         strncpy (response, "fdopen failed on connection descriptor", sizeof(response));
 535         if (input)
 536             fclose (input);
 537         else
 538             close (in);
 539         close (out);
 540         return NOTOK;
 541     }
 542
 543     poprint = snoop;
 544
 545     return OK;
 546 }
 547
 548
 549 int
 550 pop_fd (char *in, int inlen, char *out, int outlen)
 551 {
 552     snprintf (in, inlen, "%d", fileno (input));
 553     snprintf (out, outlen, "%d", fileno (output));
 554     return OK;
 555 }
 556
 557
 558 /*
 559  * Find out number of messages available
 560  * and their total size.
 561  */
 562
 563 int
 564 pop_stat (int *nmsgs, int *nbytes)
 565 {
 566
 567     if (command ("STAT") == NOTOK)
 568         return NOTOK;
 569
 570     *nmsgs = *nbytes = 0;
 571     sscanf (response, "+OK %d %d", nmsgs, nbytes);
 572
 573     return OK;
 574 }
 575
 576
 577 int
 578 pop_list (int msgno, int *nmsgs, int *msgs, int *bytes)
 579 {
 580     int i;
 581     int *ids = NULL;
 582
 583     if (msgno) {
 584         if (command ("LIST %d", msgno) == NOTOK)
 585             return NOTOK;
 586         *msgs = *bytes = 0;
 587         if (ids) {
 588             *ids = 0;
 589             sscanf (response, "+OK %d %d %d", msgs, bytes, ids);
 590         }
 591         else
 592             sscanf (response, "+OK %d %d", msgs, bytes);
 593         return OK;
 594     }
 595
 596     if (command ("LIST") == NOTOK)
 597         return NOTOK;
 598
 599     for (i = 0; i < *nmsgs; i++)
 600         switch (multiline ()) {
 601             case NOTOK:
 602                 return NOTOK;
 603             case DONE:
 604                 *nmsgs = ++i;
 605                 return OK;
 606             case OK:
 607                 *msgs = *bytes = 0;
 608                 if (ids) {
 609                     *ids = 0;
 610                     sscanf (response, "%d %d %d",
 611                             msgs++, bytes++, ids++);
 612                 }
 613                 else
 614                     sscanf (response, "%d %d", msgs++, bytes++);
 615                 break;
 616         }
 617     for (;;)
 618         switch (multiline ()) {
 619             case NOTOK:
 620                 return NOTOK;
 621             case DONE:
 622                 return OK;
 623             case OK:
 624                 break;
 625         }
 626 }
 627
 628
 629 int
 630 pop_retr (int msgno, int (*action)(char *))
 631 {
 632     return traverse (action, "RETR %d", msgno);
 633 }
 634
 635
 636 static int
 637 traverse (int (*action)(char *), const char *fmt, ...)
 638 {
 639     int result;
 640     va_list ap;
 641     char buffer[sizeof(response)];
 642
 643     va_start(ap, fmt);
 644     result = vcommand (fmt, ap);
 645     va_end(ap);
 646
 647     if (result == NOTOK)
 648         return NOTOK;
 649     strncpy (buffer, response, sizeof(buffer));
 650
 651     for (;;)
 652         switch (multiline ()) {
 653             case NOTOK:
 654                 return NOTOK;
 655
 656             case DONE:
 657                 strncpy (response, buffer, sizeof(response));
 658                 return OK;
 659
 660             case OK:
 661                 (*action) (response);
 662                 break;
 663         }
 664 }
 665
 666
 667 int
 668 pop_dele (int msgno)
 669 {
 670     return command ("DELE %d", msgno);
 671 }
 672
 673
 674 int
 675 pop_noop (void)
 676 {
 677     return command ("NOOP");
 678 }
 679
 680
 681 int
 682 pop_rset (void)
 683 {
 684     return command ("RSET");
 685 }
 686
 687
 688 int
 689 pop_top (int msgno, int lines, int (*action)(char *))
 690 {
 691     return traverse (action, "TOP %d %d", msgno, lines);
 692 }
 693
 694
 695 int
 696 pop_quit (void)
 697 {
 698     int i;
 699
 700     i = command ("QUIT");
 701     pop_done ();
 702
 703     return i;
 704 }
 705
 706
 707 int
 708 pop_done (void)
 709 {
 710 #ifdef CYRUS_SASL
 711     if (conn)
 712         sasl_dispose(&conn);
 713 #endif /* CYRUS_SASL */
 714     fclose (input);
 715     fclose (output);
 716
 717     return OK;
 718 }
 719
 720
 721 int
 722 command(const char *fmt, ...)
 723 {
 724     va_list ap;
 725     int result;
 726
 727     va_start(ap, fmt);
 728     result = vcommand(fmt, ap);
 729     va_end(ap);
 730
 731     return result;
 732 }
 733
 734
 735 static int
 736 vcommand (const char *fmt, va_list ap)
 737 {
 738     char *cp, buffer[BUFSIZ];
 739
 740     vsnprintf (buffer, sizeof(buffer), fmt, ap);
 741     if (poprint) {
 742 #ifdef CYRUS_SASL
 743         if (sasl_ssf)
 744             fprintf(stderr, "(encrypted) ");
 745 #endif /* CYRUS_SASL */
 746         if (pophack) {
 747             if ((cp = strchr (buffer, ' ')))
 748                 *cp = 0;
 749             fprintf (stderr, "---> %s ********\n", buffer);
 750             if (cp)
 751                 *cp = ' ';
 752             pophack = 0;
 753         }
 754         else
 755             fprintf (stderr, "---> %s\n", buffer);
 756     }
 757
 758     if (putline (buffer, output) == NOTOK)
 759         return NOTOK;
 760
 761 #ifdef CYRUS_SASL
 762     if (poprint && sasl_ssf)
 763         fprintf(stderr, "(decrypted) ");
 764 #endif /* CYRUS_SASL */
 765
 766     switch (sasl_getline (response, sizeof response, input)) {
 767         case OK:
 768             if (poprint)
 769                 fprintf (stderr, "<--- %s\n", response);
 770             return (*response == '+' ? OK : NOTOK);
 771
 772         case NOTOK:
 773         case DONE:
 774             if (poprint)
 775                 fprintf (stderr, "%s\n", response);
 776             return NOTOK;
 777     }
 778
 779     return NOTOK;       /* NOTREACHED */
 780 }
 781
 782
 783 int
 784 multiline (void)
 785 {
 786     char buffer[BUFSIZ + TRMLEN];
 787
 788     if (sasl_getline (buffer, sizeof buffer, input) != OK)
 789         return NOTOK;
 790 #ifdef DEBUG
 791     if (poprint) {
 792 #ifdef CYRUS_SASL
 793         if (sasl_ssf)
 794             fprintf(stderr, "(decrypted) ");
 795 #endif /* CYRUS_SASL */
 796         fprintf (stderr, "<--- %s\n", response);
 797     }
 798 #endif /* DEBUG */
 799     if (strncmp (buffer, TRM, TRMLEN) == 0) {
 800         if (buffer[TRMLEN] == 0)
 801             return DONE;
 802         else
 803             strncpy (response, buffer + TRMLEN, sizeof(response));
 804     }
 805     else
 806         strncpy (response, buffer, sizeof(response));
 807
 808     return OK;
 809 }
 810
 811 /*
 812  * Note that these functions have been modified to deal with layer encryption
 813  * in the SASL case
 814  */
 815
 816 static int
 817 sasl_getline (char *s, int n, FILE *iop)
 818 {
 819     int c = -2;
 820     char *p;
 821
 822     p = s;
 823     while (--n > 0 && (c = sasl_fgetc (iop)) != EOF && c != -2)
 824         if ((*p++ = c) == '\n')
 825             break;
 826     if (c == -2)
 827         return NOTOK;
 828     if (ferror (iop) && c != EOF) {
 829         strncpy (response, "error on connection", sizeof(response));
 830         return NOTOK;
 831     }
 832     if (c == EOF && p == s) {
 833         strncpy (response, "connection closed by foreign host", sizeof(response));
 834         return DONE;
 835     }
 836     *p = 0;
 837     if (*--p == '\n')
 838         *p = 0;
 839     if (*--p == '\r')
 840         *p = 0;
 841
 842     return OK;
 843 }
 844
 845
 846 static int
 847 putline (char *s, FILE *iop)
 848 {
 849 #ifdef CYRUS_SASL
 850     char outbuf[BUFSIZ], *buf;
 851     int result;
 852     unsigned int buflen;
 853
 854     if (!sasl_complete) {
 855 #endif /* CYRUS_SASL */
 856         fprintf (iop, "%s\r\n", s);
 857 #ifdef CYRUS_SASL
 858     } else {
 859         /*
 860          * Build an output buffer, encrypt it using sasl_encode, and
 861          * squirt out the results.
 862          */
 863         strncpy(outbuf, s, sizeof(outbuf) - 3);
 864         outbuf[sizeof(outbuf) - 3] = '\0';   /* Just in case */
 865         strcat(outbuf, "\r\n");
 866
 867         result = sasl_encode(conn, outbuf, strlen(outbuf),
 868                              (const char **) &buf, &buflen);
 869
 870         if (result != SASL_OK) {
 871             snprintf(response, sizeof(response), "SASL encoding error: %s",
 872                      sasl_errdetail(conn));
 873             return NOTOK;
 874         }
 875
 876         fwrite(buf, buflen, 1, iop);
 877     }
 878 #endif /* CYRUS_SASL */
 879
 880     fflush (iop);
 881     if (ferror (iop)) {
 882         strncpy (response, "lost connection", sizeof(response));
 883         return NOTOK;
 884     }
 885
 886     return OK;
 887 }
 888
 889 #ifdef CYRUS_SASL
 890 /*
 891  * Okay, our little fgetc replacement.  Hopefully this is a little more
 892  * efficient than the last one.
 893  */
 894 static int
 895 sasl_fgetc(FILE *f)
 896 {
 897     static unsigned char *buffer = NULL, *ptr;
 898     static unsigned int size = 0;
 899     static int cnt = 0;
 900     unsigned int retbufsize = 0;
 901     int cc, result;
 902     char *retbuf, tmpbuf[SASL_BUFFER_SIZE];
 903
 904     /*
 905      * If we have some leftover data, return that
 906      */
 907
 908     if (cnt) {
 909         cnt--;
 910         return (int) *ptr++;
 911     }
 912
 913     /*
 914      * Otherwise, fill our buffer until we have some data to return.
 915      */
 916
 917     while (retbufsize == 0) {
 918
 919         cc = read(fileno(f), tmpbuf, sizeof(tmpbuf));
 920
 921         if (cc == 0)
 922             return EOF;
 923
 924         if (cc < 0) {
 925             snprintf(response, sizeof(response), "Error during read from "
 926                      "network: %s", strerror(errno));
 927             return -2;
 928         }
 929
 930         /*
 931          * We're not allowed to call sasl_decode until sasl_complete is
 932          * true, so we do these gyrations ...
 933          */
 934
 935         if (!sasl_complete) {
 936
 937             retbuf = tmpbuf;
 938             retbufsize = cc;
 939
 940         } else {
 941
 942             result = sasl_decode(conn, tmpbuf, cc,
 943                                  (const char **) &retbuf, &retbufsize);
 944
 945             if (result != SASL_OK) {
 946                 snprintf(response, sizeof(response), "Error during SASL "
 947                          "decoding: %s", sasl_errdetail(conn));
 948                 return -2;
 949             }
 950         }
 951     }
 952
 953     if (retbufsize > size) {
 954         buffer = mh_xrealloc(buffer, retbufsize);
 955         size = retbufsize;
 956     }
 957
 958     memcpy(buffer, retbuf, retbufsize);
 959     ptr = buffer + 1;
 960     cnt = retbufsize - 1;
 961
 962     return (int) buffer[0];
 963 }
 964 #endif /* CYRUS_SASL */