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