static void
resolved_proxy_uri (SoupProxyURIResolver *proxy_resolver,
guint status, SoupURI *proxy_uri, gpointer user_data)
{
SoupMessageQueueItem *item = user_data;
SoupSession *session = item->session;
if (item_failed (item, status))
return;
if (proxy_uri) {
SoupAddress *proxy_addr;
item->state = SOUP_MESSAGE_RESOLVING_PROXY_ADDRESS;
item->proxy_uri = soup_uri_copy (proxy_uri);
proxy_addr = soup_address_new (proxy_uri->host,
proxy_uri->port);
soup_address_resolve_async (proxy_addr,
soup_session_get_async_context (session),
item->cancellable,
resolved_proxy_addr, item);
g_object_unref (proxy_addr);
return;
}
item->state = SOUP_MESSAGE_AWAITING_CONNECTION;
soup_message_queue_item_unref (item);
/* If we got here we know session still exists */
run_queue ((SoupSessionAsync *)session);
}
int
main (int argc, char **argv)
{
SoupAddress *addr;
int i;
if (argc < 2)
usage ();
g_thread_init (NULL);
g_type_init ();
for (i = 1; i < argc; i++) {
addr = soup_address_new (argv[i], 0);
if (!addr) {
fprintf (stderr, "Could not parse address %s\n", argv[1]);
exit (1);
}
soup_address_resolve_async (addr, NULL, NULL,
resolve_callback, NULL);
nlookups++;
}
loop = g_main_loop_new (NULL, TRUE);
g_main_loop_run (loop);
g_main_loop_unref (loop);
return 0;
}
static void
seahorse_ldap_source_connect_async (SeahorseLDAPSource *source,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GSimpleAsyncResult *res;
source_connect_closure *closure;
gchar *server = NULL;
gchar *pos;
#ifdef WITH_SOUP
SoupAddress *address;
#endif
res = g_simple_async_result_new (G_OBJECT (source), callback, user_data,
seahorse_ldap_source_connect_async);
closure = g_new0 (source_connect_closure, 1);
closure->cancellable = cancellable ? g_object_ref (cancellable) : NULL;
g_simple_async_result_set_op_res_gpointer (res, closure, source_connect_free);
g_object_get (source, "key-server", &server, NULL);
g_return_if_fail (server && server[0]);
if ((pos = strchr (server, ':')) != NULL)
*pos = 0;
seahorse_progress_prep_and_begin (cancellable, res, NULL);
/* If we have libsoup, try and resolve asynchronously */
#ifdef WITH_SOUP
address = soup_address_new (server, LDAP_PORT);
seahorse_progress_update (cancellable, res, _("Resolving server address: %s"), server);
soup_address_resolve_async (address, NULL, cancellable,
on_address_resolved_complete,
g_object_ref (res));
g_object_unref (address);
#else /* !WITH_SOUP */
once_resolved_start_connect (source, res, server);
#endif
g_free (server);
g_object_unref (res);
}
static void
soup_address_address_enumerator_next_async (GSocketAddressEnumerator *enumerator,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
SoupAddressAddressEnumerator *addr_enum =
SOUP_ADDRESS_ADDRESS_ENUMERATOR (enumerator);
SoupAddressPrivate *priv = SOUP_ADDRESS_GET_PRIVATE (addr_enum->addr);
GTask *task;
task = g_task_new (enumerator, cancellable, callback, user_data);
if (!priv->sockaddr) {
soup_address_resolve_async (addr_enum->addr,
g_main_context_get_thread_default (),
cancellable, got_addresses, task);
} else {
g_task_return_pointer (task, next_address (addr_enum), g_object_unref);
g_object_unref (task);
}
}
static void
soup_address_address_enumerator_next_async (GSocketAddressEnumerator *enumerator,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
SoupAddressAddressEnumerator *addr_enum =
SOUP_ADDRESS_ADDRESS_ENUMERATOR (enumerator);
SoupAddressPrivate *priv = SOUP_ADDRESS_GET_PRIVATE (addr_enum->addr);
GSimpleAsyncResult *simple;
simple = g_simple_async_result_new (G_OBJECT (enumerator),
callback, user_data,
soup_address_address_enumerator_next_async);
if (!priv->sockaddr) {
soup_address_resolve_async (addr_enum->addr, NULL, cancellable,
got_addresses, simple);
} else {
g_simple_async_result_complete_in_idle (simple);
g_object_unref (simple);
}
}
//this will insert proxy in the session
//and queue the message to be sent
void
proxify_session_async(EProxy *proxy, STNET *stnet)
{
SoupURI *proxy_uri = NULL, *su;
#if EVOLUTION_VERSION < 30304
gint ptype = gconf_client_get_int (
rss_gconf, KEY_GCONF_EVO_PROXY_TYPE, NULL);
#else
GSettings *settings = g_settings_new(CONF_SCHEMA_EVO_NETWORK);
gint ptype = g_settings_get_int (
settings, CONF_EVO_PROXY_TYPE);
#endif
switch (ptype) {
#ifndef HAVE_LIBSOUP_GNOME
case 0:
#endif
case 2:
su = soup_uri_new (stnet->url);
stnet->host = su->host;
if (su) {
if (su->scheme == SOUP_URI_SCHEME_HTTPS) {
if (rss_ep_need_proxy_https (proxy, su->host)) {
#if (DATASERVER_VERSION >=2026000)
proxy_uri = e_proxy_peek_uri_for (proxy, stnet->url);
#else
g_print("WARN: e_proxy_peek_uri_for() requires evolution-data-server 2.26\n");
soup_uri_free(su);
return;
#endif
if (proxy_uri) {
d("proxified %s with %s:%d\n", stnet->url, proxy_uri->host, proxy_uri->port);
}
} else {
d("no PROXY-%s\n", stnet->url);
}
g_object_set (
G_OBJECT (stnet->ss),
SOUP_SESSION_PROXY_URI,
proxy_uri, NULL);
soup_uri_free(su);
goto out;
} else {
stnet->addr = soup_address_new (su->host, 0);
soup_uri_free(su);
soup_address_resolve_async (stnet->addr, NULL, NULL,
rss_resolve_callback, stnet);
return;
}
}
break;
#ifdef HAVE_LIBSOUP_GNOME
case 0:
soup_session_add_feature_by_type (
stnet->ss, SOUP_TYPE_PROXY_RESOLVER_DEFAULT);
break;
#endif
}
out: stnet->callback(stnet->data);
//free stnet
}
