C++ (Cpp) g_socket_client_connect_finish Exemples

Exemple #1

Fichier : connections.c Projet : AdKwiatkos/ekg2

static void done_async_connect(GObject *obj, GAsyncResult *res, gpointer user_data) {
	GSocketClient *sock = G_SOCKET_CLIENT(obj);
	struct ekg_connection_starter *cs = user_data;
	GSocketConnection *conn;
	GError *err = NULL;
	
	conn = g_socket_client_connect_finish(sock, res, &err);
	if (conn) {
#ifdef HAVE_LIBGNUTLS
		if (cs->use_tls) {
			ekg_gnutls_new_session(sock, conn, cs);
		} else
#endif
		{
			GIOStream *cio = G_IO_STREAM(conn);
			succeeded_async_connect(
					sock, conn, cs,
					g_io_stream_get_input_stream(cio),
					g_io_stream_get_output_stream(cio));
		}
	} else {
		failed_async_connect(sock, err, cs);
		g_error_free(err);
	}
}

Exemple #2

Fichier : telepathy-transport.c Projet : stan3/debian-pidgin-sipe

static void socket_connected(GObject *client,
			     GAsyncResult *result,
			     gpointer data)
{
	struct sipe_transport_telepathy *transport = data;
	GError *error = NULL;

	transport->socket = g_socket_client_connect_finish(G_SOCKET_CLIENT(client),
							   result,
							   &error);

	if (transport->socket == NULL) {
		if (transport->tls_info) {
			SIPE_DEBUG_INFO_NOFORMAT("socket_connected: need to wait for user interaction");
			sipe_telepathy_tls_verify_async(G_OBJECT(transport->private->connection),
							transport->tls_info,
							certificate_result,
							transport);
		} else {

Exemple #3

Fichier : soup-socket.c Projet : DrGore/libsoup

static void
async_connected (GObject *client, GAsyncResult *result, gpointer data)
{
	SoupSocketAsyncConnectData *sacd = data;
	SoupSocketPrivate *priv = SOUP_SOCKET_GET_PRIVATE (sacd->sock);
	GError *error = NULL;
	GSocketConnection *conn;
	guint status;

	if (priv->async_context && !priv->use_thread_context)
		g_main_context_pop_thread_default (priv->async_context);

	conn = g_socket_client_connect_finish (G_SOCKET_CLIENT (client),
					       result, &error);
	status = socket_connected (sacd->sock, conn, error);

	sacd->callback (sacd->sock, status, sacd->user_data);
	g_object_unref (sacd->sock);
	g_slice_free (SoupSocketAsyncConnectData, sacd);
}

Exemple #4

Fichier : io.c Projet : SteveJones/j4status

static void
_j4status_io_stream_connect_callback(GObject *obj, GAsyncResult *res, gpointer user_data)
{
    J4statusIOStream *self = user_data;

    GError *error = NULL;
    GSocketConnection *connection;
    connection = g_socket_client_connect_finish(G_SOCKET_CLIENT(obj), res, &error);

    if ( connection == NULL )
    {
        g_warning("Couldn't reconnect: %s", error->message);
        g_clear_error(&error);
        if ( ++self->tries > MAX_TRIES )
            _j4status_io_remove_stream(self->io, self);
        else
            _j4status_io_stream_connect(self);
    }
    else
        _j4status_io_stream_set_connection(self, connection);
}

Exemple #5

Fichier : server.c Projet : worr/eventd

static void
_eventd_relay_connection_handler(GObject *obj, GAsyncResult *res, gpointer user_data)
{
    GError *error = NULL;
    EventdRelayServer *server = user_data;
    GSocketConnection *connection;

    connection = g_socket_client_connect_finish(G_SOCKET_CLIENT(obj), res, &error);
    if ( connection == NULL )
    {
        g_warning("Couldn't connect: %s", error->message);
        g_clear_error(&error);
        if ( ++server->tries < 4 )
            server->connection_timeout_id = g_timeout_add_seconds(3, _eventd_relay_reconnect, server);
    }
    else
    {
        libeventd_evp_context_set_connection(server->evp, connection);
        g_object_unref(connection);
        libeventd_evp_context_receive_loop(server->evp, G_PRIORITY_DEFAULT);
    }
}