/** * 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); }