glib/gio/tests/resolver.c
Sébastien Wilmet d9a44b66af gio/tests/: LGPLv2+ -> LGPLv2.1+
A lot of tests in gio/tests/ don't have a license header.

https://bugzilla.gnome.org/show_bug.cgi?id=776504
2017-05-29 19:53:34 +02:00

745 lines
18 KiB
C

/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
/* GIO - GLib Input, Output and Streaming Library
*
* Copyright (C) 2008 Red Hat, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General
* Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
*/
#include "config.h"
#include <glib.h>
#include "glibintl.h"
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifdef G_OS_UNIX
#include <unistd.h>
#endif
#include <gio/gio.h>
static GResolver *resolver;
static GCancellable *cancellable;
static GMainLoop *loop;
static int nlookups = 0;
static gboolean synchronous = FALSE;
static guint connectable_count = 0;
static GResolverRecordType record_type = 0;
static void G_GNUC_NORETURN
usage (void)
{
fprintf (stderr, "Usage: resolver [-s] [hostname | IP | service/protocol/domain ] ...\n");
fprintf (stderr, "Usage: resolver [-s] [-t MX|TXT|NS|SOA] rrname ...\n");
fprintf (stderr, " resolver [-s] -c NUMBER [hostname | IP | service/protocol/domain ]\n");
fprintf (stderr, " Use -s to do synchronous lookups.\n");
fprintf (stderr, " Use -c NUMBER (and only a single resolvable argument) to test GSocketConnectable.\n");
fprintf (stderr, " The given NUMBER determines how many times the connectable will be enumerated.\n");
fprintf (stderr, " Use -t with MX, TXT, NS or SOA to lookup DNS records of those types.\n");
exit (1);
}
G_LOCK_DEFINE_STATIC (response);
static void
done_lookup (void)
{
nlookups--;
if (nlookups == 0)
{
/* In the sync case we need to make sure we don't call
* g_main_loop_quit before the loop is actually running...
*/
g_idle_add ((GSourceFunc)g_main_loop_quit, loop);
}
}
static void
print_resolved_name (const char *phys,
char *name,
GError *error)
{
G_LOCK (response);
printf ("Address: %s\n", phys);
if (error)
{
printf ("Error: %s\n", error->message);
g_error_free (error);
}
else
{
printf ("Name: %s\n", name);
g_free (name);
}
printf ("\n");
done_lookup ();
G_UNLOCK (response);
}
static void
print_resolved_addresses (const char *name,
GList *addresses,
GError *error)
{
char *phys;
GList *a;
G_LOCK (response);
printf ("Name: %s\n", name);
if (error)
{
printf ("Error: %s\n", error->message);
g_error_free (error);
}
else
{
for (a = addresses; a; a = a->next)
{
phys = g_inet_address_to_string (a->data);
printf ("Address: %s\n", phys);
g_free (phys);
g_object_unref (a->data);
}
g_list_free (addresses);
}
printf ("\n");
done_lookup ();
G_UNLOCK (response);
}
static void
print_resolved_service (const char *service,
GList *targets,
GError *error)
{
GList *t;
G_LOCK (response);
printf ("Service: %s\n", service);
if (error)
{
printf ("Error: %s\n", error->message);
g_error_free (error);
}
else
{
for (t = targets; t; t = t->next)
{
printf ("%s:%u (pri %u, weight %u)\n",
g_srv_target_get_hostname (t->data),
(guint)g_srv_target_get_port (t->data),
(guint)g_srv_target_get_priority (t->data),
(guint)g_srv_target_get_weight (t->data));
g_srv_target_free (t->data);
}
g_list_free (targets);
}
printf ("\n");
done_lookup ();
G_UNLOCK (response);
}
static void
print_resolved_mx (const char *rrname,
GList *records,
GError *error)
{
const gchar *hostname;
guint16 priority;
GList *t;
G_LOCK (response);
printf ("Domain: %s\n", rrname);
if (error)
{
printf ("Error: %s\n", error->message);
g_error_free (error);
}
else if (!records)
{
printf ("no MX records\n");
}
else
{
for (t = records; t; t = t->next)
{
g_variant_get (t->data, "(q&s)", &priority, &hostname);
printf ("%s (pri %u)\n", hostname, (guint)priority);
g_variant_unref (t->data);
}
g_list_free (records);
}
printf ("\n");
done_lookup ();
G_UNLOCK (response);
}
static void
print_resolved_txt (const char *rrname,
GList *records,
GError *error)
{
const gchar **contents;
GList *t;
gint i;
G_LOCK (response);
printf ("Domain: %s\n", rrname);
if (error)
{
printf ("Error: %s\n", error->message);
g_error_free (error);
}
else if (!records)
{
printf ("no TXT records\n");
}
else
{
for (t = records; t; t = t->next)
{
if (t != records)
printf ("\n");
g_variant_get (t->data, "(^a&s)", &contents);
for (i = 0; contents[i] != NULL; i++)
printf ("%s\n", contents[i]);
g_variant_unref (t->data);
}
g_list_free (records);
}
printf ("\n");
done_lookup ();
G_UNLOCK (response);
}
static void
print_resolved_soa (const char *rrname,
GList *records,
GError *error)
{
GList *t;
const gchar *primary_ns;
const gchar *administrator;
guint32 serial, refresh, retry, expire, ttl;
G_LOCK (response);
printf ("Zone: %s\n", rrname);
if (error)
{
printf ("Error: %s\n", error->message);
g_error_free (error);
}
else if (!records)
{
printf ("no SOA records\n");
}
else
{
for (t = records; t; t = t->next)
{
g_variant_get (t->data, "(&s&suuuuu)", &primary_ns, &administrator,
&serial, &refresh, &retry, &expire, &ttl);
printf ("%s %s (serial %u, refresh %u, retry %u, expire %u, ttl %u)\n",
primary_ns, administrator, (guint)serial, (guint)refresh,
(guint)retry, (guint)expire, (guint)ttl);
g_variant_unref (t->data);
}
g_list_free (records);
}
printf ("\n");
done_lookup ();
G_UNLOCK (response);
}
static void
print_resolved_ns (const char *rrname,
GList *records,
GError *error)
{
GList *t;
const gchar *hostname;
G_LOCK (response);
printf ("Zone: %s\n", rrname);
if (error)
{
printf ("Error: %s\n", error->message);
g_error_free (error);
}
else if (!records)
{
printf ("no NS records\n");
}
else
{
for (t = records; t; t = t->next)
{
g_variant_get (t->data, "(&s)", &hostname);
printf ("%s\n", hostname);
g_variant_unref (t->data);
}
g_list_free (records);
}
printf ("\n");
done_lookup ();
G_UNLOCK (response);
}
static void
lookup_one_sync (const char *arg)
{
GError *error = NULL;
if (record_type != 0)
{
GList *records;
records = g_resolver_lookup_records (resolver, arg, record_type, cancellable, &error);
switch (record_type)
{
case G_RESOLVER_RECORD_MX:
print_resolved_mx (arg, records, error);
break;
case G_RESOLVER_RECORD_SOA:
print_resolved_soa (arg, records, error);
break;
case G_RESOLVER_RECORD_NS:
print_resolved_ns (arg, records, error);
break;
case G_RESOLVER_RECORD_TXT:
print_resolved_txt (arg, records, error);
break;
default:
g_warn_if_reached ();
break;
}
}
else if (strchr (arg, '/'))
{
GList *targets;
/* service/protocol/domain */
char **parts = g_strsplit (arg, "/", 3);
if (!parts || !parts[2])
usage ();
targets = g_resolver_lookup_service (resolver,
parts[0], parts[1], parts[2],
cancellable, &error);
print_resolved_service (arg, targets, error);
}
else if (g_hostname_is_ip_address (arg))
{
GInetAddress *addr = g_inet_address_new_from_string (arg);
char *name;
name = g_resolver_lookup_by_address (resolver, addr, cancellable, &error);
print_resolved_name (arg, name, error);
g_object_unref (addr);
}
else
{
GList *addresses;
addresses = g_resolver_lookup_by_name (resolver, arg, cancellable, &error);
print_resolved_addresses (arg, addresses, error);
}
}
static gpointer
lookup_thread (gpointer arg)
{
lookup_one_sync (arg);
return NULL;
}
static void
start_sync_lookups (char **argv, int argc)
{
int i;
for (i = 0; i < argc; i++)
{
GThread *thread;
thread = g_thread_new ("lookup", lookup_thread, argv[i]);
g_thread_unref (thread);
}
}
static void
lookup_by_addr_callback (GObject *source, GAsyncResult *result,
gpointer user_data)
{
const char *phys = user_data;
GError *error = NULL;
char *name;
name = g_resolver_lookup_by_address_finish (resolver, result, &error);
print_resolved_name (phys, name, error);
}
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 void
lookup_service_callback (GObject *source, GAsyncResult *result,
gpointer user_data)
{
const char *service = user_data;
GError *error = NULL;
GList *targets;
targets = g_resolver_lookup_service_finish (resolver, result, &error);
print_resolved_service (service, targets, error);
}
static void
lookup_records_callback (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
const char *arg = user_data;
GError *error = NULL;
GList *records;
records = g_resolver_lookup_records_finish (resolver, result, &error);
switch (record_type)
{
case G_RESOLVER_RECORD_MX:
print_resolved_mx (arg, records, error);
break;
case G_RESOLVER_RECORD_SOA:
print_resolved_soa (arg, records, error);
break;
case G_RESOLVER_RECORD_NS:
print_resolved_ns (arg, records, error);
break;
case G_RESOLVER_RECORD_TXT:
print_resolved_txt (arg, records, error);
break;
default:
g_warn_if_reached ();
break;
}
}
static void
start_async_lookups (char **argv, int argc)
{
int i;
for (i = 0; i < argc; i++)
{
if (record_type != 0)
{
g_resolver_lookup_records_async (resolver, argv[i], record_type,
cancellable, lookup_records_callback, argv[i]);
}
else 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");
}
}
static void
print_connectable_sockaddr (GSocketAddress *sockaddr,
GError *error)
{
char *phys;
if (error)
{
printf ("Error: %s\n", error->message);
g_error_free (error);
}
else if (!G_IS_INET_SOCKET_ADDRESS (sockaddr))
{
printf ("Error: Unexpected sockaddr type '%s'\n", g_type_name_from_instance ((GTypeInstance *)sockaddr));
g_object_unref (sockaddr);
}
else
{
GInetSocketAddress *isa = G_INET_SOCKET_ADDRESS (sockaddr);
phys = g_inet_address_to_string (g_inet_socket_address_get_address (isa));
printf ("Address: %s%s%s:%d\n",
strchr (phys, ':') ? "[" : "", phys, strchr (phys, ':') ? "]" : "",
g_inet_socket_address_get_port (isa));
g_free (phys);
g_object_unref (sockaddr);
}
}
static void
do_sync_connectable (GSocketAddressEnumerator *enumerator)
{
GSocketAddress *sockaddr;
GError *error = NULL;
while ((sockaddr = g_socket_address_enumerator_next (enumerator, cancellable, &error)))
print_connectable_sockaddr (sockaddr, error);
g_object_unref (enumerator);
done_lookup ();
}
static void do_async_connectable (GSocketAddressEnumerator *enumerator);
static void
got_next_async (GObject *source, GAsyncResult *result, gpointer user_data)
{
GSocketAddressEnumerator *enumerator = G_SOCKET_ADDRESS_ENUMERATOR (source);
GSocketAddress *sockaddr;
GError *error = NULL;
sockaddr = g_socket_address_enumerator_next_finish (enumerator, result, &error);
if (sockaddr || error)
print_connectable_sockaddr (sockaddr, error);
if (sockaddr)
do_async_connectable (enumerator);
else
{
g_object_unref (enumerator);
done_lookup ();
}
}
static void
do_async_connectable (GSocketAddressEnumerator *enumerator)
{
g_socket_address_enumerator_next_async (enumerator, cancellable,
got_next_async, NULL);
}
static void
do_connectable (const char *arg, gboolean synchronous, guint count)
{
char **parts;
GSocketConnectable *connectable;
GSocketAddressEnumerator *enumerator;
if (strchr (arg, '/'))
{
/* service/protocol/domain */
parts = g_strsplit (arg, "/", 3);
if (!parts || !parts[2])
usage ();
connectable = g_network_service_new (parts[0], parts[1], parts[2]);
}
else
{
guint16 port;
parts = g_strsplit (arg, ":", 2);
if (parts && parts[1])
{
arg = parts[0];
port = strtoul (parts[1], NULL, 10);
}
else
port = 0;
if (g_hostname_is_ip_address (arg))
{
GInetAddress *addr = g_inet_address_new_from_string (arg);
GSocketAddress *sockaddr = g_inet_socket_address_new (addr, port);
g_object_unref (addr);
connectable = G_SOCKET_CONNECTABLE (sockaddr);
}
else
connectable = g_network_address_new (arg, port);
}
while (count--)
{
enumerator = g_socket_connectable_enumerate (connectable);
if (synchronous)
do_sync_connectable (enumerator);
else
do_async_connectable (enumerator);
}
g_object_unref (connectable);
}
#ifdef G_OS_UNIX
static int cancel_fds[2];
static void
interrupted (int sig)
{
gssize c;
signal (SIGINT, SIG_DFL);
c = write (cancel_fds[1], "x", 1);
g_assert_cmpint(c, ==, 1);
}
static gboolean
async_cancel (GIOChannel *source, GIOCondition cond, gpointer cancel)
{
g_cancellable_cancel (cancel);
return FALSE;
}
#endif
static gboolean
record_type_arg (const gchar *option_name,
const gchar *value,
gpointer data,
GError **error)
{
if (g_ascii_strcasecmp (value, "MX") == 0) {
record_type = G_RESOLVER_RECORD_MX;
} else if (g_ascii_strcasecmp (value, "TXT") == 0) {
record_type = G_RESOLVER_RECORD_TXT;
} else if (g_ascii_strcasecmp (value, "SOA") == 0) {
record_type = G_RESOLVER_RECORD_SOA;
} else if (g_ascii_strcasecmp (value, "NS") == 0) {
record_type = G_RESOLVER_RECORD_NS;
} else {
g_set_error (error, G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE,
"Specify MX, TXT, NS or SOA for the special record lookup types");
return FALSE;
}
return TRUE;
}
static const GOptionEntry option_entries[] = {
{ "synchronous", 's', 0, G_OPTION_ARG_NONE, &synchronous, "Synchronous connections", NULL },
{ "connectable", 'c', 0, G_OPTION_ARG_INT, &connectable_count, "Connectable count", "C" },
{ "special-type", 't', 0, G_OPTION_ARG_CALLBACK, record_type_arg, "Record type like MX, TXT, NS or SOA", "RR" },
{ NULL },
};
int
main (int argc, char **argv)
{
GOptionContext *context;
GError *error = NULL;
#ifdef G_OS_UNIX
GIOChannel *chan;
guint watch;
#endif
context = g_option_context_new ("lookups ...");
g_option_context_add_main_entries (context, option_entries, NULL);
if (!g_option_context_parse (context, &argc, &argv, &error))
{
g_printerr ("%s\n", error->message);
g_error_free (error);
usage();
}
if (argc < 2 || (argc > 2 && connectable_count))
usage ();
resolver = g_resolver_get_default ();
cancellable = g_cancellable_new ();
#ifdef G_OS_UNIX
/* Set up cancellation; we want to cancel if the user ^C's the
* program, but we can't cancel directly from an interrupt.
*/
signal (SIGINT, interrupted);
if (pipe (cancel_fds) == -1)
{
perror ("pipe");
exit (1);
}
chan = g_io_channel_unix_new (cancel_fds[0]);
watch = g_io_add_watch (chan, G_IO_IN, async_cancel, cancellable);
g_io_channel_unref (chan);
#endif
nlookups = argc - 1;
loop = g_main_loop_new (NULL, TRUE);
if (connectable_count)
{
nlookups = connectable_count;
do_connectable (argv[1], synchronous, connectable_count);
}
else
{
if (synchronous)
start_sync_lookups (argv + 1, argc - 1);
else
start_async_lookups (argv + 1, argc - 1);
}
g_main_loop_run (loop);
g_main_loop_unref (loop);
#ifdef G_OS_UNIX
g_source_remove (watch);
#endif
g_object_unref (cancellable);
return 0;
}