gresolv/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/socket.h>
  32 #include <arpa/inet.h>
  33 #include <arpa/nameser.h>
  34
  35 #include "gresolv.h"
  36
  37 struct resolv_query {
  38         GResolv *resolv;
  39
  40         guint id;
  41         guint timeout;
  42
  43         uint16_t msgid;
  44
  45         GResolvResultFunc result_func;
  46         gpointer result_data;
  47 };
  48
  49 struct resolv_nameserver {
  50         GResolv *resolv;
  51
  52         char *address;
  53         uint16_t port;
  54         unsigned long flags;
  55
  56         GIOChannel *udp_channel;
  57         guint udp_watch;
  58 };
  59
  60 struct _GResolv {
  61         gint ref_count;
  62
  63         guint next_query_id;
  64         GQueue *query_queue;
  65
  66         int index;
  67         GList *nameserver_list;
  68
  69         GResolvDebugFunc debug_func;
  70         gpointer debug_data;
  71 };
  72
  73 static inline void debug(GResolv *resolv, const char *format, ...)
  74 {
  75         char str[256];
  76         va_list ap;
  77
  78         if (resolv->debug_func == NULL)
  79                 return;
  80
  81         va_start(ap, format);
  82
  83         if (vsnprintf(str, sizeof(str), format, ap) > 0)
  84                 resolv->debug_func(str, resolv->debug_data);
  85
  86         va_end(ap);
  87 }
  88
  89 static void destroy_query(struct resolv_query *query)
  90 {
  91         if (query->timeout > 0)
  92                 g_source_remove(query->timeout);
  93
  94         g_free(query);
  95 }
  96
  97 static gboolean query_timeout(gpointer user_data)
  98 {
  99         struct resolv_query *query = user_data;
 100         GResolv *resolv = query->resolv;
 101
 102         query->timeout = 0;
 103
 104         if (query->result_func != NULL)
 105                 query->result_func(G_RESOLV_STATUS_ERROR,
 106                                                 NULL, query->result_data);
 107
 108         destroy_query(query);
 109         g_queue_remove(resolv->query_queue, query);
 110
 111         return FALSE;
 112 }
 113
 114 static void free_nameserver(struct resolv_nameserver *nameserver)
 115 {
 116         if (nameserver == NULL)
 117                 return;
 118
 119         if (nameserver->udp_watch > 0)
 120                 g_source_remove(nameserver->udp_watch);
 121
 122         if (nameserver->udp_channel != NULL)
 123                 g_io_channel_unref(nameserver->udp_channel);
 124
 125         g_free(nameserver->address);
 126         g_free(nameserver);
 127 }
 128
 129 static void flush_nameservers(GResolv *resolv)
 130 {
 131         GList *list;
 132
 133         for (list = g_list_first(resolv->nameserver_list);
 134                                         list; list = g_list_next(list))
 135                 free_nameserver(list->data);
 136
 137         g_list_free(resolv->nameserver_list);
 138         resolv->nameserver_list = NULL;
 139 }
 140
 141 static int send_query(GResolv *resolv, const unsigned char *buf, int len)
 142 {
 143         GList *list;
 144
 145         if (resolv->nameserver_list == NULL)
 146                 return -ENOENT;
 147
 148         for (list = g_list_first(resolv->nameserver_list);
 149                                         list; list = g_list_next(list)) {
 150                 struct resolv_nameserver *nameserver = list->data;
 151                 int sk, sent;
 152
 153                 if (nameserver->udp_channel == NULL)
 154                         continue;
 155
 156                 sk = g_io_channel_unix_get_fd(nameserver->udp_channel);
 157
 158                 sent = send(sk, buf, len, 0);
 159         }
 160
 161         return 0;
 162 }
 163
 164 static gint compare_query_id(gconstpointer a, gconstpointer b)
 165 {
 166         const struct resolv_query *query = a;
 167         guint id = GPOINTER_TO_UINT(b);
 168
 169         if (query->id < id)
 170                 return -1;
 171
 172         if (query->id > id)
 173                 return 1;
 174
 175         return 0;
 176 }
 177
 178 static gint compare_query_msgid(gconstpointer a, gconstpointer b)
 179 {
 180         const struct resolv_query *query = a;
 181         uint16_t msgid = GPOINTER_TO_UINT(b);
 182
 183         if (query->msgid < msgid)
 184                 return -1;
 185
 186         if (query->msgid > msgid)
 187                 return 1;
 188
 189         return 0;
 190 }
 191
 192 static void parse_response(struct resolv_nameserver *nameserver,
 193                                         const unsigned char *buf, int len)
 194 {
 195         GResolv *resolv = nameserver->resolv;
 196         GList *list;
 197         char **results;
 198         ns_msg msg;
 199         ns_rr rr;
 200         int i, n, rcode, count;
 201
 202         debug(resolv, "response from %s", nameserver->address);
 203
 204         ns_initparse(buf, len, &msg);
 205
 206         rcode = ns_msg_getflag(msg, ns_f_rcode);
 207         count = ns_msg_count(msg, ns_s_an);
 208
 209         debug(resolv, "msg id: 0x%04x rcode: %d count: %d",
 210                                         ns_msg_id(msg), rcode, count);
 211
 212         results = g_try_new(char *, count + 1);
 213         if (results == NULL)
 214                 return;
 215
 216         for (i = 0, n = 0; i < count; i++) {
 217                 char result[100];
 218
 219                 ns_parserr(&msg, ns_s_an, i, &rr);
 220
 221                 if (ns_rr_class(rr) != ns_c_in)
 222                         continue;
 223
 224                 if (ns_rr_type(rr) != ns_t_a)
 225                         continue;
 226
 227                 if (ns_rr_rdlen(rr) != NS_INADDRSZ)
 228                         continue;
 229
 230                 inet_ntop(AF_INET, ns_rr_rdata(rr), result, sizeof(result));
 231
 232                 results[n++] = g_strdup(result);
 233         }
 234
 235         results[n] = NULL;
 236
 237         list = g_queue_find_custom(resolv->query_queue,
 238                         GUINT_TO_POINTER(ns_msg_id(msg)), compare_query_msgid);
 239
 240         if (list != NULL) {
 241                 struct resolv_query *query = list->data;
 242
 243                 if (query->result_func != NULL)
 244                         query->result_func(G_RESOLV_STATUS_SUCCESS,
 245                                                 results, query->result_data);
 246
 247                 destroy_query(query);
 248                 g_queue_remove(resolv->query_queue, query);
 249         }
 250
 251         g_strfreev(results);
 252 }
 253
 254 static gboolean received_udp_data(GIOChannel *channel, GIOCondition cond,
 255                                                         gpointer user_data)
 256 {
 257         struct resolv_nameserver *nameserver = user_data;
 258         unsigned char buf[4096];
 259         int sk, len;
 260
 261         if (cond & (G_IO_NVAL | G_IO_ERR | G_IO_HUP)) {
 262                 nameserver->udp_watch = 0;
 263                 return FALSE;
 264         }
 265
 266         sk = g_io_channel_unix_get_fd(nameserver->udp_channel);
 267
 268         len = recv(sk, buf, sizeof(buf), 0);
 269         if (len < 12)
 270                 return TRUE;
 271
 272         parse_response(nameserver, buf, len);
 273
 274         return TRUE;
 275 }
 276
 277 static int connect_udp_channel(struct resolv_nameserver *nameserver)
 278 {
 279         struct sockaddr_in sin;
 280         int sk;
 281
 282         sk = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
 283         if (sk < 0)
 284                 return -EIO;
 285
 286         memset(&sin, 0, sizeof(sin));
 287         sin.sin_family = AF_INET;
 288         sin.sin_port = htons(nameserver->port);
 289         sin.sin_addr.s_addr = inet_addr(nameserver->address);
 290
 291         if (connect(sk, (struct sockaddr *) &sin, sizeof(sin)) < 0) {
 292                 close(sk);
 293                 return -EIO;
 294         }
 295
 296         nameserver->udp_channel = g_io_channel_unix_new(sk);
 297         if (nameserver->udp_channel == NULL) {
 298                 close(sk);
 299                 return -ENOMEM;
 300         }
 301
 302         g_io_channel_set_close_on_unref(nameserver->udp_channel, TRUE);
 303
 304         nameserver->udp_watch = g_io_add_watch(nameserver->udp_channel,
 305                                                 G_IO_IN, received_udp_data,
 306                                                                 nameserver);
 307
 308         return 0;
 309 }
 310
 311 GResolv *g_resolv_new(int index)
 312 {
 313         GResolv *resolv;
 314
 315         if (index < 0)
 316                 return NULL;
 317
 318         resolv = g_try_new0(GResolv, 1);
 319         if (resolv == NULL)
 320                 return NULL;
 321
 322         resolv->ref_count = 1;
 323
 324         resolv->next_query_id = 1;
 325         resolv->query_queue = g_queue_new();
 326
 327         if (resolv->query_queue == NULL) {
 328                 g_free(resolv);
 329                 return NULL;
 330         }
 331
 332         resolv->index = index;
 333         resolv->nameserver_list = NULL;
 334
 335         return resolv;
 336 }
 337
 338 GResolv *g_resolv_ref(GResolv *resolv)
 339 {
 340         if (resolv == NULL)
 341                 return NULL;
 342
 343         g_atomic_int_inc(&resolv->ref_count);
 344
 345         return resolv;
 346 }
 347
 348 void g_resolv_unref(GResolv *resolv)
 349 {
 350         struct resolv_query *query;
 351
 352         if (resolv == NULL)
 353                 return;
 354
 355         if (g_atomic_int_dec_and_test(&resolv->ref_count) == FALSE)
 356                 return;
 357
 358         while ((query = g_queue_pop_head(resolv->query_queue)))
 359                 destroy_query(query);
 360
 361         g_queue_free(resolv->query_queue);
 362
 363         flush_nameservers(resolv);
 364
 365         g_free(resolv);
 366 }
 367
 368 void g_resolv_set_debug(GResolv *resolv,
 369                                 GResolvDebugFunc func, gpointer user_data)
 370 {
 371         if (resolv == NULL)
 372                 return;
 373
 374         resolv->debug_func = func;
 375         resolv->debug_data = user_data;
 376 }
 377
 378 gboolean g_resolv_add_nameserver(GResolv *resolv, const char *address,
 379                                         uint16_t port, unsigned long flags)
 380 {
 381         struct resolv_nameserver *nameserver;
 382
 383         if (resolv == NULL)
 384                 return FALSE;
 385
 386         nameserver = g_try_new0(struct resolv_nameserver, 1);
 387         if (nameserver == NULL)
 388                 return FALSE;
 389
 390         nameserver->address = g_strdup(address);
 391         nameserver->port = port;
 392         nameserver->flags = flags;
 393
 394         if (connect_udp_channel(nameserver) < 0) {
 395                 free_nameserver(nameserver);
 396                 return FALSE;
 397         }
 398
 399         nameserver->resolv = resolv;
 400
 401         resolv->nameserver_list = g_list_append(resolv->nameserver_list,
 402                                                                 nameserver);
 403
 404         debug(resolv, "setting nameserver %s", address);
 405
 406         return TRUE;
 407 }
 408
 409 void g_resolv_flush_nameservers(GResolv *resolv)
 410 {
 411         if (resolv == NULL)
 412                 return;
 413
 414         flush_nameservers(resolv);
 415 }
 416
 417 guint g_resolv_lookup_hostname(GResolv *resolv, const char *hostname,
 418                                 GResolvResultFunc func, gpointer user_data)
 419 {
 420         struct resolv_query *query;
 421         unsigned char buf[4096];
 422         int len;
 423
 424         debug(resolv, "lookup hostname %s", hostname);
 425
 426         if (resolv == NULL)
 427                 return 0;
 428
 429         query = g_try_new0(struct resolv_query, 1);
 430         if (query == NULL)
 431                 return 0;
 432
 433         query->id = resolv->next_query_id++;
 434
 435         len = res_mkquery(ns_o_query, hostname, ns_c_in, ns_t_a,
 436                                         NULL, 0, NULL, buf, sizeof(buf));
 437
 438         query->msgid = buf[0] << 8 | buf[1];
 439
 440         query->result_func = func;
 441         query->result_data = user_data;
 442
 443         if (send_query(resolv, buf, len) < 0) {
 444                 g_free(query);
 445                 return -EIO;
 446         }
 447
 448         query->resolv = resolv;
 449
 450         g_queue_push_tail(resolv->query_queue, query);
 451
 452         query->timeout = g_timeout_add_seconds(5, query_timeout, query);
 453
 454         return query->id;
 455 }
 456
 457 gboolean g_resolv_cancel_lookup(GResolv *resolv, guint id)
 458 {
 459         GList *list;
 460
 461         list = g_queue_find_custom(resolv->query_queue,
 462                                 GUINT_TO_POINTER(id), compare_query_id);
 463
 464         if (list == NULL)
 465                 return FALSE;
 466
 467         destroy_query(list->data);
 468         g_queue_remove(resolv->query_queue, list->data);
 469
 470         return TRUE;
 471 }