static VALUE
rg_lookup_service_async(int argc, VALUE *argv, VALUE self)
{
VALUE rbservice, rbprotocol, rbdomain, rbcancellable, block;
const gchar *service;
const gchar *protocol;
const gchar *domain;
GCancellable *cancellable;
rb_scan_args(argc, argv, "31&", &rbservice, &rbprotocol, &rbdomain, &rbcancellable, &block);
service = RVAL2CSTR(rbservice);
protocol = RVAL2CSTR(rbprotocol);
domain = RVAL2CSTR(rbdomain);
cancellable = RVAL2GCANCELLABLE(rbcancellable);
SAVE_BLOCK(block);
g_resolver_lookup_service_async(_SELF(self),
service,
protocol,
domain,
cancellable,
rbgio_async_ready_callback,
(gpointer)block);
return self;
}
struct sipe_dns_query *sipe_backend_dns_query_srv(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public,
const gchar *protocol,
const gchar *transport,
const gchar *domain,
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_srv: %s/%s/%s",
protocol, transport, domain);
query->callback = callback;
query->extradata = data;
query->cancel = g_cancellable_new();
g_resolver_lookup_service_async(resolver,
protocol, transport, domain,
query->cancel,
dns_srv_response,
query);
g_object_unref(resolver);
return(query);
}
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");
}
}
PurpleStunNatDiscovery *purple_stun_discover(PurpleStunCallback cb) {
const char *servername = purple_prefs_get_string("/purple/network/stun_server");
GResolver *resolver;
purple_debug_info("stun", "using server %s\n", servername);
if(nattype.status == PURPLE_STUN_STATUS_DISCOVERING) {
if(cb)
callbacks = g_slist_append(callbacks, cb);
return &nattype;
}
if(nattype.status != PURPLE_STUN_STATUS_UNDISCOVERED) {
gboolean use_cached_result = TRUE;
/* Deal with the server name having changed since we did the
lookup */
if (servername && strlen(servername) > 1
&& !purple_strequal(servername, nattype.servername)) {
use_cached_result = FALSE;
}
/* If we don't have a successful status and it has been 5
minutes since we last did a lookup, redo the lookup */
if (nattype.status != PURPLE_STUN_STATUS_DISCOVERED
&& (time(NULL) - nattype.lookup_time) > 300) {
use_cached_result = FALSE;
}
if (use_cached_result) {
if(cb)
purple_timeout_add(10, call_callback, cb);
return &nattype;
}
}
if(!servername || (strlen(servername) < 2)) {
nattype.status = PURPLE_STUN_STATUS_UNKNOWN;
nattype.lookup_time = time(NULL);
if(cb)
purple_timeout_add(10, call_callback, cb);
return &nattype;
}
nattype.status = PURPLE_STUN_STATUS_DISCOVERING;
nattype.publicip[0] = '\0';
g_free(nattype.servername);
nattype.servername = g_strdup(servername);
callbacks = g_slist_append(callbacks, cb);
resolver = g_resolver_get_default();
g_resolver_lookup_service_async(resolver,
"stun",
"udp",
servername,
NULL,
do_test1,
(gpointer)servername);
g_object_unref(resolver);
return &nattype;
}
