void
gabble_jingle_info_take_stun_server (
GabbleJingleInfo *self,
gchar *stun_server,
guint16 stun_port,
gboolean is_fallback)
{
GResolver *resolver;
PendingStunServer *data;
if (stun_server == NULL)
return;
if (!is_fallback)
self->priv->get_stun_from_jingle = FALSE;
resolver = g_resolver_get_default ();
data = g_slice_new0 (PendingStunServer);
DEBUG ("Resolving %s STUN server %s:%u",
is_fallback ? "fallback" : "primary", stun_server, stun_port);
data->factory = self;
g_object_add_weak_pointer (G_OBJECT (self), (gpointer *) &data->factory);
data->stun_server = stun_server;
data->stun_port = stun_port;
data->fallback = is_fallback;
data->cancellable = g_cancellable_new ();
g_object_weak_ref (G_OBJECT (self), (GWeakNotify)g_cancellable_cancel,
data->cancellable);
g_resolver_lookup_by_name_async (resolver, stun_server,
data->cancellable, stun_server_resolved_cb, data);
}
static void
do_test1(GObject *sender, GAsyncResult *res, gpointer data) {
GList *services = NULL;
GError *error = NULL;
GResolver *resolver;
const char *servername = data;
int port = 3478;
services = g_resolver_lookup_service_finish(G_RESOLVER(sender),
res, &error);
if(error != NULL) {
purple_debug_info("stun", "Failed to look up srv record : %s\n", error->message);
g_error_free(error);
} else {
servername = g_srv_target_get_hostname((GSrvTarget *)services->data);
port = g_srv_target_get_port((GSrvTarget *)services->data);
}
purple_debug_info("stun", "connecting to %s:%d\n", servername, port);
resolver = g_resolver_get_default();
g_resolver_lookup_by_name_async(resolver,
servername,
NULL,
hbn_cb,
GINT_TO_POINTER(port));
g_object_unref(resolver);
g_resolver_free_targets(services);
}
static void
address_enumerate_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
GTask *task = user_data;
GProxyAddressEnumeratorPrivate *priv = g_task_get_task_data (task);
g_clear_error (&priv->last_error);
priv->proxy_address =
g_socket_address_enumerator_next_finish (priv->addr_enum,
result,
&priv->last_error);
if (priv->proxy_address)
{
if (!priv->supports_hostname && !priv->dest_ips)
{
GResolver *resolver;
resolver = g_resolver_get_default();
g_resolver_lookup_by_name_async (resolver,
priv->dest_hostname,
g_task_get_cancellable (task),
dest_hostname_lookup_cb,
task);
g_object_unref (resolver);
return;
}
return_result (task);
}
else
next_proxy (task);
}
/**
* soup_address_resolve_async:
* @addr: a #SoupAddress
* @async_context: (allow-none): the #GMainContext to call @callback from
* @cancellable: a #GCancellable object, or %NULL
* @callback: (scope async): callback to call with the result
* @user_data: data for @callback
*
* Asynchronously resolves the missing half of @addr (its IP address
* if it was created with soup_address_new(), or its hostname if it
* was created with soup_address_new_from_sockaddr() or
* soup_address_new_any().)
*
* If @cancellable is non-%NULL, it can be used to cancel the
* resolution. @callback will still be invoked in this case, with a
* status of %SOUP_STATUS_CANCELLED.
*
* It is safe to call this more than once on a given address, from the
* same thread, with the same @async_context (and doing so will not
* result in redundant DNS queries being made). But it is not safe to
* call from multiple threads, or with different @async_contexts, or
* mixed with calls to soup_address_resolve_sync().
**/
void
soup_address_resolve_async (SoupAddress *addr, GMainContext *async_context,
GCancellable *cancellable,
SoupAddressCallback callback, gpointer user_data)
{
SoupAddressPrivate *priv;
SoupAddressResolveAsyncData *res_data;
GResolver *resolver;
gboolean already_started;
g_return_if_fail (SOUP_IS_ADDRESS (addr));
priv = SOUP_ADDRESS_GET_PRIVATE (addr);
g_return_if_fail (priv->name || priv->sockaddr);
/* We don't need to do locking here because the async case is
* not intended to be thread-safe.
*/
if (priv->name && priv->sockaddr && !callback)
return;
res_data = g_slice_new0 (SoupAddressResolveAsyncData);
res_data->callback = callback;
res_data->callback_data = user_data;
already_started = priv->async_lookups != NULL;
priv->async_lookups = g_slist_prepend (priv->async_lookups, res_data);
if (already_started)
return;
g_object_ref (addr);
if (priv->name && priv->sockaddr) {
soup_add_completion (async_context, idle_complete_resolve, addr);
return;
}
resolver = g_resolver_get_default ();
if (async_context)
g_main_context_push_thread_default (async_context);
if (priv->name) {
g_resolver_lookup_by_name_async (resolver, priv->name,
cancellable,
lookup_resolved, addr);
} else {
GInetAddress *gia;
gia = soup_address_make_inet_address (addr);
g_resolver_lookup_by_address_async (resolver, gia,
cancellable,
lookup_resolved, addr);
g_object_unref (gia);
}
if (async_context)
g_main_context_pop_thread_default (async_context);
g_object_unref (resolver);
}
static void http_redirector_init(const gchar * desturl)
{
char host[128];
sscanf(desturl,"http://%128[^/^:]",host);
redirector_ip = inet_addr(host);
if (redirector_ip == INADDR_NONE)
{
g_debug(_("host in the url is not an ipv4 address, will do async dns lookup"));
GResolver * dns = g_resolver_get_default();
g_resolver_lookup_by_name_async(dns,host,NULL,redirector_host_resove_by_dns,dns);
}
sprintf((char*) httphead, (char*) httphead_t, desturl, desturl);
}
static VALUE
rg_lookup_by_name_async(int argc, VALUE *argv, VALUE self)
{
VALUE rbhostname, rbcancellable, block;
const gchar *hostname;
GCancellable *cancellable;
rb_scan_args(argc, argv, "11&", &hostname, &rbcancellable, &block);
hostname = RVAL2CSTR(rbhostname);
cancellable = RVAL2GCANCELLABLE(rbcancellable);
SAVE_BLOCK(block);
g_resolver_lookup_by_name_async(_SELF(self),
hostname,
cancellable,
rbgio_async_ready_callback,
(gpointer)block);
return self;
}
static void
start_async_lookups (char **argv, int argc)
{
int i;
for (i = 0; i < argc; i++)
{
if (strchr (argv[i], '/'))
{
/* service/protocol/domain */
char **parts = g_strsplit (argv[i], "/", 3);
if (!parts || !parts[2])
usage ();
g_resolver_lookup_service_async (resolver,
parts[0], parts[1], parts[2],
cancellable,
lookup_service_callback, argv[i]);
}
else if (g_hostname_is_ip_address (argv[i]))
{
GInetAddress *addr = g_inet_address_new_from_string (argv[i]);
g_resolver_lookup_by_address_async (resolver, addr, cancellable,
lookup_by_addr_callback, argv[i]);
g_object_unref (addr);
}
else
{
g_resolver_lookup_by_name_async (resolver, argv[i], cancellable,
lookup_by_name_callback,
argv[i]);
}
/* Stress-test the reloading code */
g_signal_emit_by_name (resolver, "reload");
}
}
void
do_dns (session *sess, char *nick, char *host,
const message_tags_data *tags_data)
{
GResolver *res = g_resolver_get_default ();
GInetAddress *addr;
char *po;
po = strrchr (host, '@');
if (po)
host = po + 1;
if (nick)
EMIT_SIGNAL_TIMESTAMP (XP_TE_RESOLVINGUSER, sess, tags_data->timestamp, nick, host);
PrintTextf (sess, _("Looking up %s..."), host);
addr = g_inet_address_new_from_string (host);
if (addr)
g_resolver_lookup_by_address_async (res, addr, NULL, dns_addr_callback, sess);
else
g_resolver_lookup_by_name_async (res, host, NULL, dns_name_callback, sess);
}
struct sipe_dns_query *sipe_backend_dns_query_a(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public,
const gchar *hostname,
guint port,
sipe_dns_resolved_cb callback,
gpointer data)
{
struct sipe_dns_query *query = g_new0(struct sipe_dns_query, 1);
GResolver *resolver = g_resolver_get_default();
SIPE_DEBUG_INFO("sipe_backend_dns_query_a: %s", hostname);
query->callback = callback;
query->extradata = data;
query->port = port;
query->cancel = g_cancellable_new();
g_resolver_lookup_by_name_async(resolver,
hostname,
query->cancel,
dns_a_response,
query);
g_object_unref(resolver);
return(query);
}
G_MODULE_EXPORT gchar * g_module_check_init(GModule *module)
{
gboolean enable;
GError * err=NULL;
gchar * url;
enable = g_key_file_get_boolean(gkeyfile,GROUP_NAME,"enable",&err);
if(err)
{
enable = TRUE;
g_error_free(err);
g_message("%s","[http_redirect]:[enable] not specified, default to enable");
err = NULL;
}
if (!enable)
{
return "[http_redirect]:[enable=false], user disabled me";
}
url = g_key_file_get_string(gkeyfile, GROUP_NAME, "url", NULL);
if(!url)
{
return "[http_redirect]:[url] not defined, please define one";
}
http_redirector_init(url);
gchar * ips = g_key_file_get_string(gkeyfile,GROUP_NAME,"whitelist",&err);
if(err)
{
g_error_free(err);
}else
{
GResolver * dns = g_resolver_get_default();
void resove_host_by_dns(GObject *source_object, GAsyncResult *res,gpointer user_data)
{
GList * hosts = g_resolver_lookup_by_name_finish(G_RESOLVER(source_object),res,NULL);
if(hosts)
{
GList * it = g_list_first(hosts);
do
{
GInetAddress * addr = (GInetAddress*)(it->data);
if(g_inet_address_get_native_size(addr)==4)
{
in_addr_t ip;
memcpy(&ip,g_inet_address_to_bytes(addr),4);
whiteip = g_list_prepend(whiteip,GUINT_TO_POINTER(ip));
g_message(_("%s's DNS result : %s"),(char*)user_data,g_inet_address_to_string(addr));
}
}while(( it = g_list_next(it)));
g_resolver_free_addresses(hosts);
}
g_object_unref(source_object);
g_free(user_data);
}
gchar *ptr;
gchar * one_host =strtok_r(ips," \t",&ptr);
while( one_host )
{
in_addr_t ip = inet_addr(one_host);
if (ip == INADDR_NONE)
{
g_object_ref(dns);
g_debug(_("host %s is not an ipv4 address, will do async dns lookup"),one_host);
g_resolver_lookup_by_name_async(dns,one_host,NULL,resove_host_by_dns,g_strdup(one_host));
}else
{
whiteip = g_list_prepend(whiteip,GUINT_TO_POINTER(ip));
}
one_host = strtok_r(NULL," \t",&ptr);
}
g_object_unref(dns);
}
