* uip/mhlistsbr.c, uip/mhlsbr.c, uip/picksbr.c: cast
[mmh] / uip / popsbr.c
1 /*
2  * popsbr.c -- POP client subroutines
3  *
4  * $Id$
5  *
6  * This code is Copyright (c) 2002, by the authors of nmh.  See the
7  * COPYRIGHT file in the root directory of the nmh distribution for
8  * complete copyright information.
9  */
10
11 #include <h/mh.h>
12 #include <h/utils.h>
13
14 #if defined(NNTP) && !defined(PSHSBR)
15 # undef NNTP
16 #endif
17
18 #ifdef NNTP                     /* building pshsbr.o from popsbr.c */
19 # include <h/nntp.h>
20 #endif /* NNTP */
21
22 #if !defined(NNTP) && defined(APOP)
23 # include <h/md5.h>
24 #endif
25
26 #ifdef CYRUS_SASL
27 # include <sasl/sasl.h>
28 # include <sasl/saslutil.h>
29 #endif /* CYRUS_SASL */
30
31 #include <h/popsbr.h>
32 #include <h/signals.h>
33 #include <signal.h>
34 #include <errno.h>
35
36 #define TRM     "."
37 #define TRMLEN  (sizeof TRM - 1)
38
39 static int poprint = 0;
40 static int pophack = 0;
41
42 char response[BUFSIZ];
43
44 static FILE *input;
45 static FILE *output;
46
47 #define targ_t char *
48
49 #if !defined(NNTP) && defined(MPOP)
50 # define command pop_command
51 # define multiline pop_multiline
52 #endif
53
54 #ifdef NNTP
55 # ifdef BPOP    /* stupid */
56 static int xtnd_last = -1;
57 static int xtnd_first = 0;
58 static char xtnd_name[512];     /* INCREDIBLE HACK!! */
59 # endif
60 #endif /* NNTP */
61
62 #ifdef CYRUS_SASL
63 static sasl_conn_t *conn;       /* SASL connection state */
64 static int sasl_complete = 0;   /* Has sasl authentication succeeded? */
65 static int maxoutbuf;           /* Maximum output buffer size */
66 static sasl_ssf_t sasl_ssf = 0; /* Security strength factor */
67 static int sasl_get_user(void *, int, const char **, unsigned *);
68 static int sasl_get_pass(sasl_conn_t *, void *, int, sasl_secret_t **);
69 struct pass_context {
70     char *user;
71     char *host;
72 };
73
74 static sasl_callback_t callbacks[] = {
75     { SASL_CB_USER, sasl_get_user, NULL },
76 #define POP_SASL_CB_N_USER 0
77     { SASL_CB_PASS, sasl_get_pass, NULL },
78 #define POP_SASL_CB_N_PASS 1
79     { SASL_CB_LOG, NULL, NULL },
80     { SASL_CB_LIST_END, NULL, NULL },
81
82 #define SASL_BUFFER_SIZE 262144
83 };
84 #else /* CYRUS_SASL */
85 # define sasl_fgetc fgetc
86 #endif /* CYRUS_SASL */
87
88 /*
89  * static prototypes
90  */
91 #if !defined(NNTP) && defined(APOP)
92 static char *pop_auth (char *, char *);
93 #endif
94
95 #if defined(NNTP) || !defined(MPOP)
96 /* otherwise they are not static functions */
97 static int command(const char *, ...);
98 static int multiline(void);
99 #endif
100
101 #ifdef CYRUS_SASL
102 static int pop_auth_sasl(char *, char *, char *);
103 static int sasl_fgetc(FILE *);
104 #endif /* CYRUS_SASL */
105
106 static int traverse (int (*)(char *), const char *, ...);
107 static int vcommand(const char *, va_list);
108 static int sasl_getline (char *, int, FILE *);
109 static int putline (char *, FILE *);
110
111
112 #if !defined(NNTP) && defined(APOP)
113 static char *
114 pop_auth (char *user, char *pass)
115 {
116     int len, buflen;
117     char *cp, *lp;
118     unsigned char *dp, *ep, digest[16];
119     MD5_CTX mdContext;
120     static char buffer[BUFSIZ];
121
122     if ((cp = strchr (response, '<')) == NULL
123             || (lp = strchr (cp, '>')) == NULL) {
124         snprintf (buffer, sizeof(buffer), "APOP not available: %s", response);
125         strncpy (response, buffer, sizeof(response));
126         return NULL;
127     }
128
129     *(++lp) = '\0';
130     snprintf (buffer, sizeof(buffer), "%s%s", cp, pass);
131
132     MD5Init (&mdContext);
133     MD5Update (&mdContext, (unsigned char *) buffer,
134                (unsigned int) strlen (buffer));
135     MD5Final (digest, &mdContext);
136
137     cp = buffer;
138     buflen = sizeof(buffer);
139
140     snprintf (cp, buflen, "%s ", user);
141     len = strlen (cp);
142     cp += len;
143     buflen -= len;
144
145     for (ep = (dp = digest) + sizeof(digest) / sizeof(digest[0]); dp < ep; ) {
146         snprintf (cp, buflen, "%02x", *dp++ & 0xff);
147         cp += 2;
148         buflen -= 2;
149     }
150     *cp = '\0';
151
152     return buffer;
153 }
154 #endif  /* !NNTP && APOP */
155
156 #ifdef CYRUS_SASL
157 /*
158  * This function implements the AUTH command for various SASL mechanisms
159  *
160  * We do the whole SASL dialog here.  If this completes, then we've
161  * authenticated successfully and have (possibly) negotiated a security
162  * layer.
163  */
164
165 int
166 pop_auth_sasl(char *user, char *host, char *mech)
167 {
168     int result, status, sasl_capability = 0;
169     unsigned int buflen, outlen;
170     char server_mechs[256], *buf, outbuf[BUFSIZ];
171     const char *chosen_mech;
172     sasl_security_properties_t secprops;
173     struct pass_context p_context;
174     sasl_ssf_t *ssf;
175     int *moutbuf;
176
177     /*
178      * First off, we're going to send the CAPA command to see if we can
179      * even support the AUTH command, and if we do, then we'll get a
180      * list of mechanisms the server supports.  If we don't support
181      * the CAPA command, then it's unlikely that we will support
182      * SASL
183      */
184
185     if (command("CAPA") == NOTOK) {
186         snprintf(response, sizeof(response),
187                  "The POP CAPA command failed; POP server does not "
188                  "support SASL");
189         return NOTOK;
190     }
191
192     while ((status = multiline()) != DONE)
193         switch (status) {
194         case NOTOK:
195             return NOTOK;
196             break;
197         case DONE:      /* Shouldn't be possible, but just in case */
198             break;
199         case OK:
200             if (strncasecmp(response, "SASL ", 5) == 0) {
201                 /*
202                  * We've seen the SASL capability.  Grab the mech list
203                  */
204                 sasl_capability++;
205                 strncpy(server_mechs, response + 5, sizeof(server_mechs));
206             }
207             break;
208         }
209
210     if (!sasl_capability) {
211         snprintf(response, sizeof(response), "POP server does not support "
212                  "SASL");
213         return NOTOK;
214     }
215
216     /*
217      * If we received a preferred mechanism, see if the server supports it.
218      */
219
220     if (mech && stringdex(mech, server_mechs) == -1) {
221         snprintf(response, sizeof(response), "Requested SASL mech \"%s\" is "
222                  "not in list of supported mechanisms:\n%s",
223                  mech, server_mechs);
224         return NOTOK;
225     }
226
227     /*
228      * Start the SASL process.  First off, initialize the SASL library.
229      */
230
231     callbacks[POP_SASL_CB_N_USER].context = user;
232     p_context.user = user;
233     p_context.host = host;
234     callbacks[POP_SASL_CB_N_PASS].context = &p_context;
235
236     result = sasl_client_init(callbacks);
237
238     if (result != SASL_OK) {
239         snprintf(response, sizeof(response), "SASL library initialization "
240                  "failed: %s", sasl_errstring(result, NULL, NULL));
241         return NOTOK;
242     }
243
244     result = sasl_client_new("pop", host, NULL, NULL, NULL, 0, &conn);
245
246     if (result != SASL_OK) {
247         snprintf(response, sizeof(response), "SASL client initialization "
248                  "failed: %s", sasl_errstring(result, NULL, NULL));
249         return NOTOK;
250     }
251
252     /*
253      * Initialize the security properties
254      */
255
256     memset(&secprops, 0, sizeof(secprops));
257     secprops.maxbufsize = SASL_BUFFER_SIZE;
258     secprops.max_ssf = UINT_MAX;
259
260     result = sasl_setprop(conn, SASL_SEC_PROPS, &secprops);
261
262     if (result != SASL_OK) {
263         snprintf(response, sizeof(response), "SASL security property "
264                  "initialization failed: %s", sasl_errdetail(conn));
265         return NOTOK;
266     }
267
268     /*
269      * Start the actual protocol.  Feed the mech list into the library
270      * and get out a possible initial challenge
271      */
272
273     result = sasl_client_start(conn,
274                                (const char *) (mech ? mech : server_mechs),
275                                NULL, (const char **) &buf,
276                                &buflen, &chosen_mech);
277
278     if (result != SASL_OK && result != SASL_CONTINUE) {
279         snprintf(response, sizeof(response), "SASL client start failed: %s",
280                  sasl_errdetail(conn));
281         return NOTOK;
282     }
283
284     if (buflen) {
285         status = sasl_encode64(buf, buflen, outbuf, sizeof(outbuf), NULL);
286         if (status != SASL_OK) {
287             snprintf(response, sizeof(response), "SASL base64 encode "
288                      "failed: %s", sasl_errstring(status, NULL, NULL));
289             return NOTOK;
290         }
291
292         status = command("AUTH %s %s", chosen_mech, outbuf);
293     } else
294         status = command("AUTH %s", chosen_mech);
295
296     while (result == SASL_CONTINUE) {
297         if (status == NOTOK)
298             return NOTOK;
299         
300         /*
301          * If we get a "+OK" prefix to our response, then we should
302          * exit out of this exchange now (because authenticated should
303          * have succeeded)
304          */
305         
306         if (strncmp(response, "+OK", 3) == 0)
307             break;
308         
309         /*
310          * Otherwise, make sure the server challenge is correctly formatted
311          */
312         
313         if (strncmp(response, "+ ", 2) != 0) {
314             command("*");
315             snprintf(response, sizeof(response),
316                      "Malformed authentication message from server");
317             return NOTOK;
318         }
319
320         result = sasl_decode64(response + 2, strlen(response + 2),
321                                outbuf, sizeof(outbuf), &outlen);
322         
323         if (result != SASL_OK) {
324             command("*");
325             snprintf(response, sizeof(response), "SASL base64 decode "
326                      "failed: %s", sasl_errstring(result, NULL, NULL));
327             return NOTOK;
328         }
329
330         result = sasl_client_step(conn, outbuf, outlen, NULL,
331                                   (const char **) &buf, &buflen);
332
333         if (result != SASL_OK && result != SASL_CONTINUE) {
334             command("*");
335             snprintf(response, sizeof(response), "SASL client negotiaton "
336                      "failed: %s", sasl_errdetail(conn));
337             return NOTOK;
338         }
339
340         status = sasl_encode64(buf, buflen, outbuf, sizeof(outbuf), NULL);
341
342         if (status != SASL_OK) {
343             command("*");
344             snprintf(response, sizeof(response), "SASL base64 encode "
345                      "failed: %s", sasl_errstring(status, NULL, NULL));
346             return NOTOK;
347         }
348
349         status = command(outbuf);
350     }
351
352     /*
353      * If we didn't get a positive final response, then error out
354      * (that probably means we failed an authorization check).
355      */
356
357     if (status != OK)
358         return NOTOK;
359
360     /*
361      * We _should_ be okay now.  Get a few properties now that negotiation
362      * has completed.
363      */
364
365     result = sasl_getprop(conn, SASL_MAXOUTBUF, (const void **) &moutbuf);
366
367     if (result != SASL_OK) {
368         snprintf(response, sizeof(response), "Cannot retrieve SASL negotiated "
369                  "output buffer size: %s", sasl_errdetail(conn));
370         return NOTOK;
371     }
372
373     maxoutbuf = *moutbuf;
374
375     result = sasl_getprop(conn, SASL_SSF, (const void **) &ssf);
376
377     sasl_ssf = *ssf;
378
379     if (result != SASL_OK) {
380         snprintf(response, sizeof(response), "Cannot retrieve SASL negotiated "
381                  "security strength factor: %s", sasl_errdetail(conn));
382         return NOTOK;
383     }
384
385     /*
386      * Limit this to what we can deal with.  Shouldn't matter much because
387      * this is only outgoing data (which should be small)
388      */
389
390     if (maxoutbuf == 0 || maxoutbuf > BUFSIZ)
391         maxoutbuf = BUFSIZ;
392
393     sasl_complete = 1;
394
395     return status;
396 }
397
398 /*
399  * Callback to return the userid sent down via the user parameter
400  */
401
402 static int
403 sasl_get_user(void *context, int id, const char **result, unsigned *len)
404 {
405     char *user = (char *) context;
406
407     if (! result || id != SASL_CB_USER)
408         return SASL_BADPARAM;
409
410     *result = user;
411     if (len)
412         *len = strlen(user);
413
414     return SASL_OK;
415 }
416
417 /*
418  * Callback to return the password (we call ruserpass, which can get it
419  * out of the .netrc
420  */
421
422 static int
423 sasl_get_pass(sasl_conn_t *conn, void *context, int id, sasl_secret_t **psecret)
424 {
425     struct pass_context *p_context = (struct pass_context *) context;
426     char *pass = NULL;
427     int len;
428
429     if (! psecret || id != SASL_CB_PASS)
430         return SASL_BADPARAM;
431
432     ruserpass(p_context->user, &(p_context->host), &pass);
433
434     len = strlen(pass);
435
436     *psecret = (sasl_secret_t *) mh_xmalloc(sizeof(sasl_secret_t) + len);
437
438     (*psecret)->len = len;
439     strcpy((char *) (*psecret)->data, pass);
440
441     return SASL_OK;
442 }
443 #endif /* CYRUS_SASL */
444
445
446 /*
447  * Split string containing proxy command into an array of arguments
448  * suitable for passing to exec. Returned array must be freed. Shouldn't
449  * be possible to call this with host set to NULL.
450  */
451 char **
452 parse_proxy(char *proxy, char *host)
453 {
454     char **pargv, **p;
455     int pargc = 2;
456     int hlen = strlen(host);
457     int plen = 1;
458     unsigned char *cur, *pro;
459     char *c;
460     
461     /* skip any initial space */
462     for (pro = (unsigned char *) proxy; isspace(*pro); pro++)
463         continue;
464     
465     /* calculate required size for argument array */
466     for (cur = pro; *cur; cur++) {
467         if (isspace(*cur) && cur[1] && !isspace(cur[1]))
468             plen++, pargc++;
469         else if (*cur == '%' && cur[1] == 'h') {
470             plen += hlen;
471             cur++;
472         } else if (!isspace(*cur))
473             plen++;
474     }
475
476    /* put together list of arguments */
477     p = pargv = mh_xmalloc(pargc * sizeof(char *));
478     c = *pargv = mh_xmalloc(plen * sizeof(char));
479     for (cur = pro; *cur; cur++) {
480         if (isspace(*cur) && cur[1] && !isspace(cur[1])) {
481             *c++ = '\0';
482             *++p = c;
483         } else if (*cur == '%' && cur[1] == 'h') {
484             strcpy (c, host);
485             c += hlen;
486             cur++;
487         } else if (!isspace(*cur))
488             *c++ = *cur;
489     }
490     *++p = NULL;
491     return pargv;
492 }
493
494 int
495 pop_init (char *host, char *user, char *pass, char *proxy, int snoop,
496           int rpop, int kpop, int sasl, char *mech)
497 {
498     int fd1, fd2;
499     char buffer[BUFSIZ];
500
501 #ifdef APOP
502     int apop;
503
504     if ((apop = rpop) < 0)
505         rpop = 0;
506 #endif
507
508     if (proxy && *proxy) {
509        int pid;
510        int inpipe[2];     /* for reading from the server */
511        int outpipe[2];    /* for sending to the server */
512
513        /* first give up any root priviledges we may have for rpop */
514        setuid(getuid());
515
516        pipe(inpipe);
517        pipe(outpipe);
518
519        pid=fork();
520        if (pid==0) {
521            char **argv;
522            
523            /* in child */
524            close(0);  
525            close(1);
526            dup2(outpipe[0],0);  /* connect read end of connection */
527            dup2(inpipe[1], 1);  /* connect write end of connection */
528            if(inpipe[0]>1) close(inpipe[0]);
529            if(inpipe[1]>1) close(inpipe[1]);
530            if(outpipe[0]>1) close(outpipe[0]);
531            if(outpipe[1]>1) close(outpipe[1]);
532
533            /* run the proxy command */
534            argv=parse_proxy(proxy, host);
535            execvp(argv[0],argv);
536
537            perror(argv[0]);
538            close(0);
539            close(1);
540            free(*argv);
541            free(argv);
542            exit(10);
543        }
544
545        /* okay in the parent we do some stuff */
546        close(inpipe[1]);  /* child uses this */
547        close(outpipe[0]); /* child uses this */
548
549        /* we read on fd1 */
550        fd1=inpipe[0];
551
552        /* and write on fd2 */
553        fd2=outpipe[1];
554
555     } else {
556
557 #ifndef NNTP
558         if ( kpop ) {
559 # ifdef KPOP
560             snprintf (buffer, sizeof(buffer), "%s/%s", KPOP_PRINCIPAL, "kpop");
561             if ((fd1 = client (host, "tcp", buffer, 0, response, sizeof(response))) == NOTOK) {
562                 return NOTOK;
563             }
564 # else  /* KPOP */
565             snprintf (response, sizeof(response), "this version of nmh compiled without KPOP support");
566             return NOTOK;
567 # endif /* KPOP */
568         } else {
569             if ((fd1 = client (host, POPSERVICE, response, sizeof(response), snoop)) == NOTOK) {
570                 return NOTOK;
571             }
572         }
573 #else   /* NNTP */
574         if ((fd1 = client (host, "nntp", response, sizeof(response), snoop)) == NOTOK)
575             return NOTOK;
576 #endif
577
578         if ((fd2 = dup (fd1)) == NOTOK) {
579             char *s;
580
581             if ((s = strerror(errno)))
582                 snprintf (response, sizeof(response),
583                     "unable to dup connection descriptor: %s", s);
584             else
585                 snprintf (response, sizeof(response),
586                     "unable to dup connection descriptor: unknown error");
587             close (fd1);
588             return NOTOK;
589         }
590     }
591 #ifndef NNTP
592     if (pop_set (fd1, fd2, snoop) == NOTOK)
593 #else   /* NNTP */
594     if (pop_set (fd1, fd2, snoop, (char *)0) == NOTOK)
595 #endif  /* NNTP */
596         return NOTOK;
597
598     SIGNAL (SIGPIPE, SIG_IGN);
599
600     switch (sasl_getline (response, sizeof response, input)) {
601         case OK: 
602             if (poprint)
603                 fprintf (stderr, "<--- %s\n", response);
604 #ifndef NNTP
605             if (*response == '+') {
606 # ifndef KPOP
607 #  ifdef APOP
608                 if (apop < 0) {
609                     char *cp = pop_auth (user, pass);
610
611                     if (cp && command ("APOP %s", cp) != NOTOK)
612                         return OK;
613                 }
614                 else
615 #  endif /* APOP */
616 #  ifdef CYRUS_SASL
617                 if (sasl) {
618                     if (pop_auth_sasl(user, host, mech) != NOTOK)
619                         return OK;
620                 } else
621 #  endif /* CYRUS_SASL */
622                 if (command ("USER %s", user) != NOTOK
623                     && command ("%s %s", rpop ? "RPOP" : (pophack++, "PASS"),
624                                         pass) != NOTOK)
625                 return OK;
626 # else /* KPOP */
627                 if (command ("USER %s", user) != NOTOK
628                     && command ("PASS %s", pass) != NOTOK)
629                 return OK;
630 # endif
631             }
632 #else /* NNTP */
633             if (*response < CHAR_ERR) {
634                 command ("MODE READER");
635                 return OK;
636             }
637 #endif
638             strncpy (buffer, response, sizeof(buffer));
639             command ("QUIT");
640             strncpy (response, buffer, sizeof(response));
641                                 /* and fall */
642
643         case NOTOK: 
644         case DONE: 
645             if (poprint)            
646                 fprintf (stderr, "%s\n", response);
647             fclose (input);
648             fclose (output);
649             return NOTOK;
650     }
651
652     return NOTOK;       /* NOTREACHED */
653 }
654
655 #ifdef NNTP
656 int
657 pop_set (int in, int out, int snoop, char *myname)
658 #else
659 int
660 pop_set (int in, int out, int snoop)
661 #endif
662 {
663
664 #ifdef NNTP
665     if (myname && *myname) {
666         /* interface from bbc to msh */
667         strncpy (xtnd_name, myname, sizeof(xtnd_name));
668     }
669 #endif  /* NNTP */
670
671     if ((input = fdopen (in, "r")) == NULL
672             || (output = fdopen (out, "w")) == NULL) {
673         strncpy (response, "fdopen failed on connection descriptor", sizeof(response));
674         if (input)
675             fclose (input);
676         else
677             close (in);
678         close (out);
679         return NOTOK;
680     }
681
682     poprint = snoop;
683
684     return OK;
685 }
686
687
688 int
689 pop_fd (char *in, int inlen, char *out, int outlen)
690 {
691     snprintf (in, inlen, "%d", fileno (input));
692     snprintf (out, outlen, "%d", fileno (output));
693     return OK;
694 }
695
696
697 /*
698  * Find out number of messages available
699  * and their total size.
700  */
701
702 int
703 pop_stat (int *nmsgs, int *nbytes)
704 {
705 #ifdef NNTP
706     char **ap;
707 #endif /* NNTP */
708
709 #ifndef NNTP
710     if (command ("STAT") == NOTOK)
711         return NOTOK;
712
713     *nmsgs = *nbytes = 0;
714     sscanf (response, "+OK %d %d", nmsgs, nbytes);
715
716 #else /* NNTP */
717     if (xtnd_last < 0) {        /* in msh, xtnd_name is set from myname */
718         if (command("GROUP %s", xtnd_name) == NOTOK)
719             return NOTOK;
720
721         ap = brkstring (response, " ", "\n"); /* "211 nart first last ggg" */
722         xtnd_first = atoi (ap[2]);
723         xtnd_last  = atoi (ap[3]);
724     }
725
726     /* nmsgs is not the real nart, but an incredible simuation */
727     if (xtnd_last > 0)
728         *nmsgs = xtnd_last - xtnd_first + 1;    /* because of holes... */
729     else
730         *nmsgs = 0;
731     *nbytes = xtnd_first;       /* for subtracting offset in msh() */
732 #endif /* NNTP */
733
734     return OK;
735 }
736
737 #ifdef NNTP
738 int
739 pop_exists (int (*action)())
740 {
741 #ifdef XMSGS            /* hacked into NNTP 1.5 */
742     if (traverse (action, "XMSGS %d-%d", (targ_t) xtnd_first, (targ_t) xtnd_last) == OK)
743         return OK;
744 #endif
745     /* provided by INN 1.4 */
746     if (traverse (action, "LISTGROUP") == OK)
747         return OK;
748     return traverse (action, "XHDR NONAME %d-%d", (targ_t) xtnd_first, (targ_t) xtnd_last);
749 }
750 #endif  /* NNTP */
751
752
753 #ifdef BPOP
754 int
755 pop_list (int msgno, int *nmsgs, int *msgs, int *bytes, int *ids)
756 #else
757 int
758 pop_list (int msgno, int *nmsgs, int *msgs, int *bytes)
759 #endif
760 {
761     int i;
762 #ifndef BPOP
763     int *ids = NULL;
764 #endif
765
766     if (msgno) {
767 #ifndef NNTP
768         if (command ("LIST %d", msgno) == NOTOK)
769             return NOTOK;
770         *msgs = *bytes = 0;
771         if (ids) {
772             *ids = 0;
773             sscanf (response, "+OK %d %d %d", msgs, bytes, ids);
774         }
775         else
776             sscanf (response, "+OK %d %d", msgs, bytes);
777 #else /* NNTP */
778         *msgs = *bytes = 0;
779         if (command ("STAT %d", msgno) == NOTOK) 
780             return NOTOK;
781         if (ids) {
782             *ids = msgno;
783         }
784 #endif /* NNTP */
785         return OK;
786     }
787
788 #ifndef NNTP
789     if (command ("LIST") == NOTOK)
790         return NOTOK;
791
792     for (i = 0; i < *nmsgs; i++)
793         switch (multiline ()) {
794             case NOTOK: 
795                 return NOTOK;
796             case DONE: 
797                 *nmsgs = ++i;
798                 return OK;
799             case OK: 
800                 *msgs = *bytes = 0;
801                 if (ids) {
802                     *ids = 0;
803                     sscanf (response, "%d %d %d",
804                             msgs++, bytes++, ids++);
805                 }
806                 else
807                     sscanf (response, "%d %d", msgs++, bytes++);
808                 break;
809         }
810     for (;;)
811         switch (multiline ()) {
812             case NOTOK: 
813                 return NOTOK;
814             case DONE: 
815                 return OK;
816             case OK: 
817                 break;
818         }
819 #else /* NNTP */
820     return NOTOK;
821 #endif /* NNTP */
822 }
823
824
825 int
826 pop_retr (int msgno, int (*action)(char *))
827 {
828 #ifndef NNTP
829     return traverse (action, "RETR %d", (targ_t) msgno);
830 #else /* NNTP */
831     return traverse (action, "ARTICLE %d", (targ_t) msgno);
832 #endif /* NNTP */
833 }
834
835
836 static int
837 traverse (int (*action)(char *), const char *fmt, ...)
838 {
839     int result;
840     va_list ap;
841     char buffer[sizeof(response)];
842
843     va_start(ap, fmt);
844     result = vcommand (fmt, ap);
845     va_end(ap);
846
847     if (result == NOTOK)
848         return NOTOK;
849     strncpy (buffer, response, sizeof(buffer));
850
851     for (;;)
852         switch (multiline ()) {
853             case NOTOK: 
854                 return NOTOK;
855
856             case DONE: 
857                 strncpy (response, buffer, sizeof(response));
858                 return OK;
859
860             case OK: 
861                 (*action) (response);
862                 break;
863         }
864 }
865
866
867 int
868 pop_dele (int msgno)
869 {
870     return command ("DELE %d", msgno);
871 }
872
873
874 int
875 pop_noop (void)
876 {
877     return command ("NOOP");
878 }
879
880
881 #if defined(MPOP) && !defined(NNTP)
882 int
883 pop_last (void)
884 {
885     return command ("LAST");
886 }
887 #endif
888
889
890 int
891 pop_rset (void)
892 {
893     return command ("RSET");
894 }
895
896
897 int
898 pop_top (int msgno, int lines, int (*action)(char *))
899 {
900 #ifndef NNTP
901     return traverse (action, "TOP %d %d", (targ_t) msgno, (targ_t) lines);
902 #else   /* NNTP */
903     return traverse (action, "HEAD %d", (targ_t) msgno);
904 #endif /* NNTP */
905 }
906
907
908 #ifdef BPOP
909 int
910 pop_xtnd (int (*action)(), char *fmt, ...)
911 {
912     int result;
913     va_list ap;
914     char buffer[BUFSIZ];
915
916 #ifdef NNTP
917     char **ap;
918 #endif
919
920     va_start(ap, fmt);
921 #ifndef NNTP
922     /* needs to be fixed... va_end needs to be added */
923     snprintf (buffer, sizeof(buffer), "XTND %s", fmt);
924     result = traverse (action, buffer, a, b, c, d);
925     va_end(ap);
926     return result;
927 #else /* NNTP */
928     snprintf (buffer, sizeof(buffer), fmt, a, b, c, d);
929     ap = brkstring (buffer, " ", "\n"); /* a hack, i know... */
930
931     if (!mh_strcasecmp(ap[0], "x-bboards")) {   /* XTND "X-BBOARDS group */
932         /* most of these parameters are meaningless under NNTP. 
933          * bbc.c was modified to set AKA and LEADERS as appropriate,
934          * the rest are left blank.
935          */
936         return OK;
937     }
938     if (!mh_strcasecmp (ap[0], "archive") && ap[1]) {
939         snprintf (xtnd_name, sizeof(xtnd_name), "%s", ap[1]);   /* save the name */
940         xtnd_last = 0;
941         xtnd_first = 1;         /* setup to fail in pop_stat */
942         return OK;
943     }
944     if (!mh_strcasecmp (ap[0], "bboards")) {
945
946         if (ap[1]) {                    /* XTND "BBOARDS group" */
947             snprintf (xtnd_name, sizeof(xtnd_name), "%s", ap[1]);       /* save the name */
948             if (command("GROUP %s", xtnd_name) == NOTOK)
949                 return NOTOK;
950
951             /* action must ignore extra args */
952             strncpy (buffer, response, sizeof(buffer));
953             ap = brkstring (response, " ", "\n");/* "211 nart first last g" */
954             xtnd_first = atoi (ap[2]);
955             xtnd_last  = atoi (ap[3]);
956
957             (*action) (buffer);         
958             return OK;
959
960         } else {                /* XTND "BBOARDS" */
961             return traverse (action, "LIST", a, b, c, d);
962         }
963     }
964     return NOTOK;       /* unknown XTND command */
965 #endif /* NNTP */
966 }
967 #endif /* BPOP */
968
969
970 int
971 pop_quit (void)
972 {
973     int i;
974
975     i = command ("QUIT");
976     pop_done ();
977
978     return i;
979 }
980
981
982 int
983 pop_done (void)
984 {
985 #ifdef CYRUS_SASL
986     if (conn)
987         sasl_dispose(&conn);
988 #endif /* CYRUS_SASL */
989     fclose (input);
990     fclose (output);
991
992     return OK;
993 }
994
995
996 #if !defined(MPOP) || defined(NNTP)
997 static
998 #endif
999 int
1000 command(const char *fmt, ...)
1001 {
1002     va_list ap;
1003     int result;
1004
1005     va_start(ap, fmt);
1006     result = vcommand(fmt, ap);
1007     va_end(ap);
1008
1009     return result;
1010 }
1011
1012
1013 static int
1014 vcommand (const char *fmt, va_list ap)
1015 {
1016     char *cp, buffer[BUFSIZ];
1017
1018     vsnprintf (buffer, sizeof(buffer), fmt, ap);
1019     if (poprint) {
1020 #ifdef CYRUS_SASL
1021         if (sasl_ssf)
1022             fprintf(stderr, "(encrypted) ");
1023 #endif /* CYRUS_SASL */
1024         if (pophack) {
1025             if ((cp = strchr (buffer, ' ')))
1026                 *cp = 0;
1027             fprintf (stderr, "---> %s ********\n", buffer);
1028             if (cp)
1029                 *cp = ' ';
1030             pophack = 0;
1031         }
1032         else
1033             fprintf (stderr, "---> %s\n", buffer);
1034     }
1035
1036     if (putline (buffer, output) == NOTOK)
1037         return NOTOK;
1038
1039 #ifdef CYRUS_SASL
1040     if (poprint && sasl_ssf)
1041         fprintf(stderr, "(decrypted) ");
1042 #endif /* CYRUS_SASL */
1043
1044     switch (sasl_getline (response, sizeof response, input)) {
1045         case OK: 
1046             if (poprint)
1047                 fprintf (stderr, "<--- %s\n", response);
1048 #ifndef NNTP
1049             return (*response == '+' ? OK : NOTOK);
1050 #else   /* NNTP */
1051             return (*response < CHAR_ERR ? OK : NOTOK);
1052 #endif  /* NNTP */
1053
1054         case NOTOK: 
1055         case DONE: 
1056             if (poprint)            
1057                 fprintf (stderr, "%s\n", response);
1058             return NOTOK;
1059     }
1060
1061     return NOTOK;       /* NOTREACHED */
1062 }
1063
1064
1065 #if defined(MPOP) && !defined(NNTP)
1066 int
1067 multiline (void)
1068 #else
1069 static int
1070 multiline (void)
1071 #endif
1072 {
1073     char buffer[BUFSIZ + TRMLEN];
1074
1075     if (sasl_getline (buffer, sizeof buffer, input) != OK)
1076         return NOTOK;
1077 #ifdef DEBUG
1078     if (poprint) {
1079 #ifdef CYRUS_SASL
1080         if (sasl_ssf)
1081             fprintf(stderr, "(decrypted) ");
1082 #endif /* CYRUS_SASL */
1083         fprintf (stderr, "<--- %s\n", response);
1084     }
1085 #endif /* DEBUG */
1086     if (strncmp (buffer, TRM, TRMLEN) == 0) {
1087         if (buffer[TRMLEN] == 0)
1088             return DONE;
1089         else
1090             strncpy (response, buffer + TRMLEN, sizeof(response));
1091     }
1092     else
1093         strncpy (response, buffer, sizeof(response));
1094
1095     return OK;
1096 }
1097
1098 /*
1099  * Note that these functions have been modified to deal with layer encryption
1100  * in the SASL case
1101  */
1102
1103 static int
1104 sasl_getline (char *s, int n, FILE *iop)
1105 {
1106     int c;
1107     char *p;
1108
1109     p = s;
1110     while (--n > 0 && (c = sasl_fgetc (iop)) != EOF && c != -2) 
1111         if ((*p++ = c) == '\n')
1112             break;
1113     if (c == -2)
1114         return NOTOK;
1115     if (ferror (iop) && c != EOF) {
1116         strncpy (response, "error on connection", sizeof(response));
1117         return NOTOK;
1118     }
1119     if (c == EOF && p == s) {
1120         strncpy (response, "connection closed by foreign host", sizeof(response));
1121         return DONE;
1122     }
1123     *p = 0;
1124     if (*--p == '\n')
1125         *p = 0;
1126     if (*--p == '\r')
1127         *p = 0;
1128
1129     return OK;
1130 }
1131
1132
1133 static int
1134 putline (char *s, FILE *iop)
1135 {
1136 #ifdef CYRUS_SASL
1137     char outbuf[BUFSIZ], *buf;
1138     int result;
1139     unsigned int buflen;
1140
1141     if (!sasl_complete) {
1142 #endif /* CYRUS_SASL */
1143         fprintf (iop, "%s\r\n", s);
1144 #ifdef CYRUS_SASL
1145     } else {
1146         /*
1147          * Build an output buffer, encrypt it using sasl_encode, and
1148          * squirt out the results.
1149          */
1150         strncpy(outbuf, s, sizeof(outbuf) - 3);
1151         outbuf[sizeof(outbuf) - 3] = '\0';   /* Just in case */
1152         strcat(outbuf, "\r\n");
1153
1154         result = sasl_encode(conn, outbuf, strlen(outbuf),
1155                              (const char **) &buf, &buflen);
1156
1157         if (result != SASL_OK) {
1158             snprintf(response, sizeof(response), "SASL encoding error: %s",
1159                      sasl_errdetail(conn));
1160             return NOTOK;
1161         }
1162
1163         fwrite(buf, buflen, 1, iop);
1164     }
1165 #endif /* CYRUS_SASL */
1166
1167     fflush (iop);
1168     if (ferror (iop)) {
1169         strncpy (response, "lost connection", sizeof(response));
1170         return NOTOK;
1171     }
1172
1173     return OK;
1174 }
1175
1176 #ifdef CYRUS_SASL
1177 /*
1178  * Okay, our little fgetc replacement.  Hopefully this is a little more
1179  * efficient than the last one.
1180  */
1181 static int
1182 sasl_fgetc(FILE *f)
1183 {
1184     static unsigned char *buffer = NULL, *ptr;
1185     static int size = 0;
1186     static int cnt = 0;
1187     unsigned int retbufsize = 0;
1188     int cc, result;
1189     char *retbuf, tmpbuf[SASL_BUFFER_SIZE];
1190
1191     /*
1192      * If we have some leftover data, return that
1193      */
1194
1195     if (cnt) {
1196         cnt--;
1197         return (int) *ptr++;
1198     }
1199
1200     /*
1201      * Otherwise, fill our buffer until we have some data to return.
1202      */
1203
1204     while (retbufsize == 0) {
1205
1206         cc = read(fileno(f), tmpbuf, sizeof(tmpbuf));
1207
1208         if (cc == 0)
1209             return EOF;
1210
1211         if (cc < 0) {
1212             snprintf(response, sizeof(response), "Error during read from "
1213                      "network: %s", strerror(errno));
1214             return -2;
1215         }
1216
1217         /*
1218          * We're not allowed to call sasl_decode until sasl_complete is
1219          * true, so we do these gyrations ...
1220          */
1221         
1222         if (!sasl_complete) {
1223
1224             retbuf = tmpbuf;
1225             retbufsize = cc;
1226
1227         } else {
1228
1229             result = sasl_decode(conn, tmpbuf, cc,
1230                                  (const char **) &retbuf, &retbufsize);
1231
1232             if (result != SASL_OK) {
1233                 snprintf(response, sizeof(response), "Error during SASL "
1234                          "decoding: %s", sasl_errdetail(conn));
1235                 return -2;
1236             }
1237         }
1238     }
1239
1240     if (retbufsize > size) {
1241         buffer = mh_xrealloc(buffer, retbufsize);
1242         size = retbufsize;
1243     }
1244
1245     memcpy(buffer, retbuf, retbufsize);
1246     ptr = buffer + 1;
1247     cnt = retbufsize - 1;
1248
1249     return (int) buffer[0];
1250 }
1251 #endif /* CYRUS_SASL */