diff -r fdd1f3a3c6df -r e83a87761544 libpurple/protocols/gg/lib/events.c
--- a/libpurple/protocols/gg/lib/events.c	Thu Feb 13 04:27:27 2014 +0100
+++ b/libpurple/protocols/gg/lib/events.c	Thu Feb 13 18:29:10 2014 +0100
@@ -1,4 +1,4 @@
-/* $Id: events.c 1144 2011-07-09 15:43:00Z wojtekka $ */
+/* $Id$ */
 
 /*
  *  (C) Copyright 2001-2006 Wojtek Kaniewski <wojtekka@irc.pl>
@@ -25,25 +25,26 @@
  * \file events.c
  *
  * \brief Obsługa zdarzeń
+ *
+ * \todo Poprawna obsługa gg_proxy_http_only
  */
 
-#include <sys/types.h>
-#include <ctype.h>
+#include "strman.h"
+#include "network.h"
 
-#include "compat.h"
 #include "libgadu.h"
 #include "protocol.h"
 #include "internal.h"
 #include "encoding.h"
 #include "debug.h"
 #include "session.h"
+#include "resolver.h"
+#include "config.h"
 
 #include <errno.h>
-#include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <time.h>
-#include <unistd.h>
 #include <ctype.h>
 #ifdef GG_CONFIG_HAVE_GNUTLS
 #  include <gnutls/gnutls.h>
@@ -52,6 +53,7 @@
 #ifdef GG_CONFIG_HAVE_OPENSSL
 #  include <openssl/err.h>
 #  include <openssl/x509.h>
+#  include <openssl/rand.h>
 #endif
 
 /**
@@ -132,9 +134,14 @@
 			free(e->event.xml_event.data);
 			break;
 
+		case GG_EVENT_JSON_EVENT:
+			free(e->event.json_event.data);
+			free(e->event.json_event.type);
+			break;
+
 		case GG_EVENT_USER_DATA:
 		{
-			int i, j;
+			unsigned int i, j;
 
 			for (i = 0; i < e->event.user_data.user_count; i++) {
 				for (j = 0; j < e->event.user_data.users[i].attr_count; j++) {
@@ -165,6 +172,14 @@
 		case GG_EVENT_USERLIST100_REPLY:
 			free(e->event.userlist100_reply.reply);
 			break;
+
+		case GG_EVENT_IMTOKEN:
+			free(e->event.imtoken.imtoken);
+			break;
+
+		case GG_EVENT_CHAT_INFO:
+			free(e->event.chat_info.participants);
+			break;
 	}
 
 	free(e);
@@ -213,6 +228,1461 @@
 /** \endcond */
 
 /**
+ * \internal Inicjalizuje struktury SSL.
+ *
+ * \param gs Struktura sesji
+ *
+ * \return 0 jeśli się powiodło, -1 jeśli wystąpił błąd
+ */
+int gg_session_init_ssl(struct gg_session *gs)
+{
+#ifdef GG_CONFIG_HAVE_GNUTLS
+	gg_session_gnutls_t *tmp;
+
+	tmp = (gg_session_gnutls_t*) gs->ssl;
+
+	if (tmp == NULL) {
+		tmp = malloc(sizeof(gg_session_gnutls_t));
+
+		if (tmp == NULL) {
+			gg_debug(GG_DEBUG_MISC, "// gg_session_connect() out of memory for GnuTLS session\n");
+			return -1;
+		}
+
+		memset(tmp, 0, sizeof(gg_session_gnutls_t));
+
+		gs->ssl = tmp;
+
+		gnutls_global_init();
+		gnutls_certificate_allocate_credentials(&tmp->xcred);
+#ifdef GG_CONFIG_SSL_SYSTEM_TRUST
+#ifdef HAVE_GNUTLS_CERTIFICATE_SET_X509_SYSTEM_TRUST
+		gnutls_certificate_set_x509_system_trust(tmp->xcred);
+#else
+		gnutls_certificate_set_x509_trust_file(tmp->xcred, GG_CONFIG_GNUTLS_SYSTEM_TRUST_STORE, GNUTLS_X509_FMT_PEM);
+#endif
+#endif
+	} else {
+		gnutls_deinit(tmp->session);
+	}
+
+	gnutls_init(&tmp->session, GNUTLS_CLIENT);
+	gnutls_set_default_priority(tmp->session);
+	gnutls_credentials_set(tmp->session, GNUTLS_CRD_CERTIFICATE, tmp->xcred);
+	gnutls_transport_set_ptr(tmp->session, (gnutls_transport_ptr_t) (long) gs->fd);
+#endif
+
+#ifdef GG_CONFIG_HAVE_OPENSSL
+	char buf[1024];
+
+	OpenSSL_add_ssl_algorithms();
+
+	if (!RAND_status()) {
+		char rdata[1024];
+		struct {
+			time_t time;
+			void *ptr;
+		} rstruct;
+
+		time(&rstruct.time);
+		rstruct.ptr = (void *) &rstruct;
+
+		RAND_seed((void *) rdata, sizeof(rdata));
+		RAND_seed((void *) &rstruct, sizeof(rstruct));
+	}
+
+	if (gs->ssl_ctx == NULL) {
+		gs->ssl_ctx = SSL_CTX_new(SSLv3_client_method());
+
+		if (gs->ssl_ctx == NULL) {
+			ERR_error_string_n(ERR_get_error(), buf, sizeof(buf));
+			gg_debug(GG_DEBUG_MISC, "// gg_session_connect() SSL_CTX_new() failed: %s\n", buf);
+			return -1;
+		}
+
+		SSL_CTX_set_verify(gs->ssl_ctx, SSL_VERIFY_NONE, NULL);
+#ifdef GG_CONFIG_SSL_SYSTEM_TRUST
+		SSL_CTX_set_default_verify_paths(gs->ssl_ctx);
+#endif
+	}
+
+	if (gs->ssl != NULL)
+		SSL_free(gs->ssl);
+
+	gs->ssl = SSL_new(gs->ssl_ctx);
+
+	if (gs->ssl == NULL) {
+		ERR_error_string_n(ERR_get_error(), buf, sizeof(buf));
+		gg_debug(GG_DEBUG_MISC, "// gg_session_connect() SSL_new() failed: %s\n", buf);
+		return -1;
+	}
+
+	SSL_set_fd(gs->ssl, gs->fd);
+#endif
+
+	return 0;
+}
+
+/**
+ * \internal Funkcja próbuje wysłać dane zakolejkowane do wysyłki.
+ *
+ * \param sess Struktura sesji
+ *
+ * \return 0 jeśli się powiodło, -1 jeśli wystąpił błąd
+ */
+static int gg_send_queued_data(struct gg_session *sess)
+{
+	int res;
+
+	if (sess->send_buf == NULL || sess->send_left == 0)
+		return 0;
+		
+	gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() sending %d bytes of queued data\n", sess->send_left);
+
+	res = send(sess->fd, sess->send_buf, sess->send_left, 0);
+
+	if (res == -1) {
+		if (errno == EAGAIN || errno == EINTR) {
+			gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() non-critical send error (errno=%d, %s)\n", errno, strerror(errno));
+
+			return 0;
+		}
+
+		gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() send() failed (errno=%d, %s)\n", errno, strerror(errno));
+
+		return -1;
+	}
+
+	if (res == sess->send_left) {
+		gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() sent all queued data\n");
+		free(sess->send_buf);
+		sess->send_buf = NULL;
+		sess->send_left = 0;
+	} else if (res > 0) {
+		gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() sent %d bytes of queued data, %d bytes left\n", res, sess->send_left - res);
+
+		memmove(sess->send_buf, sess->send_buf + res, sess->send_left - res);
+		sess->send_left -= res;
+	}
+
+	return 0;
+}
+
+/**
+ * \internal Sprawdza wynik połączenia asynchronicznego.
+ * \param gs Struktura sesji
+ * \param res_ptr Wskaźnik na kod błędu
+ * \return 0 jeśli się powiodło, -1 jeśli wystąpił błąd
+ */
+static int gg_async_connect_failed(struct gg_session *gs, int *res_ptr)
+{
+	int res = 0;
+	socklen_t res_size = sizeof(res);
+
+	if (!gs->async)
+		return 0;
+
+	if (gs->timeout == 0) {
+		*res_ptr = ETIMEDOUT;
+		return 1;
+	}
+
+	if (getsockopt(gs->fd, SOL_SOCKET, SO_ERROR, &res, &res_size) == -1) {
+		*res_ptr = errno;
+		return 1;
+	}
+
+	if (res != 0) {
+		*res_ptr = res;
+		return 1;
+	}
+
+	*res_ptr = 0;
+
+	return 0;
+}
+
+typedef enum
+{
+	GG_ACTION_WAIT,
+	GG_ACTION_NEXT,
+	GG_ACTION_FAIL
+} gg_action_t;
+
+typedef gg_action_t (*gg_state_handler_t)(struct gg_session *gs, struct gg_event *ge, enum gg_state_t next_state, enum gg_state_t alt_state, enum gg_state_t alt2_state);
+
+typedef struct
+{
+	enum gg_state_t state;
+	gg_state_handler_t handler;
+	enum gg_state_t next_state;
+	enum gg_state_t alt_state;
+	enum gg_state_t alt2_state;
+} gg_state_transition_t;
+
+/* zwraca:
+ * -1 w przypadku błędu
+ * 0 jeżeli nie ma ustawionego specjalnego managera gniazdek
+ * 1 w przypadku powodzenia
+ */
+static int gg_handle_resolve_custom(struct gg_session *sess, enum gg_state_t next_state)
+{
+	struct gg_session_private *p = sess->private_data;
+	int is_tls = 0;
+	int port;
+
+	if (p->socket_manager_type == GG_SOCKET_MANAGER_TYPE_INTERNAL)
+		return 0;
+
+	if (p->socket_manager.connect_cb == NULL) {
+		gg_debug_session(sess, GG_DEBUG_MISC | GG_DEBUG_ERROR,
+			"// gg_handle_resolve_custom() socket_manager.connect "
+			"callback is empty\n");
+		return -1;
+	}
+
+	if (p->socket_handle != NULL) {
+		gg_debug_session(sess, GG_DEBUG_MISC | GG_DEBUG_ERROR,
+			"// gg_handle_resolve_custom() socket_handle is not "
+			"NULL\n");
+		return -1;
+	}
+
+	port = sess->connect_port[sess->connect_index];
+	if (next_state == GG_STATE_SEND_HUB)
+		port = GG_APPMSG_PORT;
+
+	if (sess->ssl_flag != GG_SSL_DISABLED &&
+		next_state == GG_STATE_READING_KEY)
+	{
+		/* XXX: w tej chwili nie ma możliwości łączenia się do HUBa po
+		 * SSL, ale może będzie w przyszłości */
+		is_tls = 1;
+	}
+
+	if (is_tls && p->socket_manager_type == GG_SOCKET_MANAGER_TYPE_TCP) {
+		is_tls = 0;
+		next_state = GG_STATE_TLS_NEGOTIATION;
+	}
+
+	if (port <= 0) {
+		gg_debug_session(sess, GG_DEBUG_MISC | GG_DEBUG_ERROR,
+			"// gg_handle_resolve_custom() port <= 0\n");
+		return -1;
+	}
+
+	p->socket_failure = 0;
+	p->socket_next_state = next_state;
+	p->socket_handle = p->socket_manager.connect_cb(
+		p->socket_manager.cb_data, sess->resolver_host, port, is_tls,
+		sess->async, sess);
+
+	if (p->socket_failure != 0) {
+		if (p->socket_handle != NULL) {
+			gg_debug_session(sess, GG_DEBUG_MISC | GG_DEBUG_WARNING,
+				"// gg_handle_resolve_custom() handle should be"
+				" empty on error\n");
+		}
+		return -1;
+	}
+
+	if (p->socket_handle == NULL) {
+		gg_debug_session(sess, GG_DEBUG_MISC | GG_DEBUG_ERROR,
+			"// gg_handle_resolve_custom() returned empty "
+			"handle\n");
+		return -1;
+	}
+
+	return 1;
+}
+
+static gg_action_t gg_handle_resolve_sync(struct gg_session *sess, struct gg_event *e, enum gg_state_t next_state, enum gg_state_t alt_state, enum gg_state_t alt2_state)
+{
+	struct in_addr addr;
+	int res;
+
+	res = gg_handle_resolve_custom(sess, alt_state);
+	if (res == 1)
+		return GG_ACTION_NEXT;
+	else if (res == -1)
+		return GG_ACTION_FAIL;
+
+	addr.s_addr = inet_addr(sess->resolver_host);
+	
+	if (addr.s_addr == INADDR_NONE) {
+		struct in_addr *addr_list = NULL;
+		unsigned int addr_count;
+
+		if (gg_gethostbyname_real(sess->resolver_host, &addr_list, &addr_count, 0) == -1) {
+			gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() host %s not found\n", sess->resolver_host);
+			e->event.failure = GG_FAILURE_RESOLVING;
+			free(addr_list);
+			return GG_ACTION_FAIL;
+		}
+
+		sess->resolver_result = addr_list;
+		sess->resolver_count = addr_count;
+		sess->resolver_index = 0;
+	} else {
+		sess->resolver_result = malloc(sizeof(struct in_addr));
+
+		if (sess->resolver_result == NULL) {
+			gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() out of memory\n");
+			return GG_ACTION_FAIL;
+		}
+
+		sess->resolver_result[0].s_addr = addr.s_addr;
+		sess->resolver_count = 1;
+		sess->resolver_index = 0;
+	}
+
+	sess->state = next_state;
+
+	return GG_ACTION_NEXT;
+}
+
+static gg_action_t gg_handle_resolve_async(struct gg_session *sess, struct gg_event *e, enum gg_state_t next_state, enum gg_state_t alt_state, enum gg_state_t alt2_state)
+{
+	int res;
+
+	res = gg_handle_resolve_custom(sess, alt_state);
+	if (res == 1)
+		return GG_ACTION_WAIT;
+	else if (res == -1)
+		return GG_ACTION_FAIL;
+
+	if (sess->resolver_start(&sess->fd, &sess->resolver, sess->resolver_host) == -1) {
+		gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() resolving failed (errno=%d, %s)\n", errno, strerror(errno));
+		e->event.failure = GG_FAILURE_RESOLVING;
+		return GG_ACTION_FAIL;
+	}
+
+	sess->state = next_state;
+	sess->check = GG_CHECK_READ;
+	sess->timeout = GG_DEFAULT_TIMEOUT;
+
+	return GG_ACTION_WAIT;
+}
+
+static gg_action_t gg_handle_resolving(struct gg_session *sess, struct gg_event *e, enum gg_state_t next_state, enum gg_state_t alt_state, enum gg_state_t alt2_state)
+{
+	char buf[256];
+	int count = -1;
+	int res;
+	unsigned int i;
+
+	res = gg_resolver_recv(sess->fd, buf, sizeof(buf));
+
+	if (res == -1 && (errno == EAGAIN || errno == EINTR)) {
+		gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() non-critical error (errno=%d, %s)\n", errno, strerror(errno));
+		return GG_ACTION_WAIT;
+	}
+
+	sess->resolver_cleanup(&sess->resolver, 0);
+
+	if (res == -1) {
+		gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() read error (errno=%d, %s)\n", errno, strerror(errno));
+		e->event.failure = GG_FAILURE_RESOLVING;
+		return GG_ACTION_FAIL;
+	}
+
+	if (res > 0) {
+		char *tmp;
+
+		tmp = realloc(sess->recv_buf, sess->recv_done + res);
+
+		if (tmp == NULL)
+			return GG_ACTION_FAIL;
+
+		sess->recv_buf = tmp;
+		memcpy(sess->recv_buf + sess->recv_done, buf, res);
+		sess->recv_done += res;
+	}
+
+	/* Sprawdź, czy mamy listę zakończoną INADDR_NONE */
+
+	for (i = 0; i < sess->recv_done / sizeof(struct in_addr); i++) {
+		if (((struct in_addr*) sess->recv_buf)[i].s_addr == INADDR_NONE) {
+			count = i;
+			break;
+		}
+	}
+
+	/* Nie znaleziono hosta */
+
+	if (count == 0) {
+		gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() host not found\n");
+		e->event.failure = GG_FAILURE_RESOLVING;
+		return GG_ACTION_FAIL;
+	}
+
+	/* Nie mamy pełnej listy, ale połączenie zerwane */
+
+	if (res == 0 && count == -1) {
+		gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() connection broken\n");
+		e->event.failure = GG_FAILURE_RESOLVING;
+		return GG_ACTION_FAIL;
+	}
+
+	/* Nie mamy pełnej listy, normalna sytuacja */
+
+	if (count == -1)
+		return GG_ACTION_WAIT;
+
+#ifndef GG_DEBUG_DISABLE
+	if ((gg_debug_level & GG_DEBUG_DUMP) && (count > 0)) {
+		char *list;
+		size_t len;
+
+		len = 0;
+
+		for (i = 0; i < (unsigned int) count; i++) {
+			if (i > 0)
+				len += 2;
+
+			len += strlen(inet_ntoa(((struct in_addr*) sess->recv_buf)[i]));
+		}
+
+		list = malloc(len + 1);
+
+		if (list == NULL)
+			return GG_ACTION_FAIL;
+
+		list[0] = 0;
+
+		for (i = 0; i < (unsigned int) count; i++) {
+			if (i > 0)
+				strcat(list, ", ");
+
+			strcat(list, inet_ntoa(((struct in_addr*) sess->recv_buf)[i]));
+		}
+
+		gg_debug_session(sess, GG_DEBUG_DUMP, "// gg_watch_fd() resolved: %s\n", list);
+
+		free(list);
+	}
+#endif
+
+	gg_close(sess);
+
+	sess->state = next_state;
+	sess->resolver_result = (struct in_addr*) sess->recv_buf;
+	sess->resolver_count = count;
+	sess->resolver_index = 0;
+	sess->recv_buf = NULL;
+	sess->recv_done = 0;
+	
+	return GG_ACTION_NEXT;
+}
+
+static gg_action_t gg_handle_connect(struct gg_session *sess, struct gg_event *e, enum gg_state_t next_state, enum gg_state_t alt_state, enum gg_state_t alt2_state)
+{
+	struct in_addr addr;
+	int port;
+
+	if (sess->resolver_index >= sess->resolver_count) {
+		gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() out of addresses to connect to\n");
+		e->event.failure = GG_FAILURE_CONNECTING;
+		return GG_ACTION_FAIL;
+	}
+
+	addr = sess->resolver_result[sess->resolver_index];
+
+	if (sess->state == GG_STATE_CONNECT_HUB) {
+		port = GG_APPMSG_PORT;
+	} else {
+		sess->proxy_addr = addr.s_addr;
+		port = sess->proxy_port;
+	}
+
+	gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() connecting to %s:%d\n", inet_ntoa(addr), port);
+
+	sess->fd = gg_connect(&addr, port, sess->async);
+
+	if (sess->fd == -1) {
+		gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() connection failed (errno=%d, %s)\n", errno, strerror(errno));
+		sess->resolver_index++;
+		return GG_ACTION_NEXT;
+	}
+
+	sess->state = next_state;
+	sess->check = GG_CHECK_WRITE;
+	sess->timeout = GG_DEFAULT_TIMEOUT;
+	sess->soft_timeout = 1;
+
+	return GG_ACTION_WAIT;
+}
+
+static gg_action_t gg_handle_connecting(struct gg_session *sess, struct gg_event *e, enum gg_state_t next_state, enum gg_state_t alt_state, enum gg_state_t alt2_state)
+{
+	int res;
+
+	sess->soft_timeout = 0;
+
+	if (gg_async_connect_failed(sess, &res)) {
+		gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() connection failed (errno=%d, %s)\n", res, strerror(res));
+		gg_close(sess);
+		sess->resolver_index++;
+		sess->state = alt_state;
+	} else {
+		/* Z proxy zwykle łączymy się dwa razy, więc nie zwalniamy
+		 * adresów IP po pierwszym połączeniu. */
+		if (sess->state != GG_STATE_CONNECTING_PROXY_HUB) {
+			free(sess->resolver_result);
+			sess->resolver_result = NULL;
+		}
+
+		sess->state = next_state;
+	}
+
+	return GG_ACTION_NEXT;
+}
+
+static gg_action_t gg_handle_connect_gg(struct gg_session *sess, struct gg_event *e, enum gg_state_t next_state, enum gg_state_t alt_state, enum gg_state_t alt2_state)
+{
+	struct in_addr addr;
+	uint16_t port;
+
+	gg_debug_session(sess, GG_DEBUG_MISC, "resolver_index=%d, connect_index=%d, connect_port={%d,%d}\n", sess->resolver_index, sess->connect_index, sess->connect_port[0], sess->connect_port[1]);
+
+	if ((unsigned int) sess->connect_index >= sizeof(sess->connect_port) / sizeof(sess->connect_port[0]) || sess->connect_port[sess->connect_index] == 0) {
+		sess->connect_index = 0;
+		sess->resolver_index++;
+		if (sess->resolver_index >= sess->resolver_count) {
+			gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() out of addresses to connect to\n");
+			e->event.failure = GG_FAILURE_CONNECTING;
+			return GG_ACTION_FAIL;
+		}
+	}
+
+	addr = sess->resolver_result[sess->resolver_index];
+	port = sess->connect_port[sess->connect_index];
+
+	gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() connecting to %s:%d\n", inet_ntoa(addr), port);
+
+	sess->server_addr = addr.s_addr;
+	sess->fd = gg_connect(&addr, port, sess->async);
+
+	if (sess->fd == -1) {
+		gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() connection failed (errno=%d, %s)\n", errno, strerror(errno));
+		sess->connect_index++;
+		return GG_ACTION_NEXT;
+	}
+
+	sess->state = next_state;
+	sess->check = GG_CHECK_WRITE;
+	sess->timeout = GG_DEFAULT_TIMEOUT;
+	sess->soft_timeout = 1;
+
+	return GG_ACTION_WAIT;
+}
+
+static gg_action_t gg_handle_connecting_gg(struct gg_session *sess, struct gg_event *e, enum gg_state_t next_state, enum gg_state_t alt_state, enum gg_state_t alt2_state)
+{
+	int res;
+
+	sess->soft_timeout = 0;
+
+	/* jeśli wystąpił błąd podczas łączenia się... */
+	if (gg_async_connect_failed(sess, &res)) {
+		gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() connection failed (errno=%d, %s)\n", res, strerror(res));
+		gg_close(sess);
+		sess->connect_index++;
+		sess->state = alt_state;
+		return GG_ACTION_NEXT;
+	}
+
+	free(sess->resolver_result);
+	sess->resolver_result = NULL;
+
+	gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() connected\n");
+
+	if (sess->ssl_flag != GG_SSL_DISABLED) {
+		if (gg_session_init_ssl(sess) == -1) {
+			e->event.failure = GG_FAILURE_TLS;
+			return GG_ACTION_FAIL;
+		}
+
+		sess->state = alt2_state;
+		sess->check = GG_CHECK_WRITE;
+		sess->timeout = GG_DEFAULT_TIMEOUT;
+
+		return GG_ACTION_NEXT;
+	} else {
+		sess->state = next_state;
+		sess->check = GG_CHECK_READ;
+		sess->timeout = GG_DEFAULT_TIMEOUT;
+
+		return GG_ACTION_WAIT;
+	}
+}
+
+static gg_action_t gg_handle_send_hub(struct gg_session *sess, struct gg_event *e, enum gg_state_t next_state, enum gg_state_t alt_state, enum gg_state_t alt2_state)
+{
+	char *req, *client, *auth;
+	const char *host;
+	int res;
+	int proxy;
+	size_t req_len;
+
+	if (sess->client_version != NULL && isdigit(sess->client_version[0]))
+		client = gg_urlencode(sess->client_version);
+	else if (sess->protocol_version <= GG_PROTOCOL_VERSION_100)
+		client = gg_urlencode(GG_DEFAULT_CLIENT_VERSION_100);
+	else /* sess->protocol_version >= GG_PROTOCOL_VERSION_110 */
+		client = gg_urlencode(GG_DEFAULT_CLIENT_VERSION_110);
+
+	if (client == NULL) {
+		gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() out of memory for client version\n");
+		return GG_ACTION_FAIL;
+	}
+
+	if (sess->proxy_addr && sess->proxy_port) {
+		host = "http://" GG_APPMSG_HOST;
+		proxy = 1;
+	} else {
+		host = "";
+		proxy = 0;
+	}
+
+	auth = gg_proxy_auth();
+
+	if (sess->ssl_flag != GG_SSL_DISABLED) {
+		req = gg_saprintf
+			("GET %s/appsvc/appmsg_ver10.asp?fmnumber=%u&fmt=2&lastmsg=%d&version=%s&age=2&gender=1 HTTP/1.0\r\n"
+			"Connection: close\r\n"
+			"Host: " GG_APPMSG_HOST "\r\n"
+			"%s"
+			"\r\n", host, sess->uin, sess->last_sysmsg, client, (auth) ? auth : "");
+	} else {
+		req = gg_saprintf
+			("GET %s/appsvc/appmsg_ver8.asp?fmnumber=%u&fmt=2&lastmsg=%d&version=%s HTTP/1.0\r\n"
+			"Host: " GG_APPMSG_HOST "\r\n"
+			"%s"
+			"\r\n", host, sess->uin, sess->last_sysmsg, client, (auth) ? auth : "");
+	}
+
+	if (req == NULL) {
+		gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() out of memory\n");
+		e->event.failure = GG_FAILURE_PROXY;
+		return GG_ACTION_FAIL;
+	}
+
+	req_len = strlen(req);
+
+	free(auth);
+	free(client);
+
+	gg_debug_session(sess, GG_DEBUG_TRAFFIC, "// sending http query:\n%s", req);
+
+	res = send(sess->fd, req, req_len, 0);
+
+	free(req);
+	
+	if (res == -1 && errno != EINTR && errno != EAGAIN) {
+		gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() sending query failed\n");
+		e->event.failure = (!proxy) ? GG_FAILURE_HUB : GG_FAILURE_PROXY;
+		return GG_ACTION_FAIL;
+	}
+
+	if ((size_t) res < req_len) {
+		sess->state = alt_state;
+		sess->check = GG_CHECK_WRITE;
+		sess->timeout = GG_DEFAULT_TIMEOUT;
+	} else {
+		sess->state = next_state;
+		sess->check = GG_CHECK_READ;
+		sess->timeout = GG_DEFAULT_TIMEOUT;
+	}
+
+	return GG_ACTION_WAIT;
+}
+
+static gg_action_t gg_handle_sending_hub_proxy(struct gg_session *sess, struct gg_event *e, enum gg_state_t next_state, enum gg_state_t alt_state, enum gg_state_t alt2_state)
+{
+	if (gg_send_queued_data(sess) == -1) {
+		e->event.failure = GG_FAILURE_WRITING;
+		return GG_ACTION_FAIL;
+	}
+
+	if (sess->send_left > 0)
+		return GG_ACTION_WAIT;
+
+	sess->state = next_state;
+	sess->check = GG_CHECK_READ;
+	sess->timeout = GG_DEFAULT_TIMEOUT;
+
+	return GG_ACTION_WAIT;
+}
+
+static gg_action_t gg_handle_reading_hub_proxy(struct gg_session *sess, struct gg_event *e, enum gg_state_t next_state, enum gg_state_t alt_state, enum gg_state_t alt2_state)
+{
+	char buf[1024], *tmp, host[128];
+	int port = GG_DEFAULT_PORT;
+	int reply;
+	const char *body;
+	struct in_addr addr;
+	int res;
+	char **host_white;
+	char *host_white_default[] = GG_DEFAULT_HOST_WHITE_LIST;
+
+	res = recv(sess->fd, buf, sizeof(buf), 0);
+
+	if (res == -1 && (errno == EAGAIN || errno == EINTR)) {
+		gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() non-critical recv error (errno=%d, %s)\n", errno, strerror(errno));
+		return GG_ACTION_WAIT;
+	}
+
+	if (res == -1) {
+		gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() recv error (errno=%d, %s)\n", errno, strerror(errno));
+		e->event.failure = GG_FAILURE_CONNECTING;
+		return GG_ACTION_FAIL;
+	}
+
+	if (res != 0) {
+		tmp = realloc(sess->recv_buf, sess->recv_done + res + 1);
+
+		if (tmp == NULL) {
+			gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() not enough memory for http reply\n");
+			return GG_ACTION_FAIL;
+		}
+
+		sess->recv_buf = tmp;
+		memcpy(sess->recv_buf + sess->recv_done, buf, res);
+		sess->recv_done += res;
+		sess->recv_buf[sess->recv_done] = 0;
+	}
+
+	if (res == 0 && sess->recv_buf == NULL) {
+		gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() connection closed\n");
+		e->event.failure = GG_FAILURE_CONNECTING;
+		return GG_ACTION_FAIL;
+	}
+
+	if (res != 0)
+		return GG_ACTION_WAIT;
+
+	gg_debug_session(sess, GG_DEBUG_TRAFFIC, "// received http reply:\n%s", sess->recv_buf);
+
+	res = sscanf(sess->recv_buf, "HTTP/1.%*d %3d ", &reply);
+
+	/* sprawdzamy, czy wszystko w porządku. */
+	if (res != 1 || reply != 200) {
+		gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() invalid http reply, connection failed\n");
+		e->event.failure = GG_FAILURE_CONNECTING;
+		return GG_ACTION_FAIL;
+	}
+
+	/* szukamy początku treści */
+	body = strstr(sess->recv_buf, "\r\n\r\n");
+	
+	if (body == NULL) {
+		body = strstr(sess->recv_buf, "\n\n");
+
+		if (body == NULL) {
+			gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() can't find body\n");
+			e->event.failure = GG_FAILURE_CONNECTING;
+			return GG_ACTION_FAIL;
+		} else {
+			body += 2;
+		}
+	} else {
+		body += 4;
+	}
+
+	// 17591 0 91.197.13.71:8074 91.197.13.71
+	res = sscanf(body, "%d %*d %128s", &reply, host);
+
+	if (res != 2) {
+		gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() invalid hub reply, connection failed\n");
+		e->event.failure = GG_FAILURE_CONNECTING;
+		return GG_ACTION_FAIL;
+	}
+
+	gg_debug_session(sess, GG_DEBUG_MISC, "reply=%d, host=\"%s\"\n", reply, host);
+
+	/* jeśli pierwsza liczba w linii nie jest równa zeru,
+	 * oznacza to, że mamy wiadomość systemową. */
+	if (reply != 0) {
+		tmp = strchr(body, '\n');
+
+		if (tmp != NULL) {
+			e->type = GG_EVENT_MSG;
+			e->event.msg.msgclass = reply;
+			e->event.msg.sender = 0;
+			e->event.msg.message = (unsigned char*) strdup(tmp + 1);
+
+			if (e->event.msg.message == NULL) {
+				gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() not enough memory for system message\n");
+				return GG_ACTION_FAIL;
+			}
+		}
+	}
+
+	gg_close(sess);
+
+	tmp = strchr(host, ':');
+
+	if (tmp != NULL) {
+		*tmp = 0;
+		port = atoi(tmp + 1);
+	}
+
+	if (strcmp(host, "notoperating") == 0) {
+		gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() service unavailable\n", errno, strerror(errno));
+		e->event.failure = GG_FAILURE_UNAVAILABLE;
+		return GG_ACTION_FAIL;
+	}
+
+	addr.s_addr = inet_addr(host);
+	if (addr.s_addr == INADDR_NONE)
+		addr.s_addr = 0;
+	sess->server_addr = addr.s_addr;
+
+	free(sess->recv_buf);
+	sess->recv_buf = NULL;
+	sess->recv_done = 0;
+
+	if (sess->state != GG_STATE_READING_PROXY_HUB) {
+		if (sess->port == 0) {
+			sess->connect_port[0] = port;
+			sess->connect_port[1] = (port != GG_HTTPS_PORT) ? GG_HTTPS_PORT : 0;
+		} else {
+			sess->connect_port[0] = sess->port;
+			sess->connect_port[1] = 0;
+		}
+	} else {
+		sess->connect_port[0] = (sess->port == 0) ? GG_HTTPS_PORT : sess->port;
+		sess->connect_port[1] = 0;
+	}
+
+	free(sess->connect_host);
+	sess->connect_host = strdup(host);
+
+	if (sess->connect_host == NULL) {
+		gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() not enough memory\n");
+		return GG_ACTION_FAIL;
+	}
+
+	host_white = sess->private_data->host_white_list;
+	if (!host_white)
+		host_white = host_white_default;
+
+	if (sess->ssl_flag == GG_SSL_REQUIRED && host_white[0] != NULL) {
+		int host_ok = 0;
+		char **it;
+		int host_len;
+
+		host_len = strlen(sess->connect_host);
+
+		for (it = host_white; *it != NULL; it++) {
+			const char *white = *it;
+			int white_len, dom_offset;
+
+			white_len = strlen(white);
+			if (white_len > host_len)
+				continue;
+
+			dom_offset = host_len - white_len;
+			if (strncasecmp(sess->connect_host + dom_offset, white,
+				white_len) != 0)
+			{
+				continue;
+			}
+
+			if (white_len < host_len) {
+				if (sess->connect_host[dom_offset - 1] != '.')
+					continue;
+			}
+
+			host_ok = 1;
+			break;
+		}
+
+		if (!host_ok) {
+			gg_debug_session(sess, GG_DEBUG_MISC | GG_DEBUG_ERROR,
+				"// gg_watch_fd() the HUB server returned "
+				"a host that is not trusted (%s)\n",
+				sess->connect_host);
+			e->event.failure = GG_FAILURE_TLS;
+			return GG_ACTION_FAIL;
+		}
+	}
+
+	if (sess->state == GG_STATE_READING_HUB)
+		sess->resolver_host = sess->connect_host;
+
+	/* Jeśli łączymy się przez proxy, zacznijmy od początku listy */
+	sess->resolver_index = 0;
+
+	sess->state = (sess->async) ? next_state : alt_state;
+
+	return GG_ACTION_NEXT;
+}
+
+static gg_action_t gg_handle_send_proxy_gg(struct gg_session *sess, struct gg_event *e, enum gg_state_t next_state, enum gg_state_t alt_state, enum gg_state_t alt2_state)
+{
+	char *req, *auth;
+	size_t req_len;
+	int res;
+
+	gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() %s\n", gg_debug_state(sess->state));
+
+	if (sess->connect_index > 1 || sess->connect_port[sess->connect_index] == 0) {
+		gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() out of connection candidates\n");
+		e->event.failure = GG_FAILURE_CONNECTING;
+		return GG_ACTION_FAIL;
+	}
+
+	auth = gg_proxy_auth();
+
+	req = gg_saprintf("CONNECT %s:%d HTTP/1.0\r\n%s\r\n", sess->connect_host, sess->connect_port[sess->connect_index], (auth) ? auth : "");
+
+	free(auth);
+
+	sess->connect_index++;
+
+	if (req == NULL) {
+		gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() out of memory\n");
+		e->event.failure = GG_FAILURE_PROXY;
+		return GG_ACTION_FAIL;
+	}
+
+	req_len = strlen(req);
+
+	gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() proxy request:\n%s", req);
+
+	res = send(sess->fd, req, req_len, 0);
+
+	free(req);
+
+	if (res == -1 && errno != EINTR && errno != EAGAIN) {
+		gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() sending query failed\n");
+		e->event.failure = GG_FAILURE_PROXY;
+		return GG_ACTION_FAIL;
+	}
+
+	if ((size_t) res < req_len) {
+		sess->state = alt_state;
+		sess->check = GG_CHECK_WRITE;
+		sess->timeout = GG_DEFAULT_TIMEOUT;
+	} else {
+		sess->state = next_state;
+		sess->check = GG_CHECK_READ;
+		sess->timeout = GG_DEFAULT_TIMEOUT;
+	}
+
+	return GG_ACTION_WAIT;
+}
+
+static gg_action_t gg_handle_tls_negotiation(struct gg_session *sess, struct gg_event *e, enum gg_state_t next_state, enum gg_state_t alt_state, enum gg_state_t alt2_state)
+{
+	int valid_hostname = 0;
+
+#ifdef GG_CONFIG_HAVE_GNUTLS
+	unsigned int status;
+	int res;
+
+	gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() GG_STATE_TLS_NEGOTIATION\n");
+
+	for (;;) {
+		res = gnutls_handshake(GG_SESSION_GNUTLS(sess));
+
+		if (res == GNUTLS_E_AGAIN) {
+			gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() TLS handshake GNUTLS_E_AGAIN\n");
+
+			if (gnutls_record_get_direction(GG_SESSION_GNUTLS(sess)) == 0)
+				sess->check = GG_CHECK_READ;
+			else
+				sess->check = GG_CHECK_WRITE;
+			sess->timeout = GG_DEFAULT_TIMEOUT;
+			return GG_ACTION_WAIT;
+		}
+
+		if (res == GNUTLS_E_INTERRUPTED) {
+			gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() TLS handshake GNUTLS_E_INTERRUPTED\n");
+			continue;
+		}
+
+		if (res != GNUTLS_E_SUCCESS) {
+			gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() TLS handshake error: %d, %s\n", res, gnutls_strerror(res));
+			e->event.failure = GG_FAILURE_TLS;
+			return GG_ACTION_FAIL;
+		}
+
+		break;
+	}
+
+	gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() TLS negotiation succeded:\n");
+	gg_debug_session(sess, GG_DEBUG_MISC, "//   cipher: VERS-%s:%s:%s:%s:COMP-%s\n",
+		gnutls_protocol_get_name(gnutls_protocol_get_version(GG_SESSION_GNUTLS(sess))),
+		gnutls_cipher_get_name(gnutls_cipher_get(GG_SESSION_GNUTLS(sess))),
+		gnutls_kx_get_name(gnutls_kx_get(GG_SESSION_GNUTLS(sess))),
+		gnutls_mac_get_name(gnutls_mac_get(GG_SESSION_GNUTLS(sess))),
+		gnutls_compression_get_name(gnutls_compression_get(GG_SESSION_GNUTLS(sess))));
+
+	if (gnutls_certificate_type_get(GG_SESSION_GNUTLS(sess)) == GNUTLS_CRT_X509) {
+		unsigned int peer_count;
+		const gnutls_datum_t *peers;
+		gnutls_x509_crt_t cert;
+
+		if (gnutls_x509_crt_init(&cert) == 0) {
+			peers = gnutls_certificate_get_peers(GG_SESSION_GNUTLS(sess), &peer_count);
+
+			if (peers != NULL) {
+				char buf[256];
+				size_t size;
+
+				if (gnutls_x509_crt_import(cert, &peers[0], GNUTLS_X509_FMT_DER) == 0) {
+					size = sizeof(buf);
+					gnutls_x509_crt_get_dn(cert, buf, &size);
+					gg_debug_session(sess, GG_DEBUG_MISC, "//   cert subject: %s\n", buf);
+					size = sizeof(buf);
+					gnutls_x509_crt_get_issuer_dn(cert, buf, &size);
+					gg_debug_session(sess, GG_DEBUG_MISC, "//   cert issuer: %s\n", buf);
+
+					if (gnutls_x509_crt_check_hostname(cert, sess->connect_host) != 0)
+						valid_hostname = 1;
+				}
+			}
+
+			gnutls_x509_crt_deinit(cert);
+		}
+	}
+
+	res = gnutls_certificate_verify_peers2(GG_SESSION_GNUTLS(sess), &status);
+
+	if (res != 0 || status != 0) {
+		gg_debug_session(sess, GG_DEBUG_MISC, "//   WARNING!  unable to verify peer certificate: 0x%x, %d, %s\n", status, res, gnutls_strerror(res));
+
+		if (sess->ssl_flag == GG_SSL_REQUIRED) {
+			e->event.failure = GG_FAILURE_TLS;
+			return GG_ACTION_FAIL;
+		}
+	} else {
+		gg_debug_session(sess, GG_DEBUG_MISC, "//   verified peer certificate\n");
+	}
+
+
+#elif defined GG_CONFIG_HAVE_OPENSSL
+
+	X509 *peer;
+	int res;
+
+	gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() %s\n", gg_debug_state(sess->state));
+
+	res = SSL_connect(GG_SESSION_OPENSSL(sess));
+
+	if (res <= 0) {
+		int err;
+		
+		err = SSL_get_error(GG_SESSION_OPENSSL(sess), res);
+
+		if (res == 0) {
+			gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() disconnected during TLS negotiation\n");
+			e->event.failure = GG_FAILURE_TLS;
+			return GG_ACTION_FAIL;
+		}
+
+		if (err == SSL_ERROR_WANT_READ) {
+			gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() SSL_connect() wants to read\n");
+
+			sess->check = GG_CHECK_READ;
+			sess->timeout = GG_DEFAULT_TIMEOUT;
+			return GG_ACTION_WAIT;
+		} else if (err == SSL_ERROR_WANT_WRITE) {
+			gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() SSL_connect() wants to write\n");
+
+			sess->check = GG_CHECK_WRITE;
+			sess->timeout = GG_DEFAULT_TIMEOUT;
+			return GG_ACTION_WAIT;
+		} else {
+			char buf[256];
+
+			ERR_error_string_n(ERR_get_error(), buf, sizeof(buf));
+
+			gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() SSL_connect() bailed out: %s\n", buf);
+
+			e->event.failure = GG_FAILURE_TLS;
+			return GG_ACTION_FAIL;
+		}
+	}
+
+	gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() TLS negotiation succeded:\n//   cipher: %s\n", SSL_get_cipher_name(GG_SESSION_OPENSSL(sess)));
+
+	peer = SSL_get_peer_certificate(GG_SESSION_OPENSSL(sess));
+
+	if (peer == NULL) {
+		gg_debug_session(sess, GG_DEBUG_MISC, "//   WARNING! unable to get peer certificate!\n");
+
+		if (sess->ssl_flag == GG_SSL_REQUIRED) {
+			e->event.failure = GG_FAILURE_TLS;
+			return GG_ACTION_FAIL;
+		}
+	} else {
+		char buf[256];
+		long res;
+
+		X509_NAME_oneline(X509_get_subject_name(peer), buf, sizeof(buf));
+		gg_debug_session(sess, GG_DEBUG_MISC, "//   cert subject: %s\n", buf);
+
+		X509_NAME_oneline(X509_get_issuer_name(peer), buf, sizeof(buf));
+		gg_debug_session(sess, GG_DEBUG_MISC, "//   cert issuer: %s\n", buf);
+
+		res = SSL_get_verify_result(GG_SESSION_OPENSSL(sess));
+
+		if (res != X509_V_OK) {
+			gg_debug_session(sess, GG_DEBUG_MISC, "//   WARNING!  unable to verify peer certificate! res=%ld\n", res);
+
+			if (sess->ssl_flag == GG_SSL_REQUIRED) {
+				e->event.failure = GG_FAILURE_TLS;
+				return GG_ACTION_FAIL;
+			}
+		} else {
+			gg_debug_session(sess, GG_DEBUG_MISC, "//   verified peer certificate\n");
+		}
+
+		if (X509_NAME_get_text_by_NID(X509_get_subject_name(peer), NID_commonName, buf, sizeof(buf)) == -1)
+			buf[0] = 0;
+
+		/* Obsługa certyfikatów z wieloznacznikiem */
+		if (strchr(buf, '*') == buf && strchr(buf + 1, '*') == NULL) {
+			char *tmp;
+
+			tmp = strchr(sess->connect_host, '.');
+
+			if (tmp != NULL)
+				valid_hostname = (strcasecmp(tmp, buf + 1) == 0);
+		} else {
+			valid_hostname = (strcasecmp(sess->connect_host, buf) == 0);
+		}
+	}
+
+#else
+
+	gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() no SSL support\n");
+	e->event.failure = GG_FAILURE_TLS;
+	return GG_ACTION_FAIL;
+
+#endif
+
+	if (!valid_hostname) {
+		gg_debug_session(sess, GG_DEBUG_MISC, "//   WARNING!  unable to verify hostname\n");
+
+		if (sess->ssl_flag == GG_SSL_REQUIRED) {
+			e->event.failure = GG_FAILURE_TLS;
+			return GG_ACTION_FAIL;
+		}
+	}
+
+	sess->state = next_state;
+	sess->check = GG_CHECK_READ;
+	sess->timeout = GG_DEFAULT_TIMEOUT;
+
+	return GG_ACTION_WAIT;
+}
+
+static gg_action_t gg_handle_reading_proxy_gg(struct gg_session *sess, struct gg_event *e, enum gg_state_t next_state, enum gg_state_t alt_state, enum gg_state_t alt2_state)
+{
+	char buf[256];
+	int res;
+	int reply;
+	char *body;
+
+	res = recv(sess->fd, buf, sizeof(buf), 0);
+
+	gg_debug_session(sess, GG_DEBUG_MISC, "recv() = %d\n", res);
+
+	if (res == -1 && (errno == EAGAIN || errno == EINTR)) {
+		gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() non-critical recv error (errno=%d, %s)\n", errno, strerror(errno));
+		return GG_ACTION_WAIT;
+	}
+
+	if (res == -1) {
+		gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() recv error (errno=%d, %s)\n", errno, strerror(errno));
+		e->event.failure = GG_FAILURE_CONNECTING;
+		return GG_ACTION_FAIL;
+	}
+
+	if (res != 0) {
+		char *tmp;
+
+		tmp = realloc(sess->recv_buf, sess->recv_done + res + 1);
+
+		if (tmp == NULL) {
+			gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() not enough memory for http reply\n");
+			return GG_ACTION_FAIL;
+		}
+
+		sess->recv_buf = tmp;
+		memcpy(sess->recv_buf + sess->recv_done, buf, res);
+		sess->recv_done += res;
+		sess->recv_buf[sess->recv_done] = 0;
+	}
+
+	if (res == 0 && sess->recv_buf == NULL) {
+		gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() connection closed\n");
+		e->event.failure = GG_FAILURE_CONNECTING;
+		return GG_ACTION_FAIL;
+	}
+
+	/* szukamy początku treści */
+	body = strstr(sess->recv_buf, "\r\n\r\n");
+	
+	if (body == NULL) {
+		body = strstr(sess->recv_buf, "\n\n");
+
+		if (body == NULL) {
+			gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() can't find body\n");
+			e->event.failure = GG_FAILURE_CONNECTING;
+			return GG_ACTION_FAIL;
+		} else {
+			body += 2;
+		}
+	} else {
+		body += 4;
+	}
+
+	if (res != 0 && body == NULL)
+		return GG_ACTION_WAIT;
+
+	gg_debug_session(sess, GG_DEBUG_TRAFFIC, "// received proxy reply:\n%s\n", sess->recv_buf);
+
+	res = sscanf(sess->recv_buf, "HTTP/1.%*d %3d ", &reply);
+
+	gg_debug_session(sess, GG_DEBUG_MISC, "res = %d, reply = %d\n", res, reply);
+
+	/* sprawdzamy, czy wszystko w porządku. */
+	if (res != 1 || reply != 200) {
+		gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() invalid http reply, connection failed\n");
+		e->event.failure = GG_FAILURE_CONNECTING;
+		return GG_ACTION_FAIL;
+	}
+
+	if (body == NULL) {
+		gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() can't find body\n");
+		e->event.failure = GG_FAILURE_CONNECTING;
+		return GG_ACTION_FAIL;
+	}
+
+	gg_debug_session(sess, GG_DEBUG_MISC, "// found body!\n");
+
+	if (sess->ssl_flag != GG_SSL_DISABLED) {
+		if (gg_session_init_ssl(sess) == -1) {
+			e->event.failure = GG_FAILURE_TLS;
+			return GG_ACTION_FAIL;
+		}
+
+		/* Teoretycznie SSL jest inicjowany przez klienta, więc serwer
+		 * nie powinien niczego wysłać. */
+		if (sess->recv_buf + sess->recv_done > body) {
+			gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() unexpected SSL data\n");
+			e->event.failure = GG_FAILURE_TLS;
+			return GG_ACTION_FAIL;
+		}
+
+		free(sess->recv_buf);
+		sess->recv_buf = NULL;
+		sess->recv_done = 0;
+
+		sess->state = alt_state;
+		sess->check = GG_CHECK_WRITE;
+		sess->timeout = GG_DEFAULT_TIMEOUT;
+
+		return GG_ACTION_WAIT;
+	}
+
+	sess->state = next_state;
+	sess->check = GG_CHECK_READ;
+	sess->timeout = GG_DEFAULT_TIMEOUT;	/* Pierwszy pakiet musi przyjść */
+
+	// Jeśli zbuforowaliśmy za dużo, przeanalizuj
+
+	if (sess->recv_buf + sess->recv_done > body) {
+		sess->recv_done = sess->recv_done - (body - sess->recv_buf);
+		memmove(sess->recv_buf, body, sess->recv_done);
+		sess->state = alt2_state;
+		return GG_ACTION_NEXT;
+	} else {
+		free(sess->recv_buf);
+		sess->recv_buf = NULL;
+		sess->recv_done = 0;
+	}
+
+	return GG_ACTION_WAIT;
+}
+
+static gg_action_t gg_handle_connected(struct gg_session *sess, struct gg_event *e, enum gg_state_t next_state, enum gg_state_t alt_state, enum gg_state_t alt2_state)
+{
+#if 0
+	char buf[1024];
+	int res;
+
+	if (gg_send_queued_data(sess) == -1)
+		return GG_ACTION_FAIL;
+
+	res = gg_read(sess, buf, sizeof(buf));
+
+	if (res == -1 && (errno == EAGAIN || errno == EINTR)) {
+		gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() non-critical read error (errno=%d, %s)\n", errno, strerror(errno));
+		return GG_ACTION_WAIT;
+	}
+	
+	if (res == -1 || res == 0) {
+		if (res == -1)
+			gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() read error (errno=%d, %s)\n", errno, strerror(errno));
+		else
+			gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() connection closed\n");
+
+		if (sess->state == GG_STATE_DISCONNECTING && res == 0) {
+			e->type = GG_EVENT_DISCONNECT_ACK;
+		} else if (sess->state == GG_STATE_READING_KEY) {
+			e->event.failure = GG_FAILURE_INVALID;
+			return GG_ACTION_FAIL;
+		}
+
+		return GG_ACTION_FAIL;
+	}
+
+	gg_debug_dump(sess, GG_DEBUG_DUMP, buf, res);
+
+	if (gg_session_handle_data(sess, buf, res, e) == -1)
+		return GG_ACTION_FAIL;
+
+	if (sess->send_buf != NULL)
+		sess->check |= GG_CHECK_WRITE;
+
+	return GG_ACTION_WAIT;
+#else
+	struct gg_header *gh;
+
+	if (gg_send_queued_data(sess) == -1)
+		return GG_ACTION_FAIL;
+
+	gh = gg_recv_packet(sess);
+
+	if (gh == NULL) {
+		if (sess->state == GG_STATE_DISCONNECTING) {
+			gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() connection broken expectedly\n");
+			e->type = GG_EVENT_DISCONNECT_ACK;
+			return GG_ACTION_WAIT;
+		}
+
+		if (errno != EAGAIN) {
+			gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() gg_recv_packet failed (errno=%d, %s)\n", errno, strerror(errno));
+			return GG_ACTION_FAIL;
+		}
+	} else {
+		if (gg_session_handle_packet(sess, gh->type, (const char *) gh + sizeof(struct gg_header), gh->length, e) == -1) {
+			free(gh);
+			return GG_ACTION_FAIL;
+		}
+
+		free(gh);
+	}
+
+	sess->check = GG_CHECK_READ;
+
+	if (sess->send_buf != NULL)
+		sess->check |= GG_CHECK_WRITE;
+
+	return GG_ACTION_WAIT;
+#endif
+}
+
+static gg_action_t gg_handle_error(struct gg_session *sess, struct gg_event *e, enum gg_state_t next_state, enum gg_state_t alt_state, enum gg_state_t alt2_state)
+{
+	struct gg_session_private *p = sess->private_data;
+
+	gg_debug_session(sess, GG_DEBUG_MISC | GG_DEBUG_ERROR, "// gg_handle_error() failure=%d\n", p->socket_failure);
+
+	e->event.failure = p->socket_failure;
+
+	return GG_ACTION_FAIL;
+}
+
+static const gg_state_transition_t handlers[] =
+{
+	{ GG_STATE_RESOLVE_HUB_SYNC, gg_handle_resolve_sync, GG_STATE_CONNECT_HUB, GG_STATE_SEND_HUB, 0 },
+	{ GG_STATE_RESOLVE_GG_SYNC, gg_handle_resolve_sync, GG_STATE_CONNECT_GG, GG_STATE_READING_KEY, 0 },
+	{ GG_STATE_RESOLVE_PROXY_HUB_SYNC, gg_handle_resolve_sync, GG_STATE_CONNECT_PROXY_HUB, GG_STATE_SEND_PROXY_HUB, 0 },
+	{ GG_STATE_RESOLVE_PROXY_GG_SYNC, gg_handle_resolve_sync, GG_STATE_CONNECT_PROXY_GG, GG_STATE_SEND_PROXY_GG, 0 },
+
+	{ GG_STATE_RESOLVE_HUB_ASYNC, gg_handle_resolve_async, GG_STATE_RESOLVING_HUB, GG_STATE_SEND_HUB, 0 },
+	{ GG_STATE_RESOLVE_GG_ASYNC, gg_handle_resolve_async, GG_STATE_RESOLVING_GG, GG_STATE_READING_KEY, 0 },
+	{ GG_STATE_RESOLVE_PROXY_HUB_ASYNC, gg_handle_resolve_async, GG_STATE_RESOLVING_PROXY_HUB, GG_STATE_SEND_PROXY_HUB, 0 },
+	{ GG_STATE_RESOLVE_PROXY_GG_ASYNC, gg_handle_resolve_async, GG_STATE_RESOLVING_PROXY_GG, GG_STATE_SEND_PROXY_GG, 0 },
+
+	{ GG_STATE_RESOLVING_HUB, gg_handle_resolving, GG_STATE_CONNECT_HUB, 0, 0 },
+	{ GG_STATE_RESOLVING_GG, gg_handle_resolving, GG_STATE_CONNECT_GG, 0, 0 },
+	{ GG_STATE_RESOLVING_PROXY_HUB, gg_handle_resolving, GG_STATE_CONNECT_PROXY_HUB, 0, 0 },
+	{ GG_STATE_RESOLVING_PROXY_GG, gg_handle_resolving, GG_STATE_CONNECT_PROXY_GG, 0, 0 },
+
+	{ GG_STATE_CONNECT_HUB, gg_handle_connect, GG_STATE_CONNECTING_HUB, 0, 0 },
+	{ GG_STATE_CONNECT_PROXY_HUB, gg_handle_connect, GG_STATE_CONNECTING_PROXY_HUB, 0, 0 },
+	{ GG_STATE_CONNECT_PROXY_GG, gg_handle_connect, GG_STATE_CONNECTING_PROXY_GG, 0, 0 },
+
+	{ GG_STATE_CONNECT_GG, gg_handle_connect_gg, GG_STATE_CONNECTING_GG, 0, 0 },
+
+	{ GG_STATE_CONNECTING_HUB, gg_handle_connecting, GG_STATE_SEND_HUB, GG_STATE_CONNECT_HUB, 0 },
+	{ GG_STATE_CONNECTING_PROXY_HUB, gg_handle_connecting, GG_STATE_SEND_PROXY_HUB, GG_STATE_CONNECT_PROXY_HUB, 0 },
+	{ GG_STATE_CONNECTING_PROXY_GG, gg_handle_connecting, GG_STATE_SEND_PROXY_GG, GG_STATE_CONNECT_PROXY_GG, 0 },
+
+	{ GG_STATE_CONNECTING_GG, gg_handle_connecting_gg, GG_STATE_READING_KEY, GG_STATE_CONNECT_GG, GG_STATE_TLS_NEGOTIATION },
+
+	{ GG_STATE_SEND_HUB, gg_handle_send_hub, GG_STATE_READING_HUB, GG_STATE_SENDING_HUB, 0 },
+	{ GG_STATE_SEND_PROXY_HUB, gg_handle_send_hub, GG_STATE_READING_PROXY_HUB, GG_STATE_SENDING_PROXY_HUB, 0 },
+
+	{ GG_STATE_SEND_PROXY_GG, gg_handle_send_proxy_gg, GG_STATE_READING_PROXY_GG, GG_STATE_SENDING_PROXY_GG, 0 },
+
+	{ GG_STATE_SENDING_HUB, gg_handle_sending_hub_proxy, GG_STATE_READING_HUB, 0, 0 },
+	{ GG_STATE_SENDING_PROXY_HUB, gg_handle_sending_hub_proxy, GG_STATE_READING_PROXY_HUB, 0, 0 },
+	{ GG_STATE_SENDING_PROXY_GG, gg_handle_sending_hub_proxy, GG_STATE_READING_PROXY_GG, 0, 0 },
+
+	{ GG_STATE_READING_HUB, gg_handle_reading_hub_proxy, GG_STATE_RESOLVE_GG_ASYNC, GG_STATE_RESOLVE_GG_SYNC, 0 },
+	{ GG_STATE_READING_PROXY_HUB, gg_handle_reading_hub_proxy, GG_STATE_CONNECT_PROXY_GG, GG_STATE_CONNECT_PROXY_GG, 0 },
+
+	{ GG_STATE_READING_PROXY_GG, gg_handle_reading_proxy_gg, GG_STATE_READING_KEY, GG_STATE_TLS_NEGOTIATION, GG_STATE_READING_KEY },
+
+	{ GG_STATE_TLS_NEGOTIATION, gg_handle_tls_negotiation, GG_STATE_READING_KEY, 0, 0 },
+
+	{ GG_STATE_READING_KEY, gg_handle_connected, 0, 0, 0 },
+	{ GG_STATE_READING_REPLY, gg_handle_connected, 0, 0, 0 },
+	{ GG_STATE_CONNECTED, gg_handle_connected, 0, 0, 0 },
+	{ GG_STATE_DISCONNECTING, gg_handle_connected, 0, 0, 0 },
+	{ GG_STATE_ERROR, gg_handle_error, 0, 0, 0 },
+};
+
+struct gg_event *gg_eventqueue_add(struct gg_session *sess)
+{
+	struct gg_event *ge;
+	gg_eventqueue_t *queue_el, *it;
+
+	queue_el = gg_new0(sizeof(gg_eventqueue_t));
+	ge = gg_new0(sizeof(struct gg_event));
+
+	if (queue_el == NULL || ge == NULL) {
+		free(queue_el);
+		free(ge);
+		return NULL;
+	}
+
+	ge->type = GG_EVENT_NONE;
+
+	queue_el->event = ge;
+	if (sess->private_data->event_queue == NULL)
+		sess->private_data->event_queue = queue_el;
+	else {
+		it = sess->private_data->event_queue;
+		while (it->next != NULL)
+			it = it->next;
+		it->next = queue_el;
+	}
+
+	return ge;
+}
+
+/**
  * Funkcja wywoływana po zaobserwowaniu zmian na deskryptorze sesji.
  *
  * Funkcja zwraca strukturę zdarzenia \c gg_event. Jeśli rodzaj zdarzenia
@@ -227,787 +1697,99 @@
  */
 struct gg_event *gg_watch_fd(struct gg_session *sess)
 {
-	struct gg_event *e;
-	int res = 0;
-	int port = 0;
-	int errno2 = 0;
+	struct gg_event *ge;
+	struct gg_session_private *priv;
 
 	gg_debug_session(sess, GG_DEBUG_FUNCTION, "** gg_watch_fd(%p);\n", sess);
 
-	if (!sess) {
+	if (sess == NULL) {
 		errno = EFAULT;
 		return NULL;
 	}
 
-	if (!(e = (void*) calloc(1, sizeof(*e)))) {
+	priv = sess->private_data;
+
+	if (priv->event_queue != NULL) {
+		gg_eventqueue_t *next;
+
+		ge = priv->event_queue->event;
+		next = priv->event_queue->next;
+		free(priv->event_queue);
+		priv->event_queue = next;
+
+		if (next == NULL) {
+			sess->check = priv->check_after_queue;
+			sess->fd = priv->fd_after_queue;
+		}
+		return ge;
+	}
+
+	ge = malloc(sizeof(struct gg_event));
+
+	if (ge == NULL) {
 		gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() not enough memory for event data\n");
 		return NULL;
 	}
 
-	e->type = GG_EVENT_NONE;
-
-	if (sess->send_buf && (sess->state == GG_STATE_READING_REPLY || sess->state == GG_STATE_CONNECTED)) {
-		gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() sending %d bytes of queued data\n", sess->send_left);
-
-		res = write(sess->fd, sess->send_buf, sess->send_left);
-
-		if (res == -1 && errno != EAGAIN) {
-			gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() write() failed (errno=%d, %s)\n", errno, strerror(errno));
-
-			if (sess->state == GG_STATE_READING_REPLY)
-				e->event.failure = GG_FAILURE_CONNECTING;
-
-			goto fail;
-		}
+	memset(ge, 0, sizeof(struct gg_event));
 
-		if (res == sess->send_left) {
-			gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() sent all queued data\n");
-			free(sess->send_buf);
-			sess->send_buf = NULL;
-			sess->send_left = 0;
-		} else if (res > 0) {
-			gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() sent %d bytes of queued data, %d bytes left\n", res, sess->send_left - res);
-
-			memmove(sess->send_buf, sess->send_buf + res, sess->send_left - res);
-			sess->send_left -= res;
-		}
-
-		res = 0;
-	}
-
-	switch (sess->state) {
-		case GG_STATE_RESOLVING:
-		{
-			struct in_addr addr;
-			int failed = 0;
-
-			gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() GG_STATE_RESOLVING\n");
+	ge->type = GG_EVENT_NONE;
 
-			if (read(sess->fd, &addr, sizeof(addr)) < (signed)sizeof(addr) || addr.s_addr == INADDR_NONE) {
-				gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() resolving failed\n");
-				failed = 1;
-				errno2 = errno;
-			}
-
-			close(sess->fd);
-			sess->fd = -1;
-
-			sess->resolver_cleanup(&sess->resolver, 0);
-
-			if (failed) {
-				errno = errno2;
-				goto fail_proxy_hub;
-			}
-
-			/* jeśli jesteśmy w resolverze i mamy ustawiony port
-			 * proxy, znaczy, że resolvowaliśmy proxy. zatem
-			 * wpiszmy jego adres. */
-			if (sess->proxy_port)
-				sess->proxy_addr = addr.s_addr;
-
-			/* zapiszmy sobie adres huba i adres serwera (do
-			 * bezpośredniego połączenia, jeśli hub leży)
-			 * z resolvera. */
-			if (sess->proxy_addr && sess->proxy_port)
-				port = sess->proxy_port;
-			else {
-				sess->server_addr = sess->hub_addr = addr.s_addr;
-				port = GG_APPMSG_PORT;
-			}
-
-			gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() resolved, connecting to %s:%d\n", inet_ntoa(addr), port);
-
-			/* łączymy się albo z hubem, albo z proxy, zależnie
-			 * od tego, co resolvowaliśmy. */
-			if ((sess->fd = gg_connect(&addr, port, sess->async)) == -1) {
-				/* jeśli w trybie asynchronicznym gg_connect()
-				 * zwróci błąd, nie ma sensu próbować dalej. */
-				gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() connection failed (errno=%d, %s), critical\n", errno, strerror(errno));
-				goto fail_proxy_hub;
-			}
+	for (;;) {
+		unsigned int i, found = 0;
+		gg_action_t res;
 
-			/* jeśli podano serwer i łączmy się przez proxy,
-			 * jest to bezpośrednie połączenie, inaczej jest
-			 * do huba. */
-
-			if (sess->proxy_addr && sess->proxy_port && sess->server_addr) {
-				sess->state = GG_STATE_CONNECTING_GG;
-				sess->soft_timeout = 1;
-			} else
-				sess->state = GG_STATE_CONNECTING_HUB;
-
-			sess->check = GG_CHECK_WRITE;
-			sess->timeout = GG_DEFAULT_TIMEOUT;
-
-			break;
-		}
-
-		case GG_STATE_CONNECTING_HUB:
-		{
-			char buf[1024], *client, *auth;
-			int res = 0;
-			socklen_t res_size = sizeof(res);
-			const char *host;
-
-			gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() GG_STATE_CONNECTING_HUB\n");
-
-			/* jeśli asynchroniczne, sprawdzamy, czy nie wystąpił
-			 * przypadkiem jakiś błąd. */
-			if (sess->async && (getsockopt(sess->fd, SOL_SOCKET, SO_ERROR, &res, &res_size) || res)) {
-				gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() connection to %s failed (errno=%d, %s)\n", (sess->proxy_addr && sess->proxy_port) ? "proxy" : "hub", res, strerror(res));
-				goto fail_proxy_hub;
-			}
-
-			gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() connected to hub, sending query\n");
-
-			if (sess->client_version != NULL && isdigit(sess->client_version[0]))
-				client = gg_urlencode(sess->client_version);
-			else
-				client = gg_urlencode(GG_DEFAULT_CLIENT_VERSION);
-
-			if (client == NULL) {
-				gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() out of memory for client version\n");
-				goto fail;
-			}
+		res = GG_ACTION_FAIL;
 
-			if (!gg_proxy_http_only && sess->proxy_addr && sess->proxy_port)
-				host = "http://" GG_APPMSG_HOST;
-			else
-				host = "";
-
-			auth = gg_proxy_auth();
-
-#if defined(GG_CONFIG_HAVE_GNUTLS) || defined(GG_CONFIG_HAVE_OPENSSL)
-			if (sess->ssl != NULL) {
-				snprintf(buf, sizeof(buf) - 1,
-					"GET %s/appsvc/appmsg_ver10.asp?fmnumber=%u&fmt=2&lastmsg=%d&version=%s&age=2&gender=1 HTTP/1.0\r\n"
-					"Connection: close\r\n"
-					"Host: " GG_APPMSG_HOST "\r\n"
-					"%s"
-					"\r\n", host, sess->uin, sess->last_sysmsg, client, (auth) ? auth : "");
-			} else
-#endif
-			{
-				snprintf(buf, sizeof(buf) - 1,
-					"GET %s/appsvc/appmsg_ver8.asp?fmnumber=%u&fmt=2&lastmsg=%d&version=%s HTTP/1.0\r\n"
-					"Host: " GG_APPMSG_HOST "\r\n"
-					"%s"
-					"\r\n", host, sess->uin, sess->last_sysmsg, client, (auth) ? auth : "");
+		for (i = 0; i < sizeof(handlers) / sizeof(handlers[0]); i++) {
+			if (handlers[i].state == (enum gg_state_t) sess->state) {
+				gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() %s\n", gg_debug_state(sess->state));
+				res = (*handlers[i].handler)(sess, ge, handlers[i].next_state, handlers[i].alt_state, handlers[i].alt2_state);
+				found = 1;
+				break;
 			}
-
-			free(auth);
-			free(client);
-
-			gg_debug_session(sess, GG_DEBUG_MISC, "=> -----BEGIN-HTTP-QUERY-----\n%s\n=> -----END-HTTP-QUERY-----\n", buf);
-
-			/* zapytanie jest krótkie, więc zawsze zmieści się
-			 * do bufora gniazda. jeśli write() zwróci mniej,
-			 * stało się coś złego. */
-			if (write(sess->fd, buf, strlen(buf)) < (signed)strlen(buf)) {
-				gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() sending query failed\n");
-				goto fail_proxy_hub;
-			}
-
-			sess->state = GG_STATE_READING_DATA;
-			sess->check = GG_CHECK_READ;
-			sess->timeout = GG_DEFAULT_TIMEOUT;
-
-			break;
 		}
 
-		case GG_STATE_READING_DATA:
-		{
-			char buf[1024], *tmp, *host;
-			int port = GG_DEFAULT_PORT;
-			struct in_addr addr;
-
-			gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() GG_STATE_READING_DATA\n");
-
-			/* czytamy linię z gniazda i obcinamy \r\n. */
-			gg_read_line(sess->fd, buf, sizeof(buf) - 1);
-			gg_chomp(buf);
-			gg_debug_session(sess, GG_DEBUG_TRAFFIC, "// gg_watch_fd() received http header (%s)\n", buf);
-
-			/* sprawdzamy, czy wszystko w porządku. */
-			if (strncmp(buf, "HTTP/1.", 7) || strncmp(buf + 9, "200", 3)) {
-				gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() invalid http reply, connection failed\n");
-				goto fail_proxy_hub;
-			}
-
-			/* ignorujemy resztę nagłówka. */
-			while (strcmp(buf, "\r\n") && strcmp(buf, ""))
-				gg_read_line(sess->fd, buf, sizeof(buf) - 1);
-
-			/* czytamy pierwszą linię danych. */
-			if (gg_read_line(sess->fd, buf, sizeof(buf) - 1) == NULL) {
-				gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() read error\n");
-				goto fail_proxy_hub;
-			}
-			gg_chomp(buf);
-
-			/* jeśli pierwsza liczba w linii nie jest równa zeru,
-			 * oznacza to, że mamy wiadomość systemową. */
-			if (atoi(buf)) {
-				char tmp[1024], *foo, *sysmsg_buf = NULL;
-				int len = 0;
-
-				while (gg_read_line(sess->fd, tmp, sizeof(tmp) - 1)) {
-					if (!(foo = realloc(sysmsg_buf, len + strlen(tmp) + 2))) {
-						gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() out of memory for system message, ignoring\n");
-						break;
-					}
-
-					sysmsg_buf = foo;
-
-					if (!len)
-						strcpy(sysmsg_buf, tmp);
-					else
-						strcat(sysmsg_buf, tmp);
-
-					len += strlen(tmp);
-				}
-
-				e->type = GG_EVENT_MSG;
-				e->event.msg.msgclass = atoi(buf);
-				e->event.msg.sender = 0;
-				e->event.msg.message = (unsigned char*) sysmsg_buf;
-			}
-
-			close(sess->fd);
-			sess->fd = -1;
-
-			gg_debug_session(sess, GG_DEBUG_TRAFFIC, "// gg_watch_fd() received http data (%s)\n", buf);
-
-			/* analizujemy otrzymane dane. */
-			tmp = buf;
-
-			while (*tmp && *tmp != ' ')
-				tmp++;
-			while (*tmp && *tmp == ' ')
-				tmp++;
-			while (*tmp && *tmp != ' ')
-				tmp++;
-			while (*tmp && *tmp == ' ')
-				tmp++;
-			host = tmp;
-			while (*tmp && *tmp != ' ')
-				tmp++;
-			*tmp = 0;
-
-			if ((tmp = strchr(host, ':'))) {
-				*tmp = 0;
-				port = atoi(tmp + 1);
-			}
-
-			if (strcmp(host, "") == 0) {
-				gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() invalid response\n");
-				e->event.failure = GG_FAILURE_HUB;
-				goto fail;
-			}
-
-			if (!strcmp(host, "notoperating")) {
-				gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() service unavailable\n", errno, strerror(errno));
-				e->event.failure = GG_FAILURE_UNAVAILABLE;
-				goto fail;
-			}
-
-			addr.s_addr = inet_addr(host);
-			sess->server_addr = addr.s_addr;
-
-			if (!gg_proxy_http_only && sess->proxy_addr && sess->proxy_port) {
-				/* jeśli mamy proxy, łączymy się z nim. */
-				if ((sess->fd = gg_connect(&sess->proxy_addr, sess->proxy_port, sess->async)) == -1) {
-					/* nie wyszło? trudno. */
-					gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() connection to proxy failed (errno=%d, %s)\n", errno, strerror(errno));
-					e->event.failure = GG_FAILURE_PROXY;
-					goto fail;
-				}
-
-				sess->state = GG_STATE_CONNECTING_GG;
-				sess->check = GG_CHECK_WRITE;
-				sess->timeout = GG_DEFAULT_TIMEOUT;
-				sess->soft_timeout = 1;
-				break;
-			}
-
-			sess->port = port;
-
-			/* Jeśli podano nazwę, nie adres serwera... */
-			if (sess->server_addr == INADDR_NONE) {
-				if (sess->resolver_start(&sess->fd, &sess->resolver, host) == -1) {
-					gg_debug(GG_DEBUG_MISC, "// gg_login() resolving failed (errno=%d, %s)\n", errno, strerror(errno));
-					goto fail;
-				}
-
-				sess->state = GG_STATE_RESOLVING_GG;
-				sess->check = GG_CHECK_READ;
-				sess->timeout = GG_DEFAULT_TIMEOUT;
-				break;
-			}
-
-			/* łączymy się z właściwym serwerem. */
-			if ((sess->fd = gg_connect(&addr, sess->port, sess->async)) == -1) {
-				gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() connection failed (errno=%d, %s), trying https\n", errno, strerror(errno));
-
-				sess->port = GG_HTTPS_PORT;
-
-				/* nie wyszło? próbujemy portu 443. */
-				if ((sess->fd = gg_connect(&addr, GG_HTTPS_PORT, sess->async)) == -1) {
-					/* ostatnia deska ratunku zawiodła?
-					 * w takim razie zwijamy manatki. */
-					gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() connection failed (errno=%d, %s)\n", errno, strerror(errno));
-					e->event.failure = GG_FAILURE_CONNECTING;
-					goto fail;
-				}
-			}
-
-			sess->state = GG_STATE_CONNECTING_GG;
-			sess->check = GG_CHECK_WRITE;
-			sess->timeout = GG_DEFAULT_TIMEOUT;
-			sess->soft_timeout = 1;
-
-			break;
-		}
-
-		case GG_STATE_RESOLVING_GG:
-		{
-			struct in_addr addr;
-			int failed = 0;
-
-			gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() GG_STATE_RESOLVING_GG\n");
-
-			if (read(sess->fd, &addr, sizeof(addr)) < (signed)sizeof(addr) || addr.s_addr == INADDR_NONE) {
-				gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() resolving failed\n");
-				failed = 1;
-				errno2 = errno;
-			}
-
-			close(sess->fd);
-			sess->fd = -1;
-
-			sess->resolver_cleanup(&sess->resolver, 0);
-
-			if (failed) {
-				errno = errno2;
-				e->event.failure = GG_FAILURE_RESOLVING;
-				goto fail;
-			}
-
-			sess->server_addr = addr.s_addr;
-
-			/* łączymy się z właściwym serwerem. */
-			if ((sess->fd = gg_connect(&addr, sess->port, sess->async)) == -1) {
-				gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() connection failed (errno=%d, %s), trying https\n", errno, strerror(errno));
-
-				sess->port = GG_HTTPS_PORT;
-
-				/* nie wyszło? próbujemy portu 443. */
-				if ((sess->fd = gg_connect(&addr, GG_HTTPS_PORT, sess->async)) == -1) {
-					/* ostatnia deska ratunku zawiodła?
-					 * w takim razie zwijamy manatki. */
-					gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() connection failed (errno=%d, %s)\n", errno, strerror(errno));
-					e->event.failure = GG_FAILURE_CONNECTING;
-					goto fail;
-				}
-			}
-
-			sess->state = GG_STATE_CONNECTING_GG;
-			sess->check = GG_CHECK_WRITE;
-			sess->timeout = GG_DEFAULT_TIMEOUT;
-			sess->soft_timeout = 1;
-
-			break;
+		if (!found) {
+			gg_debug_session(sess, GG_DEBUG_MISC | GG_DEBUG_ERROR, "// gg_watch_fd() invalid state %s\n", gg_debug_state(sess->state));
+			ge->event.failure = GG_FAILURE_INTERNAL;
 		}
 
-		case GG_STATE_CONNECTING_GG:
-		{
-			int res = 0;
-			socklen_t res_size = sizeof(res);
-
-			gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() GG_STATE_CONNECTING_GG\n");
-
-			sess->soft_timeout = 0;
-
-			/* jeśli wystąpił błąd podczas łączenia się... */
-			if (sess->async && (sess->timeout == 0 || getsockopt(sess->fd, SOL_SOCKET, SO_ERROR, &res, &res_size) || res)) {
-				/* jeśli nie udało się połączenie z proxy,
-				 * nie mamy czego próbować więcej. */
-				if (sess->proxy_addr && sess->proxy_port) {
-					gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() connection to proxy failed (errno=%d, %s)\n", res, strerror(res));
-					e->event.failure = GG_FAILURE_PROXY;
-					goto fail;
-				}
-
-				close(sess->fd);
-				sess->fd = -1;
-
-#ifdef ETIMEDOUT
-				if (sess->timeout == 0)
-					errno = ETIMEDOUT;
-#endif
-
-#if defined(GG_CONFIG_HAVE_GNUTLS) || defined(GG_CONFIG_HAVE_OPENSSL)
-				/* jeśli logujemy się po TLS, nie próbujemy
-				 * się łączyć już z niczym innym w przypadku
-				 * błędu. nie dość, że nie ma sensu, to i
-				 * trzeba by się bawić w tworzenie na nowo
-				 * SSL i SSL_CTX. */
-
-				if (sess->ssl) {
-					gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() connection failed (errno=%d, %s)\n", res, strerror(res));
-					e->event.failure = GG_FAILURE_CONNECTING;
-					goto fail;
-				}
-#endif
-
-				gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() connection failed (errno=%d, %s), trying https\n", res, strerror(res));
-
-				if (sess->port == GG_HTTPS_PORT) {
-					e->event.failure = GG_FAILURE_CONNECTING;
-					goto fail;
-				}
-
-				sess->port = GG_HTTPS_PORT;
+		if (!sess->async && ge->type == GG_EVENT_NONE && res == GG_ACTION_WAIT)
+			res = GG_ACTION_NEXT;
 
-				/* próbujemy na port 443. */
-				if ((sess->fd = gg_connect(&sess->server_addr, sess->port, sess->async)) == -1) {
-					gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() connection failed (errno=%d, %s)\n", errno, strerror(errno));
-					e->event.failure = GG_FAILURE_CONNECTING;
-					goto fail;
+		switch (res) {
+			case GG_ACTION_WAIT:
+				if (priv->event_queue != NULL) {
+					priv->fd_after_queue = sess->fd;
+					priv->check_after_queue = sess->check;
+					/* wymuszamy ponowne wywołanie gg_watch_fd */
+					sess->fd = gg_get_dummy_fd(sess);
+					if (sess->fd < 0)
+						sess->fd = priv->fd_after_queue;
+					sess->check = GG_CHECK_READ | GG_CHECK_WRITE;
 				}
-
-				sess->state = GG_STATE_CONNECTING_GG;
-				sess->check = GG_CHECK_WRITE;
-				sess->timeout = GG_DEFAULT_TIMEOUT;
-				sess->soft_timeout = 1;
-
-				break;
-			}
-
-			gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() connected\n");
-
-			if (gg_proxy_http_only)
-				sess->proxy_port = 0;
-
-			/* jeśli mamy proxy, wyślijmy zapytanie. */
-			if (sess->proxy_addr && sess->proxy_port) {
-				char buf[100], *auth = gg_proxy_auth();
-				struct in_addr addr;
+				return ge;
 
-				if (sess->server_addr)
-					addr.s_addr = sess->server_addr;
-				else
-					addr.s_addr = sess->hub_addr;
+			case GG_ACTION_NEXT:
+				continue;
 
-				snprintf(buf, sizeof(buf), "CONNECT %s:%d HTTP/1.0\r\n", inet_ntoa(addr), sess->port);
-
-				gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() proxy request:\n//   %s", buf);
+			case GG_ACTION_FAIL:
+				sess->state = GG_STATE_IDLE;
 
-				/* wysyłamy zapytanie. jest ono na tyle krótkie,
-				 * że musi się zmieścić w buforze gniazda. jeśli
-				 * write() zawiedzie, stało się coś złego. */
-				if (write(sess->fd, buf, strlen(buf)) < (signed)strlen(buf)) {
-					gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() can't send proxy request\n");
-					free(auth);
-					e->event.failure = GG_FAILURE_PROXY;
-					goto fail;
-				}
+				gg_close(sess);
 
-				if (auth) {
-					gg_debug_session(sess, GG_DEBUG_MISC, "//   %s", auth);
-					if (write(sess->fd, auth, strlen(auth)) < (signed)strlen(auth)) {
-						gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() can't send proxy request\n");
-						free(auth);
-						e->event.failure = GG_FAILURE_PROXY;
-						goto fail;
-					}
-
-					free(auth);
+				if (ge->event.failure != 0) {
+					ge->type = GG_EVENT_CONN_FAILED;
+				} else {
+					free(ge);
+					ge = NULL;
 				}
 
-				if (write(sess->fd, "\r\n", 2) < 2) {
-					gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() can't send proxy request\n");
-					e->event.failure = GG_FAILURE_PROXY;
-					goto fail;
-				}
-			}
-
-#if defined(GG_CONFIG_HAVE_GNUTLS) || defined(GG_CONFIG_HAVE_OPENSSL)
-			if (sess->ssl != NULL) {
-#ifdef GG_CONFIG_HAVE_GNUTLS
-				gnutls_transport_set_ptr(GG_SESSION_GNUTLS(sess), (gnutls_transport_ptr_t)(long)sess->fd);
-#endif
-#ifdef GG_CONFIG_HAVE_OPENSSL
-				SSL_set_fd(sess->ssl, sess->fd);
-#endif
-
-				sess->state = GG_STATE_TLS_NEGOTIATION;
-				sess->check = GG_CHECK_WRITE;
-				sess->timeout = GG_DEFAULT_TIMEOUT;
-
-				break;
-			}
-#endif
-
-			sess->state = GG_STATE_READING_KEY;
-			sess->check = GG_CHECK_READ;
-			sess->timeout = GG_DEFAULT_TIMEOUT;
-
-			break;
-		}
-
-#ifdef GG_CONFIG_HAVE_GNUTLS
-		case GG_STATE_TLS_NEGOTIATION:
-		{
-			int res;
-
-			gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() GG_STATE_TLS_NEGOTIATION\n");
-
-gnutls_handshake_repeat:
-			res = gnutls_handshake(GG_SESSION_GNUTLS(sess));
-
-			if (res == GNUTLS_E_AGAIN) {
-				gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() TLS handshake GNUTLS_E_AGAIN\n");
-
-				sess->state = GG_STATE_TLS_NEGOTIATION;
-				if (gnutls_record_get_direction(GG_SESSION_GNUTLS(sess)) == 0)
-					sess->check = GG_CHECK_READ;
-				else
-					sess->check = GG_CHECK_WRITE;
-				sess->timeout = GG_DEFAULT_TIMEOUT;
-				break;
-			}
-
-			if (res == GNUTLS_E_INTERRUPTED) {
-				gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() TLS handshake GNUTLS_E_INTERRUPTED\n");
-				goto gnutls_handshake_repeat;
-			}
-
-			if (res != 0) {
-				gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() TLS handshake error %d\n", res);
-				e->type = GG_EVENT_CONN_FAILED;
-				e->event.failure = GG_FAILURE_TLS;
-				sess->state = GG_STATE_IDLE;
-				close(sess->fd);
-				sess->fd = -1;
-				break;
-			}
-
-			gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() TLS negotiation succeded:\n");
-			gg_debug_session(sess, GG_DEBUG_MISC, "//   cipher: VERS-%s:%s:%s:%s:COMP-%s\n",
-				gnutls_protocol_get_name(gnutls_protocol_get_version(GG_SESSION_GNUTLS(sess))),
-				gnutls_cipher_get_name(gnutls_cipher_get(GG_SESSION_GNUTLS(sess))),
-				gnutls_kx_get_name(gnutls_kx_get(GG_SESSION_GNUTLS(sess))),
-				gnutls_mac_get_name(gnutls_mac_get(GG_SESSION_GNUTLS(sess))),
-				gnutls_compression_get_name(gnutls_compression_get(GG_SESSION_GNUTLS(sess))));
-
-			if (gnutls_certificate_type_get(GG_SESSION_GNUTLS(sess)) == GNUTLS_CRT_X509) {
-				unsigned int peer_count;
-				const gnutls_datum_t *peers;
-				gnutls_x509_crt_t cert;
-
-				if (gnutls_x509_crt_init(&cert) == 0) {
-					peers = gnutls_certificate_get_peers(GG_SESSION_GNUTLS(sess), &peer_count);
-
-					if (peers != NULL) {
-						char buf[256];
-						size_t size;
-
-						if (gnutls_x509_crt_import(cert, &peers[0], GNUTLS_X509_FMT_DER) == 0) {
-							size = sizeof(buf);
-							gnutls_x509_crt_get_dn(cert, buf, &size);
-							gg_debug_session(sess, GG_DEBUG_MISC, "//   cert subject: %s\n", buf);
-							size = sizeof(buf);
-							gnutls_x509_crt_get_issuer_dn(cert, buf, &size);
-							gg_debug_session(sess, GG_DEBUG_MISC, "//   cert issuer: %s\n", buf);
-						}
-					}
-
-					gnutls_x509_crt_deinit(cert);
-				}
-			}
-
-			sess->state = GG_STATE_READING_KEY;
-			sess->check = GG_CHECK_READ;
-			sess->timeout = GG_DEFAULT_TIMEOUT;
-
-			break;
-		}
-#endif
-
-#ifdef GG_CONFIG_HAVE_OPENSSL
-		case GG_STATE_TLS_NEGOTIATION:
-		{
-			int res;
-			X509 *peer;
-
-			gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() GG_STATE_TLS_NEGOTIATION\n");
-
-			if ((res = SSL_connect(sess->ssl)) <= 0) {
-				int err = SSL_get_error(sess->ssl, res);
-
-				if (res == 0) {
-					gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() disconnected during TLS negotiation\n");
-
-					e->type = GG_EVENT_CONN_FAILED;
-					e->event.failure = GG_FAILURE_TLS;
-					sess->state = GG_STATE_IDLE;
-					close(sess->fd);
-					sess->fd = -1;
-					break;
-				}
-
-				if (err == SSL_ERROR_WANT_READ) {
-					gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() SSL_connect() wants to read\n");
-
-					sess->state = GG_STATE_TLS_NEGOTIATION;
-					sess->check = GG_CHECK_READ;
-					sess->timeout = GG_DEFAULT_TIMEOUT;
+				return ge;
 
-					break;
-				} else if (err == SSL_ERROR_WANT_WRITE) {
-					gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() SSL_connect() wants to write\n");
-
-					sess->state = GG_STATE_TLS_NEGOTIATION;
-					sess->check = GG_CHECK_WRITE;
-					sess->timeout = GG_DEFAULT_TIMEOUT;
-
-					break;
-				} else {
-					char buf[256];
-
-					ERR_error_string_n(ERR_get_error(), buf, sizeof(buf));
-
-					gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() SSL_connect() bailed out: %s\n", buf);
-
-					e->type = GG_EVENT_CONN_FAILED;
-					e->event.failure = GG_FAILURE_TLS;
-					sess->state = GG_STATE_IDLE;
-					close(sess->fd);
-					sess->fd = -1;
-					break;
-				}
-			}
-
-			gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() TLS negotiation succeded:\n//   cipher: %s\n", SSL_get_cipher_name(sess->ssl));
-
-			peer = SSL_get_peer_certificate(sess->ssl);
-
-			if (!peer)
-				gg_debug_session(sess, GG_DEBUG_MISC, "//   WARNING! unable to get peer certificate!\n");
-			else {
-				char buf[256];
-
-				X509_NAME_oneline(X509_get_subject_name(peer), buf, sizeof(buf));
-				gg_debug_session(sess, GG_DEBUG_MISC, "//   cert subject: %s\n", buf);
-
-				X509_NAME_oneline(X509_get_issuer_name(peer), buf, sizeof(buf));
-				gg_debug_session(sess, GG_DEBUG_MISC, "//   cert issuer: %s\n", buf);
-			}
-
-			sess->state = GG_STATE_READING_KEY;
-			sess->check = GG_CHECK_READ;
-			sess->timeout = GG_DEFAULT_TIMEOUT;
-
-			break;
+			/* Celowo nie ma default */
 		}
-#endif
-
-		case GG_STATE_READING_KEY:
-		case GG_STATE_READING_REPLY:
-		case GG_STATE_CONNECTED:
-		case GG_STATE_DISCONNECTING:
-		{
-			struct gg_header *gh;
-
-			if (sess->state == GG_STATE_READING_KEY)
-				gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() GG_STATE_READING_KEY\n");
-			else if (sess->state == GG_STATE_READING_REPLY)
-				gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() GG_STATE_READING_REPLY\n");
-			else if (sess->state == GG_STATE_CONNECTED)
-				gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() GG_STATE_CONNECTED\n");
-			else if (sess->state == GG_STATE_DISCONNECTING)
-				gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() GG_STATE_DISCONNECTING\n");
-
-			/* XXX bardzo, bardzo, bardzo głupi pomysł na pozbycie
-			 * się tekstu wrzucanego przez proxy. */
-			if (sess->state == GG_STATE_READING_KEY && sess->proxy_addr && sess->proxy_port) {
-				char buf[100];
-
-				strcpy(buf, "");
-				gg_read_line(sess->fd, buf, sizeof(buf) - 1);
-				gg_chomp(buf);
-				gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() proxy response:\n//   %s\n", buf);
-
-				while (strcmp(buf, "")) {
-					gg_read_line(sess->fd, buf, sizeof(buf) - 1);
-					gg_chomp(buf);
-					if (strcmp(buf, ""))
-						gg_debug_session(sess, GG_DEBUG_MISC, "//   %s\n", buf);
-				}
-
-				/* XXX niech czeka jeszcze raz w tej samej
-				 * fazie. głupio, ale działa. */
-				sess->proxy_port = 0;
-
-				break;
-			}
-
-			sess->last_event = time(NULL);
-
-			gh = gg_recv_packet(sess);
-
-			if (gh == NULL) {
-				gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd_connected() gg_recv_packet failed (errno=%d, %s)\n", errno, strerror(errno));
-
- 				if (errno != EAGAIN)
-					goto fail;
-			} else {
-				if (gg_session_handle_packet(sess, gh->type, (const char *) gh + sizeof(struct gg_header), gh->length, e) == -1) {
-					free(gh);
-					goto fail;
-				}
-
-				free(gh);
-			}
-
-			sess->check = GG_CHECK_READ;
-
-			break;
-		}
-	}
-
-	if (sess->send_buf && (sess->state == GG_STATE_READING_REPLY || sess->state == GG_STATE_CONNECTED))
-		sess->check |= GG_CHECK_WRITE;
-
-	return e;
-
-fail_proxy_hub:
-	if (sess->proxy_port)
-		e->event.failure = GG_FAILURE_PROXY;
-	else
-		e->event.failure = GG_FAILURE_HUB;
-
-fail:
-	sess->resolver_cleanup(&sess->resolver, 1);
-
-	sess->state = GG_STATE_IDLE;
-
-	if (sess->fd != -1) {
-		int errno2;
-
-		errno2 = errno;
-		close(sess->fd);
-		errno = errno2;
-		sess->fd = -1;
-	}
-
-	if (e->event.failure != 0) {
-		e->type = GG_EVENT_CONN_FAILED;
-		return e;
-	} else {
-		free(e);
-		return NULL;
 	}
 }