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_query {
  40         GResolv *resolv;
  41
  42         guint id;
  43         guint timeout;
  44
  45         uint16_t msgid;
  46
  47         GResolvResultFunc result_func;
  48         gpointer result_data;
  49 };
  50
  51 struct resolv_nameserver {
  52         GResolv *resolv;
  53
  54         char *address;
  55         uint16_t port;
  56         unsigned long flags;
  57
  58         GIOChannel *udp_channel;
  59         guint udp_watch;
  60 };
  61
  62 struct _GResolv {
  63         gint ref_count;
  64
  65         guint next_query_id;
  66         GQueue *query_queue;
  67
  68         int index;
  69         GList *nameserver_list;
  70
  71         struct __res_state res;
  72
  73         GResolvDebugFunc debug_func;
  74         gpointer debug_data;
  75 };
  76
  77 static inline void debug(GResolv *resolv, const char *format, ...)
  78 {
  79         char str[256];
  80         va_list ap;
  81
  82         if (resolv->debug_func == NULL)
  83                 return;
  84
  85         va_start(ap, format);
  86
  87         if (vsnprintf(str, sizeof(str), format, ap) > 0)
  88                 resolv->debug_func(str, resolv->debug_data);
  89
  90         va_end(ap);
  91 }
  92
  93 static void destroy_query(struct resolv_query *query)
  94 {
  95         if (query->timeout > 0)
  96                 g_source_remove(query->timeout);
  97
  98         g_free(query);
  99 }
 100
 101 static gboolean query_timeout(gpointer user_data)
 102 {
 103         struct resolv_query *query = user_data;
 104         GResolv *resolv = query->resolv;
 105
 106         query->timeout = 0;
 107
 108         if (query->result_func != NULL)
 109                 query->result_func(G_RESOLV_RESULT_STATUS_NO_RESPONSE,
 110                                                 NULL, query->result_data);
 111
 112         destroy_query(query);
 113         g_queue_remove(resolv->query_queue, query);
 114
 115         return FALSE;
 116 }
 117
 118 static void free_nameserver(struct resolv_nameserver *nameserver)
 119 {
 120         if (nameserver == NULL)
 121                 return;
 122
 123         if (nameserver->udp_watch > 0)
 124                 g_source_remove(nameserver->udp_watch);
 125
 126         if (nameserver->udp_channel != NULL)
 127                 g_io_channel_unref(nameserver->udp_channel);
 128
 129         g_free(nameserver->address);
 130         g_free(nameserver);
 131 }
 132
 133 static void flush_nameservers(GResolv *resolv)
 134 {
 135         GList *list;
 136
 137         for (list = g_list_first(resolv->nameserver_list);
 138                                         list; list = g_list_next(list))
 139                 free_nameserver(list->data);
 140
 141         g_list_free(resolv->nameserver_list);
 142         resolv->nameserver_list = NULL;
 143 }
 144
 145 static int send_query(GResolv *resolv, const unsigned char *buf, int len)
 146 {
 147         GList *list;
 148
 149         if (resolv->nameserver_list == NULL)
 150                 return -ENOENT;
 151
 152         for (list = g_list_first(resolv->nameserver_list);
 153                                         list; list = g_list_next(list)) {
 154                 struct resolv_nameserver *nameserver = list->data;
 155                 int sk, sent;
 156
 157                 if (nameserver->udp_channel == NULL)
 158                         continue;
 159
 160                 sk = g_io_channel_unix_get_fd(nameserver->udp_channel);
 161
 162                 sent = send(sk, buf, len, 0);
 163         }
 164
 165         return 0;
 166 }
 167
 168 static gint compare_query_id(gconstpointer a, gconstpointer b)
 169 {
 170         const struct resolv_query *query = a;
 171         guint id = GPOINTER_TO_UINT(b);
 172
 173         if (query->id < id)
 174                 return -1;
 175
 176         if (query->id > id)
 177                 return 1;
 178
 179         return 0;
 180 }
 181
 182 static gint compare_query_msgid(gconstpointer a, gconstpointer b)
 183 {
 184         const struct resolv_query *query = a;
 185         uint16_t msgid = GPOINTER_TO_UINT(b);
 186
 187         if (query->msgid < msgid)
 188                 return -1;
 189
 190         if (query->msgid > msgid)
 191                 return 1;
 192
 193         return 0;
 194 }
 195
 196 static void parse_response(struct resolv_nameserver *nameserver,
 197                                         const unsigned char *buf, int len)
 198 {
 199         GResolv *resolv = nameserver->resolv;
 200         GResolvResultStatus status;
 201         GList *list;
 202         char **results;
 203         ns_msg msg;
 204         ns_rr rr;
 205         int i, n, rcode, count;
 206
 207         debug(resolv, "response from %s", nameserver->address);
 208
 209         ns_initparse(buf, len, &msg);
 210
 211         rcode = ns_msg_getflag(msg, ns_f_rcode);
 212         count = ns_msg_count(msg, ns_s_an);
 213
 214         debug(resolv, "msg id: 0x%04x rcode: %d count: %d",
 215                                         ns_msg_id(msg), rcode, count);
 216
 217         switch (rcode) {
 218         case 0:
 219                 status = G_RESOLV_RESULT_STATUS_SUCCESS;
 220                 break;
 221         case 1:
 222                 status = G_RESOLV_RESULT_STATUS_FORMAT_ERROR;
 223                 break;
 224         case 2:
 225                 status = G_RESOLV_RESULT_STATUS_SERVER_FAILURE;
 226                 break;
 227         case 3:
 228                 status = G_RESOLV_RESULT_STATUS_NAME_ERROR;
 229                 break;
 230         case 4:
 231                 status = G_RESOLV_RESULT_STATUS_NOT_IMPLEMENTED;
 232                 break;
 233         case 5:
 234                 status = G_RESOLV_RESULT_STATUS_REFUSED;
 235                 break;
 236         default:
 237                 status = G_RESOLV_RESULT_STATUS_ERROR;
 238                 break;
 239         }
 240
 241         results = g_try_new(char *, count + 1);
 242         if (results == NULL)
 243                 return;
 244
 245         for (i = 0, n = 0; i < count; i++) {
 246                 char result[100];
 247
 248                 ns_parserr(&msg, ns_s_an, i, &rr);
 249
 250                 if (ns_rr_class(rr) != ns_c_in)
 251                         continue;
 252
 253                 if (ns_rr_type(rr) != ns_t_a)
 254                         continue;
 255
 256                 if (ns_rr_rdlen(rr) != NS_INADDRSZ)
 257                         continue;
 258
 259                 inet_ntop(AF_INET, ns_rr_rdata(rr), result, sizeof(result));
 260
 261                 results[n++] = g_strdup(result);
 262         }
 263
 264         results[n] = NULL;
 265
 266         list = g_queue_find_custom(resolv->query_queue,
 267                         GUINT_TO_POINTER(ns_msg_id(msg)), compare_query_msgid);
 268
 269         if (list != NULL) {
 270                 struct resolv_query *query = list->data;
 271
 272                 if (query->result_func != NULL)
 273                         query->result_func(status, results,
 274                                                 query->result_data);
 275
 276                 destroy_query(query);
 277                 g_queue_remove(resolv->query_queue, query);
 278         }
 279
 280         g_strfreev(results);
 281 }
 282
 283 static gboolean received_udp_data(GIOChannel *channel, GIOCondition cond,
 284                                                         gpointer user_data)
 285 {
 286         struct resolv_nameserver *nameserver = user_data;
 287         unsigned char buf[4096];
 288         int sk, len;
 289
 290         if (cond & (G_IO_NVAL | G_IO_ERR | G_IO_HUP)) {
 291                 nameserver->udp_watch = 0;
 292                 return FALSE;
 293         }
 294
 295         sk = g_io_channel_unix_get_fd(nameserver->udp_channel);
 296
 297         len = recv(sk, buf, sizeof(buf), 0);
 298         if (len < 12)
 299                 return TRUE;
 300
 301         parse_response(nameserver, buf, len);
 302
 303         return TRUE;
 304 }
 305
 306 static int connect_udp_channel(struct resolv_nameserver *nameserver)
 307 {
 308         struct addrinfo hints, *rp;
 309         char portnr[6];
 310         int err, sk;
 311
 312         memset(&hints, 0, sizeof(hints));
 313         hints.ai_family = AF_UNSPEC;
 314         hints.ai_socktype = SOCK_DGRAM;
 315         hints.ai_flags = AI_PASSIVE | AI_NUMERICSERV | AI_NUMERICHOST;
 316
 317         sprintf(portnr, "%d", nameserver->port);
 318         err = getaddrinfo(nameserver->address, portnr, &hints, &rp);
 319         if (err)
 320                 return -EINVAL;
 321
 322         /* Do not blindly copy this code elsewhere; it doesn't loop over the
 323            results using ->ai_next as it should. That's OK in *this* case
 324            because it was a numeric lookup; we *know* there's only one. */
 325         if (!rp)
 326                 return -EINVAL;
 327
 328         sk = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
 329         if (sk < 0) {
 330                 freeaddrinfo(rp);
 331                 return -EIO;
 332         }
 333
 334         if (connect(sk, rp->ai_addr, rp->ai_addrlen) < 0) {
 335                 close(sk);
 336                 freeaddrinfo(rp);
 337                 return -EIO;
 338         }
 339
 340         freeaddrinfo(rp);
 341
 342         nameserver->udp_channel = g_io_channel_unix_new(sk);
 343         if (nameserver->udp_channel == NULL) {
 344                 close(sk);
 345                 return -ENOMEM;
 346         }
 347
 348         g_io_channel_set_close_on_unref(nameserver->udp_channel, TRUE);
 349
 350         nameserver->udp_watch = g_io_add_watch(nameserver->udp_channel,
 351                                G_IO_IN | G_IO_NVAL | G_IO_ERR | G_IO_HUP,
 352                                received_udp_data, nameserver);
 353
 354         return 0;
 355 }
 356
 357 GResolv *g_resolv_new(int index)
 358 {
 359         GResolv *resolv;
 360
 361         if (index < 0)
 362                 return NULL;
 363
 364         resolv = g_try_new0(GResolv, 1);
 365         if (resolv == NULL)
 366                 return NULL;
 367
 368         resolv->ref_count = 1;
 369
 370         resolv->next_query_id = 1;
 371         resolv->query_queue = g_queue_new();
 372
 373         if (resolv->query_queue == NULL) {
 374                 g_free(resolv);
 375                 return NULL;
 376         }
 377
 378         resolv->index = index;
 379         resolv->nameserver_list = NULL;
 380
 381         res_ninit(&resolv->res);
 382
 383         return resolv;
 384 }
 385
 386 GResolv *g_resolv_ref(GResolv *resolv)
 387 {
 388         if (resolv == NULL)
 389                 return NULL;
 390
 391         g_atomic_int_inc(&resolv->ref_count);
 392
 393         return resolv;
 394 }
 395
 396 void g_resolv_unref(GResolv *resolv)
 397 {
 398         struct resolv_query *query;
 399
 400         if (resolv == NULL)
 401                 return;
 402
 403         if (g_atomic_int_dec_and_test(&resolv->ref_count) == FALSE)
 404                 return;
 405
 406         while ((query = g_queue_pop_head(resolv->query_queue)))
 407                 destroy_query(query);
 408
 409         g_queue_free(resolv->query_queue);
 410
 411         flush_nameservers(resolv);
 412
 413         res_nclose(&resolv->res);
 414
 415         g_free(resolv);
 416 }
 417
 418 void g_resolv_set_debug(GResolv *resolv,
 419                                 GResolvDebugFunc func, gpointer user_data)
 420 {
 421         if (resolv == NULL)
 422                 return;
 423
 424         resolv->debug_func = func;
 425         resolv->debug_data = user_data;
 426 }
 427
 428 gboolean g_resolv_add_nameserver(GResolv *resolv, const char *address,
 429                                         uint16_t port, unsigned long flags)
 430 {
 431         struct resolv_nameserver *nameserver;
 432
 433         if (resolv == NULL)
 434                 return FALSE;
 435
 436         nameserver = g_try_new0(struct resolv_nameserver, 1);
 437         if (nameserver == NULL)
 438                 return FALSE;
 439
 440         nameserver->address = g_strdup(address);
 441         nameserver->port = port;
 442         nameserver->flags = flags;
 443
 444         if (connect_udp_channel(nameserver) < 0) {
 445                 free_nameserver(nameserver);
 446                 return FALSE;
 447         }
 448
 449         nameserver->resolv = resolv;
 450
 451         resolv->nameserver_list = g_list_append(resolv->nameserver_list,
 452                                                                 nameserver);
 453
 454         debug(resolv, "setting nameserver %s", address);
 455
 456         return TRUE;
 457 }
 458
 459 void g_resolv_flush_nameservers(GResolv *resolv)
 460 {
 461         if (resolv == NULL)
 462                 return;
 463
 464         flush_nameservers(resolv);
 465 }
 466
 467 guint g_resolv_lookup_hostname(GResolv *resolv, const char *hostname,
 468                                 GResolvResultFunc func, gpointer user_data)
 469 {
 470         struct resolv_query *query;
 471         unsigned char buf[4096];
 472         int len;
 473
 474         debug(resolv, "lookup hostname %s", hostname);
 475
 476         if (resolv == NULL)
 477                 return 0;
 478
 479         if (resolv->nameserver_list == NULL) {
 480                 int i;
 481
 482                 for (i = 0; i < resolv->res.nscount; i++) {
 483                         char buf[100];
 484                         int family = resolv->res.nsaddr_list[i].sin_family;
 485                         void *sa_addr = &resolv->res.nsaddr_list[i].sin_addr;
 486
 487                         if (family != AF_INET && resolv->res._u._ext.nsaddrs[i]) {
 488                                 family = AF_INET6;
 489                                 sa_addr = &resolv->res._u._ext.nsaddrs[i]->sin6_addr;
 490                         }
 491                         if (family != AF_INET && family != AF_INET6)
 492                                 continue;
 493
 494                         if (inet_ntop(family, sa_addr, buf, sizeof(buf)))
 495                                 g_resolv_add_nameserver(resolv, buf, 53, 0);
 496                 }
 497
 498                 if (resolv->nameserver_list == NULL)
 499                         g_resolv_add_nameserver(resolv, "127.0.0.1", 53, 0);
 500         }
 501
 502         query = g_try_new0(struct resolv_query, 1);
 503         if (query == NULL)
 504                 return 0;
 505
 506         query->id = resolv->next_query_id++;
 507
 508         len = res_mkquery(ns_o_query, hostname, ns_c_in, ns_t_a,
 509                                         NULL, 0, NULL, buf, sizeof(buf));
 510
 511         query->msgid = buf[0] << 8 | buf[1];
 512
 513         query->result_func = func;
 514         query->result_data = user_data;
 515
 516         if (send_query(resolv, buf, len) < 0) {
 517                 g_free(query);
 518                 return -EIO;
 519         }
 520
 521         query->resolv = resolv;
 522
 523         g_queue_push_tail(resolv->query_queue, query);
 524
 525         query->timeout = g_timeout_add_seconds(5, query_timeout, query);
 526
 527         return query->id;
 528 }
 529
 530 gboolean g_resolv_cancel_lookup(GResolv *resolv, guint id)
 531 {
 532         GList *list;
 533
 534         list = g_queue_find_custom(resolv->query_queue,
 535                                 GUINT_TO_POINTER(id), compare_query_id);
 536
 537         if (list == NULL)
 538                 return FALSE;
 539
 540         destroy_query(list->data);
 541         g_queue_remove(resolv->query_queue, list->data);
 542
 543         return TRUE;
 544 }