gweb/gresolv.c

   1 /*
   2  *
   3  *  Resolver library with GLib integration
   4  *
   5  *  Copyright (C) 2009-2010  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 #include <errno.h>
  27 #include <unistd.h>
  28 #include <stdarg.h>
  29 #include <string.h>
  30 #include <resolv.h>
  31 #include <sys/types.h>
  32 #include <sys/socket.h>
  33 #include <netdb.h>
  34 #include <arpa/inet.h>
  35 #include <arpa/nameser.h>
  36
  37 #include "gresolv.h"
  38
  39 struct resolv_lookup {
  40         GResolv *resolv;
  41         guint id;
  42
  43         char **results;
  44
  45         struct resolv_query *ipv4_query;
  46         struct resolv_query *ipv6_query;
  47
  48         guint ipv4_status;
  49         guint ipv6_status;
  50
  51         GResolvResultFunc result_func;
  52         gpointer result_data;
  53 };
  54
  55 struct resolv_query {
  56         GResolv *resolv;
  57
  58         guint timeout;
  59
  60         uint16_t msgid;
  61
  62         GResolvResultFunc result_func;
  63         gpointer result_data;
  64 };
  65
  66 struct resolv_nameserver {
  67         GResolv *resolv;
  68
  69         char *address;
  70         uint16_t port;
  71         unsigned long flags;
  72
  73         GIOChannel *udp_channel;
  74         guint udp_watch;
  75 };
  76
  77 struct _GResolv {
  78         gint ref_count;
  79
  80         guint next_lookup_id;
  81         GQueue *lookup_queue;
  82         GQueue *query_queue;
  83
  84         int index;
  85         GList *nameserver_list;
  86
  87         struct __res_state res;
  88
  89         GResolvDebugFunc debug_func;
  90         gpointer debug_data;
  91 };
  92
  93 static inline void debug(GResolv *resolv, const char *format, ...)
  94 {
  95         char str[256];
  96         va_list ap;
  97
  98         if (resolv->debug_func == NULL)
  99                 return;
 100
 101         va_start(ap, format);
 102
 103         if (vsnprintf(str, sizeof(str), format, ap) > 0)
 104                 resolv->debug_func(str, resolv->debug_data);
 105
 106         va_end(ap);
 107 }
 108
 109 static void destroy_query(struct resolv_query *query)
 110 {
 111         if (query->timeout > 0)
 112                 g_source_remove(query->timeout);
 113
 114         g_free(query);
 115 }
 116
 117 static void destroy_lookup(struct resolv_lookup *lookup)
 118 {
 119         if (lookup->ipv4_query) {
 120                 destroy_query(lookup->ipv4_query);
 121                 g_queue_remove(lookup->resolv->query_queue, lookup->ipv4_query);
 122         }
 123         if (lookup->ipv6_query) {
 124                 destroy_query(lookup->ipv6_query);
 125                 g_queue_remove(lookup->resolv->query_queue, lookup->ipv4_query);
 126         }
 127         g_strfreev(lookup->results);
 128         g_free(lookup);
 129 }
 130
 131 static gboolean query_timeout(gpointer user_data)
 132 {
 133         struct resolv_query *query = user_data;
 134         GResolv *resolv = query->resolv;
 135
 136         query->timeout = 0;
 137
 138         if (query->result_func != NULL)
 139                 query->result_func(G_RESOLV_RESULT_STATUS_NO_RESPONSE,
 140                                                 NULL, query->result_data);
 141
 142         destroy_query(query);
 143         g_queue_remove(resolv->query_queue, query);
 144
 145         return FALSE;
 146 }
 147
 148 static void free_nameserver(struct resolv_nameserver *nameserver)
 149 {
 150         if (nameserver == NULL)
 151                 return;
 152
 153         if (nameserver->udp_watch > 0)
 154                 g_source_remove(nameserver->udp_watch);
 155
 156         if (nameserver->udp_channel != NULL)
 157                 g_io_channel_unref(nameserver->udp_channel);
 158
 159         g_free(nameserver->address);
 160         g_free(nameserver);
 161 }
 162
 163 static void flush_nameservers(GResolv *resolv)
 164 {
 165         GList *list;
 166
 167         for (list = g_list_first(resolv->nameserver_list);
 168                                         list; list = g_list_next(list))
 169                 free_nameserver(list->data);
 170
 171         g_list_free(resolv->nameserver_list);
 172         resolv->nameserver_list = NULL;
 173 }
 174
 175 static int send_query(GResolv *resolv, const unsigned char *buf, int len)
 176 {
 177         GList *list;
 178
 179         if (resolv->nameserver_list == NULL)
 180                 return -ENOENT;
 181
 182         for (list = g_list_first(resolv->nameserver_list);
 183                                         list; list = g_list_next(list)) {
 184                 struct resolv_nameserver *nameserver = list->data;
 185                 int sk, sent;
 186
 187                 if (nameserver->udp_channel == NULL)
 188                         continue;
 189
 190                 sk = g_io_channel_unix_get_fd(nameserver->udp_channel);
 191
 192                 sent = send(sk, buf, len, 0);
 193         }
 194
 195         return 0;
 196 }
 197
 198 static gint compare_lookup_id(gconstpointer a, gconstpointer b)
 199 {
 200         const struct resolv_lookup *lookup = a;
 201         guint id = GPOINTER_TO_UINT(b);
 202
 203         if (lookup->id < id)
 204                 return -1;
 205
 206         if (lookup->id > id)
 207                 return 1;
 208
 209         return 0;
 210 }
 211
 212 static gint compare_query_msgid(gconstpointer a, gconstpointer b)
 213 {
 214         const struct resolv_query *query = a;
 215         uint16_t msgid = GPOINTER_TO_UINT(b);
 216
 217         if (query->msgid < msgid)
 218                 return -1;
 219
 220         if (query->msgid > msgid)
 221                 return 1;
 222
 223         return 0;
 224 }
 225
 226 static void parse_response(struct resolv_nameserver *nameserver,
 227                                         const unsigned char *buf, int len)
 228 {
 229         GResolv *resolv = nameserver->resolv;
 230         GResolvResultStatus status;
 231         GList *list;
 232         char **results;
 233         ns_msg msg;
 234         ns_rr rr;
 235         int i, n, rcode, count;
 236
 237         debug(resolv, "response from %s", nameserver->address);
 238
 239         ns_initparse(buf, len, &msg);
 240
 241         rcode = ns_msg_getflag(msg, ns_f_rcode);
 242         count = ns_msg_count(msg, ns_s_an);
 243
 244         debug(resolv, "msg id: 0x%04x rcode: %d count: %d",
 245                                         ns_msg_id(msg), rcode, count);
 246
 247         switch (rcode) {
 248         case 0:
 249                 status = G_RESOLV_RESULT_STATUS_SUCCESS;
 250                 break;
 251         case 1:
 252                 status = G_RESOLV_RESULT_STATUS_FORMAT_ERROR;
 253                 break;
 254         case 2:
 255                 status = G_RESOLV_RESULT_STATUS_SERVER_FAILURE;
 256                 break;
 257         case 3:
 258                 status = G_RESOLV_RESULT_STATUS_NAME_ERROR;
 259                 break;
 260         case 4:
 261                 status = G_RESOLV_RESULT_STATUS_NOT_IMPLEMENTED;
 262                 break;
 263         case 5:
 264                 status = G_RESOLV_RESULT_STATUS_REFUSED;
 265                 break;
 266         default:
 267                 status = G_RESOLV_RESULT_STATUS_ERROR;
 268                 break;
 269         }
 270
 271         results = g_try_new(char *, count + 1);
 272         if (results == NULL)
 273                 return;
 274
 275         for (i = 0, n = 0; i < count; i++) {
 276                 char result[100];
 277
 278                 ns_parserr(&msg, ns_s_an, i, &rr);
 279
 280                 if (ns_rr_class(rr) != ns_c_in)
 281                         continue;
 282
 283                 if (ns_rr_type(rr) == ns_t_a &&
 284                     ns_rr_rdlen(rr) == NS_INADDRSZ) {
 285                         inet_ntop(AF_INET, ns_rr_rdata(rr), result, sizeof(result));
 286                 } else if (ns_rr_type(rr) == ns_t_aaaa &&
 287                            ns_rr_rdlen(rr) == NS_IN6ADDRSZ) {
 288                         inet_ntop(AF_INET6, ns_rr_rdata(rr), result, sizeof(result));
 289                 } else
 290                         continue;
 291
 292                 results[n++] = g_strdup(result);
 293         }
 294
 295         results[n] = NULL;
 296
 297         list = g_queue_find_custom(resolv->query_queue,
 298                         GUINT_TO_POINTER(ns_msg_id(msg)), compare_query_msgid);
 299
 300         if (list != NULL) {
 301                 struct resolv_query *query = list->data;
 302
 303                 /* FIXME: This set of results is *only* for a single A or AAAA
 304                    query; we need to merge both results together and then sort
 305                    them according to RFC3484. While honouring /etc/gai.conf */
 306                 if (query->result_func != NULL)
 307                         query->result_func(status, results,
 308                                                 query->result_data);
 309
 310                 destroy_query(query);
 311                 g_queue_remove(resolv->query_queue, query);
 312         }
 313
 314         g_strfreev(results);
 315 }
 316
 317 static gboolean received_udp_data(GIOChannel *channel, GIOCondition cond,
 318                                                         gpointer user_data)
 319 {
 320         struct resolv_nameserver *nameserver = user_data;
 321         unsigned char buf[4096];
 322         int sk, len;
 323
 324         if (cond & (G_IO_NVAL | G_IO_ERR | G_IO_HUP)) {
 325                 nameserver->udp_watch = 0;
 326                 return FALSE;
 327         }
 328
 329         sk = g_io_channel_unix_get_fd(nameserver->udp_channel);
 330
 331         len = recv(sk, buf, sizeof(buf), 0);
 332         if (len < 12)
 333                 return TRUE;
 334
 335         parse_response(nameserver, buf, len);
 336
 337         return TRUE;
 338 }
 339
 340 static int connect_udp_channel(struct resolv_nameserver *nameserver)
 341 {
 342         struct addrinfo hints, *rp;
 343         char portnr[6];
 344         int err, sk;
 345
 346         memset(&hints, 0, sizeof(hints));
 347         hints.ai_family = AF_UNSPEC;
 348         hints.ai_socktype = SOCK_DGRAM;
 349         hints.ai_flags = AI_PASSIVE | AI_NUMERICSERV | AI_NUMERICHOST;
 350
 351         sprintf(portnr, "%d", nameserver->port);
 352         err = getaddrinfo(nameserver->address, portnr, &hints, &rp);
 353         if (err)
 354                 return -EINVAL;
 355
 356         /* Do not blindly copy this code elsewhere; it doesn't loop over the
 357            results using ->ai_next as it should. That's OK in *this* case
 358            because it was a numeric lookup; we *know* there's only one. */
 359         if (!rp)
 360                 return -EINVAL;
 361
 362         sk = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
 363         if (sk < 0) {
 364                 freeaddrinfo(rp);
 365                 return -EIO;
 366         }
 367
 368         if (connect(sk, rp->ai_addr, rp->ai_addrlen) < 0) {
 369                 close(sk);
 370                 freeaddrinfo(rp);
 371                 return -EIO;
 372         }
 373
 374         freeaddrinfo(rp);
 375
 376         nameserver->udp_channel = g_io_channel_unix_new(sk);
 377         if (nameserver->udp_channel == NULL) {
 378                 close(sk);
 379                 return -ENOMEM;
 380         }
 381
 382         g_io_channel_set_close_on_unref(nameserver->udp_channel, TRUE);
 383
 384         nameserver->udp_watch = g_io_add_watch(nameserver->udp_channel,
 385                                G_IO_IN | G_IO_NVAL | G_IO_ERR | G_IO_HUP,
 386                                received_udp_data, nameserver);
 387
 388         return 0;
 389 }
 390
 391 GResolv *g_resolv_new(int index)
 392 {
 393         GResolv *resolv;
 394
 395         if (index < 0)
 396                 return NULL;
 397
 398         resolv = g_try_new0(GResolv, 1);
 399         if (resolv == NULL)
 400                 return NULL;
 401
 402         resolv->ref_count = 1;
 403
 404         resolv->next_lookup_id = 1;
 405
 406         resolv->query_queue = g_queue_new();
 407         if (resolv->query_queue == NULL) {
 408                 g_free(resolv);
 409                 return NULL;
 410         }
 411
 412         resolv->lookup_queue = g_queue_new();
 413         if (resolv->lookup_queue == NULL) {
 414                 g_queue_free(resolv->query_queue);
 415                 g_free(resolv);
 416                 return NULL;
 417         }
 418
 419         resolv->index = index;
 420         resolv->nameserver_list = NULL;
 421
 422         res_ninit(&resolv->res);
 423
 424         return resolv;
 425 }
 426
 427 GResolv *g_resolv_ref(GResolv *resolv)
 428 {
 429         if (resolv == NULL)
 430                 return NULL;
 431
 432         g_atomic_int_inc(&resolv->ref_count);
 433
 434         return resolv;
 435 }
 436
 437 void g_resolv_unref(GResolv *resolv)
 438 {
 439         struct resolv_query *query;
 440
 441         if (resolv == NULL)
 442                 return;
 443
 444         if (g_atomic_int_dec_and_test(&resolv->ref_count) == FALSE)
 445                 return;
 446
 447         while ((query = g_queue_pop_head(resolv->query_queue)))
 448                 destroy_query(query);
 449
 450         g_queue_free(resolv->query_queue);
 451         g_queue_free(resolv->lookup_queue);
 452
 453         flush_nameservers(resolv);
 454
 455         res_nclose(&resolv->res);
 456
 457         g_free(resolv);
 458 }
 459
 460 void g_resolv_set_debug(GResolv *resolv,
 461                                 GResolvDebugFunc func, gpointer user_data)
 462 {
 463         if (resolv == NULL)
 464                 return;
 465
 466         resolv->debug_func = func;
 467         resolv->debug_data = user_data;
 468 }
 469
 470 gboolean g_resolv_add_nameserver(GResolv *resolv, const char *address,
 471                                         uint16_t port, unsigned long flags)
 472 {
 473         struct resolv_nameserver *nameserver;
 474
 475         if (resolv == NULL)
 476                 return FALSE;
 477
 478         nameserver = g_try_new0(struct resolv_nameserver, 1);
 479         if (nameserver == NULL)
 480                 return FALSE;
 481
 482         nameserver->address = g_strdup(address);
 483         nameserver->port = port;
 484         nameserver->flags = flags;
 485
 486         if (connect_udp_channel(nameserver) < 0) {
 487                 free_nameserver(nameserver);
 488                 return FALSE;
 489         }
 490
 491         nameserver->resolv = resolv;
 492
 493         resolv->nameserver_list = g_list_append(resolv->nameserver_list,
 494                                                                 nameserver);
 495
 496         debug(resolv, "setting nameserver %s", address);
 497
 498         return TRUE;
 499 }
 500
 501 void g_resolv_flush_nameservers(GResolv *resolv)
 502 {
 503         if (resolv == NULL)
 504                 return;
 505
 506         flush_nameservers(resolv);
 507 }
 508
 509 static int count_results(char **results)
 510 {
 511         int i;
 512
 513         if (!results)
 514                 return 0;
 515
 516         for (i = 0; results[i]; i++)
 517                 ;
 518
 519         return i;
 520 }
 521
 522 static void add_result(struct resolv_lookup *lookup, char **results)
 523 {
 524         int nr_new_results = count_results(results);
 525         int nr_old_results = count_results(lookup->results);
 526         GResolvResultStatus status;
 527
 528         if (nr_new_results) {
 529                 lookup->results = g_realloc(lookup->results, sizeof(char *) *
 530                                             (nr_new_results + nr_old_results + 1));
 531
 532                 while (nr_new_results) {
 533                         lookup->results[nr_old_results++] = results[0];
 534                         results[0] = NULL;
 535                         results++;
 536                         nr_new_results--;
 537                 }
 538                 lookup->results[nr_old_results] = NULL;
 539         }
 540         if (lookup->ipv4_query || lookup->ipv6_query)
 541                 return;
 542
 543         /* FIXME: Sort results according to RFC3484 and /etc/gai.conf */
 544
 545         status = lookup->ipv4_status;
 546         if (status == G_RESOLV_RESULT_STATUS_SUCCESS)
 547                 status = lookup->ipv6_status;
 548
 549         lookup->result_func(status, lookup->results, lookup->result_data);
 550
 551         g_queue_remove(lookup->resolv->lookup_queue, lookup);
 552         destroy_lookup(lookup);
 553 }
 554
 555 static void ipv4_result(GResolvResultStatus status, char **results, gpointer data)
 556 {
 557         struct resolv_lookup *lookup = data;
 558
 559         lookup->ipv4_status = status;
 560         lookup->ipv4_query = NULL;
 561
 562         add_result(lookup, results);
 563 }
 564
 565 static void ipv6_result(GResolvResultStatus status, char **results, gpointer data)
 566 {
 567         struct resolv_lookup *lookup = data;
 568
 569         lookup->ipv6_status = status;
 570         lookup->ipv6_query = NULL;
 571
 572         add_result(lookup, results);
 573 }
 574
 575
 576 static gint add_query(struct resolv_lookup *lookup, const char *hostname, int type)
 577 {
 578         struct resolv_query *query = g_try_new0(struct resolv_query, 1);
 579         unsigned char buf[4096];
 580         int len;
 581
 582         if (query == NULL)
 583                 return -ENOMEM;
 584
 585         len = res_mkquery(ns_o_query, hostname, ns_c_in, type,
 586                                         NULL, 0, NULL, buf, sizeof(buf));
 587
 588         query->msgid = buf[0] << 8 | buf[1];
 589
 590         query->result_data = lookup;
 591
 592         if (send_query(lookup->resolv, buf, len) < 0)
 593                 return -EIO;
 594
 595         query->resolv = lookup->resolv;
 596
 597         g_queue_push_tail(lookup->resolv->query_queue, query);
 598
 599         query->timeout = g_timeout_add_seconds(5, query_timeout, query);
 600
 601         if (type == ns_t_aaaa) {
 602                 query->result_func = ipv6_result;
 603                 lookup->ipv6_query = query;
 604         } else {
 605                 query->result_func = ipv4_result;
 606                 lookup->ipv4_query = query;
 607         }
 608
 609         return 0;
 610 }
 611
 612 guint g_resolv_lookup_hostname(GResolv *resolv, const char *hostname,
 613                                 GResolvResultFunc func, gpointer user_data)
 614 {
 615         struct resolv_lookup *lookup;
 616
 617         debug(resolv, "lookup hostname %s", hostname);
 618
 619         if (resolv == NULL)
 620                 return 0;
 621
 622         if (resolv->nameserver_list == NULL) {
 623                 int i;
 624
 625                 for (i = 0; i < resolv->res.nscount; i++) {
 626                         char buf[100];
 627                         int family = resolv->res.nsaddr_list[i].sin_family;
 628                         void *sa_addr = &resolv->res.nsaddr_list[i].sin_addr;
 629
 630                         if (family != AF_INET && resolv->res._u._ext.nsaddrs[i]) {
 631                                 family = AF_INET6;
 632                                 sa_addr = &resolv->res._u._ext.nsaddrs[i]->sin6_addr;
 633                         }
 634                         if (family != AF_INET && family != AF_INET6)
 635                                 continue;
 636
 637                         if (inet_ntop(family, sa_addr, buf, sizeof(buf)))
 638                                 g_resolv_add_nameserver(resolv, buf, 53, 0);
 639                 }
 640
 641                 if (resolv->nameserver_list == NULL)
 642                         g_resolv_add_nameserver(resolv, "127.0.0.1", 53, 0);
 643         }
 644
 645         lookup = g_try_new0(struct resolv_lookup, 1);
 646         if (!lookup)
 647                 return 0;
 648
 649         lookup->resolv = resolv;
 650         lookup->result_func = func;
 651         lookup->result_data = user_data;
 652         lookup->id = resolv->next_lookup_id++;
 653
 654         if (add_query(lookup, hostname, ns_t_a)) {
 655                 g_free(lookup);
 656                 return -EIO;
 657         }
 658         if (add_query(lookup, hostname, ns_t_aaaa)) {
 659                 destroy_query(lookup->ipv4_query);
 660                 g_queue_remove(resolv->query_queue, lookup->ipv4_query);
 661                 g_free(lookup);
 662                 return -EIO;
 663         }
 664
 665         g_queue_push_tail(resolv->lookup_queue, lookup);
 666         return lookup->id;
 667 }
 668
 669 gboolean g_resolv_cancel_lookup(GResolv *resolv, guint id)
 670 {
 671         GList *list;
 672
 673         list = g_queue_find_custom(resolv->lookup_queue,
 674                                 GUINT_TO_POINTER(id), compare_lookup_id);
 675
 676         if (list == NULL)
 677                 return FALSE;
 678
 679         destroy_lookup(list->data);
 680         g_queue_remove(resolv->query_queue, list->data);
 681
 682         return TRUE;
 683 }