X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=src%2Fmain.c;h=e328ef8215ffbb1f6ce23e44f15e58a841601634;hb=3d7896a03cf97e96e2bc92b29aaf8c3b87384a1f;hp=a0d6dccaf8e9971393f211c0dcc38242547aa5d3;hpb=6c3403d470cd185d209de32d14f5272e87b4ca38;p=routeros-api.git

diff --git a/src/main.c b/src/main.c
index a0d6dcc..e328ef8 100644
--- a/src/main.c
+++ b/src/main.c
@@ -1,5 +1,5 @@
 /**
- * libmikrotik - src/main.c
+ * librouteros - src/main.c
  * Copyright (C) 2009  Florian octo Forster
  *
  * This program is free software; you can redistribute it and/or modify it
@@ -27,6 +27,8 @@
 # define _POSIX_C_SOURCE 200112L
 #endif
 
+#include "config.h"
+
 #include <stdlib.h>
 #include <stdio.h>
 #include <unistd.h>
@@ -40,12 +42,18 @@
 #include <sys/socket.h>
 #include <netdb.h>
 
+#include <gcrypt.h>
+
 #include "routeros_api.h"
 
-#if 1
-# define mt_debug(...) fprintf (stdout, __VA_ARGS__)
+#if WITH_DEBUG
+# define ros_debug(...) fprintf (stdout, __VA_ARGS__)
 #else
-# define mt_debug(...) /**/
+# define ros_debug(...) /**/
+#endif
+
+#if !__GNUC__
+# define __attribute__(x) /**/
 #endif
 
 /* FIXME */
@@ -54,21 +62,28 @@ char *strdup (const char *);
 /*
  * Private structures
  */
-struct mt_connection_s
+struct ros_connection_s
 {
 	int fd;
 };
 
-struct mt_reply_s
+struct ros_reply_s
 {
 	unsigned int params_num;
 	char *status;
 	char **keys;
 	char **values;
 
-	mt_reply_t *next;
+	ros_reply_t *next;
 };
 
+struct ros_login_data_s
+{
+	const char *username;
+	const char *password;
+};
+typedef struct ros_login_data_s ros_login_data_t;
+
 /*
  * Private functions
  */
@@ -101,7 +116,7 @@ static int read_exact (int fd, void *buffer, size_t buffer_size) /* {{{ */
 				return (status);
 		}
 
-		assert (status <= want_bytes);
+		assert (((size_t) status) <= want_bytes);
 		have_bytes += status;
 		buffer_ptr += status;
 	}
@@ -109,9 +124,9 @@ static int read_exact (int fd, void *buffer, size_t buffer_size) /* {{{ */
 	return (0);
 } /* }}} int read_exact */
 
-static mt_reply_t *reply_alloc (void) /* {{{ */
+static ros_reply_t *reply_alloc (void) /* {{{ */
 {
-	mt_reply_t *r;
+	ros_reply_t *r;
 
 	r = malloc (sizeof (*r));
 	if (r == NULL)
@@ -123,9 +138,9 @@ static mt_reply_t *reply_alloc (void) /* {{{ */
 	r->next = NULL;
 
 	return (r);
-} /* }}} mt_reply_s *reply_alloc */
+} /* }}} ros_reply_s *reply_alloc */
 
-static int reply_add_keyval (mt_reply_t *r, const char *key, /* {{{ */
+static int reply_add_keyval (ros_reply_t *r, const char *key, /* {{{ */
 		const char *val)
 {
 	char **tmp;
@@ -156,9 +171,37 @@ static int reply_add_keyval (mt_reply_t *r, const char *key, /* {{{ */
 	return (0);
 } /* }}} int reply_add_keyval */
 
-static void reply_free (mt_reply_t *r) /* {{{ */
+#if WITH_DEBUG
+static void reply_dump (const ros_reply_t *r) /* {{{ */
+{
+	if (r == NULL)
+		return;
+
+	printf ("=== BEGIN REPLY ===\n"
+			"Address: %p\n"
+			"Status: %s\n",
+			(void *) r, r->status);
+	if (r->params_num > 0)
+	{
+		unsigned int i;
+
+		printf ("Arguments:\n");
+		for (i = 0; i < r->params_num; i++)
+			printf (" %3u: %s = %s\n", i, r->keys[i], r->values[i]);
+	}
+	if (r->next != NULL)
+		printf ("Next: %p\n", (void *) r->next);
+	printf ("=== END REPLY ===\n");
+
+	reply_dump (r->next);
+} /* }}} void reply_dump */
+#else
+# define reply_dump(foo) /**/
+#endif
+
+static void reply_free (ros_reply_t *r) /* {{{ */
 {
-	mt_reply_t *next;
+	ros_reply_t *next;
 	unsigned int i;
 
 	if (r == NULL)
@@ -172,6 +215,7 @@ static void reply_free (mt_reply_t *r) /* {{{ */
 		free (r->values[i]);
 	}
 
+	free (r->status);
 	free (r->keys);
 	free (r->values);
 
@@ -294,7 +338,7 @@ static int buffer_end (char **ret_buffer, size_t *ret_buffer_size) /* {{{ */
 	return (0);
 } /* }}} int buffer_end */
 
-static int send_command (mt_connection_t *c, /* {{{ */
+static int send_command (ros_connection_t *c, /* {{{ */
 		const char *command,
 		size_t args_num, const char * const *args)
 {
@@ -305,6 +349,12 @@ static int send_command (mt_connection_t *c, /* {{{ */
 	size_t i;
 	int status;
 
+	assert (c != NULL);
+	assert (command != NULL);
+
+	if ((args == NULL) && (args_num > 0))
+		return (EINVAL);
+
 	/* FIXME: For debugging only */
 	memset (buffer, 0, sizeof (buffer));
 
@@ -315,6 +365,7 @@ static int send_command (mt_connection_t *c, /* {{{ */
 	if (status != 0)
 		return (status);
 
+	ros_debug ("send_command: command = %s;\n", command);
 	status = buffer_add (&buffer_ptr, &buffer_size, command);
 	if (status != 0)
 		return (status);
@@ -324,6 +375,7 @@ static int send_command (mt_connection_t *c, /* {{{ */
 		if (args[i] == NULL)
 			return (EINVAL);
 
+		ros_debug ("send_command: arg[%zu] = %s;\n", i, args[i]);
 		status = buffer_add (&buffer_ptr, &buffer_size, args[i]);
 		if (status != 0)
 			return (status);
@@ -348,7 +400,7 @@ static int send_command (mt_connection_t *c, /* {{{ */
 			else
 				return (errno);
 		}
-		assert (bytes_written <= buffer_size);
+		assert (((size_t) bytes_written) <= buffer_size);
 
 		buffer_ptr += bytes_written;
 		buffer_size -= bytes_written;
@@ -357,7 +409,7 @@ static int send_command (mt_connection_t *c, /* {{{ */
 	return (0);
 } /* }}} int send_command */
 
-static int read_word (mt_connection_t *c, /* {{{ */
+static int read_word (ros_connection_t *c, /* {{{ */
 		char *buffer, size_t *buffer_size)
 {
 	size_t req_size;
@@ -367,54 +419,56 @@ static int read_word (mt_connection_t *c, /* {{{ */
 	if ((buffer == NULL) || (*buffer_size < 1))
 		return (EINVAL);
 
+	assert (c != NULL);
+
 	/* read one byte from the socket */
 	status = read_exact (c->fd, word_length, 1);
 	if (status != 0)
 		return (status);
 
 	/* Calculate `req_size' */
-	if (((unsigned char) buffer[0]) == 0xF0) /* {{{ */
+	if (((unsigned char) word_length[0]) == 0xF0) /* {{{ */
 	{
 		status = read_exact (c->fd, &word_length[1], 4);
 		if (status != 0)
 			return (status);
 
-		req_size = (buffer[1] << 24)
-			| (buffer[2] << 16)
-			| (buffer[3] << 8)
-			| buffer[4];
+		req_size = (word_length[1] << 24)
+			| (word_length[2] << 16)
+			| (word_length[3] << 8)
+			| word_length[4];
 	}
-	else if ((buffer[0] & 0xE0) == 0xE0)
+	else if ((word_length[0] & 0xE0) == 0xE0)
 	{
 		status = read_exact (c->fd, &word_length[1], 3);
 		if (status != 0)
 			return (status);
 
-		req_size = ((buffer[0] & 0x1F) << 24)
-			| (buffer[1] << 16)
-			| (buffer[2] << 8)
-			| buffer[3];
+		req_size = ((word_length[0] & 0x1F) << 24)
+			| (word_length[1] << 16)
+			| (word_length[2] << 8)
+			| word_length[3];
 	}
-	else if ((buffer[0] & 0xC0) == 0xC0)
+	else if ((word_length[0] & 0xC0) == 0xC0)
 	{
 		status = read_exact (c->fd, &word_length[1], 2);
 		if (status != 0)
 			return (status);
 
-		req_size = ((buffer[0] & 0x3F) << 16)
-			| (buffer[1] << 8)
-			| buffer[2];
+		req_size = ((word_length[0] & 0x3F) << 16)
+			| (word_length[1] << 8)
+			| word_length[2];
 	}
-	else if ((buffer[0] & 0x80) == 0x80)
+	else if ((word_length[0] & 0x80) == 0x80)
 	{
 		status = read_exact (c->fd, &word_length[1], 1);
 		if (status != 0)
 			return (status);
 
-		req_size = ((buffer[0] & 0x7F) << 8)
-			| buffer[1];
+		req_size = ((word_length[0] & 0x7F) << 8)
+			| word_length[1];
 	}
-	else if ((buffer[0] & 0x80) == 0)
+	else if ((word_length[0] & 0x80) == 0)
 	{
 		req_size = (size_t) word_length[0];
 	}
@@ -443,17 +497,17 @@ static int read_word (mt_connection_t *c, /* {{{ */
 	return (0);
 } /* }}} int buffer_decode_next */
 
-static mt_reply_t *receive_reply (mt_connection_t *c) /* {{{ */
+static ros_reply_t *receive_sentence (ros_connection_t *c) /* {{{ */
 {
 	char buffer[4096];
 	size_t buffer_size;
 	int status;
 
-	mt_reply_t *head;
-	mt_reply_t *tail;
+	ros_reply_t *r;
 
-	head = NULL;
-	tail = NULL;
+	r = reply_alloc ();
+	if (r == NULL)
+		return (NULL);
 
 	while (42)
 	{
@@ -470,33 +524,11 @@ static mt_reply_t *receive_reply (mt_connection_t *c) /* {{{ */
 
 		if (buffer[0] == '!') /* {{{ */
 		{
-			mt_reply_t *tmp;
-
-			tmp = reply_alloc ();
-			if (tmp == NULL)
-			{
-				status = ENOMEM;
-				break;
-			}
-
-			tmp->status = strdup (&buffer[1]);
-			if (tmp->status == NULL)
-			{
-				reply_free (tmp);
-				status = ENOMEM;
+			if (r->status != NULL)
+				free (r->status);
+			r->status = strdup (&buffer[1]);
+			if (r->status == NULL)
 				break;
-			}
-
-			if (tail == NULL)
-			{
-				head = tmp;
-				tail = tmp;
-			}
-			else
-			{
-				tail->next = tmp;
-				tail = tmp;
-			}
 		} /* }}} if (buffer[0] == '!') */
 		else if (buffer[0] == '=') /* {{{ */
 		{
@@ -513,22 +545,59 @@ static mt_reply_t *receive_reply (mt_connection_t *c) /* {{{ */
 			*val = 0;
 			val++;
 
-			reply_add_keyval (tail, key, val);
+			reply_add_keyval (r, key, val);
 		} /* }}} if (buffer[0] == '=') */
 		else
 		{
-			printf ("Ignoring unknown word: %s\n", buffer);
+			ros_debug ("receive_sentence: Ignoring unknown word: %s\n", buffer);
 		}
 	} /* while (42) */
 	
-	if (status != 0)
+	if (r->status == NULL)
 	{
-		reply_free (head);
+		reply_free (r);
 		return (NULL);
 	}
 
+	return (r);
+} /* }}} ros_reply_t *receive_sentence */
+
+static ros_reply_t *receive_reply (ros_connection_t *c) /* {{{ */
+{
+	ros_reply_t *head;
+	ros_reply_t *tail;
+
+	if (c == NULL)
+		return (NULL);
+
+	head = NULL;
+	tail = NULL;
+
+	while (42)
+	{
+		ros_reply_t *tmp;
+
+		tmp = receive_sentence (c);
+		if (tmp == NULL)
+			break;
+
+		if (tail == NULL)
+		{
+			head = tmp;
+			tail = tmp;
+		}
+		else
+		{
+			tail->next = tmp;
+			tail = tmp;
+		}
+
+		if (strcmp ("done", tmp->status) == 0)
+			break;
+	} /* while (42) */
+	
 	return (head);
-} /* }}} mt_reply_t *receive_reply */
+} /* }}} ros_reply_t *receive_reply */
 
 static int create_socket (const char *node, const char *service) /* {{{ */
 {
@@ -537,7 +606,7 @@ static int create_socket (const char *node, const char *service) /* {{{ */
 	struct addrinfo *ai_ptr;
 	int status;
 
-	mt_debug ("create_socket (node = %s, service = %s);\n",
+	ros_debug ("create_socket (node = %s, service = %s);\n",
 			node, service);
 
 	memset (&ai_hint, 0, sizeof (ai_hint));
@@ -562,34 +631,175 @@ static int create_socket (const char *node, const char *service) /* {{{ */
 				ai_ptr->ai_protocol);
 		if (fd < 0)
 		{
-			mt_debug ("create_socket: socket(2) failed.\n");
+			ros_debug ("create_socket: socket(2) failed.\n");
 			continue;
 		}
 
 		status = connect (fd, ai_ptr->ai_addr, ai_ptr->ai_addrlen);
 		if (status != 0)
 		{
-			mt_debug ("create_socket: connect(2) failed.\n");
+			ros_debug ("create_socket: connect(2) failed.\n");
 			close (fd);
 			continue;
 		}
 
+		freeaddrinfo (ai_list);
 		return (fd);
 	}
 
 	freeaddrinfo (ai_list);
-
 	return (-1);
 } /* }}} int create_socket */
 
+static int login2_handler (__attribute__((unused)) ros_connection_t *c, /* {{{ */
+		const ros_reply_t *r,
+		__attribute__((unused)) void *user_data)
+{
+	if (r == NULL)
+		return (EINVAL);
+
+	reply_dump (r);
+
+	if (strcmp (r->status, "trap") == 0)
+	{
+		ros_debug ("login2_handler: Logging in failed: %s.\n",
+				ros_reply_param_val_by_key (r, "message"));
+		return (EACCES);
+	}
+	else if (strcmp (r->status, "done") != 0)
+	{
+		ros_debug ("login2_handler: Unexpected status: %s.\n", r->status);
+		return (EPROTO);
+	}
+
+	return (0);
+} /* }}} int login2_handler */
+
+static void hash_binary_to_hex (char hex[33], uint8_t binary[16]) /* {{{ */
+{
+	int i;
+
+	for (i = 0; i < 16; i++)
+	{
+		char tmp[3];
+		snprintf (tmp, 3, "%02"PRIx8, binary[i]);
+		tmp[2] = 0;
+		hex[2*i] = tmp[0];
+		hex[2*i+1] = tmp[1];
+	}
+	hex[32] = 0;
+} /* }}} void hash_binary_to_hex */
+
+static void hash_hex_to_binary (uint8_t binary[16], char hex[33]) /* {{{ */
+{
+	int i;
+
+	for (i = 0; i < 16; i++)
+	{
+		char tmp[3];
+
+		tmp[0] = hex[2*i];
+		tmp[1] = hex[2*i + 1];
+		tmp[2] = 0;
+
+		binary[i] = (uint8_t) strtoul (tmp, /* endptr = */ NULL, /* base = */ 16);
+	}
+} /* }}} void hash_hex_to_binary */
+
+static void make_password_hash (char response_hex[33], /* {{{ */
+		const char *password, size_t password_length, char challenge_hex[33])
+{
+	uint8_t challenge_bin[16];
+	uint8_t response_bin[16];
+	char data_buffer[password_length+17];
+	gcry_md_hd_t md_handle;
+
+	hash_hex_to_binary (challenge_bin, challenge_hex);
+
+	data_buffer[0] = 0;
+	memcpy (&data_buffer[1], password, password_length);
+	memcpy (&data_buffer[1+password_length], challenge_bin, 16);
+
+	gcry_md_open (&md_handle, GCRY_MD_MD5, /* flags = */ 0);
+	gcry_md_write (md_handle, data_buffer, sizeof (data_buffer));
+	memcpy (response_bin, gcry_md_read (md_handle, GCRY_MD_MD5), 16);
+	gcry_md_close (md_handle);
+
+	hash_binary_to_hex (response_hex, response_bin);
+} /* }}} void make_password_hash */
+
+static int login_handler (ros_connection_t *c, const ros_reply_t *r, /* {{{ */
+		void *user_data)
+{
+	const char *ret;
+	char challenge_hex[33];
+	char response_hex[33];
+	ros_login_data_t *login_data;
+
+	const char *params[2];
+	char param_name[1024];
+	char param_response[64];
+
+	if (r == NULL)
+		return (EINVAL);
+
+	/* The expected result looks like this:
+	 * -- 8< --
+	 *  !done 
+	 *  =ret=ebddd18303a54111e2dea05a92ab46b4
+	 * -- >8 --
+	 */
+	reply_dump (r);
+
+	if (strcmp (r->status, "done") != 0)
+	{
+		ros_debug ("login_handler: Unexpected status: %s.\n", r->status);
+		return (EPROTO);
+	}
+
+	login_data = user_data;
+	if (login_data == NULL)
+		return (EINVAL);
+
+	ret = ros_reply_param_val_by_key (r, "ret");
+	if (ret == NULL)
+	{
+		ros_debug ("login_handler: Reply does not have parameter \"ret\".\n");
+		return (EPROTO);
+	}
+	ros_debug ("login_handler: ret = %s;\n", ret);
+
+	if (strlen (ret) != 32)
+	{
+		ros_debug ("login_handler: Unexpected length of the \"ret\" argument.\n");
+		return (EPROTO);
+	}
+	strcpy (challenge_hex, ret);
+
+	make_password_hash (response_hex, 
+			login_data->password, strlen (login_data->password),
+			challenge_hex);
+
+	snprintf (param_name, sizeof (param_name), "=name=%s", login_data->username);
+	snprintf (param_response, sizeof (param_response),
+			"=response=00%s", response_hex);
+	params[0] = param_name;
+	params[1] = param_response;
+
+	return (ros_query (c, "/login", 2, params, login2_handler,
+				/* user data = */ NULL));
+} /* }}} int login_handler */
+
 /*
  * Public functions
  */
-mt_connection_t *mt_connect (const char *node, const char *service, /* {{{ */
+ros_connection_t *ros_connect (const char *node, const char *service, /* {{{ */
 		const char *username, const char *password)
 {
 	int fd;
-	mt_connection_t *c;
+	ros_connection_t *c;
+	int status;
+	ros_login_data_t user_data;
 
 	if ((node == NULL) || (username == NULL) || (password == NULL))
 		return (NULL);
@@ -608,10 +818,22 @@ mt_connection_t *mt_connect (const char *node, const char *service, /* {{{ */
 
 	c->fd = fd;
 
+	user_data.username = username;
+	user_data.password = password;
+	status = ros_query (c, "/login", /* args num = */ 0, /* args = */ NULL,
+			login_handler, &user_data);
+
+	if (status != 0)
+	{
+		ros_disconnect (c);
+		errno = status;
+		return (NULL);
+	}
+
 	return (c);
-} /* }}} mt_connection_t *mt_connect */
+} /* }}} ros_connection_t *ros_connect */
 
-int mt_disconnect (mt_connection_t *c) /* {{{ */
+int ros_disconnect (ros_connection_t *c) /* {{{ */
 {
 	if (c == NULL)
 		return (EINVAL);
@@ -625,15 +847,18 @@ int mt_disconnect (mt_connection_t *c) /* {{{ */
 	free (c);
 
 	return (0);
-} /* }}} int mt_disconnect */
+} /* }}} int ros_disconnect */
 
-int mt_query (mt_connection_t *c, /* {{{ */
+int ros_query (ros_connection_t *c, /* {{{ */
 		const char *command,
 		size_t args_num, const char * const *args,
-		mt_reply_handler_t handler, void *user_data)
+		ros_reply_handler_t handler, void *user_data)
 {
 	int status;
-	mt_reply_t *r;
+	ros_reply_t *r;
+
+	if ((c == NULL) || (command == NULL) || (handler == NULL))
+		return (EINVAL);
 
 	status = send_command (c, command, args_num, args);
 	if (status != 0)
@@ -651,36 +876,36 @@ int mt_query (mt_connection_t *c, /* {{{ */
 
 	/* ... and return. */
 	return (status);
-} /* }}} int mt_query */
+} /* }}} int ros_query */
 
-const mt_reply_t *mt_reply_next (const mt_reply_t *r) /* {{{ */
+const ros_reply_t *ros_reply_next (const ros_reply_t *r) /* {{{ */
 {
 	if (r == NULL)
 		return (NULL);
 
 	return (r->next);
-} /* }}} mt_reply_t *mt_reply_next */
+} /* }}} ros_reply_t *ros_reply_next */
 
-int mt_reply_num (const mt_reply_t *r) /* {{{ */
+int ros_reply_num (const ros_reply_t *r) /* {{{ */
 {
 	int ret;
-	const mt_reply_t *ptr;
+	const ros_reply_t *ptr;
 
 	ret = 0;
 	for (ptr = r; ptr != NULL; ptr = ptr->next)
 		ret++;
 
 	return (ret);
-} /* }}} int mt_reply_num */
+} /* }}} int ros_reply_num */
 
-const char *mt_reply_status (const mt_reply_t *r) /* {{{ */
+const char *ros_reply_status (const ros_reply_t *r) /* {{{ */
 {
 	if (r == NULL)
 		return (NULL);
 	return (r->status);
-} /* }}} char *mt_reply_status */
+} /* }}} char *ros_reply_status */
 
-const char *mt_reply_param_key_by_index (const mt_reply_t *r, /* {{{ */
+const char *ros_reply_param_key_by_index (const ros_reply_t *r, /* {{{ */
 		unsigned int index)
 {
 	if (r == NULL)
@@ -690,9 +915,9 @@ const char *mt_reply_param_key_by_index (const mt_reply_t *r, /* {{{ */
 		return (NULL);
 
 	return (r->keys[index]);
-} /* }}} char *mt_reply_param_key_by_index */
+} /* }}} char *ros_reply_param_key_by_index */
 
-const char *mt_reply_param_val_by_index (const mt_reply_t *r, /* {{{ */
+const char *ros_reply_param_val_by_index (const ros_reply_t *r, /* {{{ */
 		unsigned int index)
 {
 	if (r == NULL)
@@ -702,9 +927,9 @@ const char *mt_reply_param_val_by_index (const mt_reply_t *r, /* {{{ */
 		return (NULL);
 
 	return (r->values[index]);
-} /* }}} char *mt_reply_param_key_by_index */
+} /* }}} char *ros_reply_param_key_by_index */
 
-const char *mt_reply_param_val_by_key (const mt_reply_t *r, /* {{{ */
+const char *ros_reply_param_val_by_key (const ros_reply_t *r, /* {{{ */
 		const char *key)
 {
 	unsigned int i;
@@ -717,6 +942,16 @@ const char *mt_reply_param_val_by_key (const mt_reply_t *r, /* {{{ */
 			return (r->values[i]);
 
 	return (NULL);
-} /* }}} char *mt_reply_param_val_by_key */
+} /* }}} char *ros_reply_param_val_by_key */
+
+int ros_version (void) /* {{{ */
+{
+	return (ROS_VERSION);
+} /* }}} int ros_version */
+
+const char *ros_version_string (void) /* {{{ */
+{
+	return (ROS_VERSION_STRING);
+} /* }}} char *ros_version_string */
 
 /* vim: set ts=2 sw=2 noet fdm=marker : */