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
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
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
lookup_by_name_callback (GObject *source, GAsyncResult *result,
gpointer user_data)
{
const char *name = user_data;
GError *error = NULL;
GList *addresses;
addresses = g_resolver_lookup_by_name_finish (resolver, result, &error);
print_resolved_addresses (name, addresses, error);
}
static VALUE
rg_lookup_by_name_finish(VALUE self, VALUE result)
{
GError *error = NULL;
GList *addresses;
addresses = g_resolver_lookup_by_name_finish(_SELF(self),
RVAL2GASYNCRESULT(result),
&error);
if (addresses == NULL)
rbgio_raise_error(error);
return GLIST2ARY_UNREF_FREE(addresses);
}
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);
}
