static void dns_name_callback (GObject *obj, GAsyncResult *result, gpointer user_data) { GResolver *resolver = G_RESOLVER(obj); session *sess = (session*)user_data; GList* addrs; gchar* addr; GList* list; g_return_if_fail (is_session (sess)); addrs = g_resolver_lookup_by_name_finish (resolver, result, NULL); if (addrs) { PrintText (sess, _("Resolved to:")); for (list = g_list_first (addrs); list; list = g_list_next (list)) { addr = g_inet_address_to_string (list->data); PrintTextf (sess, " %s", addr); } g_resolver_free_addresses (addrs); } else PrintText (sess, _("Not found")); }
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 hbn_cb(GObject *sender, GAsyncResult *res, gpointer data) { StunHBNListenData *ld = NULL; GError *error = NULL; ld = g_new0(StunHBNListenData, 1); ld->addresses = g_resolver_lookup_by_name_finish(G_RESOLVER(sender), res, &error); if(error != NULL) { nattype.status = PURPLE_STUN_STATUS_UNDISCOVERED; nattype.lookup_time = time(NULL); do_callbacks(); return; } ld->port = GPOINTER_TO_INT(data); if (!purple_network_listen_range(12108, 12208, AF_UNSPEC, SOCK_DGRAM, TRUE, hbn_listen_cb, ld)) { nattype.status = PURPLE_STUN_STATUS_UNKNOWN; nattype.lookup_time = time(NULL); do_callbacks(); return; } }
static void dns_a_response(GObject *resolver, GAsyncResult *result, gpointer data) { GError *error = NULL; GList *addresses = g_resolver_lookup_by_name_finish(G_RESOLVER(resolver), result, &error); struct sipe_dns_query *query = data; if (addresses) { GInetAddress *address = addresses->data; gchar *ipstr = g_inet_address_to_string(address); query->callback(query->extradata, ipstr, query->port); g_free(ipstr); g_resolver_free_addresses(addresses); } else { SIPE_DEBUG_INFO("dns_a_response: failed: %s", error ? error->message : "UNKNOWN"); g_error_free(error); if (query->callback) query->callback(query->extradata, NULL, 0); } g_object_unref(query->cancel); g_free(query); }
static void dns_srv_response(GObject *resolver, GAsyncResult *result, gpointer data) { GError *error = NULL; GList *targets = g_resolver_lookup_service_finish(G_RESOLVER(resolver), result, &error); struct sipe_dns_query *query = data; if (targets) { GSrvTarget *target = targets->data; query->callback(query->extradata, g_srv_target_get_hostname(target), g_srv_target_get_port(target)); g_resolver_free_targets(targets); } else { SIPE_DEBUG_INFO("dns_srv_response: failed: %s", error ? error->message : "UNKNOWN"); g_error_free(error); if (query->callback) query->callback(query->extradata, NULL, 0); } g_object_unref(query->cancel); g_free(query); }
static void stun_server_resolved_cb (GObject *resolver, GAsyncResult *result, gpointer user_data) { PendingStunServer *data = user_data; GabbleJingleInfo *self = data->factory; GError *e = NULL; gchar *stun_server; GList *entries; if (self != NULL) g_object_weak_unref (G_OBJECT (self), (GWeakNotify)g_cancellable_cancel, data->cancellable); entries = g_resolver_lookup_by_name_finish ( G_RESOLVER (resolver), result, &e); if (entries == NULL) { DEBUG ("Failed to resolve STUN server %s:%u: %s", data->stun_server, data->stun_port, e->message); g_error_free (e); goto out; } stun_server = g_inet_address_to_string (entries->data); g_resolver_free_addresses (entries); DEBUG ("Resolved STUN server %s:%u to %s:%u", data->stun_server, data->stun_port, stun_server, data->stun_port); if (self == NULL) { g_free (stun_server); goto out; } if (data->fallback) { g_free (self->priv->fallback_stun_server); self->priv->fallback_stun_server = stun_server; self->priv->fallback_stun_port = data->stun_port; } else { g_free (self->priv->stun_server); self->priv->stun_server = stun_server; self->priv->stun_port = data->stun_port; g_signal_emit (self, signals[STUN_SERVER_CHANGED], 0, stun_server, data->stun_port); } out: pending_stun_server_free (data); g_object_unref (resolver); }
static void dns_addr_callback (GObject *obj, GAsyncResult *result, gpointer user_data) { GResolver *resolver = G_RESOLVER(obj); session *sess = (session*)user_data; gchar *addr; g_return_if_fail (is_session(sess)); addr = g_resolver_lookup_by_address_finish (resolver, result, NULL); if (addr) PrintTextf (sess, _("Resolved to %s"), addr); else PrintText (sess, _("Not found")); }
static void dest_hostname_lookup_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->dest_ips = g_resolver_lookup_by_name_finish (G_RESOLVER (object), result, &priv->last_error); if (priv->dest_ips) return_result (task); else { g_clear_object (&priv->proxy_address); next_proxy (task); } }
static void lookup_resolved (GObject *source, GAsyncResult *result, gpointer user_data) { GResolver *resolver = G_RESOLVER (source); SoupAddressResolveAsyncData *res_data = user_data; SoupAddress *addr = res_data->addr; SoupAddressPrivate *priv = SOUP_ADDRESS_GET_PRIVATE (addr); GError *error = NULL; guint status; if (!priv->sockaddr) { GList *addrs; addrs = g_resolver_lookup_by_name_finish (resolver, result, &error); status = update_addrs (addr, addrs, error); g_resolver_free_addresses (addrs); } else if (!priv->name) { char *name; name = g_resolver_lookup_by_address_finish (resolver, result, &error); status = update_name (addr, name, error); g_free (name); } else status = SOUP_STATUS_OK; /* For the enumerator impl, below */ g_object_ref (addr); g_object_set_data (G_OBJECT (addr), "async-resolved-error", error); complete_resolve_async (res_data, status); g_object_set_data (G_OBJECT (addr), "async-resolved-error", NULL); g_object_unref (addr); if (error) g_error_free (error); }
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); }
static void g_unix_resolver_init (GUnixResolver *gur) { g_unix_resolver_reload (G_RESOLVER (gur)); }