#ifdef G_OS_UNIX
#include "gunixresolver.h"
+#include <sys/stat.h>
#endif
#ifdef G_OS_WIN32
#include "gwin32resolver.h"
* making it easy to connect to a remote host/service.
*/
+enum {
+ RELOAD,
+ LAST_SIGNAL
+};
+
+static guint signals[LAST_SIGNAL] = { 0 };
+
+struct _GResolverPrivate {
+#ifdef G_OS_UNIX
+ time_t resolv_conf_timestamp;
+#else
+ int dummy;
+#endif
+};
+
/**
* GResolver:
*
{
volatile GType type;
+ g_type_class_add_private (resolver_class, sizeof (GResolverPrivate));
+
/* Make sure _g_networking_init() has been called */
type = g_inet_address_get_type ();
*/
_g_resolver_addrinfo_hints.ai_socktype = SOCK_STREAM;
_g_resolver_addrinfo_hints.ai_protocol = IPPROTO_TCP;
+
+ /**
+ * GResolver::reload:
+ * @resolver: a #GResolver
+ *
+ * Emitted when the resolver notices that the system resolver
+ * configuration has changed.
+ **/
+ signals[RELOAD] =
+ g_signal_new (I_("reload"),
+ G_TYPE_RESOLVER,
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GResolverClass, reload),
+ NULL, NULL,
+ g_cclosure_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
}
static void
g_resolver_init (GResolver *resolver)
{
+#ifdef G_OS_UNIX
+ struct stat st;
+#endif
+
+ resolver->priv = G_TYPE_INSTANCE_GET_PRIVATE (resolver, G_TYPE_RESOLVER, GResolverPrivate);
+
+#ifdef G_OS_UNIX
+ if (stat (_PATH_RESCONF, &st) == 0)
+ resolver->priv->resolv_conf_timestamp = st.st_mtime;
+#endif
}
static GResolver *default_resolver;
}
+static void
+g_resolver_maybe_reload (GResolver *resolver)
+{
+#ifdef G_OS_UNIX
+ struct stat st;
+
+ if (stat (_PATH_RESCONF, &st) == 0)
+ {
+ if (st.st_mtime != resolver->priv->resolv_conf_timestamp)
+ {
+ resolver->priv->resolv_conf_timestamp = st.st_mtime;
+ res_init ();
+ g_signal_emit (resolver, signals[RELOAD], 0);
+ }
+ }
+#endif
+}
+
/**
* g_resolver_lookup_by_name:
* @resolver: a #GResolver
if (g_hostname_is_non_ascii (hostname))
hostname = ascii_hostname = g_hostname_to_ascii (hostname);
+ g_resolver_maybe_reload (resolver);
addrs = G_RESOLVER_GET_CLASS (resolver)->
lookup_by_name (resolver, hostname, cancellable, error);
if (g_hostname_is_non_ascii (hostname))
hostname = ascii_hostname = g_hostname_to_ascii (hostname);
+ g_resolver_maybe_reload (resolver);
G_RESOLVER_GET_CLASS (resolver)->
lookup_by_name_async (resolver, hostname, cancellable, callback, user_data);
g_return_val_if_fail (G_IS_RESOLVER (resolver), NULL);
g_return_val_if_fail (G_IS_INET_ADDRESS (address), NULL);
+ g_resolver_maybe_reload (resolver);
return G_RESOLVER_GET_CLASS (resolver)->
lookup_by_address (resolver, address, cancellable, error);
}
g_return_if_fail (G_IS_RESOLVER (resolver));
g_return_if_fail (G_IS_INET_ADDRESS (address));
+ g_resolver_maybe_reload (resolver);
G_RESOLVER_GET_CLASS (resolver)->
lookup_by_address_async (resolver, address, cancellable, callback, user_data);
}
rrname = g_resolver_get_service_rrname (service, protocol, domain);
+ g_resolver_maybe_reload (resolver);
targets = G_RESOLVER_GET_CLASS (resolver)->
lookup_service (resolver, rrname, cancellable, error);
rrname = g_resolver_get_service_rrname (service, protocol, domain);
+ g_resolver_maybe_reload (resolver);
G_RESOLVER_GET_CLASS (resolver)->
lookup_service_async (resolver, rrname, cancellable, callback, user_data);
static gboolean g_unix_resolver_watch (GIOChannel *iochannel,
GIOCondition condition,
gpointer user_data);
+static void g_unix_resolver_reload (GResolver *resolver);
static void
g_unix_resolver_init (GUnixResolver *gur)
{
- gint fd;
- GIOChannel *io;
-
- /* FIXME: how many workers? */
- gur->asyncns = _g_asyncns_new (2);
-
- fd = _g_asyncns_fd (gur->asyncns);
- io = g_io_channel_unix_new (fd);
- gur->watch = g_io_add_watch (io, G_IO_IN | G_IO_HUP | G_IO_ERR,
- g_unix_resolver_watch, gur);
- g_io_channel_unref (io);
+ g_unix_resolver_reload (G_RESOLVER (gur));
}
static void
G_OBJECT_CLASS (g_unix_resolver_parent_class)->finalize (object);
}
+static void
+g_unix_resolver_reload (GResolver *resolver)
+{
+ GUnixResolver *gur = G_UNIX_RESOLVER (resolver);
+ gint fd;
+ GIOChannel *io;
+
+ if (gur->asyncns)
+ {
+ if (_g_asyncns_getnqueries (gur->asyncns) == 0)
+ {
+ g_source_remove (gur->watch);
+ _g_asyncns_free (gur->asyncns);
+ }
+ /* else, we will free it later from g_unix_resolver_watch */
+ }
+
+ /* FIXME: how many workers? */
+ gur->asyncns = _g_asyncns_new (2);
+
+ fd = _g_asyncns_fd (gur->asyncns);
+ io = g_io_channel_unix_new (fd);
+ gur->watch = g_io_add_watch (io, G_IO_IN | G_IO_HUP | G_IO_ERR,
+ g_unix_resolver_watch, gur->asyncns);
+ g_io_channel_unref (io);
+}
+
/* The various request possibilities:
*
* 1. Synchronous: handed off to the base class (GThreadedResolver);
struct _GUnixResolverRequest {
GUnixResolver *gur;
+ _g_asyncns_t *asyncns;
_g_asyncns_query_t *qy;
union {
req = g_slice_new0 (GUnixResolverRequest);
req->gur = g_object_ref (gur);
+ req->asyncns = gur->asyncns;
req->qy = qy;
req->process_func = process_func;
req->free_func = free_func;
g_unix_resolver_request_free (GUnixResolverRequest *req)
{
req->free_func (req);
- g_object_unref (req->gur);
/* We don't have to free req->cancellable and req->async_result,
* since they must already have been freed if we're here.
*/
+ /* Check if this was the last request remaining on an old asyncns. */
+ if (req->asyncns != req->gur->asyncns &&
+ _g_asyncns_getnqueries (req->asyncns) == 0)
+ _g_asyncns_free (req->asyncns);
+
+ g_object_unref (req->gur);
g_slice_free (GUnixResolverRequest, req);
}
GUnixResolverRequest *req = user_data;
GError *error = NULL;
- _g_asyncns_cancel (req->gur->asyncns, req->qy);
+ _g_asyncns_cancel (req->asyncns, req->qy);
req->qy = NULL;
g_cancellable_set_error_if_cancelled (cancellable, &error);
GIOCondition condition,
gpointer user_data)
{
- GUnixResolver *gur = user_data;
+ _g_asyncns_t *asyncns = user_data;
_g_asyncns_query_t *qy;
GUnixResolverRequest *req;
if (condition & (G_IO_HUP | G_IO_ERR))
{
- /* Shouldn't happen. Should we create a new asyncns? FIXME */
- g_warning ("asyncns died");
- gur->watch = 0;
+ /* Will happen if we reload, and then eventually kill the old
+ * _g_asyncns_t when it's done processing requests.
+ */
return FALSE;
}
- while (_g_asyncns_wait (gur->asyncns, FALSE) == 0 &&
- (qy = _g_asyncns_getnext (gur->asyncns)) != NULL)
+ while (_g_asyncns_wait (asyncns, FALSE) == 0 &&
+ (qy = _g_asyncns_getnext (asyncns)) != NULL)
{
- req = _g_asyncns_getuserdata (gur->asyncns, qy);
+ req = _g_asyncns_getuserdata (asyncns, qy);
req->process_func (req);
g_unix_resolver_request_complete (req);
}
gint retval;
GError *error = NULL;
- retval = _g_asyncns_getaddrinfo_done (req->gur->asyncns, req->qy, &res);
+ retval = _g_asyncns_getaddrinfo_done (req->asyncns, req->qy, &res);
req->u.name.addresses =
_g_resolver_addresses_from_addrinfo (req->u.name.hostname,
res, retval, &error);
gint retval;
GError *error = NULL;
- retval = _g_asyncns_getnameinfo_done (req->gur->asyncns, req->qy,
+ retval = _g_asyncns_getnameinfo_done (req->asyncns, req->qy,
host, sizeof (host), NULL, 0);
req->u.address.hostname =
_g_resolver_name_from_nameinfo (req->u.address.address,
gint len, herr;
GError *error = NULL;
- len = _g_asyncns_res_done (req->gur->asyncns, req->qy, &answer);
+ len = _g_asyncns_res_done (req->asyncns, req->qy, &answer);
if (len < 0)
herr = h_errno;
else
GResolverClass *resolver_class = G_RESOLVER_CLASS (unix_class);
GObjectClass *object_class = G_OBJECT_CLASS (unix_class);
+ resolver_class->reload = g_unix_resolver_reload;
resolver_class->lookup_by_name_async = lookup_by_name_async;
resolver_class->lookup_by_name_finish = lookup_by_name_finish;
resolver_class->lookup_by_address_async = lookup_by_address_async;