[dovecot-cvs] dovecot/src/login auth-connection.c,1.16,1.17 auth-connection.h,1.5,1.6 client-authenticate.c,1.27,1.28

[cras at procontrol.fi]

Update of /home/cvs/dovecot/src/login
In directory danu:/tmp/cvs-serv2361/src/login

Modified Files:
	auth-connection.c auth-connection.h client-authenticate.c 
Log Message:
Initial support for Cyrus SASL 2 library. I couldn't get it to work yet
though :)



Index: auth-connection.c
===================================================================
RCS file: /home/cvs/dovecot/src/login/auth-connection.c,v
retrieving revision 1.16
retrieving revision 1.17
diff -u -d -r1.16 -r1.17
--- auth-connection.c	5 Jan 2003 13:09:53 -0000	1.16
+++ auth-connection.c	5 Jan 2003 15:19:50 -0000	1.17
@@ -27,7 +27,7 @@
 	struct ostream *output;
 
 	unsigned int auth_process;
-	enum auth_method available_auth_methods;
+	enum auth_mech available_auth_mechs;
         struct auth_reply_data in_reply;
 
         struct hash_table *requests;
@@ -36,7 +36,7 @@
 	unsigned int in_reply_received:1;
 };
 
-enum auth_method available_auth_methods;
+enum auth_mech available_auth_mechs;
 
 static int auth_reconnect;
 static unsigned int request_id_counter;
@@ -140,14 +140,14 @@
 }
 
 static struct auth_connection *
-auth_connection_get(enum auth_method method, size_t size, const char **error)
+auth_connection_get(enum auth_mech mech, size_t size, const char **error)
 {
 	struct auth_connection *conn;
 	int found;
 
 	found = FALSE;
 	for (conn = auth_connections; conn != NULL; conn = conn->next) {
-		if ((conn->available_auth_methods & method)) {
+		if ((conn->available_auth_mechs & mech)) {
 			if (o_stream_have_space(conn->output, size) > 0)
 				return conn;
 
@@ -156,8 +156,8 @@
 	}
 
 	if (!found) {
-		if ((available_auth_methods & method) == 0)
-			*error = "Unsupported authentication method";
+		if ((available_auth_mechs & mech) == 0)
+			*error = "Unsupported authentication mechanism";
 		else {
 			*error = "Authentication server isn't connected, "
 				"try again later..";
@@ -171,23 +171,23 @@
 	return NULL;
 }
 
-static void update_available_auth_methods(void)
+static void update_available_auth_mechs(void)
 {
 	struct auth_connection *conn;
 
-        available_auth_methods = 0;
+        available_auth_mechs = 0;
 	for (conn = auth_connections; conn != NULL; conn = conn->next)
-                available_auth_methods |= conn->available_auth_methods;
+                available_auth_mechs |= conn->available_auth_mechs;
 }
 
 static void auth_handle_init(struct auth_connection *conn,
 			     struct auth_init_data *init_data)
 {
 	conn->auth_process = init_data->auth_process;
-	conn->available_auth_methods = init_data->auth_methods;
+	conn->available_auth_mechs = init_data->auth_mechanisms;
 	conn->init_received = TRUE;
 
-	update_available_auth_methods();
+	update_available_auth_mechs();
 }
 
 static void auth_handle_reply(struct auth_connection *conn,
@@ -281,7 +281,7 @@
 	i_stream_skip(conn->input, conn->in_reply.data_size);
 }
 
-int auth_init_request(enum auth_method method, AuthCallback callback,
+int auth_init_request(enum auth_mech mech, AuthCallback callback,
 		      void *context, const char **error)
 {
 	struct auth_connection *conn;
@@ -291,13 +291,13 @@
 	if (auth_reconnect)
 		auth_connect_missing();
 
-	conn = auth_connection_get(method, sizeof(request_data), error);
+	conn = auth_connection_get(mech, sizeof(request_data), error);
 	if (conn == NULL)
 		return FALSE;
 
 	/* create internal request structure */
 	request = i_new(struct auth_request, 1);
-	request->method = method;
+	request->mech = mech;
 	request->conn = conn;
 	request->id = ++request_id_counter;
 	request->callback = callback;
@@ -307,7 +307,7 @@
 
 	/* send request to auth */
 	request_data.type = AUTH_REQUEST_INIT;
-	request_data.method = request->method;
+	request_data.mech = request->mech;
 	request_data.id = request->id;
 	if (o_stream_send(request->conn->output, &request_data,
 			  sizeof(request_data)) < 0)

Index: auth-connection.h
===================================================================
RCS file: /home/cvs/dovecot/src/login/auth-connection.h,v
retrieving revision 1.5
retrieving revision 1.6
diff -u -d -r1.5 -r1.6
--- auth-connection.h	5 Jan 2003 13:09:53 -0000	1.5
+++ auth-connection.h	5 Jan 2003 15:19:50 -0000	1.6
@@ -11,7 +11,7 @@
 			     size_t reply_data_size, void *context);
 
 struct auth_request {
-        enum auth_method method;
+        enum auth_mech mech;
         struct auth_connection *conn;
 
 	unsigned int id;
@@ -23,9 +23,9 @@
 	unsigned int init_sent:1;
 };
 
-extern enum auth_method available_auth_methods;
+extern enum auth_mech available_auth_mechs;
 
-int auth_init_request(enum auth_method method, AuthCallback callback,
+int auth_init_request(enum auth_mech mech, AuthCallback callback,
 		      void *context, const char **error);
 
 void auth_continue_request(struct auth_request *request,

Index: client-authenticate.c
===================================================================
RCS file: /home/cvs/dovecot/src/login/client-authenticate.c,v
retrieving revision 1.27
retrieving revision 1.28
diff -u -d -r1.27 -r1.28
--- client-authenticate.c	5 Jan 2003 13:09:53 -0000	1.27
+++ client-authenticate.c	5 Jan 2003 15:19:50 -0000	1.28
@@ -9,58 +9,48 @@
 #include "safe-memset.h"
 #include "str.h"
 #include "auth-connection.h"
+#include "../auth/auth-mech-desc.h"
 #include "client.h"
 #include "client-authenticate.h"
 #include "master.h"
 
-struct auth_method_desc {
-	int method;
-	const char *name;
-	int plaintext;
-};
-
-static enum auth_method auth_methods = 0;
-static char *auth_methods_capability = NULL;
-
-static struct auth_method_desc auth_method_desc[AUTH_METHODS_COUNT] = {
-	{ AUTH_METHOD_PLAIN,		NULL,		TRUE },
-	{ AUTH_METHOD_DIGEST_MD5,	"DIGEST-MD5",	FALSE }
-};
+static enum auth_mech auth_mechs = 0;
+static char *auth_mechs_capability = NULL;
 
 const char *client_authenticate_get_capabilities(void)
 {
 	string_t *str;
 	int i;
 
-	if (auth_methods == available_auth_methods)
-		return auth_methods_capability;
+	if (auth_mechs == available_auth_mechs)
+		return auth_mechs_capability;
 
-	auth_methods = available_auth_methods;
-	i_free(auth_methods_capability);
+	auth_mechs = available_auth_mechs;
+	i_free(auth_mechs_capability);
 
 	str = t_str_new(128);
 
-	for (i = 0; i < AUTH_METHODS_COUNT; i++) {
-		if ((auth_methods & auth_method_desc[i].method) &&
-		    auth_method_desc[i].name != NULL) {
+	for (i = 0; i < AUTH_MECH_COUNT; i++) {
+		if ((auth_mechs & auth_mech_desc[i].mech) &&
+		    auth_mech_desc[i].name != NULL) {
 			str_append_c(str, ' ');
 			str_append(str, "AUTH=");
-			str_append(str, auth_method_desc[i].name);
+			str_append(str, auth_mech_desc[i].name);
 		}
 	}
 
-	auth_methods_capability = i_strdup_empty(str_c(str));
-	return auth_methods_capability;
+	auth_mechs_capability = i_strdup_empty(str_c(str));
+	return auth_mechs_capability;
 }
 
-static struct auth_method_desc *auth_method_find(const char *name)
+static struct auth_mech_desc *auth_mech_find(const char *name)
 {
 	int i;
 
-	for (i = 0; i < AUTH_METHODS_COUNT; i++) {
-		if (auth_method_desc[i].name != NULL &&
-		    strcasecmp(auth_method_desc[i].name, name) == 0)
-			return &auth_method_desc[i];
+	for (i = 0; i < AUTH_MECH_COUNT; i++) {
+		if (auth_mech_desc[i].name != NULL &&
+		    strcasecmp(auth_mech_desc[i].name, name) == 0)
+			return &auth_mech_desc[i];
 	}
 
 	return NULL;
@@ -202,8 +192,8 @@
 	buffer_append(client->plain_login, pass, strlen(pass));
 
 	client_ref(client);
-	if (auth_init_request(AUTH_METHOD_PLAIN,
-			      login_callback, client, &error)) {
+	if (auth_init_request(AUTH_MECH_PLAIN, login_callback,
+			      client, &error)) {
 		/* don't read any input from client until login is finished */
 		if (client->io != NULL) {
 			io_remove(client->io);
@@ -273,29 +263,29 @@
 	safe_memset(buffer_free_without_data(buf), 0, bufsize);
 }
 
-int cmd_authenticate(struct client *client, const char *method_name)
+int cmd_authenticate(struct client *client, const char *mech_name)
 {
-	struct auth_method_desc *method;
+	struct auth_mech_desc *mech;
 	const char *error;
 
-	if (*method_name == '\0')
+	if (*mech_name == '\0')
 		return FALSE;
 
-	method = auth_method_find(method_name);
-	if (method == NULL) {
+	mech = auth_mech_find(mech_name);
+	if (mech == NULL) {
 		client_send_tagline(client,
-				    "NO Unsupported authentication method.");
+				    "NO Unsupported authentication mechanism.");
 		return TRUE;
 	}
 
-	if (!client->tls && method->plaintext && disable_plaintext_auth) {
+	if (!client->tls && mech->plaintext && disable_plaintext_auth) {
 		client_send_tagline(client,
 				    "NO Plaintext authentication disabled.");
 		return TRUE;
 	}
 
 	client_ref(client);
-	if (auth_init_request(method->method, authenticate_callback,
+	if (auth_init_request(mech->mech, authenticate_callback,
 			      client, &error)) {
 		/* following input data will go to authentication */
 		if (client->io != NULL)