[hcoop/debian/courier-authlib.git] / authdaemonlib.c

/*
** Copyright 2000-2006 Double Precision, Inc.  See COPYING for
** distribution information.
*/

#include	"auth.h"
#include	"courierauthstaticlist.h"
#include	"courierauthsasl.h"
#include	<stdio.h>
#include	<stdlib.h>
#include	<string.h>
#if	HAVE_UNISTD_H
#include	<unistd.h>
#endif
#include	<fcntl.h>
#include        <sys/types.h>
#include        <sys/socket.h>
#include        <sys/un.h>
#include        <sys/time.h>
#if	HAVE_SYS_SELECT_H
#include	<sys/select.h>
#endif
#include        <unistd.h>
#include        <stdlib.h>
#include        <stdio.h>
#include        <errno.h>
#include	"authdaemonrc.h"
#include	"numlib/numlib.h"

static int TIMEOUT_SOCK=10,
	TIMEOUT_WRITE=10,
	TIMEOUT_READ=30; 


static int s_connect(int sockfd,
		     const struct sockaddr *addr,
		     size_t addr_s,
		     time_t connect_timeout)
{
	fd_set fdr;
	struct timeval tv;
	int	rc;

#ifdef SOL_KEEPALIVE
	setsockopt(sockfd, SOL_SOCKET, SOL_KEEPALIVE,
		   (const char *)&dummy, sizeof(dummy));
#endif

#ifdef  SOL_LINGER
        {
		struct linger l;

                l.l_onoff=0;
                l.l_linger=0;

                setsockopt(sockfd, SOL_SOCKET, SOL_LINGER,
			   (const char *)&l, sizeof(l));
        }
#endif

        /*
        ** If configuration says to use the kernel's timeout settings,
        ** just call connect, and be done with it.
        */

        if (connect_timeout == 0)
                return ( connect(sockfd, addr, addr_s));

        /* Asynchronous connect with timeout. */

        if (fcntl(sockfd, F_SETFL, O_NONBLOCK) < 0)     return (-1);

        if ( connect(sockfd, addr, addr_s) == 0)
        {
                /* That was easy, we're done. */

                if (fcntl(sockfd, F_SETFL, 0) < 0)      return (-1);
                return (0);
        }

	if (errno != EINPROGRESS)
		return -1;

	/* Wait for the connection to go through, until the timeout expires */

        FD_ZERO(&fdr);
        FD_SET(sockfd, &fdr);
        tv.tv_sec=connect_timeout;
        tv.tv_usec=0;

        rc=select(sockfd+1, 0, &fdr, 0, &tv);
        if (rc < 0)     return (-1);

        if (!FD_ISSET(sockfd, &fdr))
        {
                errno=ETIMEDOUT;
                return (-1);
        }

	{
		int     gserr;
		socklen_t gslen = sizeof(gserr);

		if (getsockopt(sockfd, SOL_SOCKET,
			       SO_ERROR,
			       (char *)&gserr, &gslen)==0)
		{
			if (gserr == 0)
				return 0;

			errno=gserr;
		}
	}
	return (-1);
}

static int opensock()
{
	int	s=socket(PF_UNIX, SOCK_STREAM, 0);
	struct  sockaddr_un skun;

	skun.sun_family=AF_UNIX;
	strcpy(skun.sun_path, AUTHDAEMONSOCK);

	if (s < 0)
	{
		perror("CRIT: authdaemon: socket() failed");
		return (-1);
	}

	{
		const char *p=getenv("TIMEOUT_SOCK");
		int n=atoi(p ? p:"0");

		if (n > 0)
			TIMEOUT_SOCK=n;
	}

	{
		const char *p=getenv("TIMEOUT_READ");
		int n=atoi(p ? p:"0");

		if (n > 0)
			TIMEOUT_READ=n;
	}

	{
		const char *p=getenv("TIMEOUT_WRITE");
		int n=atoi(p ? p:"0");

		if (n > 0)
			TIMEOUT_WRITE=n;
	}

	if (s_connect(s, (const struct sockaddr *)&skun, sizeof(skun),
		      TIMEOUT_SOCK))
	{
		perror("ERR: authdaemon: s_connect() failed");
		if (errno == ETIMEDOUT || errno == ECONNREFUSED)
			fprintf(stderr, "ERR: [Hint: perhaps authdaemond is not running?]\n");
		close(s);
		return (-1);
	}
	return (s);
}

static int writeauth(int fd, const char *p, unsigned pl)
{
fd_set  fds;
struct  timeval tv;

	while (pl)
	{
	int     n;

		FD_ZERO(&fds);
		FD_SET(fd, &fds);
		tv.tv_sec=TIMEOUT_WRITE;
		tv.tv_usec=0;
		if (select(fd+1, 0, &fds, 0, &tv) <= 0 || !FD_ISSET(fd, &fds))
			return (-1);
		n=write(fd, p, pl);
		if (n <= 0)     return (-1);
		p += n;
		pl -= n;
	}
	return (0);
}

static void readauth(int fd, char *p, unsigned pl, const char *term)
{
time_t	end_time, curtime;
unsigned len = 0, tlen = strlen(term);

	--pl;

	time(&end_time);
	end_time += TIMEOUT_READ;

	while (pl)
	{
	int     n;
	fd_set  fds;
	struct  timeval tv;

		time(&curtime);
		if (curtime >= end_time)
			break;

		FD_ZERO(&fds);
		FD_SET(fd, &fds);
		tv.tv_sec=end_time - curtime;
		tv.tv_usec=0;
		if (select(fd+1, &fds, 0, 0, &tv) <= 0 || !FD_ISSET(fd, &fds))
			break;

		n=read(fd, p, pl);
		if (n <= 0)
			break;
		p += n;
		pl -= n;
		/* end-of-message detection for authpipe */
		len += n;
		if (len >= tlen && strncmp(p-tlen, term, tlen) == 0)
			break;
		else if (len == 5 && strncmp(p-5, "FAIL\n", 5) == 0)
			break;
	}
	*p=0;
}

int _authdaemondopasswd(int wrfd, int rdfd, char *buffer, int bufsiz)
{
	if (writeauth(wrfd, buffer, strlen(buffer)))
		return 1;
	
	readauth(rdfd, buffer, bufsiz, "\n");

	if (strcmp(buffer, "OK\n"))
	{
		errno=EPERM;
		return -1;
	}
	return 0;
}

int authdaemondopasswd(char *buffer, int bufsiz)
{
	int s=opensock();
	int rc;

	if (s < 0)
		return (1);
	rc = _authdaemondopasswd(s, s, buffer, bufsiz);
	close(s);
	return rc;
}

int _authdaemondo(int wrfd, int rdfd, const char *authreq,
	int (*func)(struct authinfo *, void *), void *arg)
{
char	buf[BUFSIZ];
char	*p, *q, *r;
struct	authinfo a;
uid_t	u;

	if (writeauth(wrfd, authreq, strlen(authreq)))
	{
		return (1);
	}

	readauth(rdfd, buf, sizeof(buf), "\n.\n");
	memset(&a, 0, sizeof(a));
	a.homedir="";
	p=buf;
	while (*p)
	{
		for (q=p; *q; q++)
			if (*q == '\n')
			{
				*q++=0;
				break;
			}
		if (strcmp(p, ".") == 0)
		{
			return ( (*func)(&a, arg));
		}
		if (strcmp(p, "FAIL") == 0)
		{
			errno=EPERM;
			return (-1);
		}
		r=strchr(p, '=');
		if (!r)
		{
			p=q;
			continue;
		}
		*r++=0;

		if (strcmp(p, "USERNAME") == 0)
			a.sysusername=r;
		else if (strcmp(p, "UID") == 0)
		{
			u=atol(r);
			a.sysuserid= &u;
		}
		else if (strcmp(p, "GID") == 0)
		{
			a.sysgroupid=atol(r);
		}
		else if (strcmp(p, "HOME") == 0)
		{
			a.homedir=r;
		}
		else if (strcmp(p, "ADDRESS") == 0)
		{
			a.address=r;
		}
		else if (strcmp(p, "NAME") == 0)
		{
			a.fullname=r;
		}
		else if (strcmp(p, "MAILDIR") == 0)
		{
			a.maildir=r;
		}
		else if (strcmp(p, "QUOTA") == 0)
		{
			a.quota=r;
		}
		else if (strcmp(p, "PASSWD") == 0)
		{
			a.passwd=r;
		}
		else if (strcmp(p, "PASSWD2") == 0)
		{
			a.clearpasswd=r;
		}
		else if (strcmp(p, "OPTIONS") == 0)
		{
			a.options=r;
		}
		p=q;
	}
	errno=EIO;
	return (1);
}

int authdaemondo(const char *authreq,
	int (*func)(struct authinfo *, void *), void *arg)
{
int	s=opensock();
int	rc;

	if (s < 0)
	{
		return (1);
	}
	rc = _authdaemondo(s, s, authreq, func, arg);
	close(s);
	return rc;
}

void auth_daemon_cleanup()
{
}

struct enum_getch {
	char buffer[BUFSIZ];
	char *buf_ptr;
	size_t buf_left;
};

#define getauthc(fd,eg) ((eg)->buf_left-- ? \
			(unsigned char)*((eg)->buf_ptr)++:\
			fillgetauthc((fd),(eg)))

static int fillgetauthc(int fd, struct enum_getch *eg)
{
	time_t	end_time, curtime;

	time(&end_time);
	end_time += 60;

	for (;;)
	{
		int     n;
		fd_set  fds;
		struct  timeval tv;

		time(&curtime);
		if (curtime >= end_time)
			break;

		FD_ZERO(&fds);
		FD_SET(fd, &fds);
		tv.tv_sec=end_time - curtime;
		tv.tv_usec=0;
		if (select(fd+1, &fds, 0, 0, &tv) <= 0 || !FD_ISSET(fd, &fds))
			break;

		n=read(fd, eg->buffer, sizeof(eg->buffer));
		if (n <= 0)
			break;

		eg->buf_ptr=eg->buffer;
		eg->buf_left=n;

		--eg->buf_left;
		return (unsigned char)*(eg->buf_ptr)++;
	}
	return EOF;
}

static int readline(int fd, struct enum_getch *eg,
		    char *buf,
		    size_t bufsize)
{
	if (bufsize == 0)
		return EOF;

	while (--bufsize)
	{
		int ch=getauthc(fd, eg);

		if (ch == EOF)
			return -1;
		if (ch == '\n')
			break;

		*buf++=ch;
	}
	*buf=0;
	return 0;
}

int _auth_enumerate(int wrfd, int rdfd,
		     void(*cb_func)(const char *name,
				    uid_t uid,
				    gid_t gid,
				    const char *homedir,
				    const char *maildir,
				    const char *options,
				    void *void_arg),
		     void *void_arg)
{
	static char cmd[]="ENUMERATE\n";
	struct enum_getch eg;
	char linebuf[BUFSIZ];

	if (writeauth(wrfd, cmd, sizeof(cmd)-1))
	{
		return 1;
	}

	eg.buf_left=0;

	while (readline(rdfd, &eg, linebuf, sizeof(linebuf)) == 0)
	{
		char *p;
		const char *name;
		uid_t uid;
		gid_t gid;
		const char *homedir;
		const char *maildir;
		const char *options;

		if (strcmp(linebuf, ".") == 0)
		{
			(*cb_func)(NULL, 0, 0, NULL, NULL, NULL, void_arg);
			return 0;
		}

		p=strchr(linebuf, '#');
		if (p) *p=0;

		p=strchr(linebuf, '\t');

		if (p)
		{
			name=linebuf;
			*p++=0;

			uid=libmail_atouid_t(p);
			p=strchr(p, '\t');
			if (uid && p)
			{
				*p++=0;
				gid=libmail_atogid_t(p);
				p=strchr(p, '\t');
				if (gid && p)
				{
					*p++=0;
					homedir=p;
					p=strchr(p, '\t');
					maildir=NULL;
					options=NULL;

					if (p)
					{
						*p++=0;
						maildir=p;
						p=strchr(p, '\t');
						
						if (p)
						{
							*p++=0;
							options=p;
							p=strchr(p, '\t');
							if (p) *p=0;
						}
					}


					(*cb_func)(name, uid, gid, homedir,
						   maildir, options, void_arg);
				}
			}
		}
	}
	return 1;
}

void auth_enumerate( void(*cb_func)(const char *name,
				    uid_t uid,
				    gid_t gid,
				    const char *homedir,
				    const char *maildir,
				    const char *options,
				    void *void_arg),
		     void *void_arg)
{
	int s=opensock();

	if (s < 0)
		return;
	
	_auth_enumerate(s, s, cb_func, void_arg);

	close(s);
}
Commit	Line	Data
d9898ee8	1	/*
	2	** Copyright 2000-2006 Double Precision, Inc. See COPYING for
	3	** distribution information.
	4	*/
	5
	6	#include "auth.h"
b0322a85	7	#include "courierauthstaticlist.h"
d9898ee8	8	#include "courierauthsasl.h"
	9	#include <stdio.h>
	10	#include <stdlib.h>
	11	#include <string.h>
	12	#if HAVE_UNISTD_H
	13	#include <unistd.h>
	14	#endif
	15	#include <fcntl.h>
	16	#include <sys/types.h>
	17	#include <sys/socket.h>
	18	#include <sys/un.h>
	19	#include <sys/time.h>
	20	#if HAVE_SYS_SELECT_H
	21	#include <sys/select.h>
	22	#endif
	23	#include <unistd.h>
	24	#include <stdlib.h>
	25	#include <stdio.h>
	26	#include <errno.h>
	27	#include "authdaemonrc.h"
	28	#include "numlib/numlib.h"
	29
	30	static int TIMEOUT_SOCK=10,
	31	TIMEOUT_WRITE=10,
	32	TIMEOUT_READ=30;
	33
d9898ee8	34
	35	static int s_connect(int sockfd,
	36	const struct sockaddr *addr,
	37	size_t addr_s,
	38	time_t connect_timeout)
	39	{
	40	fd_set fdr;
	41	struct timeval tv;
	42	int rc;
	43
	44	#ifdef SOL_KEEPALIVE
	45	setsockopt(sockfd, SOL_SOCKET, SOL_KEEPALIVE,
	46	(const char *)&dummy, sizeof(dummy));
	47	#endif
	48
	49	#ifdef SOL_LINGER
	50	{
	51	struct linger l;
	52
	53	l.l_onoff=0;
	54	l.l_linger=0;
	55
	56	setsockopt(sockfd, SOL_SOCKET, SOL_LINGER,
	57	(const char *)&l, sizeof(l));
	58	}
	59	#endif
	60
	61	/*
	62	** If configuration says to use the kernel's timeout settings,
	63	** just call connect, and be done with it.
	64	*/
	65
	66	if (connect_timeout == 0)
	67	return ( connect(sockfd, addr, addr_s));
	68
	69	/* Asynchronous connect with timeout. */
	70
	71	if (fcntl(sockfd, F_SETFL, O_NONBLOCK) < 0) return (-1);
	72
	73	if ( connect(sockfd, addr, addr_s) == 0)
	74	{
	75	/* That was easy, we're done. */
	76
	77	if (fcntl(sockfd, F_SETFL, 0) < 0) return (-1);
	78	return (0);
	79	}
	80
	81	if (errno != EINPROGRESS)
	82	return -1;
	83
	84	/* Wait for the connection to go through, until the timeout expires */
	85
	86	FD_ZERO(&fdr);
	87	FD_SET(sockfd, &fdr);
	88	tv.tv_sec=connect_timeout;
	89	tv.tv_usec=0;
	90
	91	rc=select(sockfd+1, 0, &fdr, 0, &tv);
	92	if (rc < 0) return (-1);
	93
	94	if (!FD_ISSET(sockfd, &fdr))
	95	{
	96	errno=ETIMEDOUT;
	97	return (-1);
98	}
99
100	{
101	int gserr;
102	socklen_t gslen = sizeof(gserr);
103
104	if (getsockopt(sockfd, SOL_SOCKET,
105	SO_ERROR,
106	(char *)&gserr, &gslen)==0)
107	{
108	if (gserr == 0)
109	return 0;
110
111	errno=gserr;
112	}
113	}
114	return (-1);
115	}
116
117	static int opensock()
118	{
119	int s=socket(PF_UNIX, SOCK_STREAM, 0);
120	struct sockaddr_un skun;
121
122	skun.sun_family=AF_UNIX;
123	strcpy(skun.sun_path, AUTHDAEMONSOCK);
124
125	if (s < 0)
126	{
127	perror("CRIT: authdaemon: socket() failed");
128	return (-1);
129	}
130
131	{
132	const char *p=getenv("TIMEOUT_SOCK");
133	int n=atoi(p ? p:"0");
134
135	if (n > 0)
136	TIMEOUT_SOCK=n;
137	}
138
139	{
140	const char *p=getenv("TIMEOUT_READ");
141	int n=atoi(p ? p:"0");
142
143	if (n > 0)
144	TIMEOUT_READ=n;
145	}
146
147	{
148	const char *p=getenv("TIMEOUT_WRITE");
149	int n=atoi(p ? p:"0");
150
151	if (n > 0)
152	TIMEOUT_WRITE=n;
153	}
154
155	if (s_connect(s, (const struct sockaddr *)&skun, sizeof(skun),
156	TIMEOUT_SOCK))
157	{
158	perror("ERR: authdaemon: s_connect() failed");
159	if (errno == ETIMEDOUT \|\| errno == ECONNREFUSED)
160	fprintf(stderr, "ERR: [Hint: perhaps authdaemond is not running?]\n");
161	close(s);
162	return (-1);
163	}
164	return (s);
165	}
166
167	static int writeauth(int fd, const char *p, unsigned pl)
168	{
169	fd_set fds;
170	struct timeval tv;
171
172	while (pl)
173	{
174	int n;
175
176	FD_ZERO(&fds);
177	FD_SET(fd, &fds);
178	tv.tv_sec=TIMEOUT_WRITE;
179	tv.tv_usec=0;
180	if (select(fd+1, 0, &fds, 0, &tv) <= 0 \|\| !FD_ISSET(fd, &fds))
181	return (-1);
182	n=write(fd, p, pl);
183	if (n <= 0) return (-1);
184	p += n;
185	pl -= n;
186	}
187	return (0);
188	}
189
190	static void readauth(int fd, char p, unsigned pl, const char term)
191	{
192	time_t end_time, curtime;
193	unsigned len = 0, tlen = strlen(term);
194
195	--pl;
196
197	time(&end_time);
198	end_time += TIMEOUT_READ;
199
200	while (pl)
201	{
202	int n;
203	fd_set fds;
204	struct timeval tv;
205
206	time(&curtime);
207	if (curtime >= end_time)
208	break;
209
210	FD_ZERO(&fds);
211	FD_SET(fd, &fds);
212	tv.tv_sec=end_time - curtime;
213	tv.tv_usec=0;
214	if (select(fd+1, &fds, 0, 0, &tv) <= 0 \|\| !FD_ISSET(fd, &fds))
215	break;
216
217	n=read(fd, p, pl);
218	if (n <= 0)
219	break;
220	p += n;
221	pl -= n;
222	/* end-of-message detection for authpipe */
223	len += n;
224	if (len >= tlen && strncmp(p-tlen, term, tlen) == 0)
225	break;
226	else if (len == 5 && strncmp(p-5, "FAIL\n", 5) == 0)
227	break;
228	}
229	*p=0;
230	}
231
232	int _authdaemondopasswd(int wrfd, int rdfd, char *buffer, int bufsiz)
233	{
234	if (writeauth(wrfd, buffer, strlen(buffer)))
235	return 1;
236
237	readauth(rdfd, buffer, bufsiz, "\n");
238
239	if (strcmp(buffer, "OK\n"))
240	{
241	errno=EPERM;
242	return -1;
243	}
244	return 0;
245	}
246
247	int authdaemondopasswd(char *buffer, int bufsiz)
248	{
249	int s=opensock();
250	int rc;
251
252	if (s < 0)
253	return (1);
254	rc = _authdaemondopasswd(s, s, buffer, bufsiz);
255	close(s);
256	return rc;
257	}
258
259	int _authdaemondo(int wrfd, int rdfd, const char *authreq,
260	int (func)(struct authinfo , void ), void arg)
261	{
262	char buf[BUFSIZ];
263	char p, q, *r;
264	struct authinfo a;
265	uid_t u;
266
267	if (writeauth(wrfd, authreq, strlen(authreq)))
268	{
269	return (1);
270	}
271
272	readauth(rdfd, buf, sizeof(buf), "\n.\n");
273	memset(&a, 0, sizeof(a));
274	a.homedir="";
275	p=buf;
276	while (*p)
277	{
278	for (q=p; *q; q++)
279	if (*q == '\n')
280	{
281	*q++=0;
282	break;
283	}
284	if (strcmp(p, ".") == 0)
285	{
286	return ( (*func)(&a, arg));
287	}
288	if (strcmp(p, "FAIL") == 0)
289	{
290	errno=EPERM;
291	return (-1);
292	}
293	r=strchr(p, '=');
294	if (!r)
295	{
296	p=q;
297	continue;
298	}
299	*r++=0;
300
301	if (strcmp(p, "USERNAME") == 0)
302	a.sysusername=r;
303	else if (strcmp(p, "UID") == 0)
304	{
305	u=atol(r);
306	a.sysuserid= &u;
307	}
308	else if (strcmp(p, "GID") == 0)
309	{
310	a.sysgroupid=atol(r);
311	}
312	else if (strcmp(p, "HOME") == 0)
313	{
314	a.homedir=r;
315	}
316	else if (strcmp(p, "ADDRESS") == 0)
317	{
318	a.address=r;
319	}
320	else if (strcmp(p, "NAME") == 0)
321	{
322	a.fullname=r;
323	}
324	else if (strcmp(p, "MAILDIR") == 0)
325	{
326	a.maildir=r;
327	}
328	else if (strcmp(p, "QUOTA") == 0)
329	{
330	a.quota=r;
331	}
332	else if (strcmp(p, "PASSWD") == 0)
333	{
334	a.passwd=r;
335	}
336	else if (strcmp(p, "PASSWD2") == 0)
337	{
338	a.clearpasswd=r;
339	}
340	else if (strcmp(p, "OPTIONS") == 0)
341	{
342	a.options=r;
343	}
344	p=q;
345	}
346	errno=EIO;
347	return (1);
348	}
349
350	int authdaemondo(const char *authreq,
351	int (func)(struct authinfo , void ), void arg)
352	{
353	int s=opensock();
354	int rc;
355
356	if (s < 0)
357	{
358	return (1);
359	}
360	rc = _authdaemondo(s, s, authreq, func, arg);
361	close(s);
362	return rc;
363	}
364
365	void auth_daemon_cleanup()
366	{
367	}
368
369	struct enum_getch {
370	char buffer[BUFSIZ];
371	char *buf_ptr;
372	size_t buf_left;
373	};
374
375	#define getauthc(fd,eg) ((eg)->buf_left-- ? \
376	(unsigned char)*((eg)->buf_ptr)++:\
377	fillgetauthc((fd),(eg)))
378
379	static int fillgetauthc(int fd, struct enum_getch *eg)
380	{
381	time_t end_time, curtime;
382
383	time(&end_time);
384	end_time += 60;
385
386	for (;;)
387	{
388	int n;
389	fd_set fds;
390	struct timeval tv;
391
392	time(&curtime);
393	if (curtime >= end_time)
394	break;
395
396	FD_ZERO(&fds);
397	FD_SET(fd, &fds);
398	tv.tv_sec=end_time - curtime;
399	tv.tv_usec=0;
400	if (select(fd+1, &fds, 0, 0, &tv) <= 0 \|\| !FD_ISSET(fd, &fds))
401	break;
402
403	n=read(fd, eg->buffer, sizeof(eg->buffer));
404	if (n <= 0)
405	break;
406
407	eg->buf_ptr=eg->buffer;
408	eg->buf_left=n;
409
410	--eg->buf_left;
411	return (unsigned char)*(eg->buf_ptr)++;
412	}
413	return EOF;
414	}
415
416	static int readline(int fd, struct enum_getch *eg,
417	char *buf,
418	size_t bufsize)
419	{
420	if (bufsize == 0)
421	return EOF;
422
423	while (--bufsize)
424	{
425	int ch=getauthc(fd, eg);
426
427	if (ch == EOF)
428	return -1;
429	if (ch == '\n')
430	break;
431
432	*buf++=ch;
433	}
434	*buf=0;
435	return 0;
436	}
437
438	int _auth_enumerate(int wrfd, int rdfd,
439	void(cb_func)(const char name,
440	uid_t uid,
441	gid_t gid,
442	const char *homedir,
443	const char *maildir,
444	const char *options,
445	void *void_arg),
446	void *void_arg)
447	{
448	static char cmd[]="ENUMERATE\n";
449	struct enum_getch eg;
450	char linebuf[BUFSIZ];
451
452	if (writeauth(wrfd, cmd, sizeof(cmd)-1))
453	{
454	return 1;
455	}
456
457	eg.buf_left=0;
458
459	while (readline(rdfd, &eg, linebuf, sizeof(linebuf)) == 0)
460	{
461	char *p;
462	const char *name;
463	uid_t uid;
464	gid_t gid;
465	const char *homedir;
466	const char *maildir;
467	const char *options;
468
469	if (strcmp(linebuf, ".") == 0)
470	{
471	(*cb_func)(NULL, 0, 0, NULL, NULL, NULL, void_arg);
472	return 0;
473	}
474
475	p=strchr(linebuf, '#');
476	if (p) *p=0;
477
478	p=strchr(linebuf, '\t');
479
480	if (p)
481	{
482	name=linebuf;
483	*p++=0;
484
485	uid=libmail_atouid_t(p);
486	p=strchr(p, '\t');
487	if (uid && p)
488	{
489	*p++=0;
490	gid=libmail_atogid_t(p);
491	p=strchr(p, '\t');
492	if (gid && p)
493	{
494	*p++=0;
495	homedir=p;
496	p=strchr(p, '\t');
497	maildir=NULL;
498	options=NULL;
499
500	if (p)
501	{
502	*p++=0;
503	maildir=p;
504	p=strchr(p, '\t');
505
506	if (p)
507	{
508	*p++=0;
509	options=p;
510	p=strchr(p, '\t');
511	if (p) *p=0;
512	}
513	}
514
515
516	(*cb_func)(name, uid, gid, homedir,
517	maildir, options, void_arg);
518	}
519	}
520	}
521	}
522	return 1;
523	}
524
525	void auth_enumerate( void(cb_func)(const char name,
526	uid_t uid,
527	gid_t gid,
528	const char *homedir,
529	const char *maildir,
530	const char *options,
531	void *void_arg),
532	void *void_arg)
533	{
534	int s=opensock();
535
536	if (s < 0)
537	return;
538
539	_auth_enumerate(s, s, cb_func, void_arg);
540
541	close(s);
542	}