2 * smtp.c -- nmh SMTP interface
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.
15 #include <h/signals.h>
18 #include <sasl/sasl.h>
19 #include <sasl/saslutil.h>
20 #include <sys/socket.h>
21 #include <netinet/in.h>
22 #include <arpa/inet.h>
25 #endif /* CYRUS_SASL */
28 * This module implements an interface to SendMail very similar
29 * to the MMDF mm_(3) routines. The sm_() routines herein talk
30 * SMTP to a sendmail process, mapping SMTP reply codes into
35 * On older 4.2BSD machines without the POSIX function `sigaction',
36 * the alarm handing stuff for time-outs will NOT work due to the way
37 * syscalls get restarted. This is not really crucial, since SendMail
38 * is generally well-behaved in this area.
43 * It appears that some versions of Sendmail will return Code 451
44 * when they don't really want to indicate a failure.
45 * "Code 451 almost always means sendmail has deferred; we don't
46 * really want bomb out at this point since sendmail will rectify
47 * things later." So, if you define SENDMAILBUG, Code 451 is
48 * considered the same as Code 250. Yuck!
55 #define NBITS ((sizeof (int)) * 8)
58 * these codes must all be different!
60 #define SM_OPEN 300 /* Changed to 5 minutes to comply with a SHOULD in RFC 1123 */
63 #define SM_MAIL 301 /* changed to 5 minutes and a second (for uniqueness), see above */
64 #define SM_RCPT 302 /* see above */
65 #define SM_DATA 120 /* see above */
66 #define SM_TEXT 180 /* see above */
67 #define SM_DOT 600 /* see above */
72 static int sm_addrs = 0;
73 static int sm_alarmed = 0;
74 static int sm_child = NOTOK;
75 static int sm_debug = 0;
76 static int sm_nl = TRUE;
77 static int sm_verbose = 0;
79 static FILE *sm_rfp = NULL;
80 static FILE *sm_wfp = NULL;
84 * Some globals needed by SASL
87 static sasl_conn_t *conn = NULL; /* SASL connection state */
88 static int sasl_complete = 0; /* Has authentication succeded? */
89 static sasl_ssf_t sasl_ssf; /* Our security strength factor */
90 static char *sasl_pw_context[2]; /* Context to pass into sm_get_pass */
91 static int maxoutbuf; /* Maximum crypto output buffer */
92 static char *sasl_outbuffer; /* SASL output buffer for encryption */
93 static int sasl_outbuflen; /* Current length of data in outbuf */
94 static char *sasl_inbuffer; /* SASL input buffer for encryption */
95 static char *sasl_inptr; /* Pointer to current inbuf position */
96 static int sasl_inbuflen; /* Current length of data in inbuf */
97 static int sm_get_user(void *, int, const char **, unsigned *);
98 static int sm_get_pass(sasl_conn_t *, void *, int, sasl_secret_t **);
99 static int sm_fgetc(FILE *);
101 static sasl_callback_t callbacks[] = {
102 { SASL_CB_USER, sm_get_user, NULL },
103 #define SM_SASL_N_CB_USER 0
104 { SASL_CB_PASS, sm_get_pass, NULL },
105 #define SM_SASL_N_CB_PASS 1
106 { SASL_CB_AUTHNAME, sm_get_user, NULL },
107 #define SM_SASL_N_CB_AUTHNAME 2
108 { SASL_CB_LIST_END, NULL, NULL },
111 #define SASL_MAXRECVBUF 65536
112 #else /* CYRUS_SASL */
113 #define sm_fgetc fgetc
114 #endif /* CYRUS_SASL */
116 static char *sm_noreply = "No reply text given";
117 static char *sm_moreply = "; ";
119 struct smtp sm_reply; /* global... */
123 static int doingEHLO;
124 char *EHLOkeys[MAXEHLO + 1];
129 static int smtp_init (char *, char *, char *, int, int, int, int, int, int,
131 static int sendmail_init (char *, char *, int, int, int, int, int, int,
134 static int rclient (char *, char *);
135 static int sm_ierror (char *fmt, ...);
136 static int smtalk (int time, char *fmt, ...);
137 static int sm_wrecord (char *, int);
138 static int sm_wstream (char *, int);
139 static int sm_werror (void);
140 static int smhear (void);
141 static int sm_rrecord (char *, int *);
142 static int sm_rerror (int);
143 static RETSIGTYPE alrmser (int);
144 static char *EHLOset (char *);
145 static int sm_fwrite(char *, int);
146 static int sm_fputs(char *);
147 static int sm_fputc(int);
148 static void sm_fflush(void);
149 static int sm_fgets(char *, int, FILE *);
153 * Function prototypes needed for SASL
156 static int sm_auth_sasl(char *, char *, char *);
157 #endif /* CYRUS_SASL */
160 sm_init (char *client, char *server, char *port, int watch, int verbose,
161 int debug, int onex, int queued, int sasl, char *saslmech,
164 if (sm_mts == MTS_SMTP)
165 return smtp_init (client, server, port, watch, verbose,
166 debug, onex, queued, sasl, saslmech, user);
168 return sendmail_init (client, server, watch, verbose,
169 debug, onex, queued, sasl, saslmech, user);
173 smtp_init (char *client, char *server, char *port, int watch, int verbose,
174 int debug, int onex, int queued,
175 int sasl, char *saslmech, char *user)
179 #endif /* CYRUS_SASL */
180 int result, sd1, sd2;
185 sm_verbose = verbose;
188 if (sm_rfp != NULL && sm_wfp != NULL)
191 if (client == NULL || *client == '\0') {
195 client = LocalName(); /* no clientname -> LocalName */
200 if (client == NULL || *client == '\0')
201 client = "localhost";
205 sasl_inbuffer = malloc(SASL_MAXRECVBUF);
207 return sm_ierror("Unable to allocate %d bytes for read buffer",
209 #endif /* CYRUS_SASL */
211 if ((sd1 = rclient (server, port)) == NOTOK)
214 if ((sd2 = dup (sd1)) == NOTOK) {
216 return sm_ierror ("unable to dup");
219 SIGNAL (SIGALRM, alrmser);
220 SIGNAL (SIGPIPE, SIG_IGN);
222 if ((sm_rfp = fdopen (sd1, "r")) == NULL
223 || (sm_wfp = fdopen (sd2, "w")) == NULL) {
226 sm_rfp = sm_wfp = NULL;
227 return sm_ierror ("unable to fdopen");
245 * Give EHLO or HELO command
247 if (client && *client) {
249 result = smtalk (SM_HELO, "EHLO %s", client);
252 if (result >= 500 && result <= 599)
253 result = smtalk (SM_HELO, "HELO %s", client);
263 * If the user asked for SASL, then check to see if the SMTP server
264 * supports it. Otherwise, error out (because the SMTP server
265 * might have been spoofed; we don't want to just silently not
270 if (! (server_mechs = EHLOset("AUTH"))) {
272 return sm_ierror("SMTP server does not support SASL");
275 if (saslmech && stringdex(saslmech, server_mechs) == -1) {
277 return sm_ierror("Requested SASL mech \"%s\" is not in the "
278 "list of supported mechanisms:\n%s",
279 saslmech, server_mechs);
282 if (sm_auth_sasl(user, saslmech ? saslmech : server_mechs,
288 #endif /* CYRUS_SASL */
291 if (watch && EHLOset ("XVRB"))
292 smtalk (SM_HELO, "VERB on");
293 if (onex && EHLOset ("XONE"))
294 smtalk (SM_HELO, "ONEX");
295 if (queued && EHLOset ("XQUE"))
296 smtalk (SM_HELO, "QUED");
302 sendmail_init (char *client, char *server, int watch, int verbose,
303 int debug, int onex, int queued,
304 int sasl, char *saslmech, char *user)
308 #endif /* CYRUS_SASL */
316 sm_verbose = verbose;
318 if (sm_rfp != NULL && sm_wfp != NULL)
321 if (client == NULL || *client == '\0') {
325 client = LocalName(); /* no clientname -> LocalName */
329 if (client == NULL || *client == '\0')
330 client = "localhost";
334 sasl_inbuffer = malloc(SASL_MAXRECVBUF);
336 return sm_ierror("Unable to allocate %d bytes for read buffer",
338 #endif /* CYRUS_SASL */
340 if (pipe (pdi) == NOTOK)
341 return sm_ierror ("no pipes");
342 if (pipe (pdo) == NOTOK) {
345 return sm_ierror ("no pipes");
348 for (i = 0; (sm_child = fork ()) == NOTOK && i < 5; i++)
357 return sm_ierror ("unable to fork");
360 if (pdo[0] != fileno (stdin))
361 dup2 (pdo[0], fileno (stdin));
362 if (pdi[1] != fileno (stdout))
363 dup2 (pdi[1], fileno (stdout));
364 if (pdi[1] != fileno (stderr))
365 dup2 (pdi[1], fileno (stderr));
366 for (i = fileno (stderr) + 1; i < NBITS; i++)
370 vec[vecp++] = r1bindex (sendmail, '/');
373 vec[vecp++] = watch ? "-odi" : queued ? "-odq" : "-odb";
374 vec[vecp++] = "-oem";
379 # endif /* not RAND */
380 #endif /* not ZMAILER */
385 execvp (sendmail, vec);
386 fprintf (stderr, "unable to exec ");
388 _exit (-1); /* NOTREACHED */
391 SIGNAL (SIGALRM, alrmser);
392 SIGNAL (SIGPIPE, SIG_IGN);
396 if ((sm_rfp = fdopen (pdi[0], "r")) == NULL
397 || (sm_wfp = fdopen (pdo[1], "w")) == NULL) {
400 sm_rfp = sm_wfp = NULL;
401 return sm_ierror ("unable to fdopen");
416 if (client && *client) {
418 result = smtalk (SM_HELO, "EHLO %s", client);
421 if (500 <= result && result <= 599)
422 result = smtalk (SM_HELO, "HELO %s", client);
436 * If the user asked for SASL, then check to see if the SMTP server
437 * supports it. Otherwise, error out (because the SMTP server
438 * might have been spoofed; we don't want to just silently not
443 if (! (server_mechs = EHLOset("AUTH"))) {
445 return sm_ierror("SMTP server does not support SASL");
448 if (saslmech && stringdex(saslmech, server_mechs) == -1) {
450 return sm_ierror("Requested SASL mech \"%s\" is not in the "
451 "list of supported mechanisms:\n%s",
452 saslmech, server_mechs);
455 if (sm_auth_sasl(user, saslmech ? saslmech : server_mechs,
461 #endif /* CYRUS_SASL */
465 smtalk (SM_HELO, "ONEX");
468 smtalk (SM_HELO, "VERB on");
475 rclient (char *server, char *service)
478 char response[BUFSIZ];
480 if ((sd = client (server, service, response, sizeof(response),
484 sm_ierror ("%s", response);
489 sm_winit (int mode, char *from)
491 char *smtpcom = NULL;
511 /* Hopefully, we do not get here. */
515 switch (smtalk (SM_MAIL, "%s FROM:<%s>", smtpcom, from)) {
532 sm_wadr (char *mbox, char *host, char *path)
534 switch (smtalk (SM_RCPT, host && *host ? "RCPT TO:<%s%s@%s>"
536 path ? path : "", mbox, host)) {
546 #endif /* SENDMAILBUG */
571 switch (smtalk (SM_DATA, "DATA")) {
580 #endif /* SENDMAILBUG */
597 sm_wtxt (char *buffer, int len)
603 result = sm_wstream (buffer, len);
606 return (result == NOTOK ? RP_BHST : RP_OK);
613 if (sm_wstream ((char *) NULL, 0) == NOTOK)
616 switch (smtalk (SM_DOT + 3 * sm_addrs, ".")) {
624 #endif /* SENDMAILBUG */
642 if (sm_mts == MTS_SENDMAIL) {
653 if (sm_rfp == NULL && sm_wfp == NULL)
658 smtalk (SM_QUIT, "QUIT");
662 sm_note.code = sm_reply.code;
663 sm_note.length = sm_reply.length;
664 memcpy (sm_note.text, sm_reply.text, sm_reply.length + 1);/* fall */
666 if (smtalk (SM_RSET, "RSET") == 250 && type == DONE)
668 if (sm_mts == MTS_SMTP)
669 smtalk (SM_QUIT, "QUIT");
671 kill (sm_child, SIGKILL);
676 sm_reply.code = sm_note.code;
677 sm_reply.length = sm_note.length;
678 memcpy (sm_reply.text, sm_note.text, sm_note.length + 1);
683 if (sm_rfp != NULL) {
688 if (sm_wfp != NULL) {
694 if (sm_mts == MTS_SMTP) {
699 if (sasl_outbuffer) {
700 free(sasl_outbuffer);
705 #endif /* CYRUS_SASL */
707 status = pidwait (sm_child, OK);
711 sm_rfp = sm_wfp = NULL;
712 return (status ? RP_BHST : RP_OK);
717 * This function implements SASL authentication for SMTP. If this function
718 * completes successfully, then authentication is successful and we've
719 * (optionally) negotiated a security layer.
722 sm_auth_sasl(char *user, char *mechlist, char *inhost)
725 unsigned int buflen, outlen;
726 char *buf, outbuf[BUFSIZ], host[NI_MAXHOST];
727 const char *chosen_mech;
728 sasl_security_properties_t secprops;
733 * Initialize the callback contexts
737 user = getusername();
739 callbacks[SM_SASL_N_CB_USER].context = user;
740 callbacks[SM_SASL_N_CB_AUTHNAME].context = user;
743 * This is a _bit_ of a hack ... but if the hostname wasn't supplied
744 * to us on the command line, then call getpeername and do a
745 * reverse-address lookup on the IP address to get the name.
748 memset(host, 0, sizeof(host));
751 struct sockaddr_storage sin;
752 socklen_t len = sizeof(sin);
755 if (getpeername(fileno(sm_wfp), (struct sockaddr *) &sin, &len) < 0) {
756 sm_ierror("getpeername on SMTP socket failed: %s",
761 result = getnameinfo((struct sockaddr *) &sin, len, host, sizeof(host),
762 NULL, 0, NI_NAMEREQD);
764 sm_ierror("Unable to look up name of connected host: %s",
765 gai_strerror(result));
769 strncpy(host, inhost, sizeof(host) - 1);
772 sasl_pw_context[0] = host;
773 sasl_pw_context[1] = user;
775 callbacks[SM_SASL_N_CB_PASS].context = sasl_pw_context;
777 result = sasl_client_init(callbacks);
779 if (result != SASL_OK) {
780 sm_ierror("SASL library initialization failed: %s",
781 sasl_errstring(result, NULL, NULL));
785 result = sasl_client_new("smtp", host, NULL, NULL, NULL, 0, &conn);
787 if (result != SASL_OK) {
788 sm_ierror("SASL client initialization failed: %s",
789 sasl_errstring(result, NULL, NULL));
794 * Initialize the security properties
797 memset(&secprops, 0, sizeof(secprops));
798 secprops.maxbufsize = SASL_MAXRECVBUF;
799 secprops.max_ssf = UINT_MAX;
801 result = sasl_setprop(conn, SASL_SEC_PROPS, &secprops);
803 if (result != SASL_OK) {
804 sm_ierror("SASL security property initialization failed: %s",
805 sasl_errstring(result, NULL, NULL));
810 * Start the actual protocol. Feed the mech list into the library
811 * and get out a possible initial challenge
814 result = sasl_client_start(conn, mechlist, NULL, (const char **) &buf,
815 &buflen, (const char **) &chosen_mech);
817 if (result != SASL_OK && result != SASL_CONTINUE) {
818 sm_ierror("SASL client start failed: %s", sasl_errdetail(conn));
823 * If we got an initial challenge, send it as part of the AUTH
824 * command; otherwise, just send a plain AUTH command.
828 status = sasl_encode64(buf, buflen, outbuf, sizeof(outbuf), NULL);
829 if (status != SASL_OK) {
830 sm_ierror("SASL base64 encode failed: %s",
831 sasl_errstring(status, NULL, NULL));
835 status = smtalk(SM_AUTH, "AUTH %s %s", chosen_mech, outbuf);
837 status = smtalk(SM_AUTH, "AUTH %s", chosen_mech);
840 * Now we loop until we either fail, get a SASL_OK, or a 235
841 * response code. Receive the challenges and process them until
845 while (result == SASL_CONTINUE) {
848 * If we get a 235 response, that means authentication has
849 * succeeded and we need to break out of the loop (yes, even if
850 * we still get SASL_CONTINUE from sasl_client_step()).
852 * Otherwise, if we get a message that doesn't seem to be a
853 * valid response, then abort
858 else if (status < 300 || status > 399)
862 * Special case; a zero-length response from the SMTP server
863 * is returned as a single =. If we get that, then set buflen
864 * to be zero. Otherwise, just decode the response.
867 if (strcmp("=", sm_reply.text) == 0) {
870 result = sasl_decode64(sm_reply.text, sm_reply.length,
871 outbuf, sizeof(outbuf), &outlen);
873 if (result != SASL_OK) {
874 smtalk(SM_AUTH, "*");
875 sm_ierror("SASL base64 decode failed: %s",
876 sasl_errstring(result, NULL, NULL));
881 result = sasl_client_step(conn, outbuf, outlen, NULL,
882 (const char **) &buf, &buflen);
884 if (result != SASL_OK && result != SASL_CONTINUE) {
885 smtalk(SM_AUTH, "*");
886 sm_ierror("SASL client negotiation failed: %s",
887 sasl_errstring(result, NULL, NULL));
891 status = sasl_encode64(buf, buflen, outbuf, sizeof(outbuf), NULL);
893 if (status != SASL_OK) {
894 smtalk(SM_AUTH, "*");
895 sm_ierror("SASL base64 encode failed: %s",
896 sasl_errstring(status, NULL, NULL));
900 status = smtalk(SM_AUTH, outbuf);
904 * Make sure that we got the correct response
907 if (status < 200 || status > 299)
911 * We _should_ have completed the authentication successfully.
912 * Get a few properties from the authentication exchange.
915 result = sasl_getprop(conn, SASL_MAXOUTBUF, (const void **) &outbufmax);
917 if (result != SASL_OK) {
918 sm_ierror("Cannot retrieve SASL negotiated output buffer size: %s",
919 sasl_errstring(result, NULL, NULL));
923 maxoutbuf = *outbufmax;
925 result = sasl_getprop(conn, SASL_SSF, (const void **) &ssf);
929 if (result != SASL_OK) {
930 sm_ierror("Cannot retrieve SASL negotiated security strength "
931 "factor: %s", sasl_errstring(result, NULL, NULL));
936 sasl_outbuffer = malloc(maxoutbuf);
938 if (sasl_outbuffer == NULL) {
939 sm_ierror("Unable to allocate %d bytes for SASL output "
940 "buffer", maxoutbuf);
945 sasl_inptr = sasl_inbuffer;
947 sasl_outbuffer = NULL;
948 /* Don't NULL out sasl_inbuffer because it could be used in
958 * Our callback functions to feed data to the SASL library
962 sm_get_user(void *context, int id, const char **result, unsigned *len)
964 char *user = (char *) context;
966 if (! result || ((id != SASL_CB_USER) && (id != SASL_CB_AUTHNAME)))
967 return SASL_BADPARAM;
977 sm_get_pass(sasl_conn_t *conn, void *context, int id,
978 sasl_secret_t **psecret)
980 char **pw_context = (char **) context;
984 if (! psecret || id != SASL_CB_PASS)
985 return SASL_BADPARAM;
987 ruserpass(pw_context[0], &(pw_context[1]), &pass);
991 *psecret = (sasl_secret_t *) malloc(sizeof(sasl_secret_t) + len);
998 (*psecret)->len = len;
999 strcpy((char *) (*psecret)->data, pass);
1004 #endif /* CYRUS_SASL */
1007 sm_ierror (char *fmt, ...)
1012 vsnprintf (sm_reply.text, sizeof(sm_reply.text), fmt, ap);
1015 sm_reply.length = strlen (sm_reply.text);
1016 sm_reply.code = NOTOK;
1022 smtalk (int time, char *fmt, ...)
1026 char buffer[BUFSIZ];
1029 vsnprintf (buffer, sizeof(buffer), fmt, ap);
1035 printf("(encrypted) ");
1036 #endif /* CYRUS_SASL */
1037 printf ("=> %s\n", buffer);
1042 alarm ((unsigned) time);
1043 if ((result = sm_wrecord (buffer, strlen (buffer))) != NOTOK)
1052 * write the buffer to the open SMTP channel
1056 sm_wrecord (char *buffer, int len)
1059 return sm_werror ();
1061 sm_fwrite (buffer, len);
1065 return (ferror (sm_wfp) ? sm_werror () : OK);
1070 sm_wstream (char *buffer, int len)
1073 static char lc = '\0';
1076 return sm_werror ();
1078 if (buffer == NULL && len == 0) {
1082 return (ferror (sm_wfp) ? sm_werror () : OK);
1085 for (bp = buffer; len > 0; bp++, len--) {
1094 sm_fputc ('.');/* FALL THROUGH */
1099 if (ferror (sm_wfp))
1100 return sm_werror ();
1105 return (ferror (sm_wfp) ? sm_werror () : OK);
1109 * Write out to the network, but do buffering for SASL (if enabled)
1113 sm_fwrite(char *buffer, int len)
1117 unsigned int outputlen;
1119 if (sasl_complete == 0 || sasl_ssf == 0)
1120 #endif /* CYRUS_SASL */
1121 fwrite(buffer, sizeof(*buffer), len, sm_wfp);
1124 while (len >= maxoutbuf - sasl_outbuflen) {
1125 memcpy(sasl_outbuffer + sasl_outbuflen, buffer,
1126 maxoutbuf - sasl_outbuflen);
1127 len -= maxoutbuf - sasl_outbuflen;
1130 if (sasl_encode(conn, sasl_outbuffer, maxoutbuf,
1131 &output, &outputlen) != SASL_OK) {
1132 sm_ierror("Unable to SASL encode connection data: %s",
1133 sasl_errdetail(conn));
1137 fwrite(output, sizeof(*output), outputlen, sm_wfp);
1141 memcpy(sasl_outbuffer + sasl_outbuflen, buffer, len);
1142 sasl_outbuflen += len;
1145 #endif /* CYRUS_SASL */
1146 return ferror(sm_wfp) ? NOTOK : RP_OK;
1150 * Convenience functions to replace occurences of fputs() and fputc()
1154 sm_fputs(char *buffer)
1156 return sm_fwrite(buffer, strlen(buffer));
1164 return sm_fwrite(&h, 1);
1168 * Flush out any pending data on the connection
1176 unsigned int outputlen;
1179 if (sasl_complete == 1 && sasl_ssf > 0 && sasl_outbuflen > 0) {
1180 result = sasl_encode(conn, sasl_outbuffer, sasl_outbuflen,
1181 &output, &outputlen);
1182 if (result != SASL_OK) {
1183 sm_ierror("Unable to SASL encode connection data: %s",
1184 sasl_errdetail(conn));
1188 fwrite(output, sizeof(*output), outputlen, sm_wfp);
1191 #endif /* CYRUS_SASL */
1200 strlen (strcpy (sm_reply.text, sm_wfp == NULL ? "no socket opened"
1201 : sm_alarmed ? "write to socket timed out"
1202 : "error writing to socket"));
1204 return (sm_reply.code = NOTOK);
1211 int i, code, cont, bc = 0, rc, more;
1214 char **ehlo = NULL, buffer[BUFSIZ];
1217 static int at_least_once = 0;
1219 if (at_least_once) {
1222 for (ehlo = EHLOkeys; *ehlo; ehlo++) {
1236 sm_reply.length = 0;
1237 sm_reply.text[0] = 0;
1239 rc = sizeof(sm_reply.text) - 1;
1241 for (more = FALSE; sm_rrecord ((char *) (bp = (unsigned char *) buffer),
1246 printf("(decrypted) ");
1247 #endif /* CYRUS_SASL */
1248 printf ("<= %s\n", buffer);
1253 && strncmp (buffer, "250", sizeof("250") - 1) == 0
1254 && (buffer[3] == '-' || doingEHLO == 2)
1256 if (doingEHLO == 2) {
1257 if ((*ehlo = malloc ((size_t) (strlen (buffer + 4) + 1)))) {
1258 strcpy (*ehlo++, buffer + 4);
1260 if (ehlo >= EHLOkeys + MAXEHLO)
1270 for (; bc > 0 && (!isascii (*bp) || !isdigit (*bp)); bp++, bc--)
1274 code = atoi ((char *) bp);
1276 for (; bc > 0 && isspace (*bp); bp++, bc--)
1278 if (bc > 0 && *bp == '-') {
1281 for (; bc > 0 && isspace (*bp); bp++, bc--)
1286 if (code != sm_reply.code || cont)
1290 sm_reply.code = code;
1293 /* can never fail to 0-terminate because of size of buffer vs fixed string */
1294 strncpy (buffer, sm_noreply, sizeof(buffer));
1295 bp = (unsigned char *) buffer;
1296 bc = strlen (sm_noreply);
1300 if ((i = min (bc, rc)) > 0) {
1304 i = strlen(sm_moreply);
1305 if (more && rc > i + 1) {
1306 memcpy (rp, sm_moreply, i); /* safe because of check in if() */
1313 if (sm_reply.code < 100) {
1315 printf ("%s\n", sm_reply.text);
1321 sm_reply.length = rp - sm_reply.text;
1322 sm_reply.text[sm_reply.length] = 0;
1323 return sm_reply.code;
1330 sm_rrecord (char *buffer, int *len)
1335 return sm_rerror(0);
1337 buffer[*len = 0] = 0;
1339 if ((retval = sm_fgets (buffer, BUFSIZ, sm_rfp)) != RP_OK)
1341 *len = strlen (buffer);
1342 /* *len should be >0 except on EOF, but check for safety's sake */
1344 return sm_rerror (RP_EOF);
1345 if (buffer[*len - 1] != '\n')
1346 while ((retval = sm_fgetc (sm_rfp)) != '\n' && retval != EOF &&
1350 if ((*len > 1) && (buffer[*len - 2] == '\r'))
1359 * Our version of fgets, which calls our private fgetc function
1363 sm_fgets(char *buffer, int size, FILE *f)
1377 } while (size > 1 && c != '\n');
1387 * Read from the network, but do SASL encryption
1393 char tmpbuf[BUFSIZ], *retbuf;
1394 unsigned int retbufsize = 0;
1398 * If we have leftover data, return it
1401 if (sasl_inbuflen) {
1403 return (int) *sasl_inptr++;
1407 * If not, read from the network until we have some data to return
1410 while (retbufsize == 0) {
1412 cc = read(fileno(f), tmpbuf, sizeof(tmpbuf));
1418 sm_ierror("Unable to read from network: %s", strerror(errno));
1423 * Don't call sasl_decode unless sasl is complete and we have
1424 * encryption working
1427 if (sasl_complete == 0 || sasl_ssf == 0) {
1431 result = sasl_decode(conn, tmpbuf, cc, (const char **) &retbuf,
1434 if (result != SASL_OK) {
1435 sm_ierror("Unable to decode SASL network data: %s",
1436 sasl_errdetail(conn));
1442 if (retbufsize > SASL_MAXRECVBUF) {
1443 sm_ierror("Received data (%d bytes) is larger than the buffer "
1444 "size (%d bytes)", retbufsize, SASL_MAXRECVBUF);
1448 memcpy(sasl_inbuffer, retbuf, retbufsize);
1449 sasl_inptr = sasl_inbuffer + 1;
1450 sasl_inbuflen = retbufsize - 1;
1452 return (int) sasl_inbuffer[0];
1454 #endif /* CYRUS_SASL */
1459 if (sm_mts == MTS_SMTP)
1461 strlen (strcpy (sm_reply.text, sm_rfp == NULL ? "no socket opened"
1462 : sm_alarmed ? "read from socket timed out"
1463 : rc == RP_EOF ? "premature end-of-file on socket"
1464 : "error reading from socket"));
1467 strlen (strcpy (sm_reply.text, sm_rfp == NULL ? "no pipe opened"
1468 : sm_alarmed ? "read from pipe timed out"
1469 : rc == RP_EOF ? "premature end-of-file on pipe"
1470 : "error reading from pipe"));
1472 return (sm_reply.code = NOTOK);
1479 #ifndef RELIABLE_SIGNALS
1480 SIGNAL (SIGALRM, alrmser);
1485 printf ("timed out...\n");
1492 rp_string (int code)
1495 static char buffer[BUFSIZ];
1497 switch (sm_reply.code != NOTOK ? code : NOTOK) {
1517 snprintf (buffer, sizeof(buffer), "[%s] %s", text, sm_reply.text);
1537 snprintf (buffer, sizeof(buffer), "[%s] %3d %s",
1538 text, sm_reply.code, sm_reply.text);
1550 for (ehlo = EHLOkeys; *ehlo; ehlo++) {
1552 if (strncmp (ep, s, len) == 0) {
1553 for (ep += len; *ep == ' '; ep++)