dnsproxy: Only one copy of the relevant buffers will be made to a TCP request
[framework/connectivity/connman.git] / src / resolver.c
index 5fc01a6..a9d1341 100644 (file)
@@ -2,7 +2,7 @@
  *
  *  Connection Manager
  *
- *  Copyright (C) 2007-2009  Intel Corporation. All rights reserved.
+ *  Copyright (C) 2007-2012  Intel Corporation. All rights reserved.
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License version 2 as
 #include <config.h>
 #endif
 
+#define _GNU_SOURCE
 #include <stdio.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <unistd.h>
 #include <string.h>
 #include <sys/stat.h>
+#include <resolv.h>
 
 #include "connman.h"
 
+#define RESOLVER_FLAG_PUBLIC (1 << 0)
+
+/*
+ * Threshold for RDNSS lifetime. Will be used to trigger RS
+ * before RDNSS entries actually expire
+ */
+#define RESOLVER_LIFETIME_REFRESH_THRESHOLD 0.8
+
 struct entry_data {
-       struct connman_resolver *resolver;
        char *interface;
        char *domain;
        char *server;
+       unsigned int flags;
+       unsigned int lifetime;
+       guint timeout;
 };
 
 static GSList *entry_list = NULL;
-static GSList *resolver_list = NULL;
+static connman_bool_t dnsproxy_enabled = FALSE;
+
+struct resolvfile_entry {
+       char *interface;
+       char *domain;
+       char *server;
+};
+
+static GList *resolvfile_list = NULL;
+
+static void resolvfile_remove_entries(GList *entries)
+{
+       GList *list;
+
+       for (list = entries; list; list = list->next) {
+               struct resolvfile_entry *entry = list->data;
+
+               resolvfile_list = g_list_remove(resolvfile_list, entry);
+
+               g_free(entry->server);
+               g_free(entry->domain);
+               g_free(entry->interface);
+               g_free(entry);
+       }
+
+       g_list_free(entries);
+}
+
+static int resolvfile_export(void)
+{
+       GList *list;
+       GString *content;
+       int fd, err;
+       unsigned int count;
+       mode_t old_umask;
+
+       content = g_string_new("# Generated by Connection Manager\n");
+
+       /*
+        * Domains and nameservers are added in reverse so that the most
+        * recently appended entry is the primary one. No more than
+        * MAXDNSRCH/MAXNS entries are used.
+        */
+
+       for (count = 0, list = g_list_last(resolvfile_list);
+                                               list && (count < MAXDNSRCH);
+                                               list = g_list_previous(list)) {
+               struct resolvfile_entry *entry = list->data;
+
+               if (!entry->domain)
+                       continue;
+
+               if (count == 0)
+                       g_string_append_printf(content, "search ");
+
+               g_string_append_printf(content, "%s ", entry->domain);
+               count++;
+       }
+
+       if (count)
+               g_string_append_printf(content, "\n");
+
+       for (count = 0, list = g_list_last(resolvfile_list);
+                                               list && (count < MAXNS);
+                                               list = g_list_previous(list)) {
+               struct resolvfile_entry *entry = list->data;
+
+               if (!entry->server)
+                       continue;
+
+               g_string_append_printf(content, "nameserver %s\n",
+                                                               entry->server);
+               count++;
+       }
+
+       old_umask = umask(022);
+
+       fd = open("/etc/resolv.conf", O_RDWR | O_CREAT | O_CLOEXEC,
+                                       S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
+       if (fd < 0) {
+               err = -errno;
+               goto done;
+       }
+
+       if (ftruncate(fd, 0) < 0) {
+               err = -errno;
+               goto failed;
+       }
+
+       err = 0;
+
+       if (write(fd, content->str, content->len) < 0)
+               err = -errno;
+
+failed:
+       close(fd);
+
+done:
+       g_string_free(content, TRUE);
+       umask(old_umask);
+
+       return err;
+}
+
+int __connman_resolvfile_append(const char *interface, const char *domain,
+                                                       const char *server)
+{
+       struct resolvfile_entry *entry;
+
+       DBG("interface %s server %s", interface, server);
+
+       if (interface == NULL)
+               return -ENOENT;
+
+       entry = g_try_new0(struct resolvfile_entry, 1);
+       if (entry == NULL)
+               return -ENOMEM;
+
+       entry->interface = g_strdup(interface);
+       entry->domain = g_strdup(domain);
+       entry->server = g_strdup(server);
+
+       resolvfile_list = g_list_append(resolvfile_list, entry);
+
+       return resolvfile_export();
+}
+
+int __connman_resolvfile_remove(const char *interface, const char *domain,
+                                                       const char *server)
+{
+       GList *list, *matches = NULL;
+
+       DBG("interface %s server %s", interface, server);
+
+       for (list = resolvfile_list; list; list = g_list_next(list)) {
+               struct resolvfile_entry *entry = list->data;
+
+               if (interface != NULL &&
+                               g_strcmp0(entry->interface, interface) != 0)
+                       continue;
+
+               if (domain != NULL && g_strcmp0(entry->domain, domain) != 0)
+                       continue;
+
+               if (g_strcmp0(entry->server, server) != 0)
+                       continue;
+
+               matches = g_list_append(matches, entry);
+       }
+
+       resolvfile_remove_entries(matches);
+
+       return resolvfile_export();
+}
 
 static void remove_entries(GSList *entries)
 {
@@ -48,14 +213,19 @@ static void remove_entries(GSList *entries)
 
        for (list = entries; list; list = list->next) {
                struct entry_data *entry = list->data;
-               struct connman_resolver *resolver = entry->resolver;
 
                entry_list = g_slist_remove(entry_list, entry);
 
-               if (resolver && resolver->remove)
-                       resolver->remove(entry->interface, entry->domain,
-                                                               entry->server);
+               if (dnsproxy_enabled == TRUE) {
+                       __connman_dnsproxy_remove(entry->interface, entry->domain,
+                                                       entry->server);
+               } else {
+                       __connman_resolvfile_remove(entry->interface, entry->domain,
+                                                       entry->server);
+               }
 
+               if (entry->timeout)
+                       g_source_remove(entry->timeout);
                g_free(entry->server);
                g_free(entry->domain);
                g_free(entry->interface);
@@ -65,116 +235,204 @@ static void remove_entries(GSList *entries)
        g_slist_free(entries);
 }
 
-static gint compare_priority(gconstpointer a, gconstpointer b)
+static gboolean resolver_expire_cb(gpointer user_data)
 {
-       const struct connman_resolver *resolver1 = a;
-       const struct connman_resolver *resolver2 = b;
+       struct entry_data *entry = user_data;
+       GSList *list;
+       int index;
 
-       return resolver2->priority - resolver1->priority;
+       DBG("interface %s domain %s server %s",
+                       entry->interface, entry->domain, entry->server);
+
+       list = g_slist_append(NULL, entry);
+
+       index = connman_inet_ifindex(entry->interface);
+       if (index >= 0) {
+               struct connman_service *service;
+               service = __connman_service_lookup_from_index(index);
+               if (service != NULL)
+                       __connman_service_nameserver_remove(service,
+                                                       entry->server, TRUE);
+       }
+
+       remove_entries(list);
+
+       return FALSE;
 }
 
-/**
- * connman_resolver_register:
- * @resolver: resolver module
- *
- * Register a new resolver module
- *
- * Returns: %0 on success
- */
-int connman_resolver_register(struct connman_resolver *resolver)
+static gboolean resolver_refresh_cb(gpointer user_data)
 {
-       GSList *list;
-
-       DBG("resolver %p name %s", resolver, resolver->name);
+       struct entry_data *entry = user_data;
+       int index;
+       unsigned int interval;
+       struct connman_service *service = NULL;
+
+       /* Round up what we have left from lifetime */
+       interval = entry->lifetime *
+               (1 - RESOLVER_LIFETIME_REFRESH_THRESHOLD) + 1.0;
+
+       DBG("RDNSS start interface %s domain %s "
+                       "server %s remaining lifetime %d",
+                       entry->interface, entry->domain,
+                       entry->server, interval);
+
+       entry->timeout = g_timeout_add_seconds(interval,
+                       resolver_expire_cb, entry);
+
+       index = connman_inet_ifindex(entry->interface);
+       if (index >= 0) {
+               service = __connman_service_lookup_from_index(index);
+               if (service != NULL) {
+                       /*
+                        * Send Router Solicitation to refresh RDNSS entries
+                        * before their lifetime expires
+                        */
+                       __connman_refresh_rs_ipv6(
+                                       __connman_service_get_network(service),
+                                       index);
+               }
+       }
+       return FALSE;
+}
 
-       resolver_list = g_slist_insert_sorted(resolver_list, resolver,
-                                                       compare_priority);
+static int append_resolver(const char *interface, const char *domain,
+                               const char *server, unsigned int lifetime,
+                                                       unsigned int flags)
+{
+       struct entry_data *entry;
+       unsigned int interval;
 
-       if (resolver->append == NULL)
-               return 0;
+       DBG("interface %s domain %s server %s lifetime %d flags %d",
+                               interface, domain, server, lifetime, flags);
 
-       for (list = entry_list; list; list = list->next) {
-               struct entry_data *entry = list->data;
+       if (server == NULL && domain == NULL)
+               return -EINVAL;
 
-               if (entry->resolver)
-                       continue;
+       entry = g_try_new0(struct entry_data, 1);
+       if (entry == NULL)
+               return -ENOMEM;
 
-               if (resolver->append(entry->interface, entry->domain,
-                                                       entry->server) == 0)
-                       entry->resolver = resolver;
+       entry->interface = g_strdup(interface);
+       entry->domain = g_strdup(domain);
+       entry->server = g_strdup(server);
+       entry->flags = flags;
+       entry->lifetime = lifetime;
+       if (lifetime) {
+               int index;
+               interval = lifetime * RESOLVER_LIFETIME_REFRESH_THRESHOLD;
+
+               DBG("RDNSS start interface %s domain %s "
+                               "server %s lifetime threshold %d",
+                               interface, domain, server, interval);
+
+               entry->timeout = g_timeout_add_seconds(interval,
+                               resolver_refresh_cb, entry);
+
+               /*
+                * We update the service only for those nameservers
+                * that are automagically added via netlink (lifetime > 0)
+                */
+               index = connman_inet_ifindex(interface);
+               if (server != NULL && index >= 0) {
+                       struct connman_service *service;
+                       service = __connman_service_lookup_from_index(index);
+                       if (service != NULL)
+                               __connman_service_nameserver_append(service,
+                                                               server, TRUE);
+               }
        }
+       entry_list = g_slist_append(entry_list, entry);
+
+       if (dnsproxy_enabled == TRUE)
+               __connman_dnsproxy_append(interface, domain, server);
+       else
+               __connman_resolvfile_append(interface, domain, server);
 
        return 0;
 }
 
 /**
- * connman_resolver_unregister:
- * @resolver: resolver module
+ * connman_resolver_append:
+ * @interface: network interface
+ * @domain: domain limitation
+ * @server: server address
  *
- * Remove a previously registered resolver module
+ * Append resolver server address to current list
  */
-void connman_resolver_unregister(struct connman_resolver *resolver)
+int connman_resolver_append(const char *interface, const char *domain,
+                                               const char *server)
 {
-       GSList *list, *matches = NULL;
+       GSList *list;
 
-       DBG("resolver %p name %s", resolver, resolver->name);
+       DBG("interface %s domain %s server %s", interface, domain, server);
 
-       resolver_list = g_slist_remove(resolver_list, resolver);
+       if (server == NULL && domain == NULL)
+               return -EINVAL;
 
        for (list = entry_list; list; list = list->next) {
                struct entry_data *entry = list->data;
 
-               if (entry->resolver != resolver)
+               if (entry->timeout > 0)
                        continue;
 
-               matches = g_slist_append(matches, entry);
+               if (g_strcmp0(entry->interface, interface) == 0 &&
+                               g_strcmp0(entry->domain, domain) == 0 &&
+                               g_strcmp0(entry->server, server) == 0)
+                       return -EEXIST;
        }
 
-       remove_entries(matches);
+       return append_resolver(interface, domain, server, 0, 0);
 }
 
 /**
- * connman_resolver_append:
+ * connman_resolver_append_lifetime:
  * @interface: network interface
  * @domain: domain limitation
  * @server: server address
+ * @timeout: server lifetime in seconds
  *
  * Append resolver server address to current list
  */
-int connman_resolver_append(const char *interface, const char *domain,
-                                                       const char *server)
+int connman_resolver_append_lifetime(const char *interface, const char *domain,
+                               const char *server, unsigned int lifetime)
 {
-       struct entry_data *entry;
        GSList *list;
+       unsigned int interval;
 
-       DBG("interface %s domain %s server %s", interface, domain, server);
+       DBG("interface %s domain %s server %s lifetime %d",
+                               interface, domain, server, lifetime);
 
-       if (server == NULL)
+       if (server == NULL && domain == NULL)
                return -EINVAL;
 
-       entry = g_try_new0(struct entry_data, 1);
-       if (entry == NULL)
-               return -ENOMEM;
+       for (list = entry_list; list; list = list->next) {
+               struct entry_data *entry = list->data;
 
-       entry->interface = g_strdup(interface);
-       entry->domain = g_strdup(domain);
-       entry->server = g_strdup(server);
+               if (entry->timeout == 0 ||
+                               g_strcmp0(entry->interface, interface) != 0 ||
+                               g_strcmp0(entry->domain, domain) != 0 ||
+                               g_strcmp0(entry->server, server) != 0)
+                       continue;
 
-       entry_list = g_slist_append(entry_list, entry);
+               g_source_remove(entry->timeout);
 
-       for (list = resolver_list; list; list = list->next) {
-               struct connman_resolver *resolver = list->data;
+               if (lifetime == 0) {
+                       resolver_expire_cb(entry);
+                       return 0;
+               }
 
-               if (resolver->append == NULL)
-                       continue;
+               interval = lifetime * RESOLVER_LIFETIME_REFRESH_THRESHOLD;
 
-               if (resolver->append(interface, domain, server) == 0) {
-                       entry->resolver = resolver;
-                       break;
-               }
+               DBG("RDNSS start interface %s domain %s "
+                               "server %s lifetime threshold %d",
+                               interface, domain, server, interval);
+
+               entry->timeout = g_timeout_add_seconds(interval,
+                               resolver_refresh_cb, entry);
+               return 0;
        }
 
-       return 0;
+       return append_resolver(interface, domain, server, lifetime, 0);
 }
 
 /**
@@ -192,23 +450,20 @@ int connman_resolver_remove(const char *interface, const char *domain,
 
        DBG("interface %s domain %s server %s", interface, domain, server);
 
-       if (server == NULL)
-               return -EINVAL;
-
        for (list = entry_list; list; list = list->next) {
                struct entry_data *entry = list->data;
 
-               if (interface != NULL &&
-                               g_strcmp0(entry->interface, interface) != 0)
+               if (g_strcmp0(entry->interface, interface) != 0)
                        continue;
 
-               if (domain != NULL && g_strcmp0(entry->domain, domain) != 0)
+               if (g_strcmp0(entry->domain, domain) != 0)
                        continue;
 
                if (g_strcmp0(entry->server, server) != 0)
                        continue;
 
                matches = g_slist_append(matches, entry);
+               break;
        }
 
        if (matches == NULL)
@@ -252,130 +507,120 @@ int connman_resolver_remove_all(const char *interface)
 }
 
 /**
- * connman_resolver_append_public_server:
- * @server: server address
+ * connman_resolver_flush:
  *
- * Append public resolver server address to current list
+ * Flush pending resolver requests
  */
-int connman_resolver_append_public_server(const char *server)
+void connman_resolver_flush(void)
 {
-       DBG("server %s", server);
+       if (dnsproxy_enabled == TRUE)
+               __connman_dnsproxy_flush();
 
-       return connman_resolver_append(NULL, NULL, server);
+       return;
 }
 
-/**
- * connman_resolver_remove_public_server:
- * @server: server address
- *
- * Remove public resolver server address to current list
- */
-int connman_resolver_remove_public_server(const char *server)
+int __connman_resolver_redo_servers(const char *interface)
 {
-       DBG("server %s", server);
-
-       return connman_resolver_remove(NULL, NULL, server);
-}
-
-static int selftest_append(const char *interface, const char *domain,
-                                                       const char *server)
-{
-       DBG("server %s", server);
-
-       return 0;
-}
-
-static int selftest_remove(const char *interface, const char *domain,
-                                                       const char *server)
-{
-       DBG("server %s", server);
-
-       return 0;
-}
-
-static struct connman_resolver selftest_resolver = {
-       .name     = "selftest",
-       .priority = CONNMAN_RESOLVER_PRIORITY_HIGH + 42,
-       .append   = selftest_append,
-       .remove   = selftest_remove,
-};
-
-int __connman_resolver_selftest(void)
-{
-       connman_resolver_append("wlan0", "lwn.net", "192.168.0.1");
+       GSList *list;
 
-       connman_resolver_register(&selftest_resolver);
+       if (dnsproxy_enabled == FALSE)
+               return 0;
 
-       connman_resolver_append("eth0", "moblin.org", "192.168.42.1");
-       connman_resolver_append("wlan0", "lwn.net", "192.168.0.2");
+       DBG("interface %s", interface);
 
-       connman_resolver_append_public_server("8.8.8.8");
+       if (interface == NULL)
+               return -EINVAL;
 
-       connman_resolver_remove_public_server("8.8.8.8");
+       for (list = entry_list; list; list = list->next) {
+               struct entry_data *entry = list->data;
 
-       connman_resolver_remove_all("wlan0");
+               if (entry->timeout == 0 ||
+                               g_strcmp0(entry->interface, interface) != 0)
+                       continue;
 
-       connman_resolver_unregister(&selftest_resolver);
+               /*
+                * We remove the server, and then re-create so that it will
+                * use proper source addresses when sending DNS queries.
+                */
+               __connman_dnsproxy_remove(entry->interface, entry->domain,
+                                       entry->server);
+               /*
+                * Remove also the resolver timer for the old server entry.
+                * A new timer will be set for the new server entry
+                * when the next Router Advertisement message arrives
+                * with RDNSS/DNSSL settings.
+                */
+               g_source_remove(entry->timeout);
+
+               __connman_dnsproxy_append(entry->interface, entry->domain,
+                                       entry->server);
+       }
 
        return 0;
 }
 
-static int resolvfile_append(const char *interface, const char *domain,
-                                                       const char *server)
+static void free_entry(gpointer data)
 {
-       char *cmd;
-       int fd, len, err;
-
-       DBG("interface %s server %s", interface, server);
-
-       if (interface == NULL)
-               return -ENOENT;
+       struct entry_data *entry = data;
+       g_free(entry->interface);
+       g_free(entry->domain);
+       g_free(entry->server);
+       g_free(entry);
+}
 
-       fd = open("/etc/resolv.conf", O_RDWR | O_CREAT,
-                                       S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
-       if (fd < 0)
-               return -errno;
+static void free_resolvfile(gpointer data)
+{
+       struct resolvfile_entry *entry = data;
+       g_free(entry->interface);
+       g_free(entry->domain);
+       g_free(entry->server);
+       g_free(entry);
+}
 
-       err = ftruncate(fd, 0);
+int __connman_resolver_init(connman_bool_t dnsproxy)
+{
+       int i;
+       char **ns;
 
-       cmd = g_strdup_printf("# Generated by Connection Manager\n"
-                                               "options edns0\n"
-                                               "nameserver %s\n", server);
+       DBG("dnsproxy %d", dnsproxy);
 
-       len = write(fd, cmd, strlen(cmd));
+       if (dnsproxy == FALSE)
+               return 0;
 
-       g_free(cmd);
+       if (__connman_dnsproxy_init() < 0) {
+               /* Fall back to resolv.conf */
+               return 0;
+       }
 
-       close(fd);
+       dnsproxy_enabled = TRUE;
 
-       return 0;
-}
-
-static int resolvfile_remove(const char *interface, const char *domain,
-                                                       const char *server)
-{
-       DBG("interface %s server %s", interface, server);
+       ns = connman_setting_get_string_list("FallbackNameservers");
+       for (i = 0; ns != NULL && ns[i] != NULL; i += 1) {
+               DBG("server %s", ns[i]);
+               append_resolver(NULL, NULL, ns[i], 0, RESOLVER_FLAG_PUBLIC);
+       }
 
        return 0;
 }
 
-static struct connman_resolver resolvfile_resolver = {
-       .name           = "resolvfile",
-       .priority       = CONNMAN_RESOLVER_PRIORITY_LOW,
-       .append         = resolvfile_append,
-       .remove         = resolvfile_remove,
-};
-
-int __connman_resolver_init(void)
-{
-       DBG("");
-
-       return connman_resolver_register(&resolvfile_resolver);
-}
-
 void __connman_resolver_cleanup(void)
 {
        DBG("");
 
-       connman_resolver_unregister(&resolvfile_resolver);
+       if (dnsproxy_enabled == TRUE)
+               __connman_dnsproxy_cleanup();
+       else {
+               GList *list;
+               GSList *slist;
+
+               for (list = resolvfile_list; list; list = g_list_next(list))
+                       free_resolvfile(list->data);
+               g_list_free(resolvfile_list);
+               resolvfile_list = NULL;
+
+               for (slist = entry_list; slist; slist = g_slist_next(slist))
+                       free_entry(slist->data);
+               g_slist_free(entry_list);
+               entry_list = NULL;
+       }
 }