[dovecot-cvs] dovecot/src/auth auth-client-connection.c,NONE,1.1
auth-client-connection.h,NONE,1.1 auth-client-interface.h,NONE,1.1
auth-master-connection.c,NONE,1.1 auth-master-connection.h,NONE,1.1
Makefile.am,1.20,1.21 auth-master-interface.h,1.2,1.3
main.c,1.20,1.21 mech-anonymous.c,1.1,1.2
mech-digest-md5.c,1.12,1.13 mech-plain.c,1.13,1.14 mech.c,1.11,1.12
mech.h,1.9,1.10 auth-login-interface.h,1.5,NONE
login-connection.c,1.24,NONE login-connection.h,1.4,NONE
master-connection.c,1.11,NONE master-connection.h,1.1,NONE
cras at procontrol.fi
cras at procontrol.fi
Fri Aug 22 06:42:15 EEST 2003
- Previous message: [dovecot-cvs] dovecot/src Makefile.am,1.6,1.7
- Next message: [dovecot-cvs]
dovecot/src/login-common Makefile.am,1.4,1.5 auth-common.c,1.4,1.5
auth-common.h,1.1,1.2 client-common.h,1.3,1.4 common.h,1.2,1.3
main.c,1.12,1.13 master.c,1.6,1.7 master.h,1.3,1.4
auth-connection.c,1.13,NONE auth-connection.h,1.4,NONE
- Messages sorted by:
[ date ]
[ thread ]
[ subject ]
[ author ]
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 ---
- Previous message: [dovecot-cvs] dovecot/src Makefile.am,1.6,1.7
- Next message: [dovecot-cvs]
dovecot/src/login-common Makefile.am,1.4,1.5 auth-common.c,1.4,1.5
auth-common.h,1.1,1.2 client-common.h,1.3,1.4 common.h,1.2,1.3
main.c,1.12,1.13 master.c,1.6,1.7 master.h,1.3,1.4
auth-connection.c,1.13,NONE auth-connection.h,1.4,NONE
- Messages sorted by:
[ date ]
[ thread ]
[ subject ]
[ author ]
More information about the dovecot-cvs
mailing list