/**
* soup_socket_connect_async:
* @sock: a client #SoupSocket (which must not already be connected)
* @cancellable: a #GCancellable, or %NULL
* @callback: (scope async): callback to call after connecting
* @user_data: data to pass to @callback
*
* Begins asynchronously connecting to @sock's remote address. The
* socket will call @callback when it succeeds or fails (but not
* before returning from this function).
*
* If @cancellable is non-%NULL, it can be used to cancel the
* connection. @callback will still be invoked in this case, with a
* status of %SOUP_STATUS_CANCELLED.
**/
void
soup_socket_connect_async (SoupSocket *sock, GCancellable *cancellable,
SoupSocketCallback callback, gpointer user_data)
{
SoupSocketPrivate *priv;
SoupSocketAsyncConnectData *sacd;
GSocketClient *client;
g_return_if_fail (SOUP_IS_SOCKET (sock));
priv = SOUP_SOCKET_GET_PRIVATE (sock);
g_return_if_fail (priv->remote_addr != NULL);
sacd = g_slice_new0 (SoupSocketAsyncConnectData);
sacd->sock = g_object_ref (sock);
sacd->callback = callback;
sacd->user_data = user_data;
priv->connect_cancel = cancellable ? g_object_ref (cancellable) : g_cancellable_new ();
if (priv->async_context && !priv->use_thread_context)
g_main_context_push_thread_default (priv->async_context);
client = new_socket_client (sock);
g_socket_client_connect_async (client,
G_SOCKET_CONNECTABLE (priv->remote_addr),
priv->connect_cancel,
async_connected, sacd);
g_object_unref (client);
}
void
eventd_relay_server_start(EventdRelayServer *server)
{
if ( server->address == NULL )
return;
GSocketClient *client;
client = g_socket_client_new();
g_socket_client_connect_async(client, server->address, NULL, _eventd_relay_connection_handler, server);
g_object_unref(client);
}
static VALUE
rg_connect_async(int argc, VALUE *argv, VALUE self)
{
VALUE rbconnectable, rbcancellable, block;
GCancellable *cancellable;
GSocketConnectable *connectable;
rb_scan_args(argc, argv, "11&", &rbconnectable, &rbcancellable, &block);
connectable = RVAL2GSOCKETCONNECTABLE(rbconnectable);
cancellable = RVAL2GCANCELLABLE(rbcancellable);
SAVE_BLOCK(block);
g_socket_client_connect_async(_SELF(self),
connectable,
cancellable,
rbgio_async_ready_callback,
(gpointer)block);
return self;
}
static void
_j4status_io_stream_connect(J4statusIOStream *self)
{
if ( self->connection != NULL )
{
g_object_unref(self->in);
g_object_unref(self->out);
g_object_unref(self->connection);
self->connection = NULL;
self->out = NULL;
self->in = NULL;
}
GSocketClient *client;
client = g_socket_client_new();
g_socket_client_connect_async(client, G_SOCKET_CONNECTABLE(self->address), NULL, _j4status_io_stream_connect_callback, self);
g_object_unref(client);
}
