Added lots of "(void)" casts to standard function calls.
[users/heiko/exim.git] / src / src / auths / pwcheck.c
1 /* $Cambridge: exim/src/src/auths/pwcheck.c,v 1.2 2005/06/27 14:29:44 ph10 Exp $ */
2
3 /* SASL server API implementation
4  * Rob Siemborski
5  * Tim Martin
6  * $Id: checkpw.c,v 1.49 2002/03/07 19:14:04 ken3 Exp $
7  */
8 /*
9  * Copyright (c) 2001 Carnegie Mellon University.  All rights reserved.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  *
15  * 1. Redistributions of source code must retain the above copyright
16  *    notice, this list of conditions and the following disclaimer.
17  *
18  * 2. Redistributions in binary form must reproduce the above copyright
19  *    notice, this list of conditions and the following disclaimer in
20  *    the documentation and/or other materials provided with the
21  *    distribution.
22  *
23  * 3. The name "Carnegie Mellon University" must not be used to
24  *    endorse or promote products derived from this software without
25  *    prior written permission. For permission or any other legal
26  *    details, please contact
27  *      Office of Technology Transfer
28  *      Carnegie Mellon University
29  *      5000 Forbes Avenue
30  *      Pittsburgh, PA  15213-3890
31  *      (412) 268-4387, fax: (412) 268-7395
32  *      tech-transfer@andrew.cmu.edu
33  *
34  * 4. Redistributions of any form whatsoever must retain the following
35  *    acknowledgment:
36  *    "This product includes software developed by Computing Services
37  *     at Carnegie Mellon University (http://www.cmu.edu/computing/)."
38  *
39  * CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO
40  * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
41  * AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE
42  * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
43  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
44  * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
45  * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
46  */
47
48 /*
49  * Taken from Cyrus-SASL library and adapted by Alexander S. Sabourenkov
50  * Oct 2001 - Apr 2002: Slightly modified by Philip Hazel.
51  * Aug 2003: new code for saslauthd from Alexander S. Sabourenkov incorporated
52  *           by Philip Hazel (minor mods to avoid compiler warnings)
53  *
54  * screwdriver@lxnt.info
55  *
56  */
57
58 /* Originally this module supported only the pwcheck daemon, which is where its
59 name comes from. Nowadays it supports saslauthd as well; pwcheck is in fact
60 deprecated. The definitions of CYRUS_PWCHECK_SOCKET and CYRUS_SASLAUTHD_SOCKET
61 determine whether the facilities are actually supported or not. */
62
63
64 #include "../exim.h"
65 #include "pwcheck.h"
66
67
68 #if defined(CYRUS_PWCHECK_SOCKET) || defined(CYRUS_SASLAUTHD_SOCKET)
69
70 #include <sys/uio.h>
71
72 static int retry_read(int, void *, unsigned );
73 static int retry_writev(int, struct iovec *, int );
74 static int read_string(int, uschar **);
75 static int write_string(int, const uschar *, int);
76
77 #endif
78
79
80 /* A dummy function that always fails if pwcheck support is not
81 wanted. */
82
83 #ifndef CYRUS_PWCHECK_SOCKET
84 int pwcheck_verify_password(const char *userid,
85                             const char *passwd,
86                             const char **reply)
87 {
88 userid = userid;  /* Keep picky compilers happy */
89 passwd = passwd;
90 *reply = "pwcheck support is not included in this Exim binary";
91 return PWCHECK_FAIL;
92 }
93
94
95 /* This is the real function */
96
97 #else
98
99  /* taken from cyrus-sasl file checkpw.c */
100  /* pwcheck daemon-authenticated login */
101  int pwcheck_verify_password(const char *userid,
102                                   const char *passwd,
103                                   const char **reply)
104  {
105      int s, start, r, n;
106      struct sockaddr_un srvaddr;
107      struct iovec iov[2];
108      static char response[1024];
109
110      if (reply) { *reply = NULL; }
111
112      s = socket(AF_UNIX, SOCK_STREAM, 0);
113      if (s == -1) { return PWCHECK_FAIL; }
114
115      memset((char *)&srvaddr, 0, sizeof(srvaddr));
116      srvaddr.sun_family = AF_UNIX;
117      strncpy(srvaddr.sun_path, CYRUS_PWCHECK_SOCKET, sizeof(srvaddr.sun_path));
118      r = connect(s, (struct sockaddr *)&srvaddr, sizeof(srvaddr));
119      if (r == -1) {
120         DEBUG(D_auth)
121             debug_printf("Cannot connect to pwcheck daemon (at '%s')\n",CYRUS_PWCHECK_SOCKET);
122        if (reply) { *reply = "cannot connect to pwcheck daemon"; }
123        return PWCHECK_FAIL;
124      }
125
126      iov[0].iov_base = (char *)userid;
127      iov[0].iov_len = strlen(userid)+1;
128      iov[1].iov_base = (char *)passwd;
129      iov[1].iov_len = strlen(passwd)+1;
130
131      retry_writev(s, iov, 2);
132
133      start = 0;
134      while (start < sizeof(response) - 1) {
135        n = read(s, response+start, sizeof(response) - 1 - start);
136        if (n < 1) break;
137        start += n;
138      }
139
140      (void)close(s);
141
142      if (start > 1 && !strncmp(response, "OK", 2)) {
143        return PWCHECK_OK;
144      }
145
146      response[start] = '\0';
147      if (reply) { *reply = response; }
148      return PWCHECK_NO;
149  }
150
151 #endif
152
153
154
155  /* A dummy function that always fails if saslauthd support is not
156 wanted. */
157
158 #ifndef CYRUS_SASLAUTHD_SOCKET
159 int saslauthd_verify_password(const uschar *userid,
160                 const uschar *passwd,
161                 const uschar *service,
162                 const uschar *realm,
163                 const uschar **reply)
164 {
165 userid = userid;  /* Keep picky compilers happy */
166 passwd = passwd;
167 service = service;
168 realm = realm;
169 *reply = US"saslauthd support is not included in this Exim binary";
170 return PWCHECK_FAIL;
171 }
172
173
174 /* This is the real function */
175
176 #else
177  /* written from scratch  */
178  /* saslauthd daemon-authenticated login */
179
180 int saslauthd_verify_password(const uschar *userid,
181                 const uschar *password,
182                 const uschar *service,
183                 const uschar *realm,
184                 const uschar **reply)
185 {
186     uschar *daemon_reply;
187     int s, r;
188     struct sockaddr_un srvaddr;
189
190     DEBUG(D_auth)
191        debug_printf("saslauthd userid='%s' servicename='%s'"
192                     " realm='%s'\n", userid, service, realm );
193
194     if (reply)
195         *reply = NULL;
196
197     s = socket(AF_UNIX, SOCK_STREAM, 0);
198     if (s == -1) {
199         if (reply)
200             *reply = CUstrerror(errno);
201        return PWCHECK_FAIL;
202     }
203
204     memset((char *)&srvaddr, 0, sizeof(srvaddr));
205     srvaddr.sun_family = AF_UNIX;
206     strncpy(srvaddr.sun_path, CYRUS_SASLAUTHD_SOCKET,
207             sizeof(srvaddr.sun_path));
208     r = connect(s, (struct sockaddr *)&srvaddr, sizeof(srvaddr));
209     if (r == -1) {
210         DEBUG(D_auth)
211             debug_printf("Cannot connect to saslauthd daemon (at '%s'): %s\n",
212                          CYRUS_SASLAUTHD_SOCKET, strerror(errno));
213        if (reply)
214            *reply = string_sprintf("cannot connect to saslauthd daemon at "
215                                    "%s: %s", CYRUS_SASLAUTHD_SOCKET,
216                                    strerror(errno));
217        return PWCHECK_FAIL;
218     }
219
220     if ( write_string(s, userid, Ustrlen(userid)) < 0) {
221         DEBUG(D_auth)
222             debug_printf("Failed to send userid to saslauthd daemon \n");
223         (void)close(s);
224         return PWCHECK_FAIL;
225     }
226
227     if ( write_string(s, password, Ustrlen(password)) < 0) {
228         DEBUG(D_auth)
229             debug_printf("Failed to send password to saslauthd daemon \n");
230         (void)close(s);
231         return PWCHECK_FAIL;
232     }
233
234     memset((void *)password, 0, Ustrlen(password));
235
236     if ( write_string(s, service, Ustrlen(service)) < 0) {
237         DEBUG(D_auth)
238             debug_printf("Failed to send service name to saslauthd daemon \n");
239         (void)close(s);
240         return PWCHECK_FAIL;
241     }
242
243     if ( write_string(s, realm, Ustrlen(realm)) < 0) {
244         DEBUG(D_auth)
245             debug_printf("Failed to send realm to saslauthd daemon \n");
246         (void)close(s);
247         return PWCHECK_FAIL;
248     }
249
250     if ( read_string(s, &daemon_reply ) < 2) {
251         DEBUG(D_auth)
252             debug_printf("Corrupted answer '%s' received. \n", daemon_reply);
253         (void)close(s);
254         return PWCHECK_FAIL;
255     }
256
257     (void)close(s);
258
259     DEBUG(D_auth)
260         debug_printf("Answer '%s' received. \n", daemon_reply);
261
262     *reply = daemon_reply;
263
264     if ( (daemon_reply[0] == 'O') && (daemon_reply[1] == 'K') )
265         return PWCHECK_OK;
266
267     if ( (daemon_reply[0] == 'N') && (daemon_reply[1] == 'O') )
268         return PWCHECK_NO;
269
270     return PWCHECK_FAIL;
271 }
272
273 #endif
274
275
276 /* helper functions */
277 #if defined(CYRUS_PWCHECK_SOCKET) || defined(CYRUS_SASLAUTHD_SOCKET)
278
279 #define MAX_REQ_LEN 1024
280
281 /* written from scratch */
282
283 /* FUNCTION: read_string */
284
285 /* SYNOPSIS
286  * read a sasld-style counted string into
287  * store-allocated buffer, set pointer to the buffer,
288  * return number of bytes read or -1 on failure.
289  * END SYNOPSIS */
290
291 static int read_string(int fd, uschar **retval) {
292     unsigned short count;
293     int rc;
294
295     rc = (retry_read(fd, &count, sizeof(count)) < (int) sizeof(count));
296     if (!rc) {
297         count = ntohs(count);
298         if (count > MAX_REQ_LEN) {
299             return -1;
300         } else {
301             *retval = store_get(count + 1);
302             rc = (retry_read(fd, *retval, count) < (int) count);
303             (*retval)[count] = '\0';
304             return count;
305         }
306     }
307     return -1;
308 }
309
310
311 /* FUNCTION: write_string */
312
313 /* SYNOPSIS
314  * write a sasld-style counted string into given fd
315  * written bytes on success, -1 on failure.
316  * END SYNOPSIS */
317
318 static int write_string(int fd, const uschar *string, int len) {
319     unsigned short count;
320     int rc;
321     struct iovec iov[2];
322
323     count = htons(len);
324
325     iov[0].iov_base = (void *) &count;
326     iov[0].iov_len = sizeof(count);
327     iov[1].iov_base = (void *) string;
328     iov[1].iov_len = len;
329
330     rc = retry_writev(fd, iov, 2);
331
332     return rc;
333 }
334
335
336 /* taken from cyrus-sasl file saslauthd/saslauthd-unix.c  */
337
338 /* FUNCTION: retry_read */
339
340 /* SYNOPSIS
341  * Keep calling the read() system call with 'fd', 'buf', and 'nbyte'
342  * until all the data is read in or an error occurs.
343  * END SYNOPSIS */
344 static int retry_read(int fd, void *inbuf, unsigned nbyte)
345 {
346     int n;
347     int nread = 0;
348     char *buf = (char *)inbuf;
349
350     if (nbyte == 0) return 0;
351
352     for (;;) {
353        n = read(fd, buf, nbyte);
354        if (n == 0) {
355            /* end of file */
356            return -1;
357        }
358        if (n == -1) {
359            if (errno == EINTR) continue;
360            return -1;
361        }
362
363        nread += n;
364
365        if (n >= (int) nbyte) return nread;
366
367        buf += n;
368        nbyte -= n;
369     }
370 }
371
372 /* END FUNCTION: retry_read */
373
374 /* FUNCTION: retry_writev */
375
376 /* SYNOPSIS
377  * Keep calling the writev() system call with 'fd', 'iov', and 'iovcnt'
378  * until all the data is written out or an error occurs.
379  * END SYNOPSIS */
380
381 static int     /* R: bytes written, or -1 on error */
382 retry_writev (
383   /* PARAMETERS */
384   int fd,                              /* I: fd to write on */
385   struct iovec *iov,                   /* U: iovec array base
386                                         *    modified as data written */
387   int iovcnt                           /* I: number of iovec entries */
388   /* END PARAMETERS */
389   )
390 {
391     /* VARIABLES */
392     int n;                             /* return value from writev() */
393     int i;                             /* loop counter */
394     int written;                       /* bytes written so far */
395     static int iov_max;                        /* max number of iovec entries */
396     /* END VARIABLES */
397
398     /* initialization */
399 #ifdef MAXIOV
400     iov_max = MAXIOV;
401 #else /* ! MAXIOV */
402 # ifdef IOV_MAX
403     iov_max = IOV_MAX;
404 # else /* ! IOV_MAX */
405     iov_max = 8192;
406 # endif /* ! IOV_MAX */
407 #endif /* ! MAXIOV */
408     written = 0;
409
410     for (;;) {
411
412        while (iovcnt && iov[0].iov_len == 0) {
413            iov++;
414            iovcnt--;
415        }
416
417        if (!iovcnt) {
418            return written;
419        }
420
421        n = writev(fd, iov, iovcnt > iov_max ? iov_max : iovcnt);
422        if (n == -1) {
423            if (errno == EINVAL && iov_max > 10) {
424                iov_max /= 2;
425                continue;
426            }
427            if (errno == EINTR) {
428                continue;
429            }
430            return -1;
431        } else {
432            written += n;
433        }
434
435        for (i = 0; i < iovcnt; i++) {
436            if (iov[i].iov_len > (unsigned) n) {
437                iov[i].iov_base = (char *)iov[i].iov_base + n;
438                iov[i].iov_len -= n;
439                break;
440            }
441            n -= iov[i].iov_len;
442            iov[i].iov_len = 0;
443        }
444
445        if (i == iovcnt) {
446            return written;
447        }
448     }
449     /* NOTREACHED */
450 }
451
452 /* END FUNCTION: retry_writev */
453 #endif
454
455 /* End of auths/pwcheck.c */