2 * popsbr.c -- POP client subroutines
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.
13 # include <sasl/sasl.h>
14 # include <sasl/saslutil.h>
15 #endif /* CYRUS_SASL */
18 #include <h/signals.h>
23 #define TRMLEN (sizeof TRM - 1)
25 static int poprint = 0;
26 static int pophack = 0;
28 char response[BUFSIZ];
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 **);
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 },
53 #define SASL_BUFFER_SIZE 262144
55 #else /* CYRUS_SASL */
56 # define sasl_fgetc fgetc
57 #endif /* CYRUS_SASL */
63 static int command(const char *, ...);
64 static int multiline(void);
67 static int pop_auth_sasl(char *, char *, char *);
68 static int sasl_fgetc(FILE *);
69 #endif /* CYRUS_SASL */
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 *);
79 * This function implements the AUTH command for various SASL mechanisms
81 * We do the whole SASL dialog here. If this completes, then we've
82 * authenticated successfully and have (possibly) negotiated a security
87 pop_auth_sasl(char *user, char *host, char *mech)
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;
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
106 if (command("CAPA") == NOTOK) {
107 snprintf(response, sizeof(response),
108 "The POP CAPA command failed; POP server does not "
113 while ((status = multiline()) != DONE)
118 case DONE: /* Shouldn't be possible, but just in case */
121 if (strncasecmp(response, "SASL ", 5) == 0) {
123 * We've seen the SASL capability. Grab the mech list
126 strncpy(server_mechs, response + 5, sizeof(server_mechs));
131 if (!sasl_capability) {
132 snprintf(response, sizeof(response), "POP server does not support "
138 * If we received a preferred mechanism, see if the server supports it.
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",
149 * Start the SASL process. First off, initialize the SASL library.
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;
157 result = sasl_client_init(callbacks);
159 if (result != SASL_OK) {
160 snprintf(response, sizeof(response), "SASL library initialization "
161 "failed: %s", sasl_errstring(result, NULL, NULL));
165 result = sasl_client_new("pop", host, NULL, NULL, NULL, 0, &conn);
167 if (result != SASL_OK) {
168 snprintf(response, sizeof(response), "SASL client initialization "
169 "failed: %s", sasl_errstring(result, NULL, NULL));
174 * Initialize the security properties
177 memset(&secprops, 0, sizeof(secprops));
178 secprops.maxbufsize = SASL_BUFFER_SIZE;
179 secprops.max_ssf = UINT_MAX;
181 result = sasl_setprop(conn, SASL_SEC_PROPS, &secprops);
183 if (result != SASL_OK) {
184 snprintf(response, sizeof(response), "SASL security property "
185 "initialization failed: %s", sasl_errdetail(conn));
190 * Start the actual protocol. Feed the mech list into the library
191 * and get out a possible initial challenge
194 result = sasl_client_start(conn,
195 (const char *) (mech ? mech : server_mechs),
196 NULL, (const char **) &buf,
197 &buflen, &chosen_mech);
199 if (result != SASL_OK && result != SASL_CONTINUE) {
200 snprintf(response, sizeof(response), "SASL client start failed: %s",
201 sasl_errdetail(conn));
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));
213 status = command("AUTH %s %s", chosen_mech, outbuf);
215 status = command("AUTH %s", chosen_mech);
217 while (result == SASL_CONTINUE) {
222 * If we get a "+OK" prefix to our response, then we should
223 * exit out of this exchange now (because authenticated should
227 if (strncmp(response, "+OK", 3) == 0)
231 * Otherwise, make sure the server challenge is correctly formatted
234 if (strncmp(response, "+ ", 2) != 0) {
236 snprintf(response, sizeof(response),
237 "Malformed authentication message from server");
241 result = sasl_decode64(response + 2, strlen(response + 2),
242 outbuf, sizeof(outbuf), &outlen);
244 if (result != SASL_OK) {
246 snprintf(response, sizeof(response), "SASL base64 decode "
247 "failed: %s", sasl_errstring(result, NULL, NULL));
251 result = sasl_client_step(conn, outbuf, outlen, NULL,
252 (const char **) &buf, &buflen);
254 if (result != SASL_OK && result != SASL_CONTINUE) {
256 snprintf(response, sizeof(response), "SASL client negotiaton "
257 "failed: %s", sasl_errdetail(conn));
261 status = sasl_encode64(buf, buflen, outbuf, sizeof(outbuf), NULL);
263 if (status != SASL_OK) {
265 snprintf(response, sizeof(response), "SASL base64 encode "
266 "failed: %s", sasl_errstring(status, NULL, NULL));
270 status = command(outbuf);
274 * If we didn't get a positive final response, then error out
275 * (that probably means we failed an authorization check).
282 * We _should_ be okay now. Get a few properties now that negotiation
286 result = sasl_getprop(conn, SASL_MAXOUTBUF, (const void **) &moutbuf);
288 if (result != SASL_OK) {
289 snprintf(response, sizeof(response), "Cannot retrieve SASL negotiated "
290 "output buffer size: %s", sasl_errdetail(conn));
294 maxoutbuf = *moutbuf;
296 result = sasl_getprop(conn, SASL_SSF, (const void **) &ssf);
300 if (result != SASL_OK) {
301 snprintf(response, sizeof(response), "Cannot retrieve SASL negotiated "
302 "security strength factor: %s", sasl_errdetail(conn));
307 * Limit this to what we can deal with. Shouldn't matter much because
308 * this is only outgoing data (which should be small)
311 if (maxoutbuf == 0 || maxoutbuf > BUFSIZ)
320 * Callback to return the userid sent down via the user parameter
324 sasl_get_user(void *context, int id, const char **result, unsigned *len)
326 char *user = (char *) context;
328 if (! result || id != SASL_CB_USER)
329 return SASL_BADPARAM;
339 * Callback to return the password (we call ruserpass, which can get it
344 sasl_get_pass(sasl_conn_t *conn, void *context, int id, sasl_secret_t **psecret)
348 struct pass_context *p_context = (struct pass_context *) context;
352 if (! psecret || id != SASL_CB_PASS)
353 return SASL_BADPARAM;
355 ruserpass(p_context->user, &(p_context->host), &pass);
359 *psecret = (sasl_secret_t *) mh_xmalloc(sizeof(sasl_secret_t) + len);
361 (*psecret)->len = len;
362 strcpy((char *) (*psecret)->data, pass);
366 #endif /* CYRUS_SASL */
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.
375 parse_proxy(char *proxy, char *host)
379 int hlen = strlen(host);
381 unsigned char *cur, *pro;
384 /* skip any initial space */
385 for (pro = (unsigned char *) proxy; isspace(*pro); pro++)
388 /* calculate required size for argument array */
389 for (cur = pro; *cur; cur++) {
390 if (isspace(*cur) && cur[1] && !isspace(cur[1]))
392 else if (*cur == '%' && cur[1] == 'h') {
395 } else if (!isspace(*cur))
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])) {
406 } else if (*cur == '%' && cur[1] == 'h') {
410 } else if (!isspace(*cur))
418 pop_init (char *host, char *port, char *user, char *pass, char *proxy,
419 int snoop, int sasl, char *mech)
424 if (proxy && *proxy) {
426 int inpipe[2]; /* for reading from the server */
427 int outpipe[2]; /* for sending to the server */
429 /* first give up any root priviledges we may have for rpop */
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]);
449 /* run the proxy command */
450 argv=parse_proxy(proxy, host);
451 execvp(argv[0],argv);
461 /* okay in the parent we do some stuff */
462 close(inpipe[1]); /* child uses this */
463 close(outpipe[0]); /* child uses this */
467 /* and write on fd2 */
472 if ((fd1 = client (host, port ? port : "pop3", response,
473 sizeof(response), snoop)) == NOTOK) {
477 if ((fd2 = dup (fd1)) == NOTOK) {
480 if ((s = strerror(errno)))
481 snprintf (response, sizeof(response),
482 "unable to dup connection descriptor: %s", s);
484 snprintf (response, sizeof(response),
485 "unable to dup connection descriptor: unknown error");
490 if (pop_set (fd1, fd2, snoop) == NOTOK)
493 SIGNAL (SIGPIPE, SIG_IGN);
495 switch (sasl_getline (response, sizeof response, input)) {
498 fprintf (stderr, "<--- %s\n", response);
499 if (*response == '+') {
502 if (pop_auth_sasl(user, host, mech) != NOTOK)
505 # endif /* CYRUS_SASL */
506 if (command ("USER %s", user) != NOTOK
507 && command ("%s %s", (pophack++, "PASS"),
511 strncpy (buffer, response, sizeof(buffer));
513 strncpy (response, buffer, sizeof(response));
519 fprintf (stderr, "%s\n", response);
525 return NOTOK; /* NOTREACHED */
529 pop_set (int in, int out, int snoop)
532 if ((input = fdopen (in, "r")) == NULL
533 || (output = fdopen (out, "w")) == NULL) {
534 strncpy (response, "fdopen failed on connection descriptor", sizeof(response));
550 pop_fd (char *in, int inlen, char *out, int outlen)
552 snprintf (in, inlen, "%d", fileno (input));
553 snprintf (out, outlen, "%d", fileno (output));
559 * Find out number of messages available
560 * and their total size.
564 pop_stat (int *nmsgs, int *nbytes)
567 if (command ("STAT") == NOTOK)
570 *nmsgs = *nbytes = 0;
571 sscanf (response, "+OK %d %d", nmsgs, nbytes);
578 pop_list (int msgno, int *nmsgs, int *msgs, int *bytes)
584 if (command ("LIST %d", msgno) == NOTOK)
589 sscanf (response, "+OK %d %d %d", msgs, bytes, ids);
592 sscanf (response, "+OK %d %d", msgs, bytes);
596 if (command ("LIST") == NOTOK)
599 for (i = 0; i < *nmsgs; i++)
600 switch (multiline ()) {
610 sscanf (response, "%d %d %d",
611 msgs++, bytes++, ids++);
614 sscanf (response, "%d %d", msgs++, bytes++);
618 switch (multiline ()) {
630 pop_retr (int msgno, int (*action)(char *))
632 return traverse (action, "RETR %d", msgno);
637 traverse (int (*action)(char *), const char *fmt, ...)
641 char buffer[sizeof(response)];
644 result = vcommand (fmt, ap);
649 strncpy (buffer, response, sizeof(buffer));
652 switch (multiline ()) {
657 strncpy (response, buffer, sizeof(response));
661 (*action) (response);
670 return command ("DELE %d", msgno);
677 return command ("NOOP");
684 return command ("RSET");
689 pop_top (int msgno, int lines, int (*action)(char *))
691 return traverse (action, "TOP %d %d", msgno, lines);
700 i = command ("QUIT");
713 #endif /* CYRUS_SASL */
722 command(const char *fmt, ...)
728 result = vcommand(fmt, ap);
736 vcommand (const char *fmt, va_list ap)
738 char *cp, buffer[BUFSIZ];
740 vsnprintf (buffer, sizeof(buffer), fmt, ap);
744 fprintf(stderr, "(encrypted) ");
745 #endif /* CYRUS_SASL */
747 if ((cp = strchr (buffer, ' ')))
749 fprintf (stderr, "---> %s ********\n", buffer);
755 fprintf (stderr, "---> %s\n", buffer);
758 if (putline (buffer, output) == NOTOK)
762 if (poprint && sasl_ssf)
763 fprintf(stderr, "(decrypted) ");
764 #endif /* CYRUS_SASL */
766 switch (sasl_getline (response, sizeof response, input)) {
769 fprintf (stderr, "<--- %s\n", response);
770 return (*response == '+' ? OK : NOTOK);
775 fprintf (stderr, "%s\n", response);
779 return NOTOK; /* NOTREACHED */
786 char buffer[BUFSIZ + TRMLEN];
788 if (sasl_getline (buffer, sizeof buffer, input) != OK)
794 fprintf(stderr, "(decrypted) ");
795 #endif /* CYRUS_SASL */
796 fprintf (stderr, "<--- %s\n", response);
799 if (strncmp (buffer, TRM, TRMLEN) == 0) {
800 if (buffer[TRMLEN] == 0)
803 strncpy (response, buffer + TRMLEN, sizeof(response));
806 strncpy (response, buffer, sizeof(response));
812 * Note that these functions have been modified to deal with layer encryption
817 sasl_getline (char *s, int n, FILE *iop)
823 while (--n > 0 && (c = sasl_fgetc (iop)) != EOF && c != -2)
824 if ((*p++ = c) == '\n')
828 if (ferror (iop) && c != EOF) {
829 strncpy (response, "error on connection", sizeof(response));
832 if (c == EOF && p == s) {
833 strncpy (response, "connection closed by foreign host", sizeof(response));
847 putline (char *s, FILE *iop)
850 char outbuf[BUFSIZ], *buf;
854 if (!sasl_complete) {
855 #endif /* CYRUS_SASL */
856 fprintf (iop, "%s\r\n", s);
860 * Build an output buffer, encrypt it using sasl_encode, and
861 * squirt out the results.
863 strncpy(outbuf, s, sizeof(outbuf) - 3);
864 outbuf[sizeof(outbuf) - 3] = '\0'; /* Just in case */
865 strcat(outbuf, "\r\n");
867 result = sasl_encode(conn, outbuf, strlen(outbuf),
868 (const char **) &buf, &buflen);
870 if (result != SASL_OK) {
871 snprintf(response, sizeof(response), "SASL encoding error: %s",
872 sasl_errdetail(conn));
876 fwrite(buf, buflen, 1, iop);
878 #endif /* CYRUS_SASL */
882 strncpy (response, "lost connection", sizeof(response));
891 * Okay, our little fgetc replacement. Hopefully this is a little more
892 * efficient than the last one.
897 static unsigned char *buffer = NULL, *ptr;
898 static unsigned int size = 0;
900 unsigned int retbufsize = 0;
902 char *retbuf, tmpbuf[SASL_BUFFER_SIZE];
905 * If we have some leftover data, return that
914 * Otherwise, fill our buffer until we have some data to return.
917 while (retbufsize == 0) {
919 cc = read(fileno(f), tmpbuf, sizeof(tmpbuf));
925 snprintf(response, sizeof(response), "Error during read from "
926 "network: %s", strerror(errno));
931 * We're not allowed to call sasl_decode until sasl_complete is
932 * true, so we do these gyrations ...
935 if (!sasl_complete) {
942 result = sasl_decode(conn, tmpbuf, cc,
943 (const char **) &retbuf, &retbufsize);
945 if (result != SASL_OK) {
946 snprintf(response, sizeof(response), "Error during SASL "
947 "decoding: %s", sasl_errdetail(conn));
953 if (retbufsize > size) {
954 buffer = mh_xrealloc(buffer, retbufsize);
958 memcpy(buffer, retbuf, retbufsize);
960 cnt = retbufsize - 1;
962 return (int) buffer[0];
964 #endif /* CYRUS_SASL */