Fri Aug 22 06:42:15 EEST 2003

Update of /home/cvs/dovecot/src/auth
In directory danu:/tmp/cvs-serv8684/src/auth

Modified Files:
	Makefile.am auth-master-interface.h main.c mech-anonymous.c 
	mech-digest-md5.c mech-plain.c mech.c mech.h 
Added Files:
	auth-client-connection.c auth-client-connection.h 
	auth-client-interface.h auth-master-connection.c 
	auth-master-connection.h 
Removed Files:
	auth-login-interface.h login-connection.c login-connection.h 
	master-connection.c master-connection.h 
Log Message:
Moved client side code for auth process handling to lib-auth. Some other login process cleanups.

--- NEW FILE: auth-client-connection.c ---
/* Copyright (C) 2002-2003 Timo Sirainen */

#include "common.h"
#include "ioloop.h"
#include "istream.h"
#include "ostream.h"
#include "network.h"
#include "hash.h"
#include "safe-memset.h"
#include "mech.h"
#include "auth-client-connection.h"
#include "auth-master-connection.h"

#include <stdlib.h>
#include <syslog.h>

#define MAX_INBUF_SIZE \
	(sizeof(struct auth_client_request_continue) + \
	 AUTH_CLIENT_MAX_REQUEST_DATA_SIZE)
#define MAX_OUTBUF_SIZE (1024*50)

static void auth_client_connection_unref(struct auth_client_connection *conn);

static void request_callback(struct auth_client_request_reply *reply,
			     const void *data,
			     struct auth_client_connection *conn)
{
	ssize_t ret;

	ret = o_stream_send(conn->output, reply, sizeof(*reply));
	if ((size_t)ret == sizeof(*reply)) {
		if (reply->data_size == 0) {
			/* all sent */
			auth_client_connection_unref(conn);
			return;
		}

		ret = o_stream_send(conn->output, data, reply->data_size);
		if ((size_t)ret == reply->data_size) {
			/* all sent */
			auth_client_connection_unref(conn);
			return;
		}
	}

	if (ret >= 0) {
		i_warning("Auth client %u: Transmit buffer full, killing it",
			  conn->pid);
	}

	auth_client_connection_destroy(conn);
	auth_client_connection_unref(conn);
}

struct auth_client_connection *
auth_client_connection_lookup(struct auth_master_connection *master,
			      unsigned int pid)
{
	struct auth_client_connection *conn;

	for (conn = master->clients; conn != NULL; conn = conn->next) {
		if (conn->pid == pid)
			return conn;
	}

	return NULL;
}

static void auth_client_input_handshake(struct auth_client_connection *conn)
{
        struct auth_client_handshake_request rec;
        unsigned char *data;
	size_t size;

	data = i_stream_get_modifyable_data(conn->input, &size);
	if (size < sizeof(rec))
		return;

	/* Don't just cast because of alignment issues. */
	memcpy(&rec, data, sizeof(rec));
	i_stream_skip(conn->input, sizeof(rec));

	if (rec.client_pid == 0) {
		i_error("BUG: Auth client said it's PID 0");
		auth_client_connection_destroy(conn);
	} else if (auth_client_connection_lookup(conn->master,
						 rec.client_pid) != NULL) {
		/* well, it might have just reconnected very fast .. although
		   there's not much reason for it. */
		i_error("BUG: Auth client gave a PID %u of existing connection",
			rec.client_pid);
		auth_client_connection_destroy(conn);
	} else {
		conn->pid = rec.client_pid;
	}
}

static void auth_client_input_request(struct auth_client_connection *conn)
{
        enum auth_client_request_type type;
        unsigned char *data;
	size_t size;

	data = i_stream_get_modifyable_data(conn->input, &size);
	if (size < sizeof(type))
		return;

	/* note that we can't directly cast the received data pointer into
	   structures, as it may not be aligned properly. */
	memcpy(&type, data, sizeof(type));

	if (type == AUTH_CLIENT_REQUEST_NEW) {
		struct auth_client_request_new request;

		if (size < sizeof(request))
			return;

		memcpy(&request, data, sizeof(request));
		i_stream_skip(conn->input, sizeof(request));

		/* we have a full init request */
		conn->refcount++;
		mech_request_new(conn, &request, request_callback);
	} else if (type == AUTH_CLIENT_REQUEST_CONTINUE) {
                struct auth_client_request_continue request;

		if (size < sizeof(request))
			return;

		memcpy(&request, data, sizeof(request));
		if (size < sizeof(request) + request.data_size)
			return;

		i_stream_skip(conn->input, sizeof(request) + request.data_size);

		/* we have a full continued request */
		conn->refcount++;
		mech_request_continue(conn, &request, data + sizeof(request),
				      request_callback);

		/* clear any sensitive data from memory */
		safe_memset(data + sizeof(request), 0, request.data_size);
	} else {
		/* unknown request */
		i_error("BUG: Auth client %u sent us unknown request %u",
			conn->pid, type);
		auth_client_connection_destroy(conn);
	}
}

static void auth_client_input(void *context)
{
	struct auth_client_connection *conn  = context;

	switch (i_stream_read(conn->input)) {
	case 0:
		return;
	case -1:
		/* disconnected */
		auth_client_connection_destroy(conn);
		return;
	case -2:
		/* buffer full */
		i_error("BUG: Auth client %u sent us more than %d bytes",
			conn->pid, (int)MAX_INBUF_SIZE);
		auth_client_connection_destroy(conn);
		return;
	}

	if (conn->pid == 0)
		auth_client_input_handshake(conn);
	else
		auth_client_input_request(conn);
}

struct auth_client_connection *
auth_client_connection_create(struct auth_master_connection *master, int fd)
{
	struct auth_client_connection *conn;
	pool_t pool;

	pool = pool_alloconly_create("Auth client", 4096);
	conn = p_new(pool, struct auth_client_connection, 1);
	conn->pool = pool;
	conn->master = master;
	conn->refcount = 1;

	conn->fd = fd;
	conn->input = i_stream_create_file(fd, default_pool, MAX_INBUF_SIZE,
					   FALSE);
	conn->output = o_stream_create_file(fd, default_pool, MAX_OUTBUF_SIZE,
					    FALSE);
	conn->io = io_add(fd, IO_READ, auth_client_input, conn);

	conn->auth_requests = hash_create(default_pool, conn->pool,
					  0, NULL, NULL);

	conn->next = master->clients;
	master->clients = conn;

	if (o_stream_send(conn->output, &master->handshake_reply,
			  sizeof(master->handshake_reply)) < 0) {
		auth_client_connection_destroy(conn);
		conn = NULL;
	}

	return conn;
}

static void auth_request_hash_destroy(void *key __attr_unused__, void *value,
				      void *context __attr_unused__)
{
	struct auth_request *auth_request = value;

	auth_request->auth_free(auth_request);
}

void auth_client_connection_destroy(struct auth_client_connection *conn)
{
	struct auth_client_connection **pos;

	if (conn->fd == -1)
		return;

	for (pos = &conn->master->clients; *pos != NULL; pos = &(*pos)->next) {
		if (*pos == conn) {
			*pos = conn->next;
			break;
		}
	}

	i_stream_close(conn->input);
	o_stream_close(conn->output);

	io_remove(conn->io);
	conn->io = 0;

	net_disconnect(conn->fd);
	conn->fd = -1;

	conn->master = NULL;
        auth_client_connection_unref(conn);
}

static void auth_client_connection_unref(struct auth_client_connection *conn)
{
	if (--conn->refcount > 0)
		return;

	hash_foreach(conn->auth_requests, auth_request_hash_destroy, NULL);
	hash_destroy(conn->auth_requests);

	i_stream_unref(conn->input);
	o_stream_unref(conn->output);

	pool_unref(conn->pool);
}

static void auth_request_hash_timeout_check(void *key __attr_unused__,
					    void *value, void *context)
{
	struct auth_client_connection *conn = context;
	struct auth_request *auth_request = value;

	if (auth_request->created + AUTH_REQUEST_TIMEOUT < ioloop_time) {
		i_warning("Login process has too old (%us) requests, "
			  "killing it.",
			  (unsigned int)(ioloop_time - auth_request->created));

		auth_client_connection_destroy(conn);
		hash_foreach_stop();
	}
}

static void request_timeout(void *context __attr_unused__)
{
        struct auth_master_connection *master = context;
	struct auth_client_connection *conn;

	for (conn = master->clients; conn != NULL; conn = conn->next) {
		conn->refcount++;
		hash_foreach(conn->auth_requests,
			     auth_request_hash_timeout_check, conn);
		auth_client_connection_unref(conn);
	}
}

void auth_client_connections_init(struct auth_master_connection *master)
{
	master->handshake_reply.server_pid = master->pid;
	master->handshake_reply.auth_mechanisms = auth_mechanisms;

	master->to_clients = timeout_add(5000, request_timeout, master);
}

void auth_client_connections_deinit(struct auth_master_connection *master)
{
	struct auth_client_connection *next;

	while (master->clients != NULL) {
		next = master->clients->next;
		auth_client_connection_destroy(master->clients);
		master->clients = next;
	}

	timeout_remove(master->to_clients);
	master->to_clients = NULL;
}

--- NEW FILE: auth-client-connection.h ---
#ifndef __AUTH_CLIENT_CONNECTION_H
#define __AUTH_CLIENT_CONNECTION_H

#include "auth-client-interface.h"

struct auth_client_connection {
	struct auth_client_connection *next;

	struct auth_master_connection *master;
	int refcount;

	int fd;
	struct io *io;
	struct istream *input;
	struct ostream *output;

	pool_t pool;
	struct hash_table *auth_requests;

	unsigned int pid;
};

struct auth_client_connection *
auth_client_connection_create(struct auth_master_connection *master, int fd);
void auth_client_connection_destroy(struct auth_client_connection *conn);

struct auth_client_connection *
auth_client_connection_lookup(struct auth_master_connection *master,
			      unsigned int pid);

void auth_client_connections_init(struct auth_master_connection *master);
void auth_client_connections_deinit(struct auth_master_connection *master);

#endif

--- NEW FILE: auth-client-interface.h ---
#ifndef __AUTH_CLIENT_INTERFACE_H
#define __AUTH_CLIENT_INTERFACE_H

/* max. size for auth_client_request_continue.data[] */
#define AUTH_CLIENT_MAX_REQUEST_DATA_SIZE 4096

/* Client process must finish with single authentication requests in this time,
   or the whole connection will be killed. */
#define AUTH_REQUEST_TIMEOUT 120

enum auth_mech {
	AUTH_MECH_PLAIN		= 0x01,
	AUTH_MECH_DIGEST_MD5	= 0x02,
	AUTH_MECH_ANONYMOUS	= 0x04,

	AUTH_MECH_COUNT
};

enum auth_protocol {
	AUTH_PROTOCOL_IMAP	= 0x01,
	AUTH_PROTOCOL_POP3	= 0x02
};

enum auth_client_request_type {
	AUTH_CLIENT_REQUEST_NEW = 1,
        AUTH_CLIENT_REQUEST_CONTINUE
};

enum auth_client_result {
	AUTH_CLIENT_RESULT_CONTINUE = 1,
	AUTH_CLIENT_RESULT_SUCCESS,
	AUTH_CLIENT_RESULT_FAILURE
};

/* Client -> Server */
struct auth_client_handshake_request {
	unsigned int client_pid; /* unique identifier for client process */
};

/* Server -> Client */
struct auth_client_handshake_reply {
	unsigned int server_pid; /* unique auth process identifier */
	enum auth_mech auth_mechanisms; /* valid authentication mechanisms */
};

/* New authentication request */
struct auth_client_request_new {
	enum auth_client_request_type type; /* AUTH_CLIENT_REQUEST_NEW */
	unsigned int id; /* unique ID for the request */

	enum auth_mech mech;
	enum auth_protocol protocol;
};

/* Continue authentication request */
struct auth_client_request_continue {
	enum auth_client_request_type type; /* AUTH_CLIENT_REQUEST_CONTINUE */
	unsigned int id;

	size_t data_size;
	/* unsigned char data[]; */
};

/* Reply to authentication */
struct auth_client_request_reply {
	unsigned int id;

	enum auth_client_result result;

	/* variable width data, indexes into data[].
	   Ignore if it points outside data_size. */
	size_t username_idx; /* NUL-terminated */
	size_t reply_idx; /* last, non-NUL terminated */

	size_t data_size;
	/* unsigned char data[]; */
};

#endif

--- NEW FILE: auth-master-connection.c ---
/* Copyright (C) 2002 Timo Sirainen */

#include "common.h"
#include "buffer.h"
#include "hash.h"
#include "ioloop.h"
#include "ostream.h"
#include "network.h"
#include "mech.h"
#include "userdb.h"
#include "auth-client-connection.h"
#include "auth-master-connection.h"

#define MAX_OUTBUF_SIZE (1024*50)

static struct auth_master_reply failure_reply =
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };

struct master_userdb_request {
	struct auth_master_connection *conn;
	unsigned int tag;
};

static int auth_master_connection_unref(struct auth_master_connection *conn);

static size_t reply_add(buffer_t *buf, const char *str)
{
	size_t index;

	if (str == NULL || *str == '\0')
		return (size_t)-1;

	index = buffer_get_used_size(buf) - sizeof(struct auth_master_reply);
	buffer_append(buf, str, strlen(str)+1);
	return index;
}

static struct auth_master_reply *
fill_reply(const struct user_data *user, size_t *reply_size)
{
	struct auth_master_reply reply, *reply_p;
	buffer_t *buf;
	char *p;

	buf = buffer_create_dynamic(data_stack_pool,
				    sizeof(reply) + 256, (size_t)-1);
	memset(&reply, 0, sizeof(reply));
	buffer_append(buf, &reply, sizeof(reply));

	reply.success = TRUE;

	reply.uid = user->uid;
	reply.gid = user->gid;

	reply.system_user_idx = reply_add(buf, user->system_user);
	reply.virtual_user_idx = reply_add(buf, user->virtual_user);
	reply.mail_idx = reply_add(buf, user->mail);

	p = user->home != NULL ? strstr(user->home, "/./") : NULL;
	if (p == NULL) {
		reply.home_idx = reply_add(buf, user->home);
		reply.chroot_idx = reply_add(buf, NULL);
	} else {
		/* wu-ftpd like <chroot>/./<home> */
		reply.chroot_idx =
			reply_add(buf, t_strdup_until(user->home, p));
		reply.home_idx = reply_add(buf, p + 3);
	}

	*reply_size = buffer_get_used_size(buf);
	reply.data_size = *reply_size - sizeof(reply);

	reply_p = buffer_get_space_unsafe(buf, 0, sizeof(reply));
	*reply_p = reply;

	return reply_p;
}

static void master_send_reply(struct auth_master_connection *conn,
			      struct auth_master_reply *reply,
			      size_t reply_size, unsigned int tag)
{
	ssize_t ret;

	reply->tag = tag;
	for (;;) {
		ret = o_stream_send(conn->output, reply, reply_size);
		if (ret < 0) {
			/* master died, kill ourself too */
			io_loop_stop(ioloop);
			break;
		}

		if ((size_t)ret == reply_size)
			break;

		/* buffer full, we have to block */
		i_warning("Master transmit buffer full, blocking..");
		if (o_stream_flush(conn->output) < 0) {
			/* transmit error, probably master died */
			io_loop_stop(ioloop);
			break;
		}
	}
}

static void userdb_callback(struct user_data *user, void *context)
{
	struct master_userdb_request *master_request = context;
	struct auth_master_reply *reply;
	size_t reply_size;

	if (auth_master_connection_unref(master_request->conn)) {
		if (user == NULL) {
			master_send_reply(master_request->conn, &failure_reply,
					  sizeof(failure_reply),
					  master_request->tag);
		} else {
			reply = fill_reply(user, &reply_size);
			master_send_reply(master_request->conn, reply,
					  reply_size, master_request->tag);
		}
	}
	i_free(master_request);
}

static void master_handle_request(struct auth_master_connection *conn,
				  struct auth_master_request *request)
{
	struct auth_client_connection *client_conn;
	struct auth_request *auth_request;
	struct master_userdb_request *master_request;

	client_conn = auth_client_connection_lookup(conn, request->client_pid);
	auth_request = client_conn == NULL ? NULL :
		hash_lookup(client_conn->auth_requests,
			    POINTER_CAST(request->id));

	if (auth_request == NULL) {
		if (verbose) {
			i_info("Master request %u.%u not found",
			       request->client_pid, request->id);
		}
		master_send_reply(conn, &failure_reply, sizeof(failure_reply),
				  request->tag);
	} else {
		/* the auth request is finished, we don't need it anymore */
		mech_request_free(client_conn, auth_request, request->id);

		master_request = i_new(struct master_userdb_request, 1);
		master_request->conn = conn;
		master_request->tag = request->tag;

		conn->refcount++;
		userdb->lookup(auth_request->user, userdb_callback,
			       master_request);
	}
}

static void master_input(void *context)
{
	struct auth_master_connection *conn = context;
	int ret;

	ret = net_receive(conn->fd,
			  conn->request_buf + conn->request_pos,
			  sizeof(conn->request_buf) - conn->request_pos);
	if (ret < 0) {
		/* master died, kill ourself too */
		io_loop_stop(ioloop);
		return;
	}

	conn->request_pos += ret;
	if (conn->request_pos >= sizeof(conn->request_buf)) {
		/* reply is now read */
		master_handle_request(conn, (struct auth_master_request *)
				      conn->request_buf);
		conn->request_pos = 0;
	}
}

struct auth_master_connection *
auth_master_connection_new(int fd, unsigned int pid)
{
	struct auth_master_connection *conn;

	conn = i_new(struct auth_master_connection, 1);
	conn->refcount = 1;
	conn->pid = pid;
	conn->fd = fd;
	conn->output = o_stream_create_file(MASTER_SOCKET_FD, default_pool,
					    MAX_OUTBUF_SIZE, FALSE);
	conn->io = io_add(MASTER_SOCKET_FD, IO_READ, master_input, conn);

	/* just a note to master that we're ok. if we die before,
	   master should shutdown itself. */
	o_stream_send(conn->output, "O", 1);
	return conn;
}

void auth_master_connection_free(struct auth_master_connection *conn)
{
	if (conn->fd == -1)
		return;

	conn->fd = -1;
	o_stream_close(conn->output);

	io_remove(conn->io);
	conn->io = NULL;

	auth_master_connection_unref(conn);
}

static int auth_master_connection_unref(struct auth_master_connection *conn)
{
	if (--conn->refcount > 0)
		return TRUE;

	o_stream_unref(conn->output);
	i_free(conn);
	return FALSE;
}

--- NEW FILE: auth-master-connection.h ---
#ifndef __AUTH_MASTER_CONNECTION_H
#define __AUTH_MASTER_CONNECTION_H

#include "auth-master-interface.h"

struct auth_master_connection {
	unsigned int pid;
	int refcount;

	int fd;
	struct ostream *output;
	struct io *io;

	unsigned int request_pos;
	unsigned char request_buf[sizeof(struct auth_master_request)];

	struct auth_client_handshake_reply handshake_reply;
	struct auth_client_connection *clients;
	struct timeout *to_clients;
};

struct auth_master_connection *
auth_master_connection_new(int fd, unsigned int pid);
void auth_master_connection_free(struct auth_master_connection *conn);

#endif

Index: Makefile.am
===================================================================
RCS file: /home/cvs/dovecot/src/auth/Makefile.am,v
retrieving revision 1.20
retrieving revision 1.21
diff -u -d -r1.20 -r1.21
--- Makefile.am	14 May 2003 18:23:04 -0000	1.20
+++ Makefile.am	22 Aug 2003 02:42:13 -0000	1.21
@@ -16,13 +16,13 @@
 	$(MODULE_LIBS)
 
 dovecot_auth_SOURCES = \
+	auth-client-connection.c \
+	auth-master-connection.c \
 	auth-module.c \
 	db-ldap.c \
 	db-pgsql.c \
 	db-passwd-file.c \
-	login-connection.c \
 	main.c \
-	master-connection.c \
 	md5crypt.c \
 	mech.c \
 	mech-anonymous.c \
@@ -48,7 +48,9 @@
 	userdb-pgsql.c
 
 noinst_HEADERS = \
-	auth-login-interface.h \
+	auth-client-connection.h \
+	auth-client-interface.h \
+	auth-master-connection.h \
 	auth-master-interface.h \
 	auth-mech-desc.h \
 	auth-module.h \
@@ -56,8 +58,6 @@
 	db-pgsql.h \
 	db-passwd-file.h \
 	common.h \
-	login-connection.h \
-	master-connection.h \
 	md5crypt.h \
 	mech.h \
 	mycrypt.h \

Index: auth-master-interface.h
===================================================================
RCS file: /home/cvs/dovecot/src/auth/auth-master-interface.h,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- auth-master-interface.h	8 May 2003 04:28:30 -0000	1.2
+++ auth-master-interface.h	22 Aug 2003 02:42:13 -0000	1.3
@@ -7,7 +7,7 @@
 	unsigned int tag;
 
 	unsigned int id;
-	unsigned int login_pid;
+	unsigned int client_pid;
 };
 
 struct auth_master_reply {

Index: main.c
===================================================================
RCS file: /home/cvs/dovecot/src/auth/main.c,v
retrieving revision 1.20
retrieving revision 1.21
diff -u -d -r1.20 -r1.21
--- main.c	23 May 2003 14:40:49 -0000	1.20
+++ main.c	22 Aug 2003 02:42:13 -0000	1.21
@@ -10,8 +10,8 @@
 #include "mech.h"
 #include "userdb.h"
 #include "passdb.h"
-#include "master-connection.h"
-#include "login-connection.h"
+#include "auth-master-connection.h"
+#include "auth-client-connection.h"
 
 #include <stdlib.h>
 #include <syslog.h>
@@ -19,6 +19,7 @@
 struct ioloop *ioloop;
 int verbose = FALSE, verbose_debug = FALSE;
 
+static struct auth_master_connection *master;
 static struct io *io_listen;
 
 static void sig_quit(int signo __attr_unused__)
@@ -36,7 +37,7 @@
 			i_fatal("accept() failed: %m");
 	} else {
 		net_set_nonblock(fd, TRUE);
-		(void)login_connection_create(fd);
+		(void)auth_client_connection_create(master, fd);
 	}
 }
 
@@ -69,21 +70,31 @@
 
 static void main_init(void)
 {
+	const char *env;
+	unsigned int pid;
+
 	lib_init_signals(sig_quit);
 
 	verbose = getenv("VERBOSE") != NULL;
 	verbose_debug = getenv("VERBOSE_DEBUG") != NULL;
 
+	env = getenv("AUTH_PROCESS");
+	if (env == NULL)
+		i_fatal("AUTH_PROCESS environment is unset");
+
+	pid = atoi(env);
+	if (pid == 0)
+		i_fatal("AUTH_PROCESS can't be 0");
+
 	mech_init();
 	userdb_init();
 	passdb_init();
 
-	login_connections_init();
-
 	io_listen = io_add(LOGIN_LISTEN_FD, IO_READ, auth_accept, NULL);
 
 	/* initialize master last - it sends the "we're ok" notification */
-	master_connection_init();
+	master = auth_master_connection_new(MASTER_SOCKET_FD, pid);
+	auth_client_connections_init(master);
 }
 
 static void main_deinit(void)
@@ -93,13 +104,13 @@
 
 	io_remove(io_listen);
 
-	login_connections_deinit();
+	auth_client_connections_deinit(master);
 
 	passdb_deinit();
 	userdb_deinit();
 	mech_deinit();
 
-	master_connection_deinit();
+	auth_master_connection_free(master);
 	random_deinit();
 
 	closelog();

Index: mech-anonymous.c
===================================================================
RCS file: /home/cvs/dovecot/src/auth/mech-anonymous.c,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -d -r1.1 -r1.2
--- mech-anonymous.c	8 May 2003 03:24:57 -0000	1.1
+++ mech-anonymous.c	22 Aug 2003 02:42:13 -0000	1.2
@@ -5,7 +5,7 @@
 
 static int
 mech_anonymous_auth_continue(struct auth_request *auth_request,
-			     struct auth_login_request_continue *request,
+			     struct auth_client_request_continue *request,
 			     const unsigned char *data,
 			     mech_callback_t *callback)
 {
@@ -29,11 +29,11 @@
 }
 
 static struct auth_request *
-mech_anonymous_auth_new(struct login_connection *conn, unsigned int id,
+mech_anonymous_auth_new(struct auth_client_connection *conn, unsigned int id,
 			mech_callback_t *callback)
 {
         struct auth_request *auth_request;
-	struct auth_login_reply reply;
+	struct auth_client_request_reply reply;
 	pool_t pool;
 
 	pool = pool_alloconly_create("anonymous_auth_request", 256);
@@ -45,7 +45,7 @@
 	/* initialize reply */
 	memset(&reply, 0, sizeof(reply));
 	reply.id = id;
-	reply.result = AUTH_LOGIN_RESULT_CONTINUE;
+	reply.result = AUTH_CLIENT_RESULT_CONTINUE;
 
 	callback(&reply, NULL, conn);
 	return auth_request;

Index: mech-digest-md5.c
===================================================================
RCS file: /home/cvs/dovecot/src/auth/mech-digest-md5.c,v
retrieving revision 1.12
retrieving revision 1.13
diff -u -d -r1.12 -r1.13
--- mech-digest-md5.c	2 Apr 2003 02:09:41 -0000	1.12
+++ mech-digest-md5.c	22 Aug 2003 02:42:13 -0000	1.13
@@ -526,15 +526,15 @@
 {
 	struct digest_auth_request *auth =
 		(struct digest_auth_request *) request;
-	struct auth_login_reply reply;
+	struct auth_client_request_reply reply;
 
-	mech_init_login_reply(&reply);
+	mech_init_auth_client_reply(&reply);
 	reply.id = request->id;
 
 	if (!verify_credentials(auth, result))
-		reply.result = AUTH_LOGIN_RESULT_FAILURE;
+		reply.result = AUTH_CLIENT_RESULT_FAILURE;
 	else {
-		reply.result = AUTH_LOGIN_RESULT_CONTINUE;
+		reply.result = AUTH_CLIENT_RESULT_CONTINUE;
 		reply.data_size = strlen(auth->rspauth);
 		auth->authenticated = TRUE;
 	}
@@ -544,17 +544,17 @@
 
 static int
 mech_digest_md5_auth_continue(struct auth_request *auth_request,
-			      struct auth_login_request_continue *request,
+			      struct auth_client_request_continue *request,
 			      const unsigned char *data,
 			      mech_callback_t *callback)
 {
 	struct digest_auth_request *auth =
 		(struct digest_auth_request *)auth_request;
-	struct auth_login_reply reply;
+	struct auth_client_request_reply reply;
 	const char *error, *realm;
 
 	/* initialize reply */
-	mech_init_login_reply(&reply);
+	mech_init_auth_client_reply(&reply);
 	reply.id = request->id;
 
 	if (auth->authenticated) {
@@ -596,7 +596,7 @@
 	}
 
 	/* failed */
-	reply.result = AUTH_LOGIN_RESULT_FAILURE;
+	reply.result = AUTH_CLIENT_RESULT_FAILURE;
 	reply.data_size = strlen(error)+1;
 	callback(&reply, error, auth_request->conn);
 	return FALSE;
@@ -608,10 +608,10 @@
 }
 
 static struct auth_request *
-mech_digest_md5_auth_new(struct login_connection *conn,
+mech_digest_md5_auth_new(struct auth_client_connection *conn,
 			 unsigned int id, mech_callback_t *callback)
 {
-	struct auth_login_reply reply;
+	struct auth_client_request_reply reply;
 	struct digest_auth_request *auth;
 	pool_t pool;
 	string_t *challenge;
@@ -626,9 +626,9 @@
 	auth->qop = QOP_AUTH;
 
 	/* initialize reply */
-	mech_init_login_reply(&reply);
+	mech_init_auth_client_reply(&reply);
 	reply.id = id;
-	reply.result = AUTH_LOGIN_RESULT_CONTINUE;
+	reply.result = AUTH_CLIENT_RESULT_CONTINUE;
 
 	/* send the initial challenge */
 	reply.reply_idx = 0;

Index: mech-plain.c
===================================================================
RCS file: /home/cvs/dovecot/src/auth/mech-plain.c,v
retrieving revision 1.13
retrieving revision 1.14
diff -u -d -r1.13 -r1.14
--- mech-plain.c	8 May 2003 03:18:43 -0000	1.13
+++ mech-plain.c	22 Aug 2003 02:42:13 -0000	1.14
@@ -13,7 +13,7 @@
 
 static int
 mech_plain_auth_continue(struct auth_request *auth_request,
-			 struct auth_login_request_continue *request,
+			 struct auth_client_request_continue *request,
 			 const unsigned char *data, mech_callback_t *callback)
 {
 	const char *authid, *authenid;
@@ -82,11 +82,11 @@
 }
 
 static struct auth_request *
-mech_plain_auth_new(struct login_connection *conn, unsigned int id,
+mech_plain_auth_new(struct auth_client_connection *conn, unsigned int id,
 		    mech_callback_t *callback)
 {
         struct auth_request *auth_request;
-	struct auth_login_reply reply;
+	struct auth_client_request_reply reply;
 	pool_t pool;
 
 	pool = pool_alloconly_create("plain_auth_request", 256);
@@ -98,7 +98,7 @@
 	/* initialize reply */
 	memset(&reply, 0, sizeof(reply));
 	reply.id = id;
-	reply.result = AUTH_LOGIN_RESULT_CONTINUE;
+	reply.result = AUTH_CLIENT_RESULT_CONTINUE;
 
 	callback(&reply, NULL, conn);
 	return auth_request;

Index: mech.c
===================================================================
RCS file: /home/cvs/dovecot/src/auth/mech.c,v
retrieving revision 1.11
retrieving revision 1.12
diff -u -d -r1.11 -r1.12
--- mech.c	8 May 2003 03:24:57 -0000	1.11
+++ mech.c	22 Aug 2003 02:42:13 -0000	1.12
@@ -5,7 +5,7 @@
 #include "buffer.h"
 #include "hash.h"
 #include "mech.h"
-#include "login-connection.h"
+#include "auth-client-connection.h"
 
 #include <stdlib.h>
 
@@ -23,7 +23,7 @@
 
 static int set_use_cyrus_sasl;
 static struct mech_module_list *mech_modules;
-static struct auth_login_reply failure_reply;
+static struct auth_client_request_reply failure_reply;
 
 void mech_register_module(struct mech_module *module)
 {
@@ -59,8 +59,8 @@
 	}
 }
 
-void mech_request_new(struct login_connection *conn,
-		      struct auth_login_request_new *request,
+void mech_request_new(struct auth_client_connection *conn,
+		      struct auth_client_request_new *request,
 		      mech_callback_t *callback)
 {
 	struct mech_module_list *list;
@@ -68,8 +68,8 @@
 
 	if ((auth_mechanisms & request->mech) == 0) {
 		/* unsupported mechanism */
-		i_error("BUG: login requested unsupported "
-			"auth mechanism %d", request->mech);
+		i_error("BUG: Auth client %u requested unsupported "
+			"auth mechanism %d", conn->pid, request->mech);
 		failure_reply.id = request->id;
 		callback(&failure_reply, NULL, conn);
 		return;
@@ -104,8 +104,8 @@
 	}
 }
 
-void mech_request_continue(struct login_connection *conn,
-			   struct auth_login_request_continue *request,
+void mech_request_continue(struct auth_client_connection *conn,
+			   struct auth_client_request_continue *request,
 			   const unsigned char *data,
 			   mech_callback_t *callback)
 {
@@ -124,22 +124,22 @@
 	}
 }
 
-void mech_request_free(struct login_connection *conn,
+void mech_request_free(struct auth_client_connection *conn,
 		       struct auth_request *auth_request, unsigned int id)
 {
 	auth_request->auth_free(auth_request);
 	hash_remove(conn->auth_requests, POINTER_CAST(id));
 }
 
-void mech_init_login_reply(struct auth_login_reply *reply)
+void mech_init_auth_client_reply(struct auth_client_request_reply *reply)
 {
 	memset(reply, 0, sizeof(*reply));
 
-	reply->username_idx = (unsigned int)-1;
-	reply->reply_idx = (unsigned int)-1;
+	reply->username_idx = (size_t)-1;
+	reply->reply_idx = (size_t)-1;
 }
 
-void *mech_auth_success(struct auth_login_reply *reply,
+void *mech_auth_success(struct auth_client_request_reply *reply,
 			struct auth_request *auth_request,
 			const void *data, size_t data_size)
 {
@@ -157,7 +157,7 @@
 		buffer_append(buf, data, data_size);
 	}
 
-	reply->result = AUTH_LOGIN_RESULT_SUCCESS;
+	reply->result = AUTH_CLIENT_RESULT_SUCCESS;
 	reply->data_size = buffer_get_used_size(buf);
 	return buffer_get_modifyable_data(buf, NULL);
 }
@@ -165,7 +165,7 @@
 void mech_auth_finish(struct auth_request *auth_request,
 		      const void *data, size_t data_size, int success)
 {
-	struct auth_login_reply reply;
+	struct auth_client_request_reply reply;
 	void *reply_data;
 
 	memset(&reply, 0, sizeof(reply));
@@ -174,10 +174,10 @@
 	if (success) {
 		reply_data = mech_auth_success(&reply, auth_request,
 					       data, data_size);
-		reply.result = AUTH_LOGIN_RESULT_SUCCESS;
+		reply.result = AUTH_CLIENT_RESULT_SUCCESS;
 	} else {
 		reply_data = NULL;
-		reply.result = AUTH_LOGIN_RESULT_FAILURE;
+		reply.result = AUTH_CLIENT_RESULT_FAILURE;
 	}
 
 	auth_request->callback(&reply, reply_data, auth_request->conn);
@@ -213,7 +213,7 @@
 	auth_mechanisms = 0;
 
 	memset(&failure_reply, 0, sizeof(failure_reply));
-	failure_reply.result = AUTH_LOGIN_RESULT_FAILURE;
+	failure_reply.result = AUTH_CLIENT_RESULT_FAILURE;
 
 	anonymous_username = getenv("ANONYMOUS_USERNAME");
 	if (anonymous_username != NULL && *anonymous_username == '\0')

Index: mech.h
===================================================================
RCS file: /home/cvs/dovecot/src/auth/mech.h,v
retrieving revision 1.9
retrieving revision 1.10
diff -u -d -r1.9 -r1.10
--- mech.h	8 May 2003 03:24:57 -0000	1.9
+++ mech.h	22 Aug 2003 02:42:13 -0000	1.10
@@ -1,18 +1,19 @@
 #ifndef __MECH_H
 #define __MECH_H
 
-#include "auth-login-interface.h"
+#include "auth-client-interface.h"
 
-struct login_connection;
+struct auth_client_connection;
 
-typedef void mech_callback_t(struct auth_login_reply *reply,
-			     const void *data, struct login_connection *conn);
+typedef void mech_callback_t(struct auth_client_request_reply *reply,
+			     const void *data,
+			     struct auth_client_connection *conn);
 
 struct auth_request {
 	pool_t pool;
 	char *user;
 
-	struct login_connection *conn;
+	struct auth_client_connection *conn;
 	unsigned int id;
 	time_t created;
 
@@ -20,7 +21,7 @@
 	mech_callback_t *callback;
 
 	int (*auth_continue)(struct auth_request *auth_request,
-			     struct auth_login_request_continue *request,
+			     struct auth_client_request_continue *request,
 			     const unsigned char *data,
 			     mech_callback_t *callback);
 	void (*auth_free)(struct auth_request *auth_request);
@@ -30,7 +31,7 @@
 struct mech_module {
 	enum auth_mech mech;
 
-	struct auth_request *(*auth_new)(struct login_connection *conn,
+	struct auth_request *(*auth_new)(struct auth_client_connection *conn,
 					 unsigned int id,
 					 mech_callback_t *callback);
 };
@@ -44,18 +45,18 @@
 void mech_register_module(struct mech_module *module);
 void mech_unregister_module(struct mech_module *module);
 
-void mech_request_new(struct login_connection *conn,
-		      struct auth_login_request_new *request,
+void mech_request_new(struct auth_client_connection *conn,
+		      struct auth_client_request_new *request,
 		      mech_callback_t *callback);
-void mech_request_continue(struct login_connection *conn,
-			   struct auth_login_request_continue *request,
+void mech_request_continue(struct auth_client_connection *conn,
+			   struct auth_client_request_continue *request,
 			   const unsigned char *data,
 			   mech_callback_t *callback);
-void mech_request_free(struct login_connection *conn,
+void mech_request_free(struct auth_client_connection *conn,
 		       struct auth_request *auth_request, unsigned int id);
 
-void mech_init_login_reply(struct auth_login_reply *reply);
-void *mech_auth_success(struct auth_login_reply *reply,
+void mech_init_auth_client_reply(struct auth_client_request_reply *reply);
+void *mech_auth_success(struct auth_client_request_reply *reply,
 			struct auth_request *auth_request,
 			const void *data, size_t data_size);
 void mech_auth_finish(struct auth_request *auth_request,
@@ -64,9 +65,10 @@
 int mech_is_valid_username(const char *username);
 
 void mech_cyrus_sasl_init_lib(void);
-struct auth_request *mech_cyrus_sasl_new(struct login_connection *conn,
-					 struct auth_login_request_new *request,
-					 mech_callback_t *callback);
+struct auth_request *
+mech_cyrus_sasl_new(struct auth_client_connection *conn,
+		    struct auth_client_request_new *request,
+		    mech_callback_t *callback);
 
 void mech_init(void);
 void mech_deinit(void);

--- auth-login-interface.h DELETED ---

--- login-connection.c DELETED ---

--- login-connection.h DELETED ---

--- master-connection.c DELETED ---

--- master-connection.h DELETED ---

