address parsing

git-svn-id: https://gnunet.org/svn/gnunet@25826 140774ce-b5e7-0310-ab8b-a85725594a96

3 files changed, 458 insertions, 48 deletions

diff --git a/src/transport/plugin_transport_http_common.c b/src/transport/plugin_transport_http_common.c
index 0c9bfffc8e..5c6d197919 100644
--- a/src/transport/plugin_transport_http_common.c
+++ b/src/transport/plugin_transport_http_common.c
@@ -27,13 +27,14 @@
 #include "platform.h"
 #include "gnunet_common.h"
 #include "gnunet_transport_plugin.h"
+#include "plugin_transport_http_common.h"
 
 struct SplittedHTTPAddress
 {
-	char *protocoll;
+	char *protocol;
 	char *host;
-	char *port;
 	char *path;
+	int port;
 };
 
 struct SplittedHTTPAddress *
@@ -41,14 +42,17 @@ http_split_address (const char * addr)
 {
 	struct SplittedHTTPAddress  *sp;
 	char *src = GNUNET_strdup (addr);
-	char *protocoll_start = NULL;
+	char *protocol_start = NULL;
 	char *host_start = NULL;
+	char *v6_end = NULL;
 	char *port_start = NULL;
 	char *path_start = NULL;
 
-	protocoll_start = src;
+	protocol_start = src;
 	sp = GNUNET_malloc (sizeof (struct SplittedHTTPAddress));
 
+	/* Address string consists of protocol://host[:port]path*/
+
 	host_start = strstr (src, "://");
 	if (NULL == host_start)
 	{
@@ -58,47 +62,94 @@ http_split_address (const char * addr)
 	}
 
 	host_start[0] = '\0';
-	sp->protocoll = GNUNET_strdup (protocoll_start);
+	sp->protocol = GNUNET_strdup (protocol_start);
 
 	host_start += strlen ("://");
 	if (strlen (host_start) == 0)
-	if (NULL == host_start)
 	{
 			GNUNET_free (src);
+			GNUNET_free (sp->protocol);
 			GNUNET_free (sp);
 			return NULL;
 	}
-	port_start = strstr (host_start, ":");
-	if (NULL == port_start)
+
+	/* Find path start */
+	path_start = strchr (host_start, '/');
+	if (NULL != path_start)
 	{
-		path_start = strstr (host_start, "/");
+			sp->path = GNUNET_strdup (path_start);
+			path_start[0] = '\0';
 	}
 	else
+		sp->path = GNUNET_strdup ("");
+
+	if (strlen(host_start) < 1)
 	{
-		port_start[0] = '\0';
-		port_start ++;
-		sp->host = GNUNET_strdup (host_start);
-		path_start = strstr (port_start, "/");
+			GNUNET_free (src);
+			GNUNET_free (sp->protocol);
+			GNUNET_free (sp->path);
+			GNUNET_free (sp);
+			return NULL;
 	}
 
-	if (NULL == path_start)
-  {
-			if (NULL != port_start)
-				sp->port = GNUNET_strdup (port_start);
-			sp->path = NULL;
-  }
-	else
+	if (NULL != (port_start = strrchr (host_start, ':')))
 	{
-			if (NULL != port_start)
+			/* *We COULD have a port, but also an IPv6 address! */
+			if (NULL != (v6_end = strchr(host_start, ']')))
+			{
+					if  (v6_end < port_start)
+					{
+							/* IPv6 address + port */
+							port_start[0] = '\0';
+							port_start ++;
+							sp->port = atoi (port_start);
+					}
+					else
+					{
+							/* IPv6 address + no port */
+							if (0 == strcmp(sp->protocol, "https"))
+								sp->port = HTTPS_DEFAULT_PORT;
+							else if (0 == strcmp(sp->protocol, "http"))
+								sp->port = HTTP_DEFAULT_PORT;
+					}
+			}
+			else
 			{
-					path_start[0] = '\0';
-					sp->port = GNUNET_strdup (port_start);
-					path_start[0] = '/';
+					/* No IPv6 address */
+					port_start[0] = '\0';
+					port_start ++;
+					sp->port = atoi (port_start);
 			}
-			sp->path = GNUNET_strdup(path_start);
 	}
-	GNUNET_free (src);
-	fprintf (stderr, "protocoll: `%s', host `%s' port `%s' path `%s'\n", sp->protocoll, sp->host, sp->port, sp->path);
+	else
+	{
+		/* No ':' as port separator, default port for protocol */
+		if (0 == strcmp(sp->protocol, "https"))
+			sp->port = HTTPS_DEFAULT_PORT;
+		else if (0 == strcmp(sp->protocol, "http"))
+			sp->port = HTTP_DEFAULT_PORT;
+		else
+		{
+				GNUNET_break (0);
+				GNUNET_free (src);
+				GNUNET_free (sp->protocol);
+				GNUNET_free (sp->path);
+				GNUNET_free (sp);
+				return NULL;
+		}
+	}
+	if (strlen (host_start) > 0)
+			sp->host = GNUNET_strdup (host_start);
+	else
+	{
+			GNUNET_break (0);
+			GNUNET_free (src);
+			GNUNET_free (sp->protocol);
+			GNUNET_free (sp->path);
+			GNUNET_free (sp);
+			return NULL;
+	}
+	//fprintf (stderr, "addr: `%s' protocol: `%s', host `%s' port `%u' path `%s'\n", addr, sp->protocol, sp->host, sp->port, sp->path);
 	return sp;
 }
 
@@ -133,7 +184,6 @@ http_common_plugin_address_pretty_printer (void *cls, const char *type,
       asc (asc_cls, NULL);
       return;
   }
-  http_split_address (addr);
   asc (asc_cls, saddr);
   asc (asc_cls, NULL);
 }
@@ -314,7 +364,7 @@ http_common_address_get_size (const void *addr)
  * @param addrlen2 address 2 length
  * @return GNUNET_YES if equal, GNUNET_NO if not, GNUNET_SYSERR on error
  */
-int
+size_t
 http_common_cmp_addresses (const void *addr1, size_t addrlen1, const void *addr2, size_t addrlen2)
 {
   const char *a1 = (const char *) addr1;
diff --git a/src/transport/plugin_transport_http_common.h b/src/transport/plugin_transport_http_common.h
index 0cc6de5eec..31676c2848 100644
--- a/src/transport/plugin_transport_http_common.h
+++ b/src/transport/plugin_transport_http_common.h
@@ -50,6 +50,10 @@
 
 #endif
 
+#define HTTP_DEFAULT_PORT 80
+#define HTTPS_DEFAULT_PORT 443
+
+
 struct SplittedHTTPAddress;
 
 struct SplittedHTTPAddress *
@@ -147,7 +151,7 @@ http_common_socket_from_address (const void *addr, size_t addrlen, int *res);
  * @return the size
  */
 size_t
-http_common_address_get_size (void *addr);
+http_common_address_get_size (const void *addr);
 
 
 /**
diff --git a/src/transport/test_http_common.c b/src/transport/test_http_common.c
index 60aa3bfd3f..05c4adb647 100644
--- a/src/transport/test_http_common.c
+++ b/src/transport/test_http_common.c
@@ -18,13 +18,8 @@
      Boston, MA 02111-1307, USA.
 */
 /**
- * @file transport/test_transport_api.c
- * @brief base test case for transport implementations
- *
- * This test case serves as a base for tcp, udp, and udp-nat
- * transport test cases.  Based on the executable being run
- * the correct test case will be performed.  Conservation of
- * C code apparently.
+ * @file transport/test_http_common.c
+ * @brief base test case for common http functionality
  */
 #include "platform.h"
 #include "gnunet_transport_service.h"
@@ -33,10 +28,10 @@
 
 struct SplittedHTTPAddress
 {
-	char *protocoll;
+	char *protocol;
 	char *host;
-	char *port;
 	char *path;
+	int port;
 };
 
 void
@@ -46,25 +41,386 @@ clean (struct SplittedHTTPAddress *addr)
 	{
 		GNUNET_free_non_null (addr->host);
 		GNUNET_free_non_null (addr->path);
-		GNUNET_free_non_null (addr->port);
-		GNUNET_free_non_null (addr->protocoll);
+		GNUNET_free_non_null (addr->protocol);
 		GNUNET_free_non_null (addr);
 	}
 }
 
+
+int
+check (struct SplittedHTTPAddress *addr,
+			 char * protocol,
+			 char * host,
+			 int port,
+			 char * path)
+{
+
+	if (NULL == addr)
+		return GNUNET_NO;
+	if (((NULL == addr->protocol) && (NULL != protocol)) ||
+			((NULL != addr->protocol) && (NULL == protocol)))
+	{
+		GNUNET_break (0);
+		return GNUNET_NO;
+	}
+	else if ((NULL != addr->protocol) && (NULL != protocol))
+	{
+		if (0 != strcmp(addr->protocol, protocol))
+		{
+			GNUNET_break (0);
+			return GNUNET_NO;
+		}
+	}
+
+	if (((NULL == addr->host) && (NULL != host)) ||
+			((NULL != addr->host) && (NULL == host)))
+	{
+		GNUNET_break (0);
+		return GNUNET_NO;
+	}
+	else if ((NULL != addr->host) && (NULL != host))
+	{
+		if (0 != strcmp(addr->host, host))
+		{
+			GNUNET_break (0);
+			return GNUNET_NO;
+		}
+	}
+
+
+	if (((NULL == addr->path) && (NULL != path)) ||
+			((NULL != addr->path) && (NULL == path)))
+	{
+		GNUNET_break (0);
+		return GNUNET_NO;
+	}
+	else if ((NULL != addr->path) && (NULL != path))
+	{
+		if (0 != strcmp(addr->path, path))
+		{
+			GNUNET_break (0);
+			return GNUNET_NO;
+		}
+	}
+
+	if ((addr->port != port))
+	{
+		GNUNET_break (0);
+		return GNUNET_NO;
+	}
+
+	return GNUNET_OK;
+}
+
+void
+test_hostname ()
+{
+  struct SplittedHTTPAddress * spa;
+  spa = http_split_address ("http://test.local");
+  if (NULL == spa)
+  {
+  	GNUNET_break (0);
+  }
+  else
+  {
+  		if (GNUNET_OK != check(spa, "http", "test.local", HTTP_DEFAULT_PORT, ""))
+  		{
+  				GNUNET_break (0);
+  		}
+  		clean (spa);
+  }
+
+  spa = http_split_address ("http://test.local");
+  if (NULL == spa)
+  {
+  	GNUNET_break (0);
+  }
+  else
+  {
+  		if (GNUNET_OK != check(spa, "http", "test.local", HTTP_DEFAULT_PORT, ""))
+  		{
+  				GNUNET_break (0);
+  		}
+  		clean (spa);
+  }
+
+
+  spa = http_split_address ("http://test.local/");
+  if (NULL == spa)
+  {
+  	GNUNET_break (0);
+  }
+  else
+  {
+  		if (GNUNET_OK != check(spa, "http", "test.local", HTTP_DEFAULT_PORT, "/"))
+  		{
+  				GNUNET_break (0);
+  		}
+  		clean (spa);
+  }
+
+  spa = http_split_address ("http://test.local/path");
+  if (NULL == spa)
+  {
+  	GNUNET_break (0);
+  }
+  else
+  {
+  		if (GNUNET_OK != check(spa, "http", "test.local", HTTP_DEFAULT_PORT, "/path"))
+  		{
+  				GNUNET_break (0);
+  		}
+  		clean (spa);
+  }
+
+  spa = http_split_address ("http://test.local/path/");
+  if (NULL == spa)
+  {
+  	GNUNET_break (0);
+  }
+  else
+  {
+  		if (GNUNET_OK != check(spa, "http", "test.local", HTTP_DEFAULT_PORT, "/path/"))
+  		{
+  				GNUNET_break (0);
+  		}
+  		clean (spa);
+
+
+  }
+
+  spa = http_split_address ("http://test.local:1000/path/");
+  if (NULL == spa)
+  {
+  	GNUNET_break (0);
+  }
+  else
+  {
+  		if (GNUNET_OK != check(spa, "http", "test.local", 1000, "/path/"))
+  		{
+  				GNUNET_break (0);
+  		}
+  		clean (spa);
+  }
+}
+
+void
+test_ipv4 ()
+{
+  struct SplittedHTTPAddress * spa;
+  spa = http_split_address ("http://127.0.0.1");
+  if (NULL == spa)
+  {
+  	GNUNET_break (0);
+  }
+  else
+  {
+  		if (GNUNET_OK != check(spa, "http", "127.0.0.1", HTTP_DEFAULT_PORT, ""))
+  		{
+  				GNUNET_break (0);
+  		}
+  		clean (spa);
+  }
+
+  spa = http_split_address ("http://127.0.0.1");
+  if (NULL == spa)
+  {
+  	GNUNET_break (0);
+  }
+  else
+  {
+  		if (GNUNET_OK != check(spa, "http", "127.0.0.1", HTTP_DEFAULT_PORT, ""))
+  		{
+  				GNUNET_break (0);
+  		}
+  		clean (spa);
+  }
+
+
+  spa = http_split_address ("http://127.0.0.1/");
+  if (NULL == spa)
+  {
+  	GNUNET_break (0);
+  }
+  else
+  {
+  		if (GNUNET_OK != check(spa, "http", "127.0.0.1", HTTP_DEFAULT_PORT, "/"))
+  		{
+  				GNUNET_break (0);
+  		}
+  		clean (spa);
+  }
+
+  spa = http_split_address ("http://127.0.0.1/path");
+  if (NULL == spa)
+  {
+  	GNUNET_break (0);
+  }
+  else
+  {
+  		if (GNUNET_OK != check(spa, "http", "127.0.0.1", HTTP_DEFAULT_PORT, "/path"))
+  		{
+  				GNUNET_break (0);
+  		}
+  		clean (spa);
+  }
+
+  spa = http_split_address ("http://127.0.0.1/path/");
+  if (NULL == spa)
+  {
+  	GNUNET_break (0);
+  }
+  else
+  {
+  		if (GNUNET_OK != check(spa, "http", "127.0.0.1", HTTP_DEFAULT_PORT, "/path/"))
+  		{
+  				GNUNET_break (0);
+  		}
+  		clean (spa);
+
+
+  }
+
+  spa = http_split_address ("http://127.0.0.1:1000/path/");
+  if (NULL == spa)
+  {
+  	GNUNET_break (0);
+  }
+  else
+  {
+  		if (GNUNET_OK != check(spa, "http", "127.0.0.1", 1000, "/path/"))
+  		{
+  				GNUNET_break (0);
+  		}
+  		clean (spa);
+  }
+}
+
+void
+test_ipv6 ()
+{
+  struct SplittedHTTPAddress * spa;
+  spa = http_split_address ("http://[::1]");
+  if (NULL == spa)
+  {
+  	GNUNET_break (0);
+  }
+  else
+  {
+  		if (GNUNET_OK != check(spa, "http", "[::1]", HTTP_DEFAULT_PORT, ""))
+  		{
+  				GNUNET_break (0);
+  		}
+  		clean (spa);
+  }
+
+  spa = http_split_address ("http://[::1]");
+  if (NULL == spa)
+  {
+  	GNUNET_break (0);
+  }
+  else
+  {
+  		if (GNUNET_OK != check(spa, "http", "[::1]", HTTP_DEFAULT_PORT, ""))
+  		{
+  				GNUNET_break (0);
+  		}
+  		clean (spa);
+  }
+
+
+  spa = http_split_address ("http://[::1]/");
+  if (NULL == spa)
+  {
+  	GNUNET_break (0);
+  }
+  else
+  {
+  		if (GNUNET_OK != check(spa, "http", "[::1]", HTTP_DEFAULT_PORT, "/"))
+  		{
+  				GNUNET_break (0);
+  		}
+  		clean (spa);
+  }
+
+  spa = http_split_address ("http://[::1]/path");
+  if (NULL == spa)
+  {
+  	GNUNET_break (0);
+  }
+  else
+  {
+  		if (GNUNET_OK != check(spa, "http", "[::1]", HTTP_DEFAULT_PORT, "/path"))
+  		{
+  				GNUNET_break (0);
+  		}
+  		clean (spa);
+  }
+
+  spa = http_split_address ("http://[::1]/path/");
+  if (NULL == spa)
+  {
+  	GNUNET_break (0);
+  }
+  else
+  {
+  		if (GNUNET_OK != check(spa, "http", "[::1]", HTTP_DEFAULT_PORT, "/path/"))
+  		{
+  				GNUNET_break (0);
+  		}
+  		clean (spa);
+
+
+  }
+
+  spa = http_split_address ("http://[::1]:1000/path/");
+  if (NULL == spa)
+  {
+  	GNUNET_break (0);
+  }
+  else
+  {
+  		if (GNUNET_OK != check(spa, "http", "[::1]", 1000, "/path/"))
+  		{
+  				GNUNET_break (0);
+  		}
+  		clean (spa);
+  }
+}
+
 int
 main (int argc, char *argv[])
 {
   int ret = 0;
+  struct SplittedHTTPAddress * spa;
+  GNUNET_log_setup ("test", "DEBUG", NULL);
+
+  spa = http_split_address ("");
+  if (NULL != spa)
+  {
+  	clean (spa);
+  	GNUNET_break (0);
+  }
+
+  http_split_address ("http://");
+  if (NULL != spa)
+  {
+		clean (spa);
+  	GNUNET_break (0);
+  }
+
+  http_split_address ("://");
+  if (NULL != spa)
+  {
+		clean (spa);
+  	GNUNET_break (0);
+  }
 
-  clean(http_split_address (""));
-  clean(http_split_address ("http://"));
-  clean(http_split_address ("http://test/path"));
-  clean(http_split_address ("http://test:8999/path"));
-  clean(http_split_address ("http://1.2.3.4:8999/path"));
-  clean(http_split_address ("http://1.2.3.4:8999"));
+  test_hostname ();
+  test_ipv4 ();
+  test_ipv6 ();
 
   return ret;
 }
 
-/* end of test_transport_api.c */
+/* end of test_http_common.c */