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_last(resolvfile_list);
 101                                                 list && (count < MAXDNSRCH);
 102                                                 list = g_list_previous(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_last(resolvfile_list);
 119                                                 list && (count < MAXNS);
 120                                                 list = g_list_previous(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 static void 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         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                         __connman_service_nameserver_remove(service,
 305                                                         entry->server, true);
 306         }
 307
 308         remove_entries(list);
 309
 310         return FALSE;
 311 }
 312
 313 static gboolean resolver_refresh_cb(gpointer user_data)
 314 {
 315         struct entry_data *entry = user_data;
 316         unsigned int interval;
 317         struct connman_service *service = NULL;
 318
 319         /* Round up what we have left from lifetime */
 320         interval = entry->lifetime *
 321                 (1 - RESOLVER_LIFETIME_REFRESH_THRESHOLD) + 1.0;
 322
 323         DBG("RDNSS start index %d domain %s "
 324                         "server %s remaining lifetime %d",
 325                         entry->index, entry->domain,
 326                         entry->server, interval);
 327
 328         entry->timeout = g_timeout_add_seconds(interval,
 329                         resolver_expire_cb, entry);
 330
 331         if (entry->index >= 0) {
 332                 service = __connman_service_lookup_from_index(entry->index);
 333                 if (service) {
 334                         /*
 335                          * Send Router Solicitation to refresh RDNSS entries
 336                          * before their lifetime expires
 337                          */
 338                         __connman_network_refresh_rs_ipv6(
 339                                         __connman_service_get_network(service),
 340                                         entry->index);
 341                 }
 342         }
 343         return FALSE;
 344 }
 345
 346 static int append_resolver(int index, const char *domain,
 347                                 const char *server, unsigned int lifetime,
 348                                                         unsigned int flags)
 349 {
 350         struct entry_data *entry;
 351         unsigned int interval;
 352
 353         DBG("index %d domain %s server %s lifetime %d flags %d",
 354                                 index, domain, server, lifetime, flags);
 355
 356         if (!server && !domain)
 357                 return -EINVAL;
 358
 359         entry = g_try_new0(struct entry_data, 1);
 360         if (!entry)
 361                 return -ENOMEM;
 362
 363         entry->index = index;
 364         entry->domain = g_strdup(domain);
 365         entry->server = g_strdup(server);
 366         entry->flags = flags;
 367         entry->lifetime = lifetime;
 368
 369         if (server)
 370                 entry->family = connman_inet_check_ipaddress(server);
 371
 372         if (lifetime) {
 373                 interval = lifetime * RESOLVER_LIFETIME_REFRESH_THRESHOLD;
 374
 375                 DBG("RDNSS start index %d domain %s "
 376                                 "server %s lifetime threshold %d",
 377                                 index, domain, server, interval);
 378
 379                 entry->timeout = g_timeout_add_seconds(interval,
 380                                 resolver_refresh_cb, entry);
 381
 382                 /*
 383                  * We update the service only for those nameservers
 384                  * that are automagically added via netlink (lifetime > 0)
 385                  */
 386                 if (server && entry->index >= 0) {
 387                         struct connman_service *service;
 388                         service = __connman_service_lookup_from_index(entry->index);
 389                         if (service)
 390                                 __connman_service_nameserver_append(service,
 391                                                                 server, true);
 392                 }
 393         }
 394
 395         if (entry->index >= 0 && entry->server)
 396                 remove_fallback_nameservers();
 397
 398         entry_list = g_slist_append(entry_list, entry);
 399
 400         if (dnsproxy_enabled)
 401                 __connman_dnsproxy_append(entry->index, domain, server);
 402         else
 403                 __connman_resolvfile_append(entry->index, domain, server);
 404
 405         return 0;
 406 }
 407
 408 /**
 409  * connman_resolver_append:
 410  * @index: network interface index
 411  * @domain: domain limitation
 412  * @server: server address
 413  *
 414  * Append resolver server address to current list
 415  */
 416 int connman_resolver_append(int index, const char *domain,
 417                                                 const char *server)
 418 {
 419         GSList *list;
 420
 421         DBG("index %d domain %s server %s", index, domain, server);
 422
 423         if (!server && !domain)
 424                 return -EINVAL;
 425
 426         for (list = entry_list; list; list = list->next) {
 427                 struct entry_data *entry = list->data;
 428
 429                 if (entry->timeout > 0)
 430                         continue;
 431
 432                 if (entry->index == index &&
 433                                 g_strcmp0(entry->domain, domain) == 0 &&
 434                                 g_strcmp0(entry->server, server) == 0) {
 435                         if (dnsproxy_enabled)
 436                                 __connman_dnsproxy_append(entry->index, domain,
 437                                                 server);
 438
 439                         return -EEXIST;
 440                 }
 441         }
 442
 443         return append_resolver(index, domain, server, 0, 0);
 444 }
 445
 446 /**
 447  * connman_resolver_append_lifetime:
 448  * @index: network interface index
 449  * @domain: domain limitation
 450  * @server: server address
 451  * @timeout: server lifetime in seconds
 452  *
 453  * Append resolver server address to current list
 454  */
 455 int connman_resolver_append_lifetime(int index, const char *domain,
 456                                 const char *server, unsigned int lifetime)
 457 {
 458         GSList *list;
 459         unsigned int interval;
 460
 461         DBG("index %d domain %s server %s lifetime %d",
 462                                 index, domain, server, lifetime);
 463
 464         if (!server && !domain)
 465                 return -EINVAL;
 466
 467         for (list = entry_list; list; list = list->next) {
 468                 struct entry_data *entry = list->data;
 469
 470                 if (entry->timeout == 0 ||
 471                                 entry->index != index ||
 472                                 g_strcmp0(entry->domain, domain) != 0 ||
 473                                 g_strcmp0(entry->server, server) != 0)
 474                         continue;
 475
 476                 g_source_remove(entry->timeout);
 477
 478                 if (lifetime == 0) {
 479                         resolver_expire_cb(entry);
 480                         return 0;
 481                 }
 482
 483                 interval = lifetime * RESOLVER_LIFETIME_REFRESH_THRESHOLD;
 484
 485                 DBG("RDNSS start index %d domain %s "
 486                                 "server %s lifetime threshold %d",
 487                                 index, domain, server, interval);
 488
 489                 entry->timeout = g_timeout_add_seconds(interval,
 490                                 resolver_refresh_cb, entry);
 491                 return 0;
 492         }
 493
 494         return append_resolver(index, domain, server, lifetime, 0);
 495 }
 496
 497 /**
 498  * connman_resolver_remove:
 499  * @index: network interface index
 500  * @domain: domain limitation
 501  * @server: server address
 502  *
 503  * Remover resolver server address from current list
 504  */
 505 int connman_resolver_remove(int index, const char *domain, const char *server)
 506 {
 507         GSList *list, *matches = NULL;
 508
 509         DBG("index %d domain %s server %s", index, domain, server);
 510
 511         for (list = entry_list; list; list = list->next) {
 512                 struct entry_data *entry = list->data;
 513
 514                 if (entry->index != index)
 515                         continue;
 516
 517                 if (g_strcmp0(entry->domain, domain) != 0)
 518                         continue;
 519
 520                 if (g_strcmp0(entry->server, server) != 0)
 521                         continue;
 522
 523                 matches = g_slist_prepend(matches, entry);
 524                 break;
 525         }
 526
 527         if (!matches)
 528                 return -ENOENT;
 529
 530         remove_entries(matches);
 531
 532         return 0;
 533 }
 534
 535 /**
 536  * connman_resolver_remove_all:
 537  * @index: network interface index
 538  *
 539  * Remove all resolver server address for the specified interface index
 540  */
 541 int connman_resolver_remove_all(int index)
 542 {
 543         GSList *list, *matches = NULL;
 544
 545         DBG("index %d", index);
 546
 547         if (index < 0)
 548                 return -EINVAL;
 549
 550         for (list = entry_list; list; list = list->next) {
 551                 struct entry_data *entry = list->data;
 552
 553                 if (entry->index != index)
 554                         continue;
 555
 556                 matches = g_slist_prepend(matches, entry);
 557         }
 558
 559         if (!matches)
 560                 return -ENOENT;
 561
 562         remove_entries(matches);
 563
 564         return 0;
 565 }
 566
 567 int __connman_resolver_redo_servers(int index)
 568 {
 569         GSList *list;
 570
 571         if (!dnsproxy_enabled)
 572                 return 0;
 573
 574         DBG("index %d", index);
 575
 576         if (index < 0)
 577                 return -EINVAL;
 578
 579         for (list = entry_list; list; list = list->next) {
 580                 struct entry_data *entry = list->data;
 581
 582                 if (entry->timeout == 0 || entry->index != index)
 583                         continue;
 584
 585                 /*
 586                  * This function must only check IPv6 server addresses so
 587                  * do not remove IPv4 name servers unnecessarily.
 588                  */
 589                 if (entry->family != AF_INET6)
 590                         continue;
 591
 592                 /*
 593                  * We remove the server, and then re-create so that it will
 594                  * use proper source addresses when sending DNS queries.
 595                  */
 596                 __connman_dnsproxy_remove(entry->index, entry->domain,
 597                                         entry->server);
 598
 599                 __connman_dnsproxy_append(entry->index, entry->domain,
 600                                         entry->server);
 601         }
 602
 603         return 0;
 604 }
 605
 606 static void free_entry(gpointer data)
 607 {
 608         struct entry_data *entry = data;
 609         g_free(entry->domain);
 610         g_free(entry->server);
 611         g_free(entry);
 612 }
 613
 614 static void free_resolvfile(gpointer data)
 615 {
 616         struct resolvfile_entry *entry = data;
 617         g_free(entry->domain);
 618         g_free(entry->server);
 619         g_free(entry);
 620 }
 621
 622 int __connman_resolver_init(gboolean dnsproxy)
 623 {
 624         int i;
 625         char **ns;
 626
 627         DBG("dnsproxy %d", dnsproxy);
 628
 629         if (!dnsproxy)
 630                 return 0;
 631
 632         if (__connman_dnsproxy_init() < 0) {
 633                 /* Fall back to resolv.conf */
 634                 return 0;
 635         }
 636
 637         dnsproxy_enabled = true;
 638
 639         ns = connman_setting_get_string_list("FallbackNameservers");
 640         for (i = 0; ns && ns[i]; i += 1) {
 641                 DBG("server %s", ns[i]);
 642                 append_resolver(-1, NULL, ns[i], 0, RESOLVER_FLAG_PUBLIC);
 643         }
 644
 645         return 0;
 646 }
 647
 648 void __connman_resolver_cleanup(void)
 649 {
 650         DBG("");
 651
 652         if (dnsproxy_enabled)
 653                 __connman_dnsproxy_cleanup();
 654         else {
 655                 GList *list;
 656                 GSList *slist;
 657
 658                 for (list = resolvfile_list; list; list = g_list_next(list))
 659                         free_resolvfile(list->data);
 660                 g_list_free(resolvfile_list);
 661                 resolvfile_list = NULL;
 662
 663                 for (slist = entry_list; slist; slist = g_slist_next(slist))
 664                         free_entry(slist->data);
 665                 g_slist_free(entry_list);
 666                 entry_list = NULL;
 667         }
 668 }