/** * 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 VALUE rg_lookup_by_address_async(int argc, VALUE *argv, VALUE self) { VALUE rbaddress, rbcancellable, block; GInetAddress *address; GCancellable *cancellable; rb_scan_args(argc, argv, "11&", &rbaddress, &rbcancellable, &block); address = RVAL2GINETADDRESS(rbaddress); cancellable = RVAL2GCANCELLABLE(rbcancellable); SAVE_BLOCK(block); g_resolver_lookup_by_address_async(_SELF(self), address, 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); }