static void
test_happy_eyeballs_cancel_instant (void)
{
GSocketClient *client;
GSocketService *service;
GError *error = NULL;
guint16 port;
GMainLoop *loop;
GCancellable *cancel;
gboolean got_completed_event = FALSE;
/* This tests the same things as above, test_happy_eyeballs_cancel_delayed(), but
* with different timing since it sends an already cancelled cancellable */
loop = g_main_loop_new (NULL, FALSE);
service = g_socket_service_new ();
port = g_socket_listener_add_any_inet_port (G_SOCKET_LISTENER (service), NULL, &error);
g_assert_no_error (error);
g_socket_service_start (service);
client = g_socket_client_new ();
cancel = g_cancellable_new ();
g_cancellable_cancel (cancel);
g_socket_client_connect_to_host_async (client, "localhost", port, cancel, on_connected_cancelled, loop);
g_signal_connect (client, "event", G_CALLBACK (on_event), &got_completed_event);
g_main_loop_run (loop);
g_assert_true (got_completed_event);
g_main_loop_unref (loop);
g_object_unref (service);
g_object_unref (client);
g_object_unref (cancel);
}
static void
test_happy_eyeballs (void)
{
GSocketClient *client;
GSocketService *service;
GError *error = NULL;
guint16 port;
GMainLoop *loop;
loop = g_main_loop_new (NULL, FALSE);
service = g_socket_service_new ();
port = g_socket_listener_add_any_inet_port (G_SOCKET_LISTENER (service), NULL, &error);
g_assert_no_error (error);
g_socket_service_start (service);
/* All of the magic here actually happens in slow-connect-preload.c
* which as you would guess is preloaded. So this is just making a
* normal connection that happens to take 600ms each time. This will
* trigger the logic to make multiple parallel connections.
*/
client = g_socket_client_new ();
g_socket_client_connect_to_host_async (client, "localhost", port, NULL, on_connected, loop);
g_main_loop_run (loop);
g_main_loop_unref (loop);
g_object_unref (service);
g_object_unref (client);
}
int main (int argc, char *argv[])
{
GMainLoop *loop = NULL;
GSocketClient *client = NULL;
g_type_init ();
map = open("dummy.dat", O_RDWR | O_CREAT);
if (-1 == map)
{
perror ("open");
return 0;
}
data = mmap (NULL, 1024 * 1024, PROT_READ | PROT_WRITE, MAP_PRIVATE, map, 0);
if (MAP_FAILED == data)
{
perror ("mmap");
return 0;
}
client = g_socket_client_new ();
g_socket_client_connect_to_host_async (client, "127.0.0.1", 8080, NULL, on_connected, client);
loop = g_main_loop_new (NULL, FALSE);
g_main_loop_run (loop);
g_main_loop_unref (loop);
return 0;
}
static void
test_happy_eyeballs_cancel_delayed (void)
{
GSocketClient *client;
GSocketService *service;
GError *error = NULL;
guint16 port;
GMainLoop *loop;
GCancellable *cancel;
gboolean got_completed_event = FALSE;
/* This just tests that cancellation works as expected, still emits the completed signal,
* and never returns a connection */
loop = g_main_loop_new (NULL, FALSE);
service = g_socket_service_new ();
port = g_socket_listener_add_any_inet_port (G_SOCKET_LISTENER (service), NULL, &error);
g_assert_no_error (error);
g_socket_service_start (service);
client = g_socket_client_new ();
cancel = g_cancellable_new ();
g_socket_client_connect_to_host_async (client, "localhost", port, cancel, on_connected_cancelled, loop);
g_timeout_add (1, (GSourceFunc) on_timer, cancel);
g_signal_connect (client, "event", G_CALLBACK (on_event), &got_completed_event);
g_main_loop_run (loop);
g_assert_true (got_completed_event);
g_main_loop_unref (loop);
g_object_unref (service);
g_object_unref (client);
g_object_unref (cancel);
}
void idle_server_connection_connect_async(IdleServerConnection *conn, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) {
IdleServerConnectionPrivate *priv = IDLE_SERVER_CONNECTION_GET_PRIVATE(conn);
GSimpleAsyncResult *result;
if (priv->state != SERVER_CONNECTION_STATE_NOT_CONNECTED) {
IDLE_DEBUG("already connecting or connected!");
g_simple_async_report_error_in_idle(G_OBJECT(conn),
callback, user_data,
TP_ERROR, TP_ERROR_NOT_AVAILABLE,
"already connecting or connected!");
return;
}
if ((priv->host == NULL) || (priv->host[0] == '\0')) {
IDLE_DEBUG("host not set!");
g_simple_async_report_error_in_idle(G_OBJECT(conn),
callback, user_data,
TP_ERROR, TP_ERROR_NOT_AVAILABLE,
"host not set!");
return;
}
if (priv->port == 0) {
IDLE_DEBUG("port not set!");
g_simple_async_report_error_in_idle(G_OBJECT(conn),
callback, user_data,
TP_ERROR, TP_ERROR_NOT_AVAILABLE,
"port not set!");
return;
}
result = g_simple_async_result_new(G_OBJECT(conn), callback, user_data, idle_server_connection_connect_async);
g_socket_client_connect_to_host_async(priv->socket_client, priv->host, priv->port, cancellable, _connect_to_host_ready, result);
change_state(conn, SERVER_CONNECTION_STATE_CONNECTING, SERVER_CONNECTION_STATE_REASON_REQUESTED);
}
SocketStreamHandle::SocketStreamHandle(const KURL& url, SocketStreamHandleClient* client)
: SocketStreamHandleBase(url, client)
, m_readBuffer(0)
{
unsigned int port = url.hasPort() ? url.port() : (url.protocolIs("wss") ? 443 : 80);
m_id = activateHandle(this);
GRefPtr<GSocketClient> socketClient = adoptGRef(g_socket_client_new());
if (url.protocolIs("wss"))
g_socket_client_set_tls(socketClient.get(), TRUE);
g_socket_client_connect_to_host_async(socketClient.get(), url.host().utf8().data(), port, 0,
reinterpret_cast<GAsyncReadyCallback>(connectedCallback), m_id);
}
Ref<SocketStreamHandle> SocketStreamHandle::create(const URL& url, SocketStreamHandleClient& client, NetworkingContext&, SessionID)
{
Ref<SocketStreamHandle> socket = adoptRef(*new SocketStreamHandle(url, client));
unsigned port = url.hasPort() ? url.port() : (url.protocolIs("wss") ? 443 : 80);
GRefPtr<GSocketClient> socketClient = adoptGRef(g_socket_client_new());
if (url.protocolIs("wss"))
g_socket_client_set_tls(socketClient.get(), TRUE);
Ref<SocketStreamHandle> protectedSocketStreamHandle = socket.copyRef();
g_socket_client_connect_to_host_async(socketClient.get(), url.host().utf8().data(), port, socket->m_cancellable.get(),
reinterpret_cast<GAsyncReadyCallback>(connectedCallback), &protectedSocketStreamHandle.leakRef());
return socket;
}
static gboolean setup_async_connect(GSocketClient *sock, struct ekg_connection_starter *cs) {
if (*(cs->current_server)) {
debug_function("setup_async_connect(), trying %s (defport: %d)\n",
*(cs->current_server), cs->defport);
g_socket_client_connect_to_host_async(
sock, *(cs->current_server), cs->defport,
cs->cancellable,
done_async_connect,
cs);
cs->current_server++;
return TRUE;
} else
return FALSE;
}
/* Test whether given host has an AppSocket/HP JetDirect printer connected.
See http://en.wikipedia.org/wiki/JetDirect
http://www.cups.org/documentation.php/network.html */
void
pp_host_get_jetdirect_devices_async (PpHost *host,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
PpHostPrivate *priv = host->priv;
GSocketClient *client;
JetDirectData *data;
GTask *task;
gchar *address;
gpointer result;
data = g_new0 (JetDirectData, 1);
data->host = g_object_ref (host);
data->devices = g_new0 (PpDevicesList, 1);
if (priv->port == PP_HOST_UNSET_PORT)
data->port = PP_HOST_DEFAULT_JETDIRECT_PORT;
else
data->port = priv->port;
task = g_task_new (G_OBJECT (host), cancellable, callback, user_data);
g_task_set_task_data (task, data, (GDestroyNotify) jetdirect_data_free);
address = g_strdup_printf ("%s:%d", priv->hostname, data->port);
if (address != NULL && address[0] != '/')
{
client = g_socket_client_new ();
g_socket_client_connect_to_host_async (client,
address,
data->port,
cancellable,
jetdirect_connection_test_cb,
task);
g_object_unref (client);
}
else
{
result = data->devices;
data->devices = NULL;
g_task_return_pointer (task, result, (GDestroyNotify) pp_devices_list_free);
g_object_unref (task);
}
g_free (address);
}
static void
connect_impl (PnNode *conn,
const gchar *hostname,
gint port)
{
g_return_if_fail (conn);
pn_log ("begin");
pn_debug ("conn=%p,name=%s", conn, conn->name);
pn_debug ("hostname=%s,port=%d", hostname, port);
pn_debug ("next=%p", conn->next);
g_free (conn->hostname);
conn->hostname = g_strdup (hostname);
conn->port = port;
if (conn->next)
{
conn->status = PN_NODE_STATUS_CONNECTING;
conn->next->prev = conn;
pn_node_connect (conn->next, hostname, port);
conn->next->prev = NULL;
}
else
{
pn_node_close (conn);
conn->status = PN_NODE_STATUS_CONNECTING;
#if defined(USE_GIO)
GSocketClient *client;
client = g_socket_client_new();
conn->socket_cancel = g_cancellable_new();
g_socket_client_connect_to_host_async(client, hostname, port,
conn->socket_cancel, connect_cb, conn);
#elif defined(HAVE_LIBPURPLE)
conn->connect_data = purple_proxy_connect (NULL, msn_session_get_user_data (conn->session),
hostname, port, connect_cb, conn);
#endif
}
pn_log ("end");
}
static void
process_one_address (NewConnectionData *data)
{
GInetSocketAddress *addr;
gchar *host;
if (g_cancellable_is_cancelled (data->cancellable))
{
g_simple_async_result_set_error (data->simple, G_IO_ERROR,
G_IO_ERROR_CANCELLED, "Operation cancelled");
g_simple_async_result_complete (data->simple);
free_new_connection_data (data);
return;
}
addr = g_queue_pop_head (data->addresses);
/* check we haven't gotten to the end of the list */
if (addr == NULL)
{
g_simple_async_result_set_error (data->simple,
WOCKY_LL_CONNECTION_FACTORY_ERROR,
WOCKY_LL_CONNECTION_FACTORY_ERROR_NO_CONTACT_ADDRESS_CAN_BE_CONNECTED_TO,
"Failed to connect to any of the contact's addresses");
g_simple_async_result_complete (data->simple);
free_new_connection_data (data);
return;
}
host = g_inet_address_to_string (g_inet_socket_address_get_address (addr));
DEBUG ("connecting to %s (port %" G_GUINT16_FORMAT ")", host,
g_inet_socket_address_get_port (addr));
g_socket_client_connect_to_host_async (data->self->priv->client,
host, g_inet_socket_address_get_port (addr),
data->cancellable, connect_to_host_cb, data);
g_free (host);
g_object_unref (addr);
}
static void
try_tunnel (SoupServer *server, SoupMessage *msg, SoupClientContext *context)
{
Tunnel *tunnel;
SoupURI *dest_uri;
GSocketClient *sclient;
soup_server_pause_message (server, msg);
tunnel = g_new0 (Tunnel, 1);
tunnel->self = g_object_ref (server);
tunnel->msg = g_object_ref (msg);
tunnel->context = context;
dest_uri = soup_message_get_uri (msg);
sclient = g_socket_client_new ();
g_socket_client_connect_to_host_async (sclient, dest_uri->host, dest_uri->port,
NULL, tunnel_connected_cb, tunnel);
g_object_unref (sclient);
}
static VALUE
rg_connect_to_host_async(int argc, VALUE *argv, VALUE self)
{
VALUE rbhost_and_port, rbdefault_port, rbcancellable, block;
GCancellable *cancellable;
const gchar *host_and_port;
guint16 default_port;
rb_scan_args(argc, argv, "21&", &rbhost_and_port, &rbdefault_port, &rbcancellable, &block);
host_and_port = RVAL2CSTR(rbhost_and_port);
default_port = RVAL2GUINT16(rbdefault_port);
cancellable = RVAL2GCANCELLABLE(rbcancellable);
SAVE_BLOCK(block);
g_socket_client_connect_to_host_async(_SELF(self),
host_and_port,
default_port,
cancellable,
rbgio_async_ready_callback,
(gpointer)block);
return self;
}
int
main (int argc, char *argv[])
{
GOptionContext *context;
GSocketClient *client;
GSocketConnection *connection;
GSocketAddress *address;
GCancellable *cancellable;
GOutputStream *out;
GError *error = NULL;
char buffer[1000];
g_type_init ();
context = g_option_context_new (" <hostname>[:port] - send data to tcp host");
g_option_context_add_main_entries (context, cmd_entries, NULL);
if (!g_option_context_parse (context, &argc, &argv, &error))
{
g_printerr ("%s: %s\n", argv[0], error->message);
return 1;
}
if (argc != 2)
{
g_printerr ("%s: %s\n", argv[0], "Need to specify hostname");
return 1;
}
if (async)
loop = g_main_loop_new (NULL, FALSE);
if (cancel_timeout)
{
GThread *thread;
cancellable = g_cancellable_new ();
thread = g_thread_new ("cancel", cancel_thread, cancellable);
g_thread_unref (thread);
}
else
{
cancellable = NULL;
}
client = g_socket_client_new ();
if (io_timeout)
g_socket_client_set_timeout (client, io_timeout);
if (verbose)
g_signal_connect (client, "event", G_CALLBACK (socket_client_event), NULL);
if (async)
{
GAsyncResult *res;
g_socket_client_connect_to_host_async (client, argv[1], 7777,
cancellable, async_cb, &res);
g_main_loop_run (loop);
connection = g_socket_client_connect_to_host_finish (client, res, &error);
g_object_unref (res);
}
else
{
connection = g_socket_client_connect_to_host (client,
argv[1],
7777,
cancellable, &error);
}
if (connection == NULL)
{
g_printerr ("%s can't connect: %s\n", argv[0], error->message);
return 1;
}
g_object_unref (client);
address = g_socket_connection_get_remote_address (connection, &error);
if (!address)
{
g_printerr ("Error getting remote address: %s\n",
error->message);
return 1;
}
g_print ("Connected to address: %s\n",
socket_address_to_string (address));
g_object_unref (address);
if (graceful)
g_tcp_connection_set_graceful_disconnect (G_TCP_CONNECTION (connection), TRUE);
out = g_io_stream_get_output_stream (G_IO_STREAM (connection));
while (fgets(buffer, sizeof (buffer), stdin) != NULL)
{
/* FIXME if (async) */
if (!g_output_stream_write_all (out, buffer, strlen (buffer),
NULL, cancellable, &error))
{
g_warning ("send error: %s\n", error->message);
g_error_free (error);
error = NULL;
}
}
g_print ("closing stream\n");
if (async)
{
GAsyncResult *res;
g_io_stream_close_async (G_IO_STREAM (connection),
0, cancellable, async_cb, &res);
g_main_loop_run (loop);
if (!g_io_stream_close_finish (G_IO_STREAM (connection),
res, &error))
{
g_object_unref (res);
g_warning ("close error: %s\n", error->message);
return 1;
}
g_object_unref (res);
}
else
{
if (!g_io_stream_close (G_IO_STREAM (connection), cancellable, &error))
{
g_warning ("close error: %s\n", error->message);
return 1;
}
}
g_object_unref (connection);
return 0;
}
