Allow to connect to a Spice server via a HTTP proxy with CONNECT method. spice-gtk will use the SPICE_PROXY environment variable, which can currently only have the following syntax: [http://]hostname[:port] This is paving the way to more proxies support (socks4/socks5). This code is now entirely sync (it was not even completely async), the following patch will make it all async again. Tested with Squid, locally only. --- gtk/spice-session.c | 190 ++++++++++++++++++++++++++++++++++++---------------- 1 file changed, 134 insertions(+), 56 deletions(-) diff --git a/gtk/spice-session.c b/gtk/spice-session.c index e44ee08..06c1629 100644 --- a/gtk/spice-session.c +++ b/gtk/spice-session.c @@ -28,6 +28,7 @@ #include "gio-coroutine.h" #include "glib-compat.h" #include "wocky-http-proxy.h" +#include "spice-proxy.h" struct channel { SpiceChannel *channel; @@ -1573,43 +1574,128 @@ gboolean spice_session_has_channel_type(SpiceSession *session, gint type) /* ------------------------------------------------------------------ */ /* private functions */ -static GSocket *channel_connect_socket(SpiceChannel *channel, - GSocketAddress *sockaddr, - GError **error) +typedef struct spice_open_host spice_open_host; + +struct spice_open_host { + struct coroutine *from; + SpiceSession *session; + SpiceChannel *channel; + SpiceProxy *proxy; + int port; + GCancellable *cancellable; + GError *error; + GSocket *socket; +}; + +static void socket_client_connect_ready(GObject *source_object, GAsyncResult *result, + gpointer data) { - SpiceChannelPrivate *c = channel->priv; - GSocket *sock = g_socket_new(g_socket_address_get_family(sockaddr), - G_SOCKET_TYPE_STREAM, - G_SOCKET_PROTOCOL_DEFAULT, - error); + GSocketClient *client = G_SOCKET_CLIENT(source_object); + spice_open_host *open_host = data; + GSocketConnection *connection = NULL; - if (!sock) - return NULL; + SPICE_DEBUG("connect ready"); + connection = g_socket_client_connect_finish(client, result, &open_host->error); + if (connection == NULL) + goto end; - g_socket_set_blocking(sock, FALSE); - g_socket_set_keepalive(sock, TRUE); + open_host->socket = g_socket_connection_get_socket(connection); + g_object_ref(open_host->socket); - if (!g_socket_connect(sock, sockaddr, NULL, error)) { - if (*error && (*error)->code == G_IO_ERROR_PENDING) { - g_clear_error(error); - CHANNEL_DEBUG(channel, "Socket pending"); - g_coroutine_socket_wait(&c->coroutine, sock, G_IO_OUT | G_IO_ERR | G_IO_HUP); +end: + g_object_unref(connection); + g_object_unref(client); - if (!g_socket_check_connect_result(sock, error)) { - CHANNEL_DEBUG(channel, "Failed to connect %s", (*error)->message); - g_object_unref(sock); - return NULL; - } - } else { - CHANNEL_DEBUG(channel, "Socket error: %s", *error ? (*error)->message : "unknown"); - g_object_unref(sock); - return NULL; - } + coroutine_yieldto(open_host->from, NULL); +} + +/* main context */ +static void open_host_connectable_connect(spice_open_host *open_host, GSocketConnectable *connectable) +{ + GSocketClient *client; + + SPICE_DEBUG("connecting %p...", open_host); + client = g_socket_client_new(); + g_socket_client_connect_async(client, connectable, open_host->cancellable, + socket_client_connect_ready, open_host); +} + +#if GLIB_CHECK_VERSION(2,26,0) +/* main context */ +static void proxy_lookup_ready(GObject *source_object, GAsyncResult *result, + gpointer data) +{ + spice_open_host *open_host = data; + SpiceSessionPrivate *s = SPICE_SESSION_GET_PRIVATE(open_host->session); + GList *addresses = NULL, *it; + GSocketAddress *address; + + SPICE_DEBUG("proxy lookup ready"); + addresses = g_resolver_lookup_by_name_finish(G_RESOLVER(source_object), + result, &open_host->error); + if (addresses == NULL || open_host->error) { + coroutine_yieldto(open_host->from, NULL); + return; + } + + for (it = addresses; it != NULL; it = it->next) { + address = g_proxy_address_new(G_INET_ADDRESS(it->data), + spice_proxy_get_port(open_host->proxy), "http", + s->host, open_host->port, NULL, NULL); + if (address != NULL) + break; } - CHANNEL_DEBUG(channel, "Finally connected"); + open_host_connectable_connect(open_host, G_SOCKET_CONNECTABLE(address)); + g_resolver_free_addresses(addresses); +} + +static SpiceProxy* get_proxy(GError **error) +{ + SpiceProxy *proxy; + + const gchar *proxy_env = g_getenv("SPICE_PROXY"); + if (proxy_env == NULL || strlen(proxy_env) == 0) + return NULL; + + proxy = spice_proxy_new(); + if (!spice_proxy_parse(proxy, proxy_env, error)) + g_clear_object(&proxy); - return sock; + return proxy; +} +#endif + +/* main context */ +static gboolean open_host_idle_cb(gpointer data) +{ + spice_open_host *open_host = data; + SpiceSessionPrivate *s = SPICE_SESSION_GET_PRIVATE(open_host->session); + + g_return_val_if_fail(open_host != NULL, FALSE); + g_return_val_if_fail(open_host->socket == NULL, FALSE); + +#if GLIB_CHECK_VERSION(2,26,0) + open_host->proxy = get_proxy(&open_host->error); + if (open_host->proxy) { + g_resolver_lookup_by_name_async(g_resolver_get_default(), + spice_proxy_get_hostname(open_host->proxy), + open_host->cancellable, + proxy_lookup_ready, open_host); + } else +#endif + if (open_host->error != NULL) { + coroutine_yieldto(open_host->from, NULL); + return FALSE; + } else + open_host_connectable_connect(open_host, + g_network_address_new(s->host, open_host->port)); + + SPICE_DEBUG("open host %s:%d", s->host, open_host->port); + if (open_host->proxy != NULL) + SPICE_DEBUG("(with proxy %p)", open_host->proxy); + + return FALSE; } /* coroutine context */ @@ -1618,41 +1704,33 @@ GSocket* spice_session_channel_open_host(SpiceSession *session, SpiceChannel *ch gboolean use_tls) { SpiceSessionPrivate *s = SPICE_SESSION_GET_PRIVATE(session); - GSocketConnectable *addr; - GSocketAddressEnumerator *enumerator; - GSocketAddress *sockaddr; - GError *conn_error = NULL; - GSocket *sock = NULL; - int port; + spice_open_host open_host = { 0, }; if ((use_tls && !s->tls_port) || (!use_tls && !s->port)) return NULL; - port = atoi(use_tls ? s->tls_port : s->port); - - SPICE_DEBUG("Resolving host %s %d", s->host, port); + open_host.from = coroutine_self(); + open_host.session = session; + open_host.channel = channel; + open_host.port = atoi(use_tls ? s->tls_port : s->port); + g_idle_add(open_host_idle_cb, &open_host); - addr = g_network_address_new(s->host, port); + /* switch to main loop and wait for connection */ + coroutine_yield(NULL); + if (open_host.error != NULL) { + g_return_val_if_fail(open_host.socket == NULL, NULL); - enumerator = g_socket_connectable_enumerate (addr); - g_object_unref (addr); + g_warning("%s", open_host.error->message); + g_clear_error(&open_host.error); + } else { + g_return_val_if_fail(open_host.socket != NULL, NULL); - /* Try each sockaddr until we succeed. Record the first - * connection error, but not any further ones (since they'll probably - * be basically the same as the first). - */ - while (!sock && - (sockaddr = g_socket_address_enumerator_next(enumerator, NULL, &conn_error))) { - SPICE_DEBUG("Trying one socket"); - g_clear_error(&conn_error); - sock = channel_connect_socket(channel, sockaddr, &conn_error); - if (conn_error != NULL) - SPICE_DEBUG("%s", conn_error->message); - g_object_unref(sockaddr); + g_socket_set_blocking(open_host.socket, FALSE); + g_socket_set_keepalive(open_host.socket, TRUE); } - g_object_unref(enumerator); - g_clear_error(&conn_error); - return sock; + + g_clear_object(&open_host.proxy); + return open_host.socket; } -- 1.8.1.rc1.17.g75ed918 _______________________________________________ Spice-devel mailing list Spice-devel@xxxxxxxxxxxxxxxxxxxxx http://lists.freedesktop.org/mailman/listinfo/spice-devel