static void
connect_to_host_cb (GObject *source_object,
GAsyncResult *result,
gpointer user_data)
{
GSocketClient *client = G_SOCKET_CLIENT (source_object);
NewConnectionData *data = user_data;
GSocketConnection *conn;
GError *error = NULL;
WockyXmppConnection *connection;
conn = g_socket_client_connect_to_host_finish (client, result, &error);
if (conn == NULL)
{
DEBUG ("failed to connect: %s", error->message);
g_clear_error (&error);
/* shame, well let's move on */
process_one_address (data);
return;
}
connection = wocky_xmpp_connection_new (G_IO_STREAM (conn));
DEBUG ("made connection");
g_simple_async_result_set_op_res_gpointer (data->simple, connection, NULL);
g_simple_async_result_complete (data->simple);
free_new_connection_data (data);
}
static void
on_connect_to_uri (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
WebSocketClient *self = WEB_SOCKET_CLIENT (user_data);
WebSocketConnection *conn = WEB_SOCKET_CONNECTION (user_data);
GSocketConnection *connection;
GError *error = NULL;
connection = g_socket_client_connect_to_uri_finish (G_SOCKET_CLIENT (source),
result, &error);
if (error == NULL)
{
_web_socket_connection_take_io_stream (conn, G_IO_STREAM (connection));
request_handshake (self, conn);
}
else if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
{
g_error_free (error);
}
else
{
_web_socket_connection_error_and_close (conn, error, TRUE);
}
g_object_unref (self);
}
static void
_socket_connect_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
GError *error = NULL;
GMainLoop *loop = user_data;
GSocketClient *client = G_SOCKET_CLIENT (object);
GSocketConnection *connection;
connection = g_socket_client_connect_to_uri_finish (client,
result,
&error);
if (connection)
{
GSocketAddress *proxy_addr;
proxy_addr = g_socket_connection_get_remote_address (connection, NULL);
print_proxy_address (proxy_addr);
}
else
{
print_and_free_error (error);
}
g_main_loop_quit (loop);
}
static void on_connected (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GSocketClient *client = NULL;
GSocketConnection *connection = NULL;
GSocket *socket = NULL;
gint fd = 0;
GIOChannel *channel = NULL;
GError *local_error = NULL;
client = G_SOCKET_CLIENT (source_object);
connection = g_socket_client_connect_to_host_finish (client, res, &local_error);
if (local_error)
{
g_warning("connect failed: %s", local_error->message);
g_clear_error (&local_error);
return;
}
socket = g_socket_connection_get_socket (connection);
fd = g_socket_get_fd (socket);
channel = g_io_channel_unix_new (fd);
g_io_channel_set_encoding (channel, NULL, NULL);
g_io_add_watch (channel, G_IO_IN, on_read, g_object_ref (connection));
}
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);
}
}
static void
tunnel_connected_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
Tunnel *tunnel = user_data;
GError *error = NULL;
tunnel->server.iostream = (GIOStream *)
g_socket_client_connect_to_host_finish (G_SOCKET_CLIENT (object), result, &error);
if (!tunnel->server.iostream) {
soup_message_set_status (tunnel->msg, SOUP_STATUS_BAD_GATEWAY);
soup_message_set_response (tunnel->msg, "text/plain",
SOUP_MEMORY_COPY,
error->message, strlen (error->message));
g_error_free (error);
soup_server_unpause_message (tunnel->self, tunnel->msg);
tunnel_close (tunnel);
return;
}
tunnel->server.istream = g_io_stream_get_input_stream (tunnel->server.iostream);
tunnel->server.ostream = g_io_stream_get_output_stream (tunnel->server.iostream);
soup_message_set_status (tunnel->msg, SOUP_STATUS_OK);
soup_server_unpause_message (tunnel->self, tunnel->msg);
g_signal_connect (tunnel->msg, "finished",
G_CALLBACK (start_tunnel), tunnel);
}
static void
g_socket_client_finalize (GObject *object)
{
GSocketClient *client = G_SOCKET_CLIENT (object);
if (client->priv->local_address)
g_object_unref (client->priv->local_address);
if (G_OBJECT_CLASS (g_socket_client_parent_class)->finalize)
(*G_OBJECT_CLASS (g_socket_client_parent_class)->finalize) (object);
g_hash_table_unref (client->priv->app_proxies);
}
static void
connect_cb(GObject *source,
GAsyncResult *res,
gpointer user_data)
{
GSocketConnection *socket_conn;
PnNode *conn;
GError *error = NULL;
conn = PN_NODE(user_data);
socket_conn = g_socket_client_connect_to_host_finish(G_SOCKET_CLIENT(source), res, &error);
g_object_unref(source);
if (error) {
g_error_free(error);
return;
}
g_object_ref(conn);
if (socket_conn) {
GSocket *socket;
GInputStream *input;
conn->socket_conn = socket_conn;
socket = g_socket_connection_get_socket(socket_conn);
conn->status = PN_NODE_STATUS_OPEN;
input = g_io_stream_get_input_stream (G_IO_STREAM (conn->socket_conn));
g_object_ref (conn);
g_input_stream_read_async (input, conn->input_buffer, PN_BUF_LEN,
G_PRIORITY_DEFAULT, NULL,
read_cb, conn);
}
else {
conn->error = g_error_new_literal(PN_NODE_ERROR, PN_NODE_ERROR_OPEN,
"Unable to connect");
pn_node_error(conn);
}
{
PnNodeClass *class;
class = g_type_class_peek(PN_NODE_TYPE);
g_signal_emit(G_OBJECT(conn), class->open_sig, 0, conn);
}
g_object_unref(conn);
}
static void
on_connected (GObject *source_object,
GAsyncResult *result,
gpointer user_data)
{
GSocketConnection *conn;
GError *error = NULL;
conn = g_socket_client_connect_to_uri_finish (G_SOCKET_CLIENT (source_object), result, &error);
g_assert_no_error (error);
g_object_unref (conn);
g_main_loop_quit (user_data);
}
static void
connect_cb(GObject *source,
GAsyncResult *res,
gpointer user_data)
{
GSocketConnection *socket_conn;
PnNode *conn;
conn = PN_NODE(user_data);
socket_conn = g_socket_client_connect_to_host_finish(G_SOCKET_CLIENT(source), res, NULL);
g_object_unref(source);
g_object_ref(conn);
if (socket_conn) {
GIOChannel *channel;
GSocket *socket;
conn->socket_conn = socket_conn;
socket = g_socket_connection_get_socket(socket_conn);
conn->stream = pn_stream_new(g_socket_get_fd(socket));
channel = conn->stream->channel;
PN_NODE_GET_CLASS (conn)->channel_setup (conn, channel);
conn->status = PN_NODE_STATUS_OPEN;
pn_info("connected: conn=%p,channel=%p", conn, channel);
conn->read_watch = g_io_add_watch(channel, G_IO_IN, read_cb, conn);
#if 0
g_io_add_watch (channel, G_IO_ERR | G_IO_HUP | G_IO_NVAL, close_cb, conn);
#endif
}
else {
conn->error = g_error_new_literal(PN_NODE_ERROR, PN_NODE_ERROR_OPEN,
"Unable to connect");
pn_node_error(conn);
}
{
PnNodeClass *class;
class = g_type_class_peek(PN_NODE_TYPE);
g_signal_emit(G_OBJECT(conn), class->open_sig, 0, conn);
}
g_object_unref(conn);
}
static void
on_connected_cancelled (GObject *source_object,
GAsyncResult *result,
gpointer user_data)
{
GSocketConnection *conn;
GError *error = NULL;
conn = g_socket_client_connect_to_uri_finish (G_SOCKET_CLIENT (source_object), result, &error);
g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
g_assert_null (conn);
g_error_free (error);
g_main_loop_quit (user_data);
}
static void
g_socket_client_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GSocketClient *client = G_SOCKET_CLIENT (object);
switch (prop_id)
{
case PROP_FAMILY:
g_socket_client_set_family (client, g_value_get_enum (value));
break;
case PROP_TYPE:
g_socket_client_set_socket_type (client, g_value_get_enum (value));
break;
case PROP_PROTOCOL:
g_socket_client_set_protocol (client, g_value_get_enum (value));
break;
case PROP_LOCAL_ADDRESS:
g_socket_client_set_local_address (client, g_value_get_object (value));
break;
case PROP_TIMEOUT:
g_socket_client_set_timeout (client, g_value_get_uint (value));
break;
case PROP_ENABLE_PROXY:
g_socket_client_set_enable_proxy (client, g_value_get_boolean (value));
break;
case PROP_TLS:
g_socket_client_set_tls (client, g_value_get_boolean (value));
break;
case PROP_TLS_VALIDATION_FLAGS:
g_socket_client_set_tls_validation_flags (client, g_value_get_flags (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static void
jetdirect_connection_test_cb (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GSocketConnection *connection;
PpHostPrivate *priv;
PpPrintDevice *device;
JetDirectData *data;
gpointer result;
GError *error = NULL;
GTask *task = G_TASK (user_data);
data = g_task_get_task_data (task);
connection = g_socket_client_connect_to_host_finish (G_SOCKET_CLIENT (source_object),
res,
&error);
if (connection != NULL)
{
g_io_stream_close (G_IO_STREAM (connection), NULL, NULL);
g_object_unref (connection);
priv = data->host->priv;
device = g_new0 (PpPrintDevice, 1);
device->device_class = g_strdup ("network");
device->device_uri = g_strdup_printf ("socket://%s:%d",
priv->hostname,
data->port);
/* Translators: The found device is a JetDirect printer */
device->device_name = g_strdup (_("JetDirect Printer"));
device->host_name = g_strdup (priv->hostname);
device->host_port = data->port;
device->acquisition_method = ACQUISITION_METHOD_JETDIRECT;
data->devices->devices = g_list_append (data->devices->devices, device);
}
result = data->devices;
data->devices = NULL;
g_task_return_pointer (task, result, (GDestroyNotify) pp_devices_list_free);
g_object_unref (task);
}
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 {
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);
}
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);
}
static void _connect_to_host_ready(GObject *source_object, GAsyncResult *res, gpointer user_data) {
GSocketClient *socket_client = G_SOCKET_CLIENT(source_object);
GSimpleAsyncResult *result = G_SIMPLE_ASYNC_RESULT(user_data);
IdleServerConnection *conn = IDLE_SERVER_CONNECTION(g_async_result_get_source_object(G_ASYNC_RESULT(result)));
IdleServerConnectionPrivate *priv = IDLE_SERVER_CONNECTION_GET_PRIVATE(conn);
GInputStream *input_stream;
GSocket *socket_;
GSocketConnection *socket_connection;
gint nodelay = 1;
gint socket_fd;
GError *error = NULL;
socket_connection = g_socket_client_connect_to_host_finish(socket_client, res, &error);
if (socket_connection == NULL) {
IDLE_DEBUG("g_socket_client_connect_to_host failed: %s", error->message);
g_simple_async_result_set_error(result, TP_ERROR, TP_ERROR_NETWORK_ERROR, "%s", error->message);
g_error_free(error);
change_state(conn, SERVER_CONNECTION_STATE_NOT_CONNECTED, SERVER_CONNECTION_STATE_REASON_ERROR);
g_object_unref(conn);
goto cleanup;
}
socket_ = g_socket_connection_get_socket(socket_connection);
g_socket_set_keepalive(socket_, TRUE);
socket_fd = g_socket_get_fd(socket_);
setsockopt(socket_fd, IPPROTO_TCP, TCP_NODELAY, &nodelay, sizeof(nodelay));
g_tcp_connection_set_graceful_disconnect(G_TCP_CONNECTION(socket_connection), TRUE);
priv->io_stream = G_IO_STREAM(socket_connection);
input_stream = g_io_stream_get_input_stream(priv->io_stream);
_input_stream_read(conn, input_stream, _input_stream_read_ready);
change_state(conn, SERVER_CONNECTION_STATE_CONNECTED, SERVER_CONNECTION_STATE_REASON_REQUESTED);
cleanup:
g_simple_async_result_complete(result);
g_object_unref(result);
}
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);
}
}
static void
g_socket_client_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
GSocketClient *client = G_SOCKET_CLIENT (object);
switch (prop_id)
{
case PROP_FAMILY:
g_value_set_enum (value, client->priv->family);
break;
case PROP_TYPE:
g_value_set_enum (value, client->priv->type);
break;
case PROP_PROTOCOL:
g_value_set_enum (value, client->priv->protocol);
break;
case PROP_LOCAL_ADDRESS:
g_value_set_object (value, client->priv->local_address);
break;
case PROP_TIMEOUT:
g_value_set_uint (value, client->priv->timeout);
break;
case PROP_ENABLE_PROXY:
g_value_set_boolean (value, client->priv->enable_proxy);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
