src/resolver.c

   1 /*
   2  *
   3  *  Connection Manager
   4  *
   5  *  Copyright (C) 2007-2013  Intel Corporation. All rights reserved.
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License version 2 as
   9  *  published by the Free Software Foundation.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  19  *
  20  */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #define _GNU_SOURCE
  27 #include <stdio.h>
  28 #include <errno.h>
  29 #include <fcntl.h>
  30 #include <unistd.h>
  31 #include <string.h>
  32 #include <sys/stat.h>
  33 #include <resolv.h>
  34 #include <netdb.h>
  35
  36 #include "connman.h"
  37
  38 #define RESOLVER_FLAG_PUBLIC (1 << 0)
  39
  40 /*
  41  * Threshold for RDNSS lifetime. Will be used to trigger RS
  42  * before RDNSS entries actually expire
  43  */
  44 #define RESOLVER_LIFETIME_REFRESH_THRESHOLD 0.8
  45
  46 struct entry_data {
  47         int index;
  48         char *domain;
  49         char *server;
  50         int family;
  51         unsigned int flags;
  52         unsigned int lifetime;
  53         guint timeout;
  54 };
  55
  56 static GSList *entry_list = NULL;
  57 static bool dnsproxy_enabled = false;
  58
  59 struct resolvfile_entry {
  60         int index;
  61         char *domain;
  62         char *server;
  63 };
  64
  65 static GList *resolvfile_list = NULL;
  66
  67 static void resolvfile_remove_entries(GList *entries)
  68 {
  69         GList *list;
  70
  71         for (list = entries; list; list = list->next) {
  72                 struct resolvfile_entry *entry = list->data;
  73
  74                 resolvfile_list = g_list_remove(resolvfile_list, entry);
  75
  76                 g_free(entry->server);
  77                 g_free(entry->domain);
  78                 g_free(entry);
  79         }
  80
  81         g_list_free(entries);
  82 }
  83
  84 static int resolvfile_export(void)
  85 {
  86         GList *list;
  87         GString *content;
  88         int fd, err;
  89         unsigned int count;
  90         mode_t old_umask;
  91
  92         content = g_string_new("# Generated by Connection Manager\n");
  93
  94         /*
  95          * Domains and nameservers are added in reverse so that the most
  96          * recently appended entry is the primary one. No more than
  97          * MAXDNSRCH/MAXNS entries are used.
  98          */
  99
 100         for (count = 0, list = g_list_first(resolvfile_list);
 101                                                 list && (count < MAXDNSRCH);
 102                                                 list = g_list_next(list)) {
 103                 struct resolvfile_entry *entry = list->data;
 104
 105                 if (!entry->domain)
 106                         continue;
 107
 108                 if (count == 0)
 109                         g_string_append_printf(content, "search ");
 110
 111                 g_string_append_printf(content, "%s ", entry->domain);
 112                 count++;
 113         }
 114
 115         if (count)
 116                 g_string_append_printf(content, "\n");
 117
 118         for (count = 0, list = g_list_first(resolvfile_list);
 119                                                 list && (count < MAXNS);
 120                                                 list = g_list_next(list)) {
 121                 struct resolvfile_entry *entry = list->data;
 122
 123                 if (!entry->server)
 124                         continue;
 125
 126                 g_string_append_printf(content, "nameserver %s\n",
 127                                                                 entry->server);
 128                 count++;
 129         }
 130
 131         old_umask = umask(022);
 132
 133         fd = open("/etc/resolv.conf", O_RDWR | O_CREAT | O_CLOEXEC,
 134                                         S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
 135         if (fd < 0) {
 136                 err = -errno;
 137                 goto done;
 138         }
 139
 140         if (ftruncate(fd, 0) < 0) {
 141                 err = -errno;
 142                 goto failed;
 143         }
 144
 145         err = 0;
 146
 147         if (write(fd, content->str, content->len) < 0)
 148                 err = -errno;
 149
 150 failed:
 151         close(fd);
 152
 153 done:
 154         g_string_free(content, TRUE);
 155         umask(old_umask);
 156
 157         return err;
 158 }
 159
 160 int __connman_resolvfile_append(int index, const char *domain,
 161                                                         const char *server)
 162 {
 163         struct resolvfile_entry *entry;
 164
 165         DBG("index %d server %s", index, server);
 166
 167         if (index < 0)
 168                 return -ENOENT;
 169
 170         entry = g_try_new0(struct resolvfile_entry, 1);
 171         if (!entry)
 172                 return -ENOMEM;
 173
 174         entry->index = index;
 175         entry->domain = g_strdup(domain);
 176         entry->server = g_strdup(server);
 177
 178         resolvfile_list = g_list_append(resolvfile_list, entry);
 179
 180         return resolvfile_export();
 181 }
 182
 183 int __connman_resolvfile_remove(int index, const char *domain,
 184                                                         const char *server)
 185 {
 186         GList *list, *matches = NULL;
 187
 188         DBG("index %d server %s", index, server);
 189
 190         for (list = resolvfile_list; list; list = g_list_next(list)) {
 191                 struct resolvfile_entry *entry = list->data;
 192
 193                 if (index >= 0 && entry->index != index)
 194                         continue;
 195
 196                 if (domain && g_strcmp0(entry->domain, domain) != 0)
 197                         continue;
 198
 199                 if (g_strcmp0(entry->server, server) != 0)
 200                         continue;
 201
 202                 matches = g_list_append(matches, entry);
 203         }
 204
 205         resolvfile_remove_entries(matches);
 206
 207         return resolvfile_export();
 208 }
 209
 210 void __connman_resolver_append_fallback_nameservers(void)
 211 {
 212         GSList *list;
 213
 214         for (list = entry_list; list; list = list->next) {
 215                 struct entry_data *entry = list->data;
 216
 217                 if (entry->index >= 0 && entry->server)
 218                         return;
 219         }
 220
 221         for (list = entry_list; list; list = list->next) {
 222                 struct entry_data *entry = list->data;
 223
 224                 if (entry->index != -1 || !entry->server)
 225                         continue;
 226
 227                 DBG("index %d server %s", entry->index, entry->server);
 228
 229                 if (dnsproxy_enabled) {
 230                         __connman_dnsproxy_append(entry->index, entry->domain,
 231                                         entry->server);
 232                 } else {
 233                         __connman_resolvfile_append(entry->index,
 234                                         entry->domain, entry->server);
 235                 }
 236         }
 237 }
 238
 239 static void remove_fallback_nameservers(void)
 240 {
 241         GSList *list;
 242
 243         for (list = entry_list; list; list = list->next) {
 244                 struct entry_data *entry = list->data;
 245
 246                 if (entry->index >= 0 || !entry->server)
 247                         continue;
 248
 249                 DBG("index %d server %s", entry->index, entry->server);
 250
 251                 if (dnsproxy_enabled) {
 252                         __connman_dnsproxy_remove(entry->index, entry->domain,
 253                                         entry->server);
 254                 } else {
 255                         __connman_resolvfile_remove(entry->index,
 256                                         entry->domain, entry->server);
 257                 }
 258         }
 259 }
 260
 261 static void remove_entries(GSList *entries)
 262 {
 263         GSList *list;
 264
 265         for (list = entries; list; list = list->next) {
 266                 struct entry_data *entry = list->data;
 267
 268                 entry_list = g_slist_remove(entry_list, entry);
 269
 270                 if (dnsproxy_enabled) {
 271                         __connman_dnsproxy_remove(entry->index, entry->domain,
 272                                                         entry->server);
 273                 } else {
 274                         __connman_resolvfile_remove(entry->index, entry->domain,
 275                                                         entry->server);
 276                 }
 277
 278                 if (entry->timeout)
 279                         g_source_remove(entry->timeout);
 280                 g_free(entry->server);
 281                 g_free(entry->domain);
 282                 g_free(entry);
 283         }
 284
 285         g_slist_free(entries);
 286
 287         __connman_resolver_append_fallback_nameservers();
 288 }
 289
 290 static gboolean resolver_expire_cb(gpointer user_data)
 291 {
 292         struct entry_data *entry = user_data;
 293         GSList *list;
 294
 295         DBG("index %d domain %s server %s",
 296                         entry->index, entry->domain, entry->server);
 297
 298         list = g_slist_prepend(NULL, entry);
 299
 300         if (entry->index >= 0) {
 301                 struct connman_service *service;
 302                 service = __connman_service_lookup_from_index(entry->index);
 303                 if (service)
 304 #if defined TIZEN_EXT
 305                         __connman_service_nameserver_remove(service,
 306                                         entry->server, true,
 307                                         CONNMAN_IPCONFIG_TYPE_ALL);
 308 #else
 309                         __connman_service_nameserver_remove(service,
 310                                                         entry->server, true);
 311 #endif
 312         }
 313
 314         remove_entries(list);
 315
 316         return FALSE;
 317 }
 318
 319 static gboolean resolver_refresh_cb(gpointer user_data)
 320 {
 321         struct entry_data *entry = user_data;
 322         unsigned int interval;
 323         struct connman_service *service = NULL;
 324
 325         /* Round up what we have left from lifetime */
 326         interval = entry->lifetime *
 327                 (1 - RESOLVER_LIFETIME_REFRESH_THRESHOLD) + 1.0;
 328
 329         DBG("RDNSS start index %d domain %s "
 330                         "server %s remaining lifetime %d",
 331                         entry->index, entry->domain,
 332                         entry->server, interval);
 333
 334         entry->timeout = g_timeout_add_seconds(interval,
 335                         resolver_expire_cb, entry);
 336
 337         if (entry->index >= 0) {
 338                 service = __connman_service_lookup_from_index(entry->index);
 339                 if (service) {
 340                         /*
 341                          * Send Router Solicitation to refresh RDNSS entries
 342                          * before their lifetime expires
 343                          */
 344                         __connman_network_refresh_rs_ipv6(
 345                                         __connman_service_get_network(service),
 346                                         entry->index);
 347                 }
 348         }
 349         return FALSE;
 350 }
 351
 352 static int append_resolver(int index, const char *domain,
 353                                 const char *server, unsigned int lifetime,
 354                                                         unsigned int flags)
 355 {
 356         struct entry_data *entry;
 357         unsigned int interval;
 358
 359         DBG("index %d domain %s server %s lifetime %d flags %d",
 360                                 index, domain, server, lifetime, flags);
 361
 362         if (!server && !domain)
 363                 return -EINVAL;
 364
 365 #ifdef TIZEN_EXT
 366         if (g_strcmp0(server, "0.0.0.0") == 0)
 367                 return -EINVAL;
 368 #endif
 369
 370         entry = g_try_new0(struct entry_data, 1);
 371         if (!entry)
 372                 return -ENOMEM;
 373
 374         entry->index = index;
 375         entry->domain = g_strdup(domain);
 376         entry->server = g_strdup(server);
 377         entry->flags = flags;
 378         entry->lifetime = lifetime;
 379
 380         if (server)
 381                 entry->family = connman_inet_check_ipaddress(server);
 382
 383         if (lifetime) {
 384                 interval = lifetime * RESOLVER_LIFETIME_REFRESH_THRESHOLD;
 385
 386                 DBG("RDNSS start index %d domain %s "
 387                                 "server %s lifetime threshold %d",
 388                                 index, domain, server, interval);
 389
 390                 entry->timeout = g_timeout_add_seconds(interval,
 391                                 resolver_refresh_cb, entry);
 392         }
 393
 394         if (entry->index >= 0 && entry->server)
 395                 remove_fallback_nameservers();
 396
 397         entry_list = g_slist_append(entry_list, entry);
 398
 399         if (dnsproxy_enabled)
 400                 __connman_dnsproxy_append(entry->index, domain, server);
 401         else
 402                 __connman_resolvfile_append(entry->index, domain, server);
 403
 404         /*
 405          * We update the service only for those nameservers
 406          * that are automagically added via netlink (lifetime > 0)
 407          */
 408         if (server && entry->index >= 0 && lifetime) {
 409                 struct connman_service *service;
 410                 service = __connman_service_lookup_from_index(entry->index);
 411                 if (service)
 412 #if defined TIZEN_EXT
 413                         __connman_service_nameserver_append(service,
 414                                         server, true,
 415                                         CONNMAN_IPCONFIG_TYPE_ALL);
 416 #else
 417                         __connman_service_nameserver_append(service,
 418                                                         server, true);
 419 #endif
 420         }
 421
 422         return 0;
 423 }
 424
 425 /**
 426  * connman_resolver_append:
 427  * @index: network interface index
 428  * @domain: domain limitation
 429  * @server: server address
 430  *
 431  * Append resolver server address to current list
 432  */
 433 int connman_resolver_append(int index, const char *domain,
 434                                                 const char *server)
 435 {
 436         GSList *list;
 437
 438         DBG("index %d domain %s server %s", index, domain, server);
 439
 440         if (!server && !domain)
 441                 return -EINVAL;
 442
 443         for (list = entry_list; list; list = list->next) {
 444                 struct entry_data *entry = list->data;
 445
 446                 if (entry->timeout > 0)
 447                         continue;
 448
 449                 if (entry->index == index &&
 450                                 g_strcmp0(entry->domain, domain) == 0 &&
 451                                 g_strcmp0(entry->server, server) == 0) {
 452                         if (dnsproxy_enabled)
 453                                 __connman_dnsproxy_append(entry->index, domain,
 454                                                 server);
 455
 456                         return -EEXIST;
 457                 }
 458         }
 459
 460         return append_resolver(index, domain, server, 0, 0);
 461 }
 462
 463 /**
 464  * connman_resolver_append_lifetime:
 465  * @index: network interface index
 466  * @domain: domain limitation
 467  * @server: server address
 468  * @timeout: server lifetime in seconds
 469  *
 470  * Append resolver server address to current list
 471  */
 472 int connman_resolver_append_lifetime(int index, const char *domain,
 473                                 const char *server, unsigned int lifetime)
 474 {
 475         GSList *list;
 476         unsigned int interval;
 477
 478         DBG("index %d domain %s server %s lifetime %d",
 479                                 index, domain, server, lifetime);
 480
 481         if (!server && !domain)
 482                 return -EINVAL;
 483
 484         for (list = entry_list; list; list = list->next) {
 485                 struct entry_data *entry = list->data;
 486
 487                 if (entry->timeout == 0 ||
 488                                 entry->index != index ||
 489                                 g_strcmp0(entry->domain, domain) != 0 ||
 490                                 g_strcmp0(entry->server, server) != 0)
 491                         continue;
 492
 493                 g_source_remove(entry->timeout);
 494
 495                 if (lifetime == 0) {
 496                         resolver_expire_cb(entry);
 497                         return 0;
 498                 }
 499
 500                 interval = lifetime * RESOLVER_LIFETIME_REFRESH_THRESHOLD;
 501
 502                 DBG("RDNSS start index %d domain %s "
 503                                 "server %s lifetime threshold %d",
 504                                 index, domain, server, interval);
 505
 506                 entry->timeout = g_timeout_add_seconds(interval,
 507                                 resolver_refresh_cb, entry);
 508                 return 0;
 509         }
 510
 511         return append_resolver(index, domain, server, lifetime, 0);
 512 }
 513
 514 /**
 515  * connman_resolver_remove:
 516  * @index: network interface index
 517  * @domain: domain limitation
 518  * @server: server address
 519  *
 520  * Remover resolver server address from current list
 521  */
 522 int connman_resolver_remove(int index, const char *domain, const char *server)
 523 {
 524         GSList *list, *matches = NULL;
 525
 526         DBG("index %d domain %s server %s", index, domain, server);
 527
 528         for (list = entry_list; list; list = list->next) {
 529                 struct entry_data *entry = list->data;
 530
 531                 if (entry->index != index)
 532                         continue;
 533
 534                 if (g_strcmp0(entry->domain, domain) != 0)
 535                         continue;
 536
 537                 if (g_strcmp0(entry->server, server) != 0)
 538                         continue;
 539
 540                 matches = g_slist_prepend(matches, entry);
 541                 break;
 542         }
 543
 544         if (!matches)
 545                 return -ENOENT;
 546
 547         remove_entries(matches);
 548
 549         return 0;
 550 }
 551
 552 /**
 553  * connman_resolver_remove_all:
 554  * @index: network interface index
 555  *
 556  * Remove all resolver server address for the specified interface index
 557  */
 558 int connman_resolver_remove_all(int index)
 559 {
 560         GSList *list, *matches = NULL;
 561
 562         DBG("index %d", index);
 563
 564         if (index < 0)
 565                 return -EINVAL;
 566
 567         for (list = entry_list; list; list = list->next) {
 568                 struct entry_data *entry = list->data;
 569
 570                 if (entry->index != index)
 571                         continue;
 572
 573                 matches = g_slist_prepend(matches, entry);
 574         }
 575
 576         if (!matches)
 577                 return -ENOENT;
 578
 579         remove_entries(matches);
 580
 581         return 0;
 582 }
 583
 584 int __connman_resolver_redo_servers(int index)
 585 {
 586         GSList *list;
 587
 588         if (!dnsproxy_enabled)
 589                 return 0;
 590
 591         DBG("index %d", index);
 592
 593         if (index < 0)
 594                 return -EINVAL;
 595
 596         for (list = entry_list; list; list = list->next) {
 597                 struct entry_data *entry = list->data;
 598
 599                 if (entry->timeout == 0 || entry->index != index)
 600                         continue;
 601
 602                 /*
 603                  * This function must only check IPv6 server addresses so
 604                  * do not remove IPv4 name servers unnecessarily.
 605                  */
 606                 if (entry->family != AF_INET6)
 607                         continue;
 608
 609                 /*
 610                  * We remove the server, and then re-create so that it will
 611                  * use proper source addresses when sending DNS queries.
 612                  */
 613                 __connman_dnsproxy_remove(entry->index, entry->domain,
 614                                         entry->server);
 615
 616                 __connman_dnsproxy_append(entry->index, entry->domain,
 617                                         entry->server);
 618         }
 619
 620         /*
 621          * We want to re-add all search domains back to search
 622          * domain lists as they just got removed for RDNSS IPv6-servers
 623          * (above).
 624          * Removal of search domains is not necessary
 625          * as there can be only one instance of each search domain
 626          * in the each dns-servers search domain list.
 627         */
 628
 629         for (list = entry_list; list; list = list->next) {
 630                 struct entry_data *entry = list->data;
 631
 632                 if (entry->index != index)
 633                         continue;
 634
 635                 if (entry->server)
 636                         continue;
 637
 638                 __connman_dnsproxy_append(entry->index, entry->domain,
 639                                         NULL);
 640         }
 641
 642         return 0;
 643 }
 644
 645 static void free_entry(gpointer data)
 646 {
 647         struct entry_data *entry = data;
 648         g_free(entry->domain);
 649         g_free(entry->server);
 650         g_free(entry);
 651 }
 652
 653 static void free_resolvfile(gpointer data)
 654 {
 655         struct resolvfile_entry *entry = data;
 656         g_free(entry->domain);
 657         g_free(entry->server);
 658         g_free(entry);
 659 }
 660
 661 int __connman_resolver_init(gboolean dnsproxy)
 662 {
 663         int i;
 664         char **ns;
 665
 666         DBG("dnsproxy %d", dnsproxy);
 667
 668         /* get autoip nameservers */
 669         ns = __connman_inet_get_pnp_nameservers(NULL);
 670         for (i = 0; ns && ns[i]; i += 1) {
 671                 DBG("pnp server %s", ns[i]);
 672                 append_resolver(i, NULL, ns[i], 86400, 0);
 673         }
 674         g_strfreev(ns);
 675
 676         if (!dnsproxy)
 677                 return 0;
 678
 679         if (__connman_dnsproxy_init() < 0) {
 680                 /* Fall back to resolv.conf */
 681                 return 0;
 682         }
 683
 684         dnsproxy_enabled = true;
 685
 686         ns = connman_setting_get_string_list("FallbackNameservers");
 687         for (i = 0; ns && ns[i]; i += 1) {
 688                 DBG("server %s", ns[i]);
 689                 append_resolver(-1, NULL, ns[i], 0, RESOLVER_FLAG_PUBLIC);
 690         }
 691
 692         return 0;
 693 }
 694
 695 void __connman_resolver_cleanup(void)
 696 {
 697         DBG("");
 698
 699         if (dnsproxy_enabled)
 700                 __connman_dnsproxy_cleanup();
 701         else {
 702                 GList *list;
 703                 GSList *slist;
 704
 705                 for (list = resolvfile_list; list; list = g_list_next(list))
 706                         free_resolvfile(list->data);
 707                 g_list_free(resolvfile_list);
 708                 resolvfile_list = NULL;
 709
 710                 for (slist = entry_list; slist; slist = g_slist_next(slist))
 711                         free_entry(slist->data);
 712                 g_slist_free(entry_list);
 713                 entry_list = NULL;
 714         }
 715 }