plugins/dnsproxy.c

   1 /*
   2  *
   3  *  Connection Manager
   4  *
   5  *  Copyright (C) 2007-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 <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 (interface != NULL) {
 230                 if (setsockopt(sk, SOL_SOCKET, SO_BINDTODEVICE,
 231                                 interface, strlen(interface) + 1) < 0) {
 232                         connman_error("Failed to bind server %s "
 233                                                 "to interface %s",
 234                                                         server, interface);
 235                         close(sk);
 236                         return NULL;
 237                 }
 238         }
 239
 240         memset(&sin, 0, sizeof(sin));
 241         sin.sin_family = AF_INET;
 242         sin.sin_port = htons(53);
 243         sin.sin_addr.s_addr = inet_addr(server);
 244
 245         if (connect(sk, (struct sockaddr *) &sin, sizeof(sin)) < 0) {
 246                 connman_error("Failed to connect server %s", server);
 247                 close(sk);
 248                 return NULL;
 249         }
 250
 251         data = g_try_new0(struct server_data, 1);
 252         if (data == NULL) {
 253                 connman_error("Failed to allocate server %s data", server);
 254                 close(sk);
 255                 return NULL;
 256         }
 257
 258         data->channel = g_io_channel_unix_new(sk);
 259         if (data->channel == NULL) {
 260                 connman_error("Failed to create server %s channel", server);
 261                 close(sk);
 262                 g_free(data);
 263                 return NULL;
 264         }
 265
 266         g_io_channel_set_close_on_unref(data->channel, TRUE);
 267
 268         data->watch = g_io_add_watch(data->channel, G_IO_IN,
 269                                                 server_event, data);
 270
 271         data->interface = g_strdup(interface);
 272         data->domain = g_strdup(domain);
 273         data->server = g_strdup(server);
 274
 275         /* Enable new servers by default */
 276         data->enabled = TRUE;
 277
 278         connman_info("Adding DNS server %s", data->server);
 279
 280         return data;
 281 }
 282
 283 static void destroy_server(struct server_data *data)
 284 {
 285         DBG("interface %s server %s", data->interface, data->server);
 286
 287         if (data->watch > 0)
 288                 g_source_remove(data->watch);
 289
 290         g_io_channel_unref(data->channel);
 291
 292         connman_info("Removing DNS server %s", data->server);
 293
 294         g_free(data->server);
 295         g_free(data->domain);
 296         g_free(data->interface);
 297         g_free(data);
 298 }
 299
 300 static int dnsproxy_append(const char *interface, const char *domain,
 301                                                         const char *server)
 302 {
 303         struct server_data *data;
 304
 305         DBG("interface %s server %s", interface, server);
 306
 307         if (g_str_equal(server, "127.0.0.1") == TRUE)
 308                 return -ENODEV;
 309
 310         data = create_server(interface, domain, server);
 311         if (data == NULL)
 312                 return -EIO;
 313
 314         server_list = g_slist_append(server_list, data);
 315
 316         return 0;
 317 }
 318
 319 static int dnsproxy_remove(const char *interface, const char *domain,
 320                                                         const char *server)
 321 {
 322         struct server_data *data;
 323
 324         DBG("interface %s server %s", interface, server);
 325
 326         if (g_str_equal(server, "127.0.0.1") == TRUE)
 327                 return -ENODEV;
 328
 329         data = find_server(interface, domain, server);
 330         if (data == NULL)
 331                 return 0;
 332
 333         server_list = g_slist_remove(server_list, data);
 334
 335         destroy_server(data);
 336
 337         return 0;
 338 }
 339
 340 static struct connman_resolver dnsproxy_resolver = {
 341         .name           = "dnsproxy",
 342         .priority       = CONNMAN_RESOLVER_PRIORITY_HIGH,
 343         .append         = dnsproxy_append,
 344         .remove         = dnsproxy_remove,
 345 };
 346
 347 static void dnsproxy_offline_mode(connman_bool_t enabled)
 348 {
 349         GSList *list;
 350
 351         DBG("enabled %d", enabled);
 352
 353         for (list = server_list; list; list = list->next) {
 354                 struct server_data *data = list->data;
 355
 356                 if (enabled == FALSE) {
 357                         connman_info("Enabling DNS server %s", data->server);
 358                         data->enabled = TRUE;
 359                 } else {
 360                         connman_info("Disabling DNS server %s", data->server);
 361                         data->enabled = FALSE;
 362                 }
 363         }
 364 }
 365
 366 static void dnsproxy_default_changed(struct connman_service *service)
 367 {
 368         GSList *list;
 369         char *interface;
 370
 371         DBG("service %p", service);
 372
 373         if (service == NULL) {
 374                 /* When no services are active, then disable DNS proxying */
 375                 dnsproxy_offline_mode(TRUE);
 376                 return;
 377         }
 378
 379         interface = connman_service_get_interface(service);
 380         if (interface == NULL)
 381                 return;
 382
 383         for (list = server_list; list; list = list->next) {
 384                 struct server_data *data = list->data;
 385
 386                 if (g_strcmp0(data->interface, interface) == 0) {
 387                         connman_info("Enabling DNS server %s", data->server);
 388                         data->enabled = TRUE;
 389                 } else {
 390                         connman_info("Disabling DNS server %s", data->server);
 391                         data->enabled = FALSE;
 392                 }
 393         }
 394
 395         g_free(interface);
 396 }
 397
 398 static struct connman_notifier dnsproxy_notifier = {
 399         .name                   = "dnsproxy",
 400         .default_changed        = dnsproxy_default_changed,
 401         .offline_mode           = dnsproxy_offline_mode,
 402 };
 403
 404 static int parse_request(unsigned char *buf, int len,
 405                                         char *name, unsigned int size)
 406 {
 407         struct domain_hdr *hdr = (void *) buf;
 408         uint16_t qdcount = ntohs(hdr->qdcount);
 409         uint16_t arcount = ntohs(hdr->arcount);
 410         unsigned char *ptr;
 411         char *last_label = NULL;
 412         int label_count = 0;
 413         unsigned int remain, used = 0;
 414
 415         if (len < 12)
 416                 return -EINVAL;
 417
 418         DBG("id 0x%04x qr %d opcode %d qdcount %d arcount %d",
 419                                         hdr->id, hdr->qr, hdr->opcode,
 420                                                         qdcount, arcount);
 421
 422         if (hdr->qr != 0 || qdcount != 1)
 423                 return -EINVAL;
 424
 425         memset(name, 0, size);
 426
 427         ptr = buf + 12;
 428         remain = len - 12;
 429
 430         while (remain > 0) {
 431                 uint8_t len = *ptr;
 432
 433                 if (len == 0x00) {
 434                         if (label_count > 0)
 435                                 last_label = (char *) (ptr + 1);
 436                         break;
 437                 }
 438
 439                 label_count++;
 440
 441                 if (used + len + 1 > size)
 442                         return -ENOBUFS;
 443
 444                 strncat(name, (char *) (ptr + 1), len);
 445                 strcat(name, ".");
 446
 447                 used += len + 1;
 448
 449                 ptr += len + 1;
 450                 remain -= len + 1;
 451         }
 452
 453         if (arcount && remain >= 9 && last_label[4] == 0 &&
 454                                 last_label[5] == 0 && last_label[6] == 0x29) {
 455                 uint16_t edns0_bufsize;
 456
 457                 edns0_bufsize = last_label[7] << 8 | last_label[8];
 458
 459                 DBG("EDNS0 buffer size %u", edns0_bufsize);
 460
 461                 /* This is an evil hack until full TCP support has been
 462                  * implemented.
 463                  *
 464                  * Somtimes the EDNS0 request gets send with a too-small
 465                  * buffer size. Since glibc doesn't seem to crash when it
 466                  * gets a response biffer then it requested, just bump
 467                  * the buffer size up to 4KiB.
 468                  */
 469                 if (edns0_bufsize < 0x1000) {
 470                         last_label[7] = 0x10;
 471                         last_label[8] = 0x00;
 472                 }
 473         }
 474
 475         DBG("query %s (%d labels)", name, label_count);
 476
 477         return 0;
 478 }
 479
 480 static void send_response(int sk, unsigned char *buf, int len,
 481                                 const struct sockaddr *to, socklen_t tolen)
 482 {
 483         struct domain_hdr *hdr = (void *) buf;
 484         int err;
 485
 486         if (len < 12)
 487                 return;
 488
 489         DBG("id 0x%04x qr %d opcode %d", hdr->id, hdr->qr, hdr->opcode);
 490
 491         hdr->qr = 1;
 492         hdr->rcode = 2;
 493
 494         hdr->ancount = 0;
 495         hdr->nscount = 0;
 496         hdr->arcount = 0;
 497
 498         err = sendto(sk, buf, len, 0, to, tolen);
 499 }
 500
 501 static int append_query(unsigned char *buf, unsigned int size,
 502                                 const char *query, const char *domain)
 503 {
 504         unsigned char *ptr = buf;
 505         char *offset;
 506
 507         DBG("query %s domain %s", query, domain);
 508
 509         offset = (char *) query;
 510         while (offset != NULL) {
 511                 char *tmp;
 512
 513                 tmp = strchr(offset, '.');
 514                 if (tmp == NULL) {
 515                         if (strlen(offset) == 0)
 516                                 break;
 517                         *ptr = strlen(offset);
 518                         memcpy(ptr + 1, offset, strlen(offset));
 519                         ptr += strlen(offset) + 1;
 520                         break;
 521                 }
 522
 523                 *ptr = tmp - offset;
 524                 memcpy(ptr + 1, offset, tmp - offset);
 525                 ptr += tmp - offset + 1;
 526
 527                 offset = tmp + 1;
 528         }
 529
 530         offset = (char *) domain;
 531         while (offset != NULL) {
 532                 char *tmp;
 533
 534                 tmp = strchr(offset, '.');
 535                 if (tmp == NULL) {
 536                         if (strlen(offset) == 0)
 537                                 break;
 538                         *ptr = strlen(offset);
 539                         memcpy(ptr + 1, offset, strlen(offset));
 540                         ptr += strlen(offset) + 1;
 541                         break;
 542                 }
 543
 544                 *ptr = tmp - offset;
 545                 memcpy(ptr + 1, offset, tmp - offset);
 546                 ptr += tmp - offset + 1;
 547
 548                 offset = tmp + 1;
 549         }
 550
 551         *ptr++ = 0x00;
 552
 553         return ptr - buf;
 554 }
 555
 556 static gboolean request_timeout(gpointer user_data)
 557 {
 558         struct request_data *req = user_data;
 559
 560         DBG("id 0x%04x", req->srcid);
 561
 562         request_list = g_slist_remove(request_list, req);
 563
 564         if (req->resplen > 0 && req->resp != NULL) {
 565                 int sk, err;
 566
 567                 sk = g_io_channel_unix_get_fd(listener_channel);
 568
 569                 err = sendto(sk, req->resp, req->resplen, 0,
 570                                 (struct sockaddr *) &req->sin, req->len);
 571         }
 572
 573         g_free(req->resp);
 574         g_free(req);
 575
 576         return FALSE;
 577 }
 578
 579 static gboolean listener_event(GIOChannel *channel, GIOCondition condition,
 580                                                         gpointer user_data)
 581 {
 582         GSList *list;
 583         unsigned char buf[768];
 584         char query[512];
 585         struct request_data *req;
 586         struct sockaddr_in sin;
 587         socklen_t size = sizeof(sin);
 588         int sk, err, len;
 589
 590         if (condition & (G_IO_NVAL | G_IO_ERR | G_IO_HUP)) {
 591                 connman_error("Error with listener channel");
 592                 listener_watch = 0;
 593                 return FALSE;
 594         }
 595
 596         sk = g_io_channel_unix_get_fd(channel);
 597
 598         memset(&sin, 0, sizeof(sin));
 599         len = recvfrom(sk, buf, sizeof(buf), 0,
 600                                         (struct sockaddr *) &sin, &size);
 601         if (len < 2)
 602                 return TRUE;
 603
 604         DBG("Received %d bytes (id 0x%04x)", len, buf[0] | buf[1] << 8);
 605
 606         err = parse_request(buf, len, query, sizeof(query));
 607         if (err < 0 || g_slist_length(server_list) == 0) {
 608                 send_response(sk, buf, len, (struct sockaddr *) &sin, size);
 609                 return TRUE;
 610         }
 611
 612         req = g_try_new0(struct request_data, 1);
 613         if (req == NULL)
 614                 return TRUE;
 615
 616         memcpy(&req->sin, &sin, sizeof(sin));
 617         req->len = size;
 618
 619         request_id += 2;
 620         if (request_id == 0x0000 || request_id == 0xffff)
 621                 request_id += 2;
 622
 623         req->srcid = buf[0] | (buf[1] << 8);
 624         req->dstid = request_id;
 625         req->altid = request_id + 1;
 626
 627         buf[0] = req->dstid & 0xff;
 628         buf[1] = req->dstid >> 8;
 629
 630         request_list = g_slist_append(request_list, req);
 631
 632         req->numserv = 0;
 633         req->timeout = g_timeout_add_seconds(5, request_timeout, req);
 634
 635         for (list = server_list; list; list = list->next) {
 636                 struct server_data *data = list->data;
 637
 638                 DBG("server %s domain %s enabled %d",
 639                                 data->server, data->domain, data->enabled);
 640
 641                 if (data->enabled == FALSE)
 642                         continue;
 643
 644                 sk = g_io_channel_unix_get_fd(data->channel);
 645
 646                 err = send(sk, buf, len, 0);
 647
 648                 req->numserv++;
 649
 650                 if (data->domain != NULL) {
 651                         unsigned char alt[1024];
 652                         struct domain_hdr *hdr = (void *) &alt;
 653                         int altlen, domlen;
 654
 655                         domlen = strlen(data->domain) + 1;
 656                         if (domlen < 5)
 657                                 continue;
 658
 659                         alt[0] = req->altid & 0xff;
 660                         alt[1] = req->altid >> 8;
 661
 662                         memcpy(alt + 2, buf + 2, 10);
 663                         hdr->qdcount = htons(1);
 664
 665                         altlen = append_query(alt + 12, sizeof(alt) - 12,
 666                                                         query, data->domain);
 667                         if (altlen < 0)
 668                                 continue;
 669
 670                         altlen += 12;
 671
 672                         memcpy(alt + altlen, buf + altlen - domlen,
 673                                                         len - altlen + domlen);
 674
 675                         err = send(sk, alt, len + domlen + 1, 0);
 676
 677                         req->numserv++;
 678                 }
 679         }
 680
 681         return TRUE;
 682 }
 683
 684 static int create_listener(void)
 685 {
 686         const char *ifname = "lo";
 687         struct sockaddr_in sin;
 688         int sk;
 689
 690         DBG("");
 691
 692         sk = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
 693         if (sk < 0) {
 694                 connman_error("Failed to create listener socket");
 695                 return -EIO;
 696         }
 697
 698         //setsockopt(sk, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
 699         //setsockopt(sk, SOL_IP, IP_PKTINFO, &opt, sizeof(opt));
 700
 701         if (setsockopt(sk, SOL_SOCKET, SO_BINDTODEVICE,
 702                                         ifname, strlen(ifname) + 1) < 0) {
 703                 connman_error("Failed to bind listener interface");
 704                 close(sk);
 705                 return -EIO;
 706         }
 707
 708         memset(&sin, 0, sizeof(sin));
 709         sin.sin_family = AF_INET;
 710         sin.sin_port = htons(53);
 711         sin.sin_addr.s_addr = inet_addr("127.0.0.1");
 712         //sin.sin_addr.s_addr = INADDR_ANY;
 713
 714         if (bind(sk, (struct sockaddr *) &sin, sizeof(sin)) < 0) {
 715                 connman_error("Failed to bind listener socket");
 716                 close(sk);
 717                 return -EIO;
 718         }
 719
 720         listener_channel = g_io_channel_unix_new(sk);
 721         if (listener_channel == NULL) {
 722                 connman_error("Failed to create listener channel");
 723                 close(sk);
 724                 return -EIO;
 725         }
 726
 727         g_io_channel_set_close_on_unref(listener_channel, TRUE);
 728
 729         listener_watch = g_io_add_watch(listener_channel, G_IO_IN,
 730                                                         listener_event, NULL);
 731
 732         connman_resolver_append("lo", NULL, "127.0.0.1");
 733
 734         return 0;
 735 }
 736
 737 static void destroy_listener(void)
 738 {
 739         GSList *list;
 740
 741         DBG("");
 742
 743         connman_resolver_remove_all("lo");
 744
 745         if (listener_watch > 0)
 746                 g_source_remove(listener_watch);
 747
 748         for (list = request_list; list; list = list->next) {
 749                 struct request_data *req = list->data;
 750
 751                 DBG("Dropping request (id 0x%04x -> 0x%04x)",
 752                                                 req->srcid, req->dstid);
 753
 754                 g_free(req->resp);
 755                 g_free(req);
 756                 list->data = NULL;
 757         }
 758
 759         g_slist_free(request_list);
 760         request_list = NULL;
 761
 762         g_io_channel_unref(listener_channel);
 763 }
 764
 765 static int dnsproxy_init(void)
 766 {
 767         int err;
 768
 769         err = create_listener();
 770         if (err < 0)
 771                 return err;
 772
 773         err = connman_resolver_register(&dnsproxy_resolver);
 774         if (err < 0)
 775                 goto destroy;
 776
 777         err = connman_notifier_register(&dnsproxy_notifier);
 778         if (err < 0)
 779                 goto unregister;
 780
 781         return 0;
 782
 783 unregister:
 784         connman_resolver_unregister(&dnsproxy_resolver);
 785
 786 destroy:
 787         destroy_listener();
 788
 789         return err;
 790 }
 791
 792 static void dnsproxy_exit(void)
 793 {
 794         connman_notifier_unregister(&dnsproxy_notifier);
 795
 796         connman_resolver_unregister(&dnsproxy_resolver);
 797
 798         destroy_listener();
 799 }
 800
 801 CONNMAN_PLUGIN_DEFINE(dnsproxy, "DNS proxy resolver plugin", VERSION,
 802                  CONNMAN_PLUGIN_PRIORITY_DEFAULT, dnsproxy_init, dnsproxy_exit)