Initial check-in of SkypeWeb plugin

1 files changed, 772 insertions, 0 deletions

diff --git a/skypeweb/skypeweb_connection.c b/skypeweb/skypeweb_connection.c
new file mode 100644
index 0000000..0a68adb
--- /dev/null
+++ b/skypeweb/skypeweb_connection.c
@@ -0,0 +1,772 @@
+
+
+#include "skypeweb_connection.h"
+
+#if !PURPLE_VERSION_CHECK(3, 0, 0)
+	#define purple_connection_error purple_connection_error_reason
+#endif
+
+#if !GLIB_CHECK_VERSION (2, 22, 0)
+#define g_hostname_is_ip_address(hostname) (g_ascii_isdigit(hostname[0]) && g_strstr_len(hostname, 4, "."))
+#endif
+
+static void skypeweb_attempt_connection(SkypeWebConnection *);
+static void skypeweb_next_connection(SkypeWebAccount *sa);
+
+#include <zlib.h>
+
+static gchar *skypeweb_gunzip(const guchar *gzip_data, gssize *len_ptr)
+{
+	gsize gzip_data_len	= *len_ptr;
+	z_stream zstr;
+	int gzip_err = 0;
+	gchar *data_buffer;
+	gulong gzip_len = G_MAXUINT16;
+	GString *output_string = NULL;
+
+	data_buffer = g_new0(gchar, gzip_len);
+
+	zstr.next_in = NULL;
+	zstr.avail_in = 0;
+	zstr.zalloc = Z_NULL;
+	zstr.zfree = Z_NULL;
+	zstr.opaque = 0;
+	gzip_err = inflateInit2(&zstr, MAX_WBITS+32);
+	if (gzip_err != Z_OK)
+	{
+		g_free(data_buffer);
+		purple_debug_error("skypeweb", "no built-in gzip support in zlib\n");
+		return NULL;
+	}
+	
+	zstr.next_in = (Bytef *)gzip_data;
+	zstr.avail_in = gzip_data_len;
+	
+	zstr.next_out = (Bytef *)data_buffer;
+	zstr.avail_out = gzip_len;
+	
+	gzip_err = inflate(&zstr, Z_SYNC_FLUSH);
+
+	if (gzip_err == Z_DATA_ERROR)
+	{
+		inflateEnd(&zstr);
+		inflateInit2(&zstr, -MAX_WBITS);
+		if (gzip_err != Z_OK)
+		{
+			g_free(data_buffer);
+			purple_debug_error("skypeweb", "Cannot decode gzip header\n");
+			return NULL;
+		}
+		zstr.next_in = (Bytef *)gzip_data;
+		zstr.avail_in = gzip_data_len;
+		zstr.next_out = (Bytef *)data_buffer;
+		zstr.avail_out = gzip_len;
+		gzip_err = inflate(&zstr, Z_SYNC_FLUSH);
+	}
+	output_string = g_string_new("");
+	while (gzip_err == Z_OK)
+	{
+		//append data to buffer
+		output_string = g_string_append_len(output_string, data_buffer, gzip_len - zstr.avail_out);
+		//reset buffer pointer
+		zstr.next_out = (Bytef *)data_buffer;
+		zstr.avail_out = gzip_len;
+		gzip_err = inflate(&zstr, Z_SYNC_FLUSH);
+	}
+	if (gzip_err == Z_STREAM_END)
+	{
+		output_string = g_string_append_len(output_string, data_buffer, gzip_len - zstr.avail_out);
+	} else {
+		purple_debug_error("skypeweb", "gzip inflate error\n");
+	}
+	inflateEnd(&zstr);
+
+	g_free(data_buffer);	
+
+	if (len_ptr)
+		*len_ptr = output_string->len;
+
+	return g_string_free(output_string, FALSE);
+}
+
+void
+skypeweb_connection_close(SkypeWebConnection *skypewebcon)
+{
+	skypewebcon->sa->conns = g_slist_remove(skypewebcon->sa->conns, skypewebcon);
+	
+	if (skypewebcon->connect_data != NULL) {
+		purple_proxy_connect_cancel(skypewebcon->connect_data);
+		skypewebcon->connect_data = NULL;
+	}
+
+	if (skypewebcon->ssl_conn != NULL) {
+		purple_ssl_close(skypewebcon->ssl_conn);
+		skypewebcon->ssl_conn = NULL;
+	}
+
+	if (skypewebcon->fd >= 0) {
+		close(skypewebcon->fd);
+		skypewebcon->fd = -1;
+	}
+
+	if (skypewebcon->input_watcher > 0) {
+		purple_input_remove(skypewebcon->input_watcher);
+		skypewebcon->input_watcher = 0;
+	}
+	
+	purple_timeout_remove(skypewebcon->timeout_watcher);
+	
+	g_free(skypewebcon->rx_buf);
+	skypewebcon->rx_buf = NULL;
+	skypewebcon->rx_len = 0;
+}
+
+void skypeweb_connection_destroy(SkypeWebConnection *skypewebcon)
+{
+	skypeweb_connection_close(skypewebcon);
+	
+	if (skypewebcon->request != NULL)
+		g_string_free(skypewebcon->request, TRUE);
+	
+	g_free(skypewebcon->url);
+	g_free(skypewebcon->hostname);
+	g_free(skypewebcon);
+}
+
+static void skypeweb_update_cookies(SkypeWebAccount *sa, const gchar *headers)
+{
+	const gchar *cookie_start;
+	const gchar *cookie_end;
+	gchar *cookie_name;
+	gchar *cookie_value;
+	int header_len;
+
+	g_return_if_fail(headers != NULL);
+
+	header_len = strlen(headers);
+
+	/* look for the next "Set-Cookie: " */
+	/* grab the data up until ';' */
+	cookie_start = headers;
+	while ((cookie_start = strstr(cookie_start, "\r\nSet-Cookie: ")) &&
+			(cookie_start - headers) < header_len)
+	{
+		cookie_start += 14;
+		cookie_end = strchr(cookie_start, '=');
+		cookie_name = g_strndup(cookie_start, cookie_end-cookie_start);
+		cookie_start = cookie_end + 1;
+		cookie_end = strchr(cookie_start, ';');
+		cookie_value= g_strndup(cookie_start, cookie_end-cookie_start);
+		cookie_start = cookie_end;
+
+		g_hash_table_replace(sa->cookie_table, cookie_name,
+				cookie_value);
+	}
+}
+
+static void skypeweb_connection_process_data(SkypeWebConnection *skypewebcon)
+{
+	gssize len;
+	gchar *tmp;
+
+	len = skypewebcon->rx_len;
+	tmp = g_strstr_len(skypewebcon->rx_buf, len, "\r\n\r\n");
+	if (tmp == NULL) {
+		/* This is a corner case that occurs when the connection is
+		 * prematurely closed either on the client or the server.
+		 * This can either be no data at all or a partial set of
+		 * headers.  We pass along the data to be good, but don't
+		 * do any fancy massaging.  In all likelihood the result will
+		 * be tossed by the connection callback func anyways
+		 */
+		tmp = g_strndup(skypewebcon->rx_buf, len);
+	} else {
+		tmp += 4;
+		len -= g_strstr_len(skypewebcon->rx_buf, len, "\r\n\r\n") -
+				skypewebcon->rx_buf + 4;
+		tmp = g_memdup(tmp, len + 1);
+		tmp[len] = '\0';
+		skypewebcon->rx_buf[skypewebcon->rx_len - len] = '\0';
+		skypeweb_update_cookies(skypewebcon->sa, skypewebcon->rx_buf);
+
+		if (strstr(skypewebcon->rx_buf, "Content-Encoding: gzip"))
+		{
+			/* we've received compressed gzip data, decompress */
+			gchar *gunzipped;
+			gunzipped = skypeweb_gunzip((const guchar *)tmp, &len);
+			g_free(tmp);
+			tmp = gunzipped;
+		}
+	}
+
+	g_free(skypewebcon->rx_buf);
+	skypewebcon->rx_buf = NULL;
+
+	if (skypewebcon->callback != NULL) {
+		if (!len)
+		{
+			purple_debug_error("skypeweb", "No data in response\n");
+			//skypewebcon->callback(skypewebcon->sa, NULL, skypewebcon->user_data);
+		} else {
+			JsonParser *parser = json_parser_new();
+			if (!json_parser_load_from_data(parser, tmp, len, NULL))
+			{
+				if (skypewebcon->error_callback != NULL) {
+					skypewebcon->error_callback(skypewebcon->sa, tmp, len, skypewebcon->user_data);
+				} else {
+					purple_debug_error("skypeweb", "Error parsing response: %s\n", tmp);
+				}
+			} else {
+				JsonNode *root = json_parser_get_root(parser);
+				
+				//TODO
+				purple_debug_info("skypeweb", "Got response: %s\n", tmp);
+				purple_debug_info("skypeweb", "executing callback for %s\n", skypewebcon->url);
+				skypewebcon->callback(skypewebcon->sa, root, skypewebcon->user_data);
+			}
+			g_object_unref(parser);
+		}
+	}
+
+	g_free(tmp);
+}
+
+static void skypeweb_fatal_connection_cb(SkypeWebConnection *skypewebcon)
+{
+	PurpleConnection *pc = skypewebcon->sa->pc;
+
+	purple_debug_error("skypeweb", "fatal connection error\n");
+
+	skypeweb_connection_destroy(skypewebcon);
+
+	/* We died.  Do not pass Go.  Do not collect $200 */
+	/* In all seriousness, don't attempt to call the normal callback here.
+	 * That may lead to the wrong error message being displayed */
+	purple_connection_error(pc,
+				PURPLE_CONNECTION_ERROR_NETWORK_ERROR,
+				_("Server closed the connection."));
+
+}
+
+static void skypeweb_post_or_get_readdata_cb(gpointer data, gint source,
+		PurpleInputCondition cond)
+{
+	SkypeWebConnection *skypewebcon;
+	SkypeWebAccount *sa;
+	gchar buf[4096];
+	gssize len;
+
+	skypewebcon = data;
+	sa = skypewebcon->sa;
+
+	if (skypewebcon->method & SKYPEWEB_METHOD_SSL) {
+		len = purple_ssl_read(skypewebcon->ssl_conn,
+				buf, sizeof(buf) - 1);
+	} else {
+		len = recv(skypewebcon->fd, buf, sizeof(buf) - 1, 0);
+	}
+
+	if (len < 0)
+	{
+		if (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR) {
+			/* Try again later */
+			return;
+		}
+
+		if (skypewebcon->method & SKYPEWEB_METHOD_SSL && skypewebcon->rx_len > 0) {
+			/*
+			 * This is a slightly hacky workaround for a bug in either
+			 * GNU TLS or in the SSL implementation on skypeweb's web
+			 * servers.  The sequence of events is:
+			 * 1. We attempt to read the first time and successfully read
+			 *    the server's response.
+			 * 2. We attempt to read a second time and libpurple's call
+			 *    to gnutls_record_recv() returns the error
+			 *    GNUTLS_E_UNEXPECTED_PACKET_LENGTH, or
+			 *    "A TLS packet with unexpected length was received."
+			 *
+			 * Normally the server would have closed the connection
+			 * cleanly and this second read() request would have returned
+			 * 0.  Or maybe it's normal for SSL connections to be severed
+			 * in this manner?  In any case, this differs from the behavior
+			 * of the standard recv() system call.
+			 */
+			purple_debug_warning("skypeweb",
+				"ssl error, but data received.  attempting to continue\n");
+		} else {
+			/* Try resend the request */
+			skypewebcon->retry_count++;
+			if (skypewebcon->retry_count < 3) {
+				skypeweb_connection_close(skypewebcon);
+				skypewebcon->request_time = time(NULL);
+				
+				g_queue_push_head(sa->waiting_conns, skypewebcon);
+				skypeweb_next_connection(sa);
+			} else {
+				skypeweb_fatal_connection_cb(skypewebcon);
+			}
+			return;
+		}
+	}
+
+	if (len > 0)
+	{
+		buf[len] = '\0';
+
+		skypewebcon->rx_buf = g_realloc(skypewebcon->rx_buf,
+				skypewebcon->rx_len + len + 1);
+		memcpy(skypewebcon->rx_buf + skypewebcon->rx_len, buf, len + 1);
+		skypewebcon->rx_len += len;
+
+		/* Wait for more data before processing */
+		return;
+	}
+
+	/* The server closed the connection, let's parse the data */
+	skypeweb_connection_process_data(skypewebcon);
+
+	skypeweb_connection_destroy(skypewebcon);
+	
+	skypeweb_next_connection(sa);
+}
+
+static void skypeweb_post_or_get_ssl_readdata_cb (gpointer data,
+		PurpleSslConnection *ssl, PurpleInputCondition cond)
+{
+	skypeweb_post_or_get_readdata_cb(data, -1, cond);
+}
+
+static void skypeweb_post_or_get_connect_cb(gpointer data, gint source,
+		const gchar *error_message)
+{
+	SkypeWebConnection *skypewebcon;
+	gssize len;
+
+	skypewebcon = data;
+	skypewebcon->connect_data = NULL;
+
+	if (error_message)
+	{
+		purple_debug_error("skypeweb", "post_or_get_connect failure to %s\n", skypewebcon->url);
+		purple_debug_error("skypeweb", "post_or_get_connect_cb %s\n",
+				error_message);
+		skypeweb_fatal_connection_cb(skypewebcon);
+		return;
+	}
+
+	skypewebcon->fd = source;
+
+	/* TODO: Check the return value of write() */
+	len = write(skypewebcon->fd, skypewebcon->request->str,
+			skypewebcon->request->len);
+	skypewebcon->input_watcher = purple_input_add(skypewebcon->fd,
+			PURPLE_INPUT_READ,
+			skypeweb_post_or_get_readdata_cb, skypewebcon);
+}
+
+static void skypeweb_post_or_get_ssl_connect_cb(gpointer data,
+		PurpleSslConnection *ssl, PurpleInputCondition cond)
+{
+	SkypeWebConnection *skypewebcon;
+	gssize len;
+
+	skypewebcon = data;
+
+	purple_debug_info("skypeweb", "post_or_get_ssl_connect_cb\n");
+
+	/* TODO: Check the return value of write() */
+	len = purple_ssl_write(skypewebcon->ssl_conn,
+			skypewebcon->request->str, skypewebcon->request->len);
+	purple_ssl_input_add(skypewebcon->ssl_conn,
+			skypeweb_post_or_get_ssl_readdata_cb, skypewebcon);
+}
+
+static void skypeweb_host_lookup_cb(GSList *hosts, gpointer data,
+		const char *error_message)
+{
+	GSList *host_lookup_list;
+	struct sockaddr_in *addr;
+	gchar *hostname;
+	gchar *ip_address;
+	SkypeWebAccount *sa;
+	PurpleDnsQueryData *query;
+
+	/* Extract variables */
+	host_lookup_list = data;
+
+	sa = host_lookup_list->data;
+	host_lookup_list =
+			g_slist_delete_link(host_lookup_list, host_lookup_list);
+	hostname = host_lookup_list->data;
+	host_lookup_list =
+			g_slist_delete_link(host_lookup_list, host_lookup_list);
+	query = host_lookup_list->data;
+	host_lookup_list =
+			g_slist_delete_link(host_lookup_list, host_lookup_list);
+
+	/* The callback has executed, so we no longer need to keep track of
+	 * the original query.  This always needs to run when the cb is 
+	 * executed. */
+	sa->dns_queries = g_slist_remove(sa->dns_queries, query);
+
+	/* Any problems, capt'n? */
+	if (error_message != NULL)
+	{
+		purple_debug_warning("skypeweb",
+				"Error doing host lookup: %s\n", error_message);
+		return;
+	}
+
+	if (hosts == NULL)
+	{
+		purple_debug_warning("skypeweb",
+				"Could not resolve host name\n");
+		return;
+	}
+
+	/* Discard the length... */
+	hosts = g_slist_delete_link(hosts, hosts);
+	/* Copy the address then free it... */
+	addr = hosts->data;
+	ip_address = g_strdup(inet_ntoa(addr->sin_addr));
+	g_free(addr);
+	hosts = g_slist_delete_link(hosts, hosts);
+
+	/*
+	 * DNS lookups can return a list of IP addresses, but we only cache
+	 * the first one.  So free the rest.
+	 */
+	while (hosts != NULL)
+	{
+		/* Discard the length... */
+		hosts = g_slist_delete_link(hosts, hosts);
+		/* Free the address... */
+		g_free(hosts->data);
+		hosts = g_slist_delete_link(hosts, hosts);
+	}
+
+	g_hash_table_insert(sa->hostname_ip_cache, hostname, ip_address);
+}
+
+static void skypeweb_cookie_foreach_cb(gchar *cookie_name,
+		gchar *cookie_value, GString *str)
+{
+	/* TODO: Need to escape name and value? */
+	g_string_append_printf(str, "%s=%s;", cookie_name, cookie_value);
+}
+
+/**
+ * Serialize the sa->cookie_table hash table to a string.
+ */
+gchar *skypeweb_cookies_to_string(SkypeWebAccount *sa)
+{
+	GString *str;
+
+	str = g_string_new(NULL);
+
+	g_hash_table_foreach(sa->cookie_table,
+			(GHFunc)skypeweb_cookie_foreach_cb, str);
+
+	return g_string_free(str, FALSE);
+}
+
+static void skypeweb_ssl_connection_error(PurpleSslConnection *ssl,
+		PurpleSslErrorType errortype, gpointer data)
+{
+	SkypeWebConnection *skypewebcon = data;
+	SkypeWebAccount *sa = skypewebcon->sa;
+	PurpleConnection *pc = sa->pc;
+	
+	skypewebcon->ssl_conn = NULL;
+	
+	/* Try resend the request */
+	skypewebcon->retry_count++;
+	if (skypewebcon->retry_count < 3) {
+		skypeweb_connection_close(skypewebcon);
+		skypewebcon->request_time = time(NULL);
+		
+		g_queue_push_head(sa->waiting_conns, skypewebcon);
+		skypeweb_next_connection(sa);
+	} else {
+		skypeweb_connection_destroy(skypewebcon);
+		purple_connection_ssl_error(pc, errortype);
+	}
+}
+
+SkypeWebConnection *
+skypeweb_post_or_get(SkypeWebAccount *sa, SkypeWebMethod method,
+		const gchar *host, const gchar *url, const gchar *postdata,
+		SkypeWebProxyCallbackFunc callback_func, gpointer user_data,
+		gboolean keepalive)
+{
+	GString *request;
+	gchar *cookies;
+	SkypeWebConnection *skypewebcon;
+	gchar *real_url;
+	gboolean is_proxy = FALSE;
+	const gchar *user_agent;
+	const gchar* const *languages;
+	gchar *language_names;
+	PurpleProxyInfo *proxy_info = NULL;
+	gchar *proxy_auth;
+	gchar *proxy_auth_base64;
+
+	/* TODO: Fix keepalive and use it as much as possible */
+	keepalive = FALSE;
+
+	if (host == NULL)
+		host = "api.skype.com";
+
+	if (sa && sa->account)
+	{
+		if (purple_account_get_bool(sa->account, "use-https", TRUE))
+			method |= SKYPEWEB_METHOD_SSL;
+	}
+
+	if (sa && sa->account && !(method & SKYPEWEB_METHOD_SSL))
+	{
+		proxy_info = purple_proxy_get_setup(sa->account);
+		if (purple_proxy_info_get_type(proxy_info) == PURPLE_PROXY_USE_GLOBAL)
+			proxy_info = purple_global_proxy_get_info();
+		if (purple_proxy_info_get_type(proxy_info) == PURPLE_PROXY_HTTP)
+		{
+			is_proxy = TRUE;
+		}	
+	}
+	if (is_proxy == TRUE)
+	{
+		real_url = g_strdup_printf("http://%s%s", host, url);
+	} else {
+		real_url = g_strdup(url);
+	}
+
+	cookies = skypeweb_cookies_to_string(sa);
+	//user_agent = purple_account_get_string(sa->account, "user-agent", "SkypeWeb 1.2.0 / iPhone");
+	
+	if (method & SKYPEWEB_METHOD_POST && !postdata)
+		postdata = "";
+
+	/* Build the request */
+	request = g_string_new(NULL);
+	g_string_append_printf(request, "%s %s HTTP/1.0\r\n",
+			((method & SKYPEWEB_METHOD_POST) ? "POST" : ((method & SKYPEWEB_METHOD_PUT) ? "PUT" : ((method & SKYPEWEB_METHOD_DELETE) ? "DELETE" : "GET"))),
+			real_url);
+	if (is_proxy == FALSE)
+		g_string_append_printf(request, "Host: %s\r\n", host);
+	g_string_append_printf(request, "Connection: %s\r\n",
+			(keepalive ? "Keep-Alive" : "close"));
+	//g_string_append_printf(request, "User-Agent: %s\r\n", user_agent);
+	if (method & SKYPEWEB_METHOD_POST) {
+		
+		if (postdata && postdata[0] == '[' || postdata[0] == '{') {
+			g_string_append(request, "Content-Type: application/json\r\n"); // hax
+		} else {
+			g_string_append_printf(request, "Content-Type: application/x-www-form-urlencoded\r\n");
+		}
+		g_string_append_printf(request, "Content-length: %zu\r\n", strlen(postdata));
+	}
+	g_string_append_printf(request, "Accept: */*\r\n");
+	
+	if (g_str_equal(host, SKYPEWEB_CONTACTS_HOST)) {
+		g_string_append_printf(request, "X-Skypetoken: %s\r\n", sa->skype_token);
+		g_string_append(request, "X-Stratus-Caller: swx-skype.com\r\n");
+		g_string_append(request, "X-Stratus-Request: abcd1234\r\n");
+		g_string_append(request, "Origin: https://web.skype.com\r\n");
+		g_string_append(request, "Referer: https://web.skype.com/main\r\n");
+		g_string_append(request, "Accept: application/json; ver=1.0;\r\n");
+	} else if (g_str_equal(host, SKYPEWEB_MESSAGES_HOST)) {
+		g_string_append_printf(request, "RegistrationToken: %s\r\n", sa->registration_token);
+		g_string_append(request, "Referer: https://web.skype.com/main\r\n");
+		g_string_append(request, "Accept: application/json; ver=1.0;\r\n");
+		g_string_append(request, "ClientInfo: os=Windows; osVer=8.1; proc=Win32; lcid=en-us; deviceType=1; country=n/a; clientName=swx-skype.com; clientVer=908/1.0.0.20\r\n");
+	}
+	
+	//g_string_append_printf(request, "Cookie: %s\r\n", cookies);
+	g_string_append_printf(request, "Accept-Encoding: gzip\r\n");
+	if (is_proxy == TRUE)
+	{
+		if (purple_proxy_info_get_username(proxy_info) &&
+			purple_proxy_info_get_password(proxy_info))
+		{
+			proxy_auth = g_strdup_printf("%s:%s", purple_proxy_info_get_username(proxy_info), purple_proxy_info_get_password(proxy_info));
+			proxy_auth_base64 = purple_base64_encode((guchar *)proxy_auth, strlen(proxy_auth));
+			g_string_append_printf(request, "Proxy-Authorization: Basic %s\r\n", proxy_auth_base64);
+			g_free(proxy_auth_base64);
+			g_free(proxy_auth);
+		}
+	}
+
+	/* Tell the server what language we accept, so that we get error messages in our language (rather than our IP's) */
+	languages = g_get_language_names();
+	language_names = g_strjoinv(", ", (gchar **)languages);
+	purple_util_chrreplace(language_names, '_', '-');
+	g_string_append_printf(request, "Accept-Language: %s\r\n", language_names);
+	g_free(language_names);
+
+	purple_debug_info("skypeweb", "getting url %s\n", url);
+
+	g_string_append_printf(request, "\r\n");
+	if (method & SKYPEWEB_METHOD_POST)
+		g_string_append_printf(request, "%s", postdata);
+
+	/* If it needs to go over a SSL connection, we probably shouldn't print
+	 * it in the debug log.  Without this condition a user's password is
+	 * printed in the debug log */
+	if (method == SKYPEWEB_METHOD_POST)
+		purple_debug_info("skypeweb", "sending request data:\n%s\n", postdata);
+	
+	purple_debug_misc("skypeweb", "sending headers:\n%s\n", request->str);
+
+	g_free(cookies);
+
+	skypewebcon = g_new0(SkypeWebConnection, 1);
+	skypewebcon->sa = sa;
+	skypewebcon->url = real_url;
+	skypewebcon->method = method;
+	skypewebcon->hostname = g_strdup(host);
+	skypewebcon->request = request;
+	skypewebcon->callback = callback_func;
+	skypewebcon->user_data = user_data;
+	skypewebcon->fd = -1;
+	skypewebcon->connection_keepalive = keepalive;
+	skypewebcon->request_time = time(NULL);
+	
+	g_queue_push_head(sa->waiting_conns, skypewebcon);
+	skypeweb_next_connection(sa);
+	
+	return skypewebcon;
+}
+
+static void skypeweb_next_connection(SkypeWebAccount *sa)
+{
+	SkypeWebConnection *skypewebcon;
+	
+	g_return_if_fail(sa != NULL);	
+	
+	if (!g_queue_is_empty(sa->waiting_conns))
+	{
+		if(g_slist_length(sa->conns) < SKYPEWEB_MAX_CONNECTIONS)
+		{
+			skypewebcon = g_queue_pop_tail(sa->waiting_conns);
+			skypeweb_attempt_connection(skypewebcon);
+		}
+	}
+}
+
+
+static gboolean
+skypeweb_connection_timedout(gpointer userdata)
+{
+	SkypeWebConnection *skypewebcon = userdata;
+	SkypeWebAccount *sa = skypewebcon->sa;
+	
+	/* Try resend the request */
+	skypewebcon->retry_count++;
+	if (skypewebcon->retry_count < 3) {
+		skypeweb_connection_close(skypewebcon);
+		skypewebcon->request_time = time(NULL);
+		
+		g_queue_push_head(sa->waiting_conns, skypewebcon);
+		skypeweb_next_connection(sa);
+	} else {
+		skypeweb_fatal_connection_cb(skypewebcon);
+	}
+	
+	return FALSE;
+}
+
+static void skypeweb_attempt_connection(SkypeWebConnection *skypewebcon)
+{
+	gboolean is_proxy = FALSE;
+	SkypeWebAccount *sa = skypewebcon->sa;
+	PurpleProxyInfo *proxy_info = NULL;
+
+	if (sa && sa->account && !(skypewebcon->method & SKYPEWEB_METHOD_SSL))
+	{
+		proxy_info = purple_proxy_get_setup(sa->account);
+		if (purple_proxy_info_get_type(proxy_info) == PURPLE_PROXY_USE_GLOBAL)
+			proxy_info = purple_global_proxy_get_info();
+		if (purple_proxy_info_get_type(proxy_info) == PURPLE_PROXY_HTTP)
+		{
+			is_proxy = TRUE;
+		}	
+	}
+
+#if 0
+	/* Connection to attempt retries.  This code doesn't work perfectly, but
+	 * remains here for future reference if needed */
+	if (time(NULL) - skypewebcon->request_time > 5) {
+		/* We've continuously tried to remake this connection for a 
+		 * bit now.  It isn't happening, sadly.  Time to die. */
+		purple_debug_error("skypeweb", "could not connect after retries\n");
+		skypeweb_fatal_connection_cb(skypewebcon);
+		return;
+	}
+
+	purple_debug_info("skypeweb", "making connection attempt\n");
+
+	/* TODO: If we're retrying the connection, consider clearing the cached
+	 * DNS value.  This will require some juggling with the hostname param */
+	/* TODO/FIXME: This retries almost instantenously, which in some cases
+	 * runs at blinding speed.  Slow it down. */
+	/* TODO/FIXME: this doesn't retry properly on non-ssl connections */
+#endif
+	
+	sa->conns = g_slist_prepend(sa->conns, skypewebcon);
+
+	/*
+	 * Do a separate DNS lookup for the given host name and cache it
+	 * for next time.
+	 *
+	 * TODO: It would be better if we did this before we call
+	 *       purple_proxy_connect(), so we could re-use the result.
+	 *       Or even better: Use persistent HTTP connections for servers
+	 *       that we access continually.
+	 *
+	 * TODO: This cache of the hostname<-->IP address does not respect
+	 *       the TTL returned by the DNS server.  We should expire things
+	 *       from the cache after some amount of time.
+	 */
+	if (!is_proxy && !(skypewebcon->method & SKYPEWEB_METHOD_SSL) && !g_hostname_is_ip_address(skypewebcon->hostname))
+	{
+		/* Don't do this for proxy connections, since proxies do the DNS lookup */
+		gchar *host_ip;
+
+		host_ip = g_hash_table_lookup(sa->hostname_ip_cache, skypewebcon->hostname);
+		if (host_ip != NULL) {
+			g_free(skypewebcon->hostname);
+			skypewebcon->hostname = g_strdup(host_ip);
+		} else if (sa->account && !sa->account->disconnecting) {
+			GSList *host_lookup_list = NULL;
+			PurpleDnsQueryData *query;
+
+			host_lookup_list = g_slist_prepend(
+					host_lookup_list, g_strdup(skypewebcon->hostname));
+			host_lookup_list = g_slist_prepend(
+					host_lookup_list, sa);
+
+			query = purple_dnsquery_a(
+#if PURPLE_VERSION_CHECK(3, 0, 0)
+					skypewebcon->sa->account,
+#endif
+					skypewebcon->hostname, 80,
+					skypeweb_host_lookup_cb, host_lookup_list);
+			sa->dns_queries = g_slist_prepend(sa->dns_queries, query);
+			host_lookup_list = g_slist_append(host_lookup_list, query);
+		}
+	}
+
+	if (skypewebcon->method & SKYPEWEB_METHOD_SSL) {
+		skypewebcon->ssl_conn = purple_ssl_connect(sa->account, skypewebcon->hostname,
+				443, skypeweb_post_or_get_ssl_connect_cb,
+				skypeweb_ssl_connection_error, skypewebcon);
+	} else {
+		skypewebcon->connect_data = purple_proxy_connect(NULL, sa->account,
+				skypewebcon->hostname, 80, skypeweb_post_or_get_connect_cb, skypewebcon);
+	}
+	
+	skypewebcon->timeout_watcher = purple_timeout_add_seconds(120, skypeweb_connection_timedout, skypewebcon);
+
+	return;
+}
+