Added list of hand picked types initially genereted by...
[mmh] / 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 */