plugins/dnsproxy.c

   1 /*
   2  *
   3  *  Connection Manager
   4  *
   5  *  Copyright (C) 2007-2009  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 <string.h>
  29 #include <stdint.h>
  30 #include <arpa/inet.h>
  31 #include <netinet/in.h>
  32
  33 #define CONNMAN_API_SUBJECT_TO_CHANGE
  34 #include <connman/plugin.h>
  35 #include <connman/resolver.h>
  36 #include <connman/notifier.h>
  37 #include <connman/log.h>
  38
  39 #include <glib.h>
  40
  41 #if __BYTE_ORDER == __LITTLE_ENDIAN
  42 struct domain_hdr {
  43         uint16_t id;
  44         uint8_t rd:1;
  45         uint8_t tc:1;
  46         uint8_t aa:1;
  47         uint8_t opcode:4;
  48         uint8_t qr:1;
  49         uint8_t rcode:4;
  50         uint8_t z:3;
  51         uint8_t ra:1;
  52         uint16_t qdcount;
  53         uint16_t ancount;
  54         uint16_t nscount;
  55         uint16_t arcount;
  56 } __attribute__ ((packed));
  57 #elif __BYTE_ORDER == __BIG_ENDIAN
  58 struct domain_hdr {
  59         uint16_t id;
  60         uint8_t qr:1;
  61         uint8_t opcode:4;
  62         uint8_t aa:1;
  63         uint8_t tc:1;
  64         uint8_t rd:1;
  65         uint8_t ra:1;
  66         uint8_t z:3;
  67         uint8_t rcode:4;
  68         uint16_t qdcount;
  69         uint16_t ancount;
  70         uint16_t nscount;
  71         uint16_t arcount;
  72 } __attribute__ ((packed));
  73 #else
  74 #error "Unknown byte order"
  75 #endif
  76
  77 struct server_data {
  78         char *interface;
  79         char *domain;
  80         char *server;
  81         GIOChannel *channel;
  82         guint watch;
  83         gboolean enabled;
  84 };
  85
  86 struct request_data {
  87         struct sockaddr_in sin;
  88         socklen_t len;
  89         guint16 srcid;
  90         guint16 dstid;
  91         guint16 altid;
  92         guint timeout;
  93         guint numserv;
  94         guint numresp;
  95         gpointer resp;
  96         gsize resplen;
  97 };
  98
  99 static GSList *server_list = NULL;
 100 static GSList *request_list = NULL;
 101 static guint16 request_id = 0x0000;
 102
 103 static GIOChannel *listener_channel = NULL;
 104 static guint listener_watch = 0;
 105
 106 static struct request_data *find_request(guint16 id)
 107 {
 108         GSList *list;
 109
 110         for (list = request_list; list; list = list->next) {
 111                 struct request_data *req = list->data;
 112
 113                 if (req->dstid == id || req->altid == id)
 114                         return req;
 115         }
 116
 117         return NULL;
 118 }
 119
 120 static struct server_data *find_server(const char *interface,
 121                                         const char *domain, const char *server)
 122 {
 123         GSList *list;
 124
 125         DBG("interface %s server %s", interface, server);
 126
 127         for (list = server_list; list; list = list->next) {
 128                 struct server_data *data = list->data;
 129
 130                 if (data->interface == NULL || data->server == NULL)
 131                         continue;
 132
 133                 if (g_str_equal(data->interface, interface) == TRUE &&
 134                                 g_str_equal(data->server, server) == TRUE) {
 135                         if (domain == NULL) {
 136                                 if (data->domain == NULL)
 137                                         return data;
 138                                 continue;
 139                         }
 140
 141                         if (g_str_equal(data->domain, domain) == TRUE)
 142                                 return data;
 143                 }
 144         }
 145
 146         return NULL;
 147 }
 148
 149 static gboolean server_event(GIOChannel *channel, GIOCondition condition,
 150                                                         gpointer user_data)
 151 {
 152         struct server_data *data = user_data;
 153         struct request_data *req;
 154         unsigned char buf[4096];
 155         struct domain_hdr *hdr = (void *) &buf;
 156         int sk, err, len;
 157
 158         if (condition & (G_IO_NVAL | G_IO_ERR | G_IO_HUP)) {
 159                 connman_error("Error with server channel");
 160                 data->watch = 0;
 161                 return FALSE;
 162         }
 163
 164         sk = g_io_channel_unix_get_fd(channel);
 165
 166         len = recv(sk, buf, sizeof(buf), 0);
 167         if (len < 12)
 168                 return TRUE;
 169
 170         DBG("Received %d bytes (id 0x%04x)", len, buf[0] | buf[1] << 8);
 171
 172         req = find_request(buf[0] | buf[1] << 8);
 173         if (req == NULL)
 174                 return TRUE;
 175
 176         DBG("id 0x%04x rcode %d", hdr->id, hdr->rcode);
 177
 178         buf[0] = req->srcid & 0xff;
 179         buf[1] = req->srcid >> 8;
 180
 181         req->numresp++;
 182
 183         if (hdr->rcode == 0 || req->resp == NULL) {
 184                 g_free(req->resp);
 185                 req->resplen = 0;
 186
 187                 req->resp = g_try_malloc(len);
 188                 if (req->resp == NULL)
 189                         return TRUE;
 190
 191                 memcpy(req->resp, buf, len);
 192                 req->resplen = len;
 193         }
 194
 195         if (hdr->rcode > 0 && req->numresp < req->numserv)
 196                 return TRUE;
 197
 198         if (req->timeout > 0)
 199                 g_source_remove(req->timeout);
 200
 201         request_list = g_slist_remove(request_list, req);
 202
 203         sk = g_io_channel_unix_get_fd(listener_channel);
 204
 205         err = sendto(sk, req->resp, req->resplen, 0,
 206                                 (struct sockaddr *) &req->sin, req->len);
 207
 208         g_free(req->resp);
 209         g_free(req);
 210
 211         return TRUE;
 212 }
 213
 214 static struct server_data *create_server(const char *interface,
 215                                         const char *domain, const char *server)
 216 {
 217         struct server_data *data;
 218         struct sockaddr_in sin;
 219         int sk;
 220
 221         DBG("interface %s server %s", interface, server);
 222
 223         sk = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
 224         if (sk < 0) {
 225                 connman_error("Failed to create server %s socket", server);
 226                 return NULL;
 227         }
 228
 229         if (setsockopt(sk, SOL_SOCKET, SO_BINDTODEVICE,
 230                                 interface, strlen(interface) + 1) < 0) {
 231                 connman_error("Failed to bind server %s to interface %s",
 232                                                         server, interface);
 233                 close(sk);
 234                 return NULL;
 235         }
 236
 237         memset(&sin, 0, sizeof(sin));
 238         sin.sin_family = AF_INET;
 239         sin.sin_port = htons(53);
 240         sin.sin_addr.s_addr = inet_addr(server);
 241
 242         if (connect(sk, (struct sockaddr *) &sin, sizeof(sin)) < 0) {
 243                 connman_error("Failed to connect server %s", server);
 244                 close(sk);
 245                 return NULL;
 246         }
 247
 248         data = g_try_new0(struct server_data, 1);
 249         if (data == NULL) {
 250                 connman_error("Failed to allocate server %s data", server);
 251                 close(sk);
 252                 return NULL;
 253         }
 254
 255         data->channel = g_io_channel_unix_new(sk);
 256         if (data->channel == NULL) {
 257                 connman_error("Failed to create server %s channel", server);
 258                 close(sk);
 259                 g_free(data);
 260                 return NULL;
 261         }
 262
 263         g_io_channel_set_close_on_unref(data->channel, TRUE);
 264
 265         data->watch = g_io_add_watch(data->channel, G_IO_IN,
 266                                                         server_event, data);
 267
 268         data->interface = g_strdup(interface);
 269         data->domain = g_strdup(domain);
 270         data->server = g_strdup(server);
 271
 272         /* Enable new servers by default */
 273         data->enabled = TRUE;
 274
 275         connman_info("Adding DNS server %s", data->server);
 276
 277         return data;
 278 }
 279
 280 static void destroy_server(struct server_data *data)
 281 {
 282         DBG("interface %s server %s", data->interface, data->server);
 283
 284         if (data->watch > 0)
 285                 g_source_remove(data->watch);
 286
 287         g_io_channel_unref(data->channel);
 288
 289         connman_info("Removing DNS server %s", data->server);
 290
 291         g_free(data->server);
 292         g_free(data->domain);
 293         g_free(data->interface);
 294         g_free(data);
 295 }
 296
 297 static int dnsproxy_append(const char *interface, const char *domain,
 298                                                         const char *server)
 299 {
 300         struct server_data *data;
 301
 302         DBG("interface %s server %s", interface, server);
 303
 304         if (g_str_equal(server, "127.0.0.1") == TRUE)
 305                 return -ENODEV;
 306
 307         data = create_server(interface, domain, server);
 308         if (data == NULL)
 309                 return -EIO;
 310
 311         server_list = g_slist_append(server_list, data);
 312
 313         return 0;
 314 }
 315
 316 static int dnsproxy_remove(const char *interface, const char *domain,
 317                                                         const char *server)
 318 {
 319         struct server_data *data;
 320
 321         DBG("interface %s server %s", interface, server);
 322
 323         if (g_str_equal(server, "127.0.0.1") == TRUE)
 324                 return -ENODEV;
 325
 326         data = find_server(interface, domain, server);
 327         if (data == NULL)
 328                 return 0;
 329
 330         server_list = g_slist_remove(server_list, data);
 331
 332         destroy_server(data);
 333
 334         return 0;
 335 }
 336
 337 static struct connman_resolver dnsproxy_resolver = {
 338         .name           = "dnsproxy",
 339         .priority       = CONNMAN_RESOLVER_PRIORITY_HIGH,
 340         .append         = dnsproxy_append,
 341         .remove         = dnsproxy_remove,
 342 };
 343
 344 static void dnsproxy_offline_mode(connman_bool_t enabled)
 345 {
 346         GSList *list;
 347
 348         DBG("enabled %d", enabled);
 349
 350         for (list = server_list; list; list = list->next) {
 351                 struct server_data *data = list->data;
 352
 353                 if (enabled == FALSE) {
 354                         connman_info("Enabling DNS server %s", data->server);
 355                         data->enabled = TRUE;
 356                 } else {
 357                         connman_info("Disabling DNS server %s", data->server);
 358                         data->enabled = FALSE;
 359                 }
 360         }
 361 }
 362
 363 static void dnsproxy_default_changed(struct connman_service *service)
 364 {
 365         GSList *list;
 366         char *interface;
 367
 368         DBG("service %p", service);
 369
 370         if (service == NULL) {
 371                 /* When no services are active, then disable DNS proxying */
 372                 dnsproxy_offline_mode(TRUE);
 373                 return;
 374         }
 375
 376         interface = connman_service_get_interface(service);
 377         if (interface == NULL)
 378                 return;
 379
 380         for (list = server_list; list; list = list->next) {
 381                 struct server_data *data = list->data;
 382
 383                 if (g_strcmp0(data->interface, interface) == 0) {
 384                         connman_info("Enabling DNS server %s", data->server);
 385                         data->enabled = TRUE;
 386                 } else {
 387                         connman_info("Disabling DNS server %s", data->server);
 388                         data->enabled = FALSE;
 389                 }
 390         }
 391
 392         g_free(interface);
 393 }
 394
 395 static struct connman_notifier dnsproxy_notifier = {
 396         .name                   = "dnsproxy",
 397         .default_changed        = dnsproxy_default_changed,
 398         .offline_mode           = dnsproxy_offline_mode,
 399 };
 400
 401 static int parse_request(unsigned char *buf, int len,
 402                                         char *name, unsigned int size)
 403 {
 404         struct domain_hdr *hdr = (void *) buf;
 405         uint16_t qdcount = ntohs(hdr->qdcount);
 406         uint16_t arcount = ntohs(hdr->arcount);
 407         unsigned char *ptr;
 408         char *last_label = NULL;
 409         int label_count = 0;
 410         unsigned int remain, used = 0;
 411
 412         if (len < 12)
 413                 return -EINVAL;
 414
 415         DBG("id 0x%04x qr %d opcode %d qdcount %d arcount %d",
 416                                         hdr->id, hdr->qr, hdr->opcode,
 417                                                         qdcount, arcount);
 418
 419         if (hdr->qr != 0 || qdcount != 1)
 420                 return -EINVAL;
 421
 422         memset(name, 0, size);
 423
 424         ptr = buf + 12;
 425         remain = len - 12;
 426
 427         while (remain > 0) {
 428                 uint8_t len = *ptr;
 429
 430                 if (len == 0x00) {
 431                         if (label_count > 0)
 432                                 last_label = (char *) (ptr + 1);
 433                         break;
 434                 }
 435
 436                 label_count++;
 437
 438                 if (used + len + 1 > size)
 439                         return -ENOBUFS;
 440
 441                 strncat(name, (char *) (ptr + 1), len);
 442                 strcat(name, ".");
 443
 444                 used += len + 1;
 445
 446                 ptr += len + 1;
 447                 remain -= len + 1;
 448         }
 449
 450         if (arcount && remain >= 9 && last_label[4] == 0 &&
 451                                 last_label[5] == 0 && last_label[6] == 0x29) {
 452                 uint16_t edns0_bufsize;
 453
 454                 edns0_bufsize = last_label[7] << 8 | last_label[8];
 455
 456                 DBG("EDNS0 buffer size %u", edns0_bufsize);
 457
 458                 /* This is an evil hack until full TCP support has been
 459                  * implemented.
 460                  *
 461                  * Somtimes the EDNS0 request gets send with a too-small
 462                  * buffer size. Since glibc doesn't seem to crash when it
 463                  * gets a response biffer then it requested, just bump
 464                  * the buffer size up to 4KiB.
 465                  */
 466                 if (edns0_bufsize < 0x1000) {
 467                         last_label[7] = 0x10;
 468                         last_label[8] = 0x00;
 469                 }
 470         }
 471
 472         DBG("query %s (%d labels)", name, label_count);
 473
 474         return 0;
 475 }
 476
 477 static void send_response(int sk, unsigned char *buf, int len,
 478                                 const struct sockaddr *to, socklen_t tolen)
 479 {
 480         struct domain_hdr *hdr = (void *) buf;
 481         int err;
 482
 483         if (len < 12)
 484                 return;
 485
 486         DBG("id 0x%04x qr %d opcode %d", hdr->id, hdr->qr, hdr->opcode);
 487
 488         hdr->qr = 1;
 489         hdr->rcode = 2;
 490
 491         hdr->ancount = 0;
 492         hdr->nscount = 0;
 493         hdr->arcount = 0;
 494
 495         err = sendto(sk, buf, len, 0, to, tolen);
 496 }
 497
 498 static int append_query(unsigned char *buf, unsigned int size,
 499                                 const char *query, const char *domain)
 500 {
 501         unsigned char *ptr = buf;
 502         char *offset;
 503
 504         DBG("query %s domain %s", query, domain);
 505
 506         offset = (char *) query;
 507         while (offset != NULL) {
 508                 char *tmp;
 509
 510                 tmp = strchr(offset, '.');
 511                 if (tmp == NULL) {
 512                         if (strlen(offset) == 0)
 513                                 break;
 514                         *ptr = strlen(offset);
 515                         memcpy(ptr + 1, offset, strlen(offset));
 516                         ptr += strlen(offset) + 1;
 517                         break;
 518                 }
 519
 520                 *ptr = tmp - offset;
 521                 memcpy(ptr + 1, offset, tmp - offset);
 522                 ptr += tmp - offset + 1;
 523
 524                 offset = tmp + 1;
 525         }
 526
 527         offset = (char *) domain;
 528         while (offset != NULL) {
 529                 char *tmp;
 530
 531                 tmp = strchr(offset, '.');
 532                 if (tmp == NULL) {
 533                         if (strlen(offset) == 0)
 534                                 break;
 535                         *ptr = strlen(offset);
 536                         memcpy(ptr + 1, offset, strlen(offset));
 537                         ptr += strlen(offset) + 1;
 538                         break;
 539                 }
 540
 541                 *ptr = tmp - offset;
 542                 memcpy(ptr + 1, offset, tmp - offset);
 543                 ptr += tmp - offset + 1;
 544
 545                 offset = tmp + 1;
 546         }
 547
 548         *ptr++ = 0x00;
 549
 550         return ptr - buf;
 551 }
 552
 553 static gboolean request_timeout(gpointer user_data)
 554 {
 555         struct request_data *req = user_data;
 556
 557         DBG("id 0x%04x", req->srcid);
 558
 559         request_list = g_slist_remove(request_list, req);
 560
 561         if (req->resplen > 0 && req->resp != NULL) {
 562                 int sk, err;
 563
 564                 sk = g_io_channel_unix_get_fd(listener_channel);
 565
 566                 err = sendto(sk, req->resp, req->resplen, 0,
 567                                 (struct sockaddr *) &req->sin, req->len);
 568         }
 569
 570         g_free(req->resp);
 571         g_free(req);
 572
 573         return FALSE;
 574 }
 575
 576 static gboolean listener_event(GIOChannel *channel, GIOCondition condition,
 577                                                         gpointer user_data)
 578 {
 579         GSList *list;
 580         unsigned char buf[768];
 581         char query[512];
 582         struct request_data *req;
 583         struct sockaddr_in sin;
 584         socklen_t size = sizeof(sin);
 585         int sk, err, len;
 586
 587         if (condition & (G_IO_NVAL | G_IO_ERR | G_IO_HUP)) {
 588                 connman_error("Error with listener channel");
 589                 listener_watch = 0;
 590                 return FALSE;
 591         }
 592
 593         sk = g_io_channel_unix_get_fd(channel);
 594
 595         memset(&sin, 0, sizeof(sin));
 596         len = recvfrom(sk, buf, sizeof(buf), 0,
 597                                         (struct sockaddr *) &sin, &size);
 598         if (len < 2)
 599                 return TRUE;
 600
 601         DBG("Received %d bytes (id 0x%04x)", len, buf[0] | buf[1] << 8);
 602
 603         err = parse_request(buf, len, query, sizeof(query));
 604         if (err < 0 || g_slist_length(server_list) == 0) {
 605                 send_response(sk, buf, len, (struct sockaddr *) &sin, size);
 606                 return TRUE;
 607         }
 608
 609         req = g_try_new0(struct request_data, 1);
 610         if (req == NULL)
 611                 return TRUE;
 612
 613         memcpy(&req->sin, &sin, sizeof(sin));
 614         req->len = size;
 615
 616         request_id += 2;
 617         if (request_id == 0x0000 || request_id == 0xffff)
 618                 request_id += 2;
 619
 620         req->srcid = buf[0] | (buf[1] << 8);
 621         req->dstid = request_id;
 622         req->altid = request_id + 1;
 623
 624         buf[0] = req->dstid & 0xff;
 625         buf[1] = req->dstid >> 8;
 626
 627         request_list = g_slist_append(request_list, req);
 628
 629         req->numserv = 0;
 630         req->timeout = g_timeout_add_seconds(5, request_timeout, req);
 631
 632         for (list = server_list; list; list = list->next) {
 633                 struct server_data *data = list->data;
 634
 635                 DBG("server %s domain %s enabled %d",
 636                                 data->server, data->domain, data->enabled);
 637
 638                 if (data->enabled == FALSE)
 639                         continue;
 640
 641                 sk = g_io_channel_unix_get_fd(data->channel);
 642
 643                 err = send(sk, buf, len, 0);
 644
 645                 req->numserv++;
 646
 647                 if (data->domain != NULL) {
 648                         unsigned char alt[1024];
 649                         struct domain_hdr *hdr = (void *) &alt;
 650                         int altlen, domlen;
 651
 652                         domlen = strlen(data->domain) + 1;
 653                         if (domlen < 5)
 654                                 continue;
 655
 656                         alt[0] = req->altid & 0xff;
 657                         alt[1] = req->altid >> 8;
 658
 659                         memcpy(alt + 2, buf + 2, 10);
 660                         hdr->qdcount = htons(1);
 661
 662                         altlen = append_query(alt + 12, sizeof(alt) - 12,
 663                                                         query, data->domain);
 664                         if (altlen < 0)
 665                                 continue;
 666
 667                         altlen += 12;
 668
 669                         memcpy(alt + altlen, buf + altlen - domlen,
 670                                                         len - altlen + domlen);
 671
 672                         err = send(sk, alt, altlen + 4, 0);
 673
 674                         req->numserv++;
 675                 }
 676         }
 677
 678         return TRUE;
 679 }
 680
 681 static int create_listener(void)
 682 {
 683         const char *ifname = "lo";
 684         struct sockaddr_in sin;
 685         int sk;
 686
 687         DBG("");
 688
 689         sk = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
 690         if (sk < 0) {
 691                 connman_error("Failed to create listener socket");
 692                 return -EIO;
 693         }
 694
 695         //setsockopt(sk, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
 696         //setsockopt(sk, SOL_IP, IP_PKTINFO, &opt, sizeof(opt));
 697
 698         if (setsockopt(sk, SOL_SOCKET, SO_BINDTODEVICE,
 699                                         ifname, strlen(ifname) + 1) < 0) {
 700                 connman_error("Failed to bind listener interface");
 701                 close(sk);
 702                 return -EIO;
 703         }
 704
 705         memset(&sin, 0, sizeof(sin));
 706         sin.sin_family = AF_INET;
 707         sin.sin_port = htons(53);
 708         sin.sin_addr.s_addr = inet_addr("127.0.0.1");
 709         //sin.sin_addr.s_addr = INADDR_ANY;
 710
 711         if (bind(sk, (struct sockaddr *) &sin, sizeof(sin)) < 0) {
 712                 connman_error("Failed to bind listener socket");
 713                 close(sk);
 714                 return -EIO;
 715         }
 716
 717         listener_channel = g_io_channel_unix_new(sk);
 718         if (listener_channel == NULL) {
 719                 connman_error("Failed to create listener channel");
 720                 close(sk);
 721                 return -EIO;
 722         }
 723
 724         g_io_channel_set_close_on_unref(listener_channel, TRUE);
 725
 726         listener_watch = g_io_add_watch(listener_channel, G_IO_IN,
 727                                                         listener_event, NULL);
 728
 729         connman_resolver_append("lo", NULL, "127.0.0.1");
 730
 731         return 0;
 732 }
 733
 734 static void destroy_listener(void)
 735 {
 736         GSList *list;
 737
 738         DBG("");
 739
 740         connman_resolver_remove_all("lo");
 741
 742         if (listener_watch > 0)
 743                 g_source_remove(listener_watch);
 744
 745         for (list = request_list; list; list = list->next) {
 746                 struct request_data *req = list->data;
 747
 748                 DBG("Dropping request (id 0x%04x -> 0x%04x)",
 749                                                 req->srcid, req->dstid);
 750
 751                 g_free(req->resp);
 752                 g_free(req);
 753                 list->data = NULL;
 754         }
 755
 756         g_slist_free(request_list);
 757         request_list = NULL;
 758
 759         g_io_channel_unref(listener_channel);
 760 }
 761
 762 static int dnsproxy_init(void)
 763 {
 764         int err;
 765
 766         err = create_listener();
 767         if (err < 0)
 768                 return err;
 769
 770         err = connman_resolver_register(&dnsproxy_resolver);
 771         if (err < 0)
 772                 goto destroy;
 773
 774         err = connman_notifier_register(&dnsproxy_notifier);
 775         if (err < 0)
 776                 goto unregister;
 777
 778         return 0;
 779
 780 unregister:
 781         connman_resolver_unregister(&dnsproxy_resolver);
 782
 783 destroy:
 784         destroy_listener();
 785
 786         return err;
 787 }
 788
 789 static void dnsproxy_exit(void)
 790 {
 791         connman_notifier_unregister(&dnsproxy_notifier);
 792
 793         connman_resolver_unregister(&dnsproxy_resolver);
 794
 795         destroy_listener();
 796 }
 797
 798 CONNMAN_PLUGIN_DEFINE(dnsproxy, "DNS proxy resolver plugin", VERSION,
 799                  CONNMAN_PLUGIN_PRIORITY_DEFAULT, dnsproxy_init, dnsproxy_exit)