res_http_websocket: Create a websocket client

Added a websocket server client in Asterisk. Asterisk has a websocket server,
but not a client. The ability to have Asterisk be able to connect to a websocket
server can potentially be useful for future work (for instance this could allow
ARI to connect back to some external system, although more work would be needed
in order to incorporate that).

Also a couple of things to note - proxy connection support has not been
implemented and there is limited http response code handling (basically, it is
connect or not).

Also added an initial new URI handling mechanism to core.  Internet type URI's
are parsed into a data structure that contains pointers to the various parts of
the URI.

(closes issue ASTERISK-23742)
Reported by: Kevin Harwell
Review: https://reviewboard.asterisk.org/r/3541/


git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@415223 65c4cc65-6c06-0410-ace0-fbb531ad65f3

1 files changed, 321 insertions, 0 deletions

diff --git a/main/uri.c b/main/uri.c
new file mode 100644
index 000000000..6642d843b
--- /dev/null
+++ b/main/uri.c
@@ -0,0 +1,321 @@
+/*
+ * Asterisk -- An open source telephony toolkit.
+ *
+ * Copyright (C) 2014, Digium, Inc.
+ *
+ * Kevin Harwell <kharwell@digium.com>
+ *
+ * See http://www.asterisk.org for more information about
+ * the Asterisk project. Please do not directly contact
+ * any of the maintainers of this project for assistance;
+ * the project provides a web site, mailing lists and IRC
+ * channels for your use.
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License Version 2. See the LICENSE file
+ * at the top of the source tree.
+ */
+
+#include "asterisk.h"
+
+#include "asterisk/astobj2.h"
+#include "asterisk/strings.h"
+#include "asterisk/uri.h"
+
+#ifdef HAVE_URIPARSER
+#include <uriparser/Uri.h>
+#endif
+
+/*! \brief Stores parsed uri information */
+struct ast_uri {
+	/*! scheme (e.g. http, https, ws, wss, etc...) */
+	char *scheme;
+	/*! username:password */
+	char *user_info;
+	/*! host name or address */
+	char *host;
+	/*! associated port */
+	char *port;
+	/*! path info following host[:port] */
+	char *path;
+	/*! query information */
+	char *query;
+	/*! storage for uri string */
+	char uri[0];
+};
+
+/*!
+ * \brief Construct a uri object with the given values.
+ *
+ * \note The size parameters [should] include room for the string terminator
+ *       (strlen(<param>) + 1). For instance, if a scheme of 'http' is given
+ *       then the 'scheme_size' should be equal to 5.
+ */
+static struct ast_uri *ast_uri_create_(
+	const char *scheme, unsigned int scheme_size,
+	const char *user_info, unsigned int user_info_size,
+	const char *host, unsigned int host_size,
+	const char *port, unsigned int port_size,
+	const char *path, unsigned int path_size,
+	const char *query, unsigned int query_size)
+{
+#define SET_VALUE(param, field, size) \
+	do { if (param) { \
+	     ast_copy_string(p, param, size); \
+	     field = p; \
+	     p += size;	} } while (0)
+
+	char *p;
+	struct ast_uri *res = ao2_alloc(
+		sizeof(*res) + scheme_size + user_info_size + host_size +
+		port_size + path_size + query_size, NULL);
+
+	if (!res) {
+		ast_log(LOG_ERROR, "Unable to create URI object\n");
+		return NULL;
+	}
+
+	p = res->uri;
+	SET_VALUE(scheme, res->scheme, scheme_size);
+	SET_VALUE(user_info, res->user_info, user_info_size);
+	SET_VALUE(host, res->host, host_size);
+	SET_VALUE(port, res->port, port_size);
+	SET_VALUE(path, res->path, path_size);
+	SET_VALUE(query, res->query, query_size);
+	return res;
+}
+
+struct ast_uri *ast_uri_create(const char *scheme, const char *user_info,
+			       const char *host, const char *port,
+			       const char *path, const char *query)
+{
+	return ast_uri_create_(
+		scheme, scheme ? strlen(scheme) + 1 : 0,
+		user_info, user_info ? strlen(user_info) + 1 : 0,
+		host, host ? strlen(host) + 1 : 0,
+		port, port ? strlen(port) + 1 : 0,
+		path, path ? strlen(path) + 1 : 0,
+		query, query ? strlen(query) + 1 : 0);
+}
+
+struct ast_uri *ast_uri_copy_replace(const struct ast_uri *uri, const char *scheme,
+				     const char *user_info, const char *host,
+				     const char *port, const char *path,
+				     const char *query)
+{
+	return ast_uri_create(
+		scheme ? scheme : uri->scheme,
+		user_info ? user_info : uri->user_info,
+		host ? host : uri->host,
+		port ? port : uri->port,
+		path ? path : uri->path,
+		query ? query : uri->query);
+}
+
+const char *ast_uri_scheme(const struct ast_uri *uri)
+{
+	return uri->scheme;
+}
+
+const char *ast_uri_user_info(const struct ast_uri *uri)
+{
+	return uri->user_info;
+}
+
+const char *ast_uri_host(const struct ast_uri *uri)
+{
+	return uri->host;
+}
+
+const char *ast_uri_port(const struct ast_uri *uri)
+{
+	return uri->port;
+}
+
+const char *ast_uri_path(const struct ast_uri *uri)
+{
+	return uri->path;
+}
+
+const char *ast_uri_query(const struct ast_uri *uri)
+{
+	return uri->query;
+}
+
+const int ast_uri_is_secure(const struct ast_uri *uri)
+{
+	return ast_strlen_zero(uri->scheme) ? 0 :
+		*(uri->scheme + strlen(uri->scheme) - 1) == 's';
+}
+
+#ifdef HAVE_URIPARSER
+struct ast_uri *ast_uri_parse(const char *uri)
+{
+	UriParserStateA state;
+	UriUriA uria;
+	struct ast_uri *res;
+	unsigned int scheme_size, user_info_size, host_size;
+	unsigned int port_size, path_size, query_size;
+	const char *path_start, *path_end;
+
+	state.uri = &uria;
+	if (uriParseUriA(&state, uri) != URI_SUCCESS) {
+		ast_log(LOG_ERROR, "Unable to parse URI %s\n", uri);
+		uriFreeUriMembersA(&uria);
+		return NULL;
+	}
+
+	scheme_size = uria.scheme.first ?
+		uria.scheme.afterLast - uria.scheme.first + 1 : 0;
+	user_info_size = uria.userInfo.first ?
+		uria.userInfo.afterLast - uria.userInfo.first + 1 : 0;
+	host_size = uria.hostText.first ?
+		uria.hostText.afterLast - uria.hostText.first + 1 : 0;
+	port_size = uria.portText.first ?
+		uria.portText.afterLast - uria.portText.first + 1 : 0;
+
+	path_start = uria.pathHead && uria.pathHead->text.first ?
+		uria.pathHead->text.first : NULL;
+	path_end = path_start ? uria.pathTail->text.afterLast : NULL;
+	path_size = path_end ? path_end - path_start + 1 : 0;
+
+	query_size = uria.query.first ?
+		uria.query.afterLast - uria.query.first + 1 : 0;
+
+	res = ast_uri_create_(uria.scheme.first, scheme_size,
+			      uria.userInfo.first, user_info_size,
+			      uria.hostText.first, host_size,
+			      uria.portText.first, port_size,
+			      path_start, path_size,
+			      uria.query.first, query_size);
+	uriFreeUriMembersA(&uria);
+	return res;
+}
+#else
+struct ast_uri *ast_uri_parse(const char *uri)
+{
+#define SET_VALUES(value) \
+	value = uri; \
+	size_##value = p - uri + 1; \
+	uri = p + 1;
+
+	const char *p, *scheme = NULL, *user_info = NULL, *host = NULL;
+	const char *port = NULL, *path = NULL, *query = NULL;
+	unsigned int size_scheme = 0, size_user_info = 0, size_host = 0;
+	unsigned int size_port = 0, size_path = 0, size_query = 0;
+
+	if ((p = strstr(uri, "://"))) {
+		scheme = uri;
+		size_scheme = p - uri + 1;
+		uri = p + 3;
+	}
+
+	if ((p = strchr(uri, '@'))) {
+		SET_VALUES(user_info);
+	}
+
+	if ((p = strchr(uri, ':'))) {
+		SET_VALUES(host);
+	}
+
+	if ((p = strchr(uri, '/'))) {
+		if (!host) {
+			SET_VALUES(host);
+		} else {
+			SET_VALUES(port);
+		}
+	}
+
+	if ((p = strchr(uri, '?'))) {
+		query = p + 1;
+		size_query = strlen(query) + 1;
+	}
+
+	if (!host) {
+		SET_VALUES(host);
+	} else if (*(uri - 1) == ':') {
+		SET_VALUES(port);
+	} else if (*(uri - 1) == '/') {
+		SET_VALUES(path);
+	}
+
+	return ast_uri_create_(scheme, size_scheme,
+			       user_info, size_user_info,
+			       host, size_host,
+			       port, size_port,
+			       path, size_path,
+			       query, size_query);
+}
+#endif
+
+static struct ast_uri *uri_parse_and_default(const char *uri, const char *scheme,
+					     const char *port, const char *secure_port)
+{
+	struct ast_uri *res;
+	int len = strlen(scheme);
+
+	if (!strncmp(uri, scheme, len)) {
+		res = ast_uri_parse(uri);
+	} else {
+		/* make room for <scheme>:// */
+		char *with_scheme = ast_malloc(len + strlen(uri) + 4);
+		if (!with_scheme) {
+			ast_log(LOG_ERROR, "Unable to allocate uri '%s' with "
+				"scheme '%s'", uri, scheme);
+			return NULL;
+		}
+
+		/* safe - 'with_scheme' created with size equal to len of
+		   scheme plus length of uri plus space for extra characters
+		   '://' and terminator */
+		sprintf(with_scheme, "%s://%s", scheme, uri);
+		res = ast_uri_parse(with_scheme);
+		ast_free(with_scheme);
+	}
+
+	if (res && ast_strlen_zero(ast_uri_port(res))) {
+		/* default the port if not given */
+		struct ast_uri *tmp = ast_uri_copy_replace(
+			res, NULL, NULL, NULL,
+			ast_uri_is_secure(res) ? secure_port : port,
+			NULL, NULL);
+		ao2_ref(res, -1);
+		res = tmp;
+	}
+	return res;
+}
+
+struct ast_uri *ast_uri_parse_http(const char *uri)
+{
+	return uri_parse_and_default(uri, "http", "80", "443");
+}
+
+struct ast_uri *ast_uri_parse_websocket(const char *uri)
+{
+	return uri_parse_and_default(uri, "ws", "80", "443");
+}
+
+char *ast_uri_make_host_with_port(const struct ast_uri *uri)
+{
+	int host_size = ast_uri_host(uri) ?
+		strlen(ast_uri_host(uri)) : 0;
+	/* if there is a port +1 for the colon */
+	int port_size = ast_uri_port(uri) ?
+		strlen(ast_uri_port(uri)) + 1 : 0;
+	char *res = ast_malloc(host_size + port_size + 1);
+
+	if (!res) {
+		return NULL;
+	}
+
+	memcpy(res, ast_uri_host(uri), host_size);
+
+	if (ast_uri_port(uri)) {
+		res[host_size] = ':';
+		memcpy(res + host_size + 1,
+		       ast_uri_port(uri), port_size);
+	}
+
+	res[host_size + port_size + 1] = '\0';
+	return res;
+}