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/ondemand.h>
  38 #include <connman/log.h>
  39
  40 #include <glib.h>
  41
  42 #if __BYTE_ORDER == __LITTLE_ENDIAN
  43 struct domain_hdr {
  44         uint16_t id;
  45         uint8_t rd:1;
  46         uint8_t tc:1;
  47         uint8_t aa:1;
  48         uint8_t opcode:4;
  49         uint8_t qr:1;
  50         uint8_t rcode:4;
  51         uint8_t z:3;
  52         uint8_t ra:1;
  53         uint16_t qdcount;
  54         uint16_t ancount;
  55         uint16_t nscount;
  56         uint16_t arcount;
  57 } __attribute__ ((packed));
  58 #elif __BYTE_ORDER == __BIG_ENDIAN
  59 struct domain_hdr {
  60         uint16_t id;
  61         uint8_t qr:1;
  62         uint8_t opcode:4;
  63         uint8_t aa:1;
  64         uint8_t tc:1;
  65         uint8_t rd:1;
  66         uint8_t ra:1;
  67         uint8_t z:3;
  68         uint8_t rcode:4;
  69         uint16_t qdcount;
  70         uint16_t ancount;
  71         uint16_t nscount;
  72         uint16_t arcount;
  73 } __attribute__ ((packed));
  74 #else
  75 #error "Unknown byte order"
  76 #endif
  77
  78 struct partial_reply {
  79         uint16_t len;
  80         uint16_t received;
  81         unsigned char buf[];
  82 };
  83
  84 struct server_data {
  85         char *interface;
  86         char *domain;
  87         char *server;
  88         int protocol;
  89         GIOChannel *channel;
  90         guint watch;
  91         guint timeout;
  92         gboolean enabled;
  93         gboolean connected;
  94         struct partial_reply *incoming_reply;
  95 };
  96
  97 struct request_data {
  98         struct sockaddr_in sin;
  99         int client_sk;
 100         int protocol;
 101         socklen_t len;
 102         guint16 srcid;
 103         guint16 dstid;
 104         guint16 altid;
 105         guint timeout;
 106         guint watch;
 107         guint numserv;
 108         guint numresp;
 109         gpointer request;
 110         gsize request_len;
 111         gpointer name;
 112         gpointer resp;
 113         gsize resplen;
 114 };
 115
 116 static GSList *server_list = NULL;
 117 static GSList *request_list = NULL;
 118 static GSList *request_pending_list = NULL;
 119 static guint16 request_id = 0x0000;
 120
 121 static GIOChannel *udp_listener_channel = NULL;
 122 static guint udp_listener_watch = 0;
 123 static GIOChannel *tcp_listener_channel = NULL;
 124 static guint tcp_listener_watch = 0;
 125
 126 static int protocol_offset(int protocol)
 127 {
 128         switch (protocol) {
 129         case IPPROTO_UDP:
 130                 return 0;
 131
 132         case IPPROTO_TCP:
 133                 return 2;
 134
 135         default:
 136                 return -EINVAL;
 137         }
 138
 139 }
 140
 141 static struct request_data *find_request(guint16 id)
 142 {
 143         GSList *list;
 144
 145         for (list = request_list; list; list = list->next) {
 146                 struct request_data *req = list->data;
 147
 148                 if (req->dstid == id || req->altid == id)
 149                         return req;
 150         }
 151
 152         return NULL;
 153 }
 154
 155 static struct server_data *find_server(const char *interface,
 156                                         const char *domain, const char *server,
 157                                                 int protocol)
 158 {
 159         GSList *list;
 160
 161         DBG("interface %s server %s", interface, server);
 162
 163         for (list = server_list; list; list = list->next) {
 164                 struct server_data *data = list->data;
 165
 166                 if (data->interface == NULL || data->server == NULL)
 167                         continue;
 168
 169                 if (g_str_equal(data->interface, interface) == TRUE &&
 170                                 g_str_equal(data->server, server) == TRUE &&
 171                                 data->protocol == protocol) {
 172                         if (domain == NULL) {
 173                                 if (data->domain == NULL)
 174                                         return data;
 175                                 continue;
 176                         }
 177
 178                         if (g_str_equal(data->domain, domain) == TRUE)
 179                                 return data;
 180                 }
 181         }
 182
 183         return NULL;
 184 }
 185
 186
 187 static void send_response(int sk, unsigned char *buf, int len,
 188                                 const struct sockaddr *to, socklen_t tolen,
 189                                 int protocol)
 190 {
 191         struct domain_hdr *hdr;
 192         int err, offset = protocol_offset(protocol);
 193
 194         DBG("");
 195
 196         if (offset < 0)
 197                 return;
 198
 199         if (len < 12)
 200                 return;
 201
 202         hdr = (void*) (buf + offset);
 203
 204         DBG("id 0x%04x qr %d opcode %d", hdr->id, hdr->qr, hdr->opcode);
 205
 206         hdr->qr = 1;
 207         hdr->rcode = 2;
 208
 209         hdr->ancount = 0;
 210         hdr->nscount = 0;
 211         hdr->arcount = 0;
 212
 213         err = sendto(sk, buf, len, 0, to, tolen);
 214 }
 215
 216 static gboolean request_timeout(gpointer user_data)
 217 {
 218         struct request_data *req = user_data;
 219
 220         DBG("id 0x%04x", req->srcid);
 221
 222         if (req == NULL)
 223                 return FALSE;
 224
 225         request_list = g_slist_remove(request_list, req);
 226         req->numserv--;
 227
 228         if (req->resplen > 0 && req->resp != NULL) {
 229                 int sk, err;
 230
 231                 sk = g_io_channel_unix_get_fd(udp_listener_channel);
 232
 233                 err = sendto(sk, req->resp, req->resplen, 0,
 234                                 (struct sockaddr *) &req->sin, req->len);
 235         } else if (req->request && req->numserv == 0) {
 236                 struct domain_hdr *hdr;
 237
 238                 if (req->protocol == IPPROTO_TCP) {
 239                         hdr = (void *) (req->request + 2);
 240                         hdr->id = req->srcid;
 241                         send_response(req->client_sk, req->request,
 242                                         req->request_len, NULL, 0, IPPROTO_TCP);
 243
 244                 } else if (req->protocol == IPPROTO_UDP) {
 245                         int sk;
 246
 247                         hdr = (void *) (req->request);
 248                         hdr->id = req->srcid;
 249                         sk = g_io_channel_unix_get_fd(udp_listener_channel);
 250                         send_response(sk, req->request, req->request_len,
 251                                         (struct sockaddr *)&req->sin,
 252                                                 sizeof(req->sin), IPPROTO_UDP);
 253                 }
 254         }
 255
 256         g_free(req->resp);
 257         g_free(req);
 258
 259         return FALSE;
 260 }
 261
 262 static int append_query(unsigned char *buf, unsigned int size,
 263                                 const char *query, const char *domain)
 264 {
 265         unsigned char *ptr = buf;
 266         char *offset;
 267
 268         DBG("query %s domain %s", query, domain);
 269
 270         offset = (char *) query;
 271         while (offset != NULL) {
 272                 char *tmp;
 273
 274                 tmp = strchr(offset, '.');
 275                 if (tmp == NULL) {
 276                         if (strlen(offset) == 0)
 277                                 break;
 278                         *ptr = strlen(offset);
 279                         memcpy(ptr + 1, offset, strlen(offset));
 280                         ptr += strlen(offset) + 1;
 281                         break;
 282                 }
 283
 284                 *ptr = tmp - offset;
 285                 memcpy(ptr + 1, offset, tmp - offset);
 286                 ptr += tmp - offset + 1;
 287
 288                 offset = tmp + 1;
 289         }
 290
 291         offset = (char *) domain;
 292         while (offset != NULL) {
 293                 char *tmp;
 294
 295                 tmp = strchr(offset, '.');
 296                 if (tmp == NULL) {
 297                         if (strlen(offset) == 0)
 298                                 break;
 299                         *ptr = strlen(offset);
 300                         memcpy(ptr + 1, offset, strlen(offset));
 301                         ptr += strlen(offset) + 1;
 302                         break;
 303                 }
 304
 305                 *ptr = tmp - offset;
 306                 memcpy(ptr + 1, offset, tmp - offset);
 307                 ptr += tmp - offset + 1;
 308
 309                 offset = tmp + 1;
 310         }
 311
 312         *ptr++ = 0x00;
 313
 314         return ptr - buf;
 315 }
 316
 317 static int ns_resolv(struct server_data *server, struct request_data *req,
 318                                 gpointer request, gpointer name)
 319 {
 320         int sk, err;
 321
 322         sk = g_io_channel_unix_get_fd(server->channel);
 323
 324         err = send(sk, request, req->request_len, 0);
 325
 326         req->numserv++;
 327
 328         if (server->domain != NULL) {
 329                 unsigned char alt[1024];
 330                 struct domain_hdr *hdr = (void *) &alt;
 331                 int altlen, domlen, offset;
 332
 333                 offset = protocol_offset(server->protocol);
 334                 if (offset < 0)
 335                         return offset;
 336
 337                 domlen = strlen(server->domain) + 1;
 338                 if (domlen < 5)
 339                         return -EINVAL;
 340
 341                 alt[offset] = req->altid & 0xff;
 342                 alt[offset + 1] = req->altid >> 8;
 343
 344                 memcpy(alt + offset + 2, request + offset + 2, 10);
 345                 hdr->qdcount = htons(1);
 346
 347                 altlen = append_query(alt + offset + 12, sizeof(alt) - 12,
 348                                         name, server->domain);
 349                 if (altlen < 0)
 350                         return -EINVAL;
 351
 352                 altlen += 12;
 353
 354                 memcpy(alt + offset + altlen,
 355                         request + offset + altlen - domlen,
 356                                 req->request_len - altlen + domlen);
 357
 358                 if (server->protocol == IPPROTO_TCP) {
 359                         int req_len = req->request_len + domlen - 1;
 360
 361                         alt[0] = (req_len >> 8) & 0xff;
 362                         alt[1] = req_len & 0xff;
 363                 }
 364
 365                 err = send(sk, alt, req->request_len + domlen + 1, 0);
 366
 367                 req->numserv++;
 368         }
 369
 370         return 0;
 371 }
 372
 373 static int forward_dns_reply(unsigned char *reply, int reply_len, int protocol)
 374 {
 375         struct domain_hdr *hdr;
 376         struct request_data *req;
 377         int dns_id, sk, err, offset = protocol_offset(protocol);
 378
 379         if (offset < 0)
 380                 return offset;
 381
 382         hdr = (void *)(reply + offset);
 383         dns_id = reply[offset] | reply[offset + 1] << 8;
 384
 385         DBG("Received %d bytes (id 0x%04x)", reply_len, dns_id);
 386
 387         req = find_request(dns_id);
 388         if (req == NULL)
 389                 return -EINVAL;
 390
 391         DBG("id 0x%04x rcode %d", hdr->id, hdr->rcode);
 392
 393         reply[offset] = req->srcid & 0xff;
 394         reply[offset + 1] = req->srcid >> 8;
 395
 396         req->numresp++;
 397
 398         if (hdr->rcode == 0 || req->resp == NULL) {
 399                 g_free(req->resp);
 400                 req->resplen = 0;
 401
 402                 req->resp = g_try_malloc(reply_len);
 403                 if (req->resp == NULL)
 404                         return -ENOMEM;
 405
 406                 memcpy(req->resp, reply, reply_len);
 407                 req->resplen = reply_len;
 408         }
 409
 410         if (hdr->rcode > 0 && req->numresp < req->numserv)
 411                 return -EINVAL;
 412
 413         if (req->timeout > 0)
 414                 g_source_remove(req->timeout);
 415
 416         request_list = g_slist_remove(request_list, req);
 417
 418         if (protocol == IPPROTO_UDP) {
 419                 sk = g_io_channel_unix_get_fd(udp_listener_channel);
 420                 err = sendto(sk, req->resp, req->resplen, 0,
 421                                 (struct sockaddr *) &req->sin, req->len);
 422         } else {
 423                 sk = req->client_sk;
 424                 err = send(sk, req->resp, req->resplen, 0);
 425                 close(sk);
 426         }
 427
 428         g_free(req->resp);
 429         g_free(req);
 430
 431         return err;
 432 }
 433
 434 static void destroy_server(struct server_data *server)
 435 {
 436         DBG("interface %s server %s", server->interface, server->server);
 437
 438         server_list = g_slist_remove(server_list, server);
 439
 440         if (server->watch > 0)
 441                 g_source_remove(server->watch);
 442
 443         if (server->timeout > 0)
 444                 g_source_remove(server->timeout);
 445
 446         g_io_channel_unref(server->channel);
 447
 448         if (server->protocol == IPPROTO_UDP)
 449                 connman_info("Removing DNS server %s", server->server);
 450
 451         g_free(server->incoming_reply);
 452         g_free(server->server);
 453         g_free(server->domain);
 454         g_free(server->interface);
 455         g_free(server);
 456 }
 457
 458 static gboolean udp_server_event(GIOChannel *channel, GIOCondition condition,
 459                                                         gpointer user_data)
 460 {
 461         unsigned char buf[4096];
 462         int sk, err, len;
 463
 464         if (condition & (G_IO_NVAL | G_IO_ERR | G_IO_HUP)) {
 465                 struct server_data *data = user_data;
 466
 467                 connman_error("Error with UDP server %s", data->server);
 468                 data->watch = 0;
 469                 return FALSE;
 470         }
 471
 472         sk = g_io_channel_unix_get_fd(channel);
 473
 474         len = recv(sk, buf, sizeof(buf), 0);
 475         if (len < 12)
 476                 return TRUE;
 477
 478         err = forward_dns_reply(buf, len, IPPROTO_UDP);
 479
 480         return TRUE;
 481 }
 482
 483 static gboolean tcp_server_event(GIOChannel *channel, GIOCondition condition,
 484                                                         gpointer user_data)
 485 {
 486         int sk;
 487         struct server_data *server = user_data;
 488
 489         sk = g_io_channel_unix_get_fd(channel);
 490         if (sk == 0)
 491                 return FALSE;
 492
 493         if (condition & (G_IO_NVAL | G_IO_ERR | G_IO_HUP)) {
 494                 GSList *list;
 495         hangup:
 496                 DBG("TCP server channel closed");
 497
 498                 /*
 499                  * Discard any partial response which is buffered; better
 500                  * to get a proper response from a working server.
 501                  */
 502                 g_free(server->incoming_reply);
 503                 server->incoming_reply = NULL;
 504
 505                 for (list = request_list; list; list = list->next) {
 506                         struct request_data *req = list->data;
 507                         struct domain_hdr *hdr;
 508
 509                         if (req->protocol == IPPROTO_UDP)
 510                                 continue;
 511
 512                         if (req->request == NULL)
 513                                 continue;
 514
 515                         /*
 516                          * If we're not waiting for any further response
 517                          * from another name server, then we send an error
 518                          * response to the client.
 519                          */
 520                         if (req->numserv && --(req->numserv))
 521                                 continue;
 522
 523                         hdr = (void *) (req->request + 2);
 524                         hdr->id = req->srcid;
 525                         send_response(req->client_sk, req->request,
 526                                         req->request_len, NULL, 0, IPPROTO_TCP);
 527
 528                         request_list = g_slist_remove(request_list, req);
 529                 }
 530
 531                 destroy_server(server);
 532
 533                 return FALSE;
 534         }
 535
 536         if ((condition & G_IO_OUT) && !server->connected) {
 537                 GSList *list;
 538
 539                 server->connected = TRUE;
 540                 server_list = g_slist_append(server_list, server);
 541
 542                 if (server->timeout > 0) {
 543                         g_source_remove(server->timeout);
 544                         server->timeout = 0;
 545                 }
 546
 547                 for (list = request_list; list; list = list->next) {
 548                         struct request_data *req = list->data;
 549
 550                         if (req->protocol == IPPROTO_UDP)
 551                                 continue;
 552
 553                         DBG("Sending req %s over TCP", (char *)req->name);
 554
 555                         if (req->timeout > 0)
 556                                 g_source_remove(req->timeout);
 557
 558                         req->timeout = g_timeout_add_seconds(30,
 559                                                 request_timeout, req);
 560                         ns_resolv(server, req, req->request, req->name);
 561                 }
 562
 563         } else if (condition & G_IO_IN) {
 564                 struct partial_reply *reply = server->incoming_reply;
 565                 int bytes_recv;
 566
 567                 if (!reply) {
 568                         unsigned char reply_len_buf[2];
 569                         uint16_t reply_len;
 570
 571                         bytes_recv = recv(sk, reply_len_buf, 2, MSG_PEEK);
 572                         if (!bytes_recv) {
 573                                 goto hangup;
 574                         } else if (bytes_recv < 0) {
 575                                 if (errno == EAGAIN || errno == EWOULDBLOCK)
 576                                         return TRUE;
 577
 578                                 connman_error("DNS proxy error %s",
 579                                                 strerror(errno));
 580                                 goto hangup;
 581                         } else if (bytes_recv < 2)
 582                                 return TRUE;
 583
 584                         reply_len = reply_len_buf[1] | reply_len_buf[0] << 8;
 585                         reply_len += 2;
 586
 587                         DBG("TCP reply %d bytes", reply_len);
 588
 589                         reply = g_try_malloc(sizeof(*reply) + reply_len + 2);
 590                         if (!reply)
 591                                 return TRUE;
 592
 593                         reply->len = reply_len;
 594                         reply->received = 0;
 595
 596                         server->incoming_reply = reply;
 597                 }
 598
 599                 while (reply->received < reply->len) {
 600                         bytes_recv = recv(sk, reply->buf + reply->received,
 601                                         reply->len - reply->received, 0);
 602                         if (!bytes_recv) {
 603                                 connman_error("DNS proxy TCP disconnect");
 604                                 break;
 605                         } else if (bytes_recv < 0) {
 606                                 if (errno == EAGAIN || errno == EWOULDBLOCK)
 607                                         return TRUE;
 608
 609                                 connman_error("DNS proxy error %s",
 610                                                 strerror(errno));
 611                                 break;
 612                         }
 613                         reply->received += bytes_recv;
 614                 }
 615
 616                 forward_dns_reply(reply->buf, reply->received, IPPROTO_TCP);
 617
 618                 g_free(reply);
 619                 server->incoming_reply = NULL;
 620
 621                 destroy_server(server);
 622
 623                 return FALSE;
 624         }
 625
 626         return TRUE;
 627 }
 628
 629 static gboolean tcp_idle_timeout(gpointer user_data)
 630 {
 631         struct server_data *server = user_data;
 632
 633         DBG("");
 634
 635         if (server == NULL)
 636                 return FALSE;
 637
 638         destroy_server(server);
 639
 640         return FALSE;
 641 }
 642
 643 static struct server_data *create_server(const char *interface,
 644                                         const char *domain, const char *server,
 645                                         int protocol)
 646 {
 647         struct server_data *data;
 648         struct sockaddr_in sin;
 649         int sk, type, ret;
 650
 651         DBG("interface %s server %s", interface, server);
 652
 653         switch (protocol) {
 654         case IPPROTO_UDP:
 655                 type = SOCK_DGRAM;
 656                 break;
 657
 658         case IPPROTO_TCP:
 659                 type = SOCK_STREAM;
 660                 break;
 661
 662         default:
 663                 return NULL;
 664         }
 665
 666         sk = socket(AF_INET, type, protocol);
 667         if (sk < 0) {
 668                 connman_error("Failed to create server %s socket", server);
 669                 return NULL;
 670         }
 671
 672         if (interface != NULL) {
 673                 if (setsockopt(sk, SOL_SOCKET, SO_BINDTODEVICE,
 674                                 interface, strlen(interface) + 1) < 0) {
 675                         connman_error("Failed to bind server %s "
 676                                                 "to interface %s",
 677                                                         server, interface);
 678                         close(sk);
 679                         return NULL;
 680                 }
 681         }
 682
 683         data = g_try_new0(struct server_data, 1);
 684         if (data == NULL) {
 685                 connman_error("Failed to allocate server %s data", server);
 686                 close(sk);
 687                 return NULL;
 688         }
 689
 690         data->channel = g_io_channel_unix_new(sk);
 691         if (data->channel == NULL) {
 692                 connman_error("Failed to create server %s channel", server);
 693                 close(sk);
 694                 g_free(data);
 695                 return NULL;
 696         }
 697
 698         g_io_channel_set_close_on_unref(data->channel, TRUE);
 699
 700         if (protocol == IPPROTO_TCP) {
 701                 g_io_channel_set_flags(data->channel, G_IO_FLAG_NONBLOCK, NULL);
 702                 data->watch = g_io_add_watch(data->channel,
 703                         G_IO_OUT | G_IO_IN | G_IO_HUP | G_IO_NVAL | G_IO_ERR,
 704                                                 tcp_server_event, data);
 705                 data->timeout = g_timeout_add_seconds(30, tcp_idle_timeout,
 706                                                                 data);
 707         } else
 708                 data->watch = g_io_add_watch(data->channel,
 709                         G_IO_IN | G_IO_NVAL | G_IO_ERR | G_IO_HUP,
 710                                                 udp_server_event, data);
 711
 712         data->interface = g_strdup(interface);
 713         data->domain = g_strdup(domain);
 714         data->server = g_strdup(server);
 715         data->protocol = protocol;
 716
 717         memset(&sin, 0, sizeof(sin));
 718         sin.sin_family = AF_INET;
 719         sin.sin_port = htons(53);
 720         sin.sin_addr.s_addr = inet_addr(server);
 721
 722         ret = connect(sk, (struct sockaddr *) &sin, sizeof(sin));
 723         if (ret < 0) {
 724                 if ((protocol == IPPROTO_TCP && errno != EINPROGRESS) ||
 725                                 protocol == IPPROTO_UDP) {
 726                         connman_error("Failed to connect to server %s", server);
 727                         close(sk);
 728                         g_free(data);
 729                         return NULL;
 730                 }
 731         }
 732
 733         if (protocol == IPPROTO_UDP) {
 734                 /* Enable new servers by default */
 735                 data->enabled = TRUE;
 736                 connman_info("Adding DNS server %s", data->server);
 737
 738                 server_list = g_slist_append(server_list, data);
 739
 740                 return data;
 741         }
 742
 743         return NULL;
 744 }
 745
 746 static gboolean resolv(struct request_data *req,
 747                                 gpointer request, gpointer name)
 748 {
 749         GSList *list;
 750
 751         for (list = server_list; list; list = list->next) {
 752                 struct server_data *data = list->data;
 753
 754                 DBG("server %s domain %s enabled %d",
 755                                 data->server, data->domain, data->enabled);
 756
 757                 if (data->enabled == FALSE)
 758                         continue;
 759
 760                 if (data->watch == 0 && data->protocol == IPPROTO_UDP)
 761                         data->watch = g_io_add_watch(data->channel,
 762                                 G_IO_IN | G_IO_NVAL | G_IO_ERR | G_IO_HUP,
 763                                                 udp_server_event, data);
 764
 765                 if (ns_resolv(data, req, request, name) < 0)
 766                         continue;
 767         }
 768
 769         return TRUE;
 770 }
 771
 772 static int dnsproxy_append(const char *interface, const char *domain,
 773                                                         const char *server)
 774 {
 775         struct server_data *data;
 776
 777         DBG("interface %s server %s", interface, server);
 778
 779         if (g_str_equal(server, "127.0.0.1") == TRUE)
 780                 return -ENODEV;
 781
 782         data = create_server(interface, domain, server, IPPROTO_UDP);
 783         if (data == NULL)
 784                 return -EIO;
 785
 786         return 0;
 787 }
 788
 789 static void remove_server(const char *interface, const char *domain,
 790                         const char *server, int protocol)
 791 {
 792         struct server_data *data;
 793
 794         data = find_server(interface, domain, server, protocol);
 795         if (data == NULL)
 796                 return;
 797
 798         destroy_server(data);
 799 }
 800
 801 static int dnsproxy_remove(const char *interface, const char *domain,
 802                                                         const char *server)
 803 {
 804         DBG("interface %s server %s", interface, server);
 805
 806         if (g_str_equal(server, "127.0.0.1") == TRUE)
 807                 return -ENODEV;
 808
 809         remove_server(interface, domain, server, IPPROTO_UDP);
 810         remove_server(interface, domain, server, IPPROTO_TCP);
 811
 812         return 0;
 813 }
 814
 815 static void dnsproxy_flush(void)
 816 {
 817         GSList *list;
 818
 819         list = request_pending_list;
 820         while (list) {
 821                 struct request_data *req = list->data;
 822
 823                 list = list->next;
 824
 825                 request_pending_list =
 826                                 g_slist_remove(request_pending_list, req);
 827                 resolv(req, req->request, req->name);
 828                 g_free(req->request);
 829                 g_free(req->name);
 830         }
 831 }
 832
 833 static struct connman_resolver dnsproxy_resolver = {
 834         .name           = "dnsproxy",
 835         .priority       = CONNMAN_RESOLVER_PRIORITY_HIGH,
 836         .append         = dnsproxy_append,
 837         .remove         = dnsproxy_remove,
 838         .flush          = dnsproxy_flush,
 839 };
 840
 841 static void dnsproxy_offline_mode(connman_bool_t enabled)
 842 {
 843         GSList *list;
 844
 845         DBG("enabled %d", enabled);
 846
 847         for (list = server_list; list; list = list->next) {
 848                 struct server_data *data = list->data;
 849
 850                 if (enabled == FALSE) {
 851                         connman_info("Enabling DNS server %s", data->server);
 852                         data->enabled = TRUE;
 853                 } else {
 854                         connman_info("Disabling DNS server %s", data->server);
 855                         data->enabled = FALSE;
 856                 }
 857         }
 858 }
 859
 860 static void dnsproxy_default_changed(struct connman_service *service)
 861 {
 862         GSList *list;
 863         char *interface;
 864
 865         DBG("service %p", service);
 866
 867         if (service == NULL) {
 868                 /* When no services are active, then disable DNS proxying */
 869                 dnsproxy_offline_mode(TRUE);
 870                 return;
 871         }
 872
 873         interface = connman_service_get_interface(service);
 874         if (interface == NULL)
 875                 return;
 876
 877         for (list = server_list; list; list = list->next) {
 878                 struct server_data *data = list->data;
 879
 880                 if (g_strcmp0(data->interface, interface) == 0) {
 881                         connman_info("Enabling DNS server %s", data->server);
 882                         data->enabled = TRUE;
 883                 } else {
 884                         connman_info("Disabling DNS server %s", data->server);
 885                         data->enabled = FALSE;
 886                 }
 887         }
 888
 889         g_free(interface);
 890 }
 891
 892 static struct connman_notifier dnsproxy_notifier = {
 893         .name                   = "dnsproxy",
 894         .default_changed        = dnsproxy_default_changed,
 895         .offline_mode           = dnsproxy_offline_mode,
 896 };
 897
 898 static unsigned char opt_edns0_type[2] = { 0x00, 0x29 };
 899
 900 static int parse_request(unsigned char *buf, int len,
 901                                         char *name, unsigned int size)
 902 {
 903         struct domain_hdr *hdr = (void *) buf;
 904         uint16_t qdcount = ntohs(hdr->qdcount);
 905         uint16_t arcount = ntohs(hdr->arcount);
 906         unsigned char *ptr;
 907         char *last_label = NULL;
 908         unsigned int remain, used = 0;
 909
 910         if (len < 12)
 911                 return -EINVAL;
 912
 913         DBG("id 0x%04x qr %d opcode %d qdcount %d arcount %d",
 914                                         hdr->id, hdr->qr, hdr->opcode,
 915                                                         qdcount, arcount);
 916
 917         if (hdr->qr != 0 || qdcount != 1)
 918                 return -EINVAL;
 919
 920         memset(name, 0, size);
 921
 922         ptr = buf + sizeof(struct domain_hdr);
 923         remain = len - sizeof(struct domain_hdr);
 924
 925         while (remain > 0) {
 926                 uint8_t len = *ptr;
 927
 928                 if (len == 0x00) {
 929                         last_label = (char *) (ptr + 1);
 930                         break;
 931                 }
 932
 933                 if (used + len + 1 > size)
 934                         return -ENOBUFS;
 935
 936                 strncat(name, (char *) (ptr + 1), len);
 937                 strcat(name, ".");
 938
 939                 used += len + 1;
 940
 941                 ptr += len + 1;
 942                 remain -= len + 1;
 943         }
 944
 945         if (last_label && arcount && remain >= 9 && last_label[4] == 0 &&
 946                                 !memcmp(last_label + 5, opt_edns0_type, 2)) {
 947                 uint16_t edns0_bufsize;
 948
 949                 edns0_bufsize = last_label[7] << 8 | last_label[8];
 950
 951                 DBG("EDNS0 buffer size %u", edns0_bufsize);
 952
 953                 /* This is an evil hack until full TCP support has been
 954                  * implemented.
 955                  *
 956                  * Somtimes the EDNS0 request gets send with a too-small
 957                  * buffer size. Since glibc doesn't seem to crash when it
 958                  * gets a response biffer then it requested, just bump
 959                  * the buffer size up to 4KiB.
 960                  */
 961                 if (edns0_bufsize < 0x1000) {
 962                         last_label[7] = 0x10;
 963                         last_label[8] = 0x00;
 964                 }
 965         }
 966
 967         DBG("query %s", name);
 968
 969         return 0;
 970 }
 971
 972 static gboolean tcp_listener_event(GIOChannel *channel, GIOCondition condition,
 973                                                         gpointer user_data)
 974 {
 975         unsigned char buf[768];
 976         char query[512];
 977         struct request_data *req;
 978         struct server_data *server;
 979         int sk, client_sk, len, err;
 980         struct sockaddr client_addr;
 981         socklen_t client_addr_len;
 982         GSList *list;
 983
 984         DBG("condition 0x%x", condition);
 985
 986         if (condition & (G_IO_NVAL | G_IO_ERR | G_IO_HUP)) {
 987                 if (tcp_listener_watch > 0)
 988                         g_source_remove(tcp_listener_watch);
 989                 tcp_listener_watch = 0;
 990
 991                 connman_error("Error with TCP listener channel");
 992
 993                 return FALSE;
 994         }
 995
 996         sk = g_io_channel_unix_get_fd(channel);
 997
 998         client_addr_len = sizeof(struct sockaddr);
 999         client_sk = accept(sk, &client_addr, &client_addr_len);
1000         if (client_sk < 0) {
1001                 connman_error("Accept failure on TCP listener");
1002                 tcp_listener_watch = 0;
1003                 return FALSE;
1004         }
1005
1006         len = recv(client_sk, buf, sizeof(buf), 0);
1007         if (len < 2)
1008                 return TRUE;
1009
1010         DBG("Received %d bytes (id 0x%04x)", len, buf[2] | buf[3] << 8);
1011
1012         err = parse_request(buf + 2, len - 2, query, sizeof(query));
1013         if (err < 0 || (g_slist_length(server_list) == 0 &&
1014                                 connman_ondemand_connected())) {
1015                 send_response(client_sk, buf, len, NULL, 0, IPPROTO_TCP);
1016                 return TRUE;
1017         }
1018
1019         req = g_try_new0(struct request_data, 1);
1020         if (req == NULL)
1021                 return TRUE;
1022
1023         memcpy(&req->sin, (struct sockaddr_in *)&client_addr, sizeof(req->sin));
1024         req->client_sk = client_sk;
1025         req->protocol = IPPROTO_TCP;
1026         req->len = client_addr_len;
1027
1028         request_id += 2;
1029         if (request_id == 0x0000 || request_id == 0xffff)
1030                 request_id += 2;
1031
1032         req->srcid = buf[2] | (buf[3] << 8);
1033         req->dstid = request_id;
1034         req->altid = request_id + 1;
1035         req->request_len = len;
1036
1037         buf[2] = req->dstid & 0xff;
1038         buf[3] = req->dstid >> 8;
1039
1040         req->numserv = 0;
1041         request_list = g_slist_append(request_list, req);
1042
1043         for (list = server_list; list; list = list->next) {
1044                 struct server_data *data = list->data;
1045
1046                 if (data->protocol != IPPROTO_UDP || data->enabled == FALSE)
1047                         continue;
1048
1049                 server = create_server(data->interface, data->domain,
1050                                         data->server, IPPROTO_TCP);
1051
1052                 /*
1053                  * If server is NULL, we're not connected yet.
1054                  * Copy the relevant buffers and continue with
1055                  * the next nameserver.
1056                  * The request will actually be sent once we're
1057                  * properly connected over TCP to this nameserver.
1058                  */
1059                 if (server == NULL) {
1060                         req->request = g_try_malloc0(req->request_len);
1061                         if (req->request == NULL)
1062                                 return TRUE;
1063
1064                         memcpy(req->request, buf, req->request_len);
1065
1066                         req->name = g_try_malloc0(sizeof(query));
1067                         if (req->name == NULL) {
1068                                 g_free(req->request);
1069                                 return TRUE;
1070                         }
1071                         memcpy(req->name, query, sizeof(query));
1072
1073                         continue;
1074                 }
1075
1076                 if (req->timeout > 0)
1077                         g_source_remove(req->timeout);
1078
1079                 req->timeout = g_timeout_add_seconds(30, request_timeout, req);
1080                 ns_resolv(server, req, buf, query);
1081         }
1082
1083         return TRUE;
1084 }
1085
1086 static gboolean udp_listener_event(GIOChannel *channel, GIOCondition condition,
1087                                                         gpointer user_data)
1088 {
1089         unsigned char buf[768];
1090         char query[512];
1091         struct request_data *req;
1092         struct sockaddr_in sin;
1093         socklen_t size = sizeof(sin);
1094         int sk, err, len;
1095
1096         if (condition & (G_IO_NVAL | G_IO_ERR | G_IO_HUP)) {
1097                 connman_error("Error with UDP listener channel");
1098                 udp_listener_watch = 0;
1099                 return FALSE;
1100         }
1101
1102         sk = g_io_channel_unix_get_fd(channel);
1103
1104         memset(&sin, 0, sizeof(sin));
1105         len = recvfrom(sk, buf, sizeof(buf), 0,
1106                                         (struct sockaddr *) &sin, &size);
1107         if (len < 2)
1108                 return TRUE;
1109
1110         DBG("Received %d bytes (id 0x%04x)", len, buf[0] | buf[1] << 8);
1111
1112         err = parse_request(buf, len, query, sizeof(query));
1113         if (err < 0 || (g_slist_length(server_list) == 0 &&
1114                                 connman_ondemand_connected())) {
1115                 send_response(sk, buf, len, (struct sockaddr *) &sin, size,
1116                                 IPPROTO_UDP);
1117                 return TRUE;
1118         }
1119
1120         req = g_try_new0(struct request_data, 1);
1121         if (req == NULL)
1122                 return TRUE;
1123
1124         memcpy(&req->sin, &sin, sizeof(sin));
1125         req->client_sk = 0;
1126         req->protocol = IPPROTO_UDP;
1127         req->len = size;
1128
1129         request_id += 2;
1130         if (request_id == 0x0000 || request_id == 0xffff)
1131                 request_id += 2;
1132
1133         req->srcid = buf[0] | (buf[1] << 8);
1134         req->dstid = request_id;
1135         req->altid = request_id + 1;
1136         req->request_len = len;
1137
1138         buf[0] = req->dstid & 0xff;
1139         buf[1] = req->dstid >> 8;
1140
1141         if (!connman_ondemand_connected()) {
1142                 DBG("Starting on demand connection");
1143                 /*
1144                  * We're not connected, let's queue the request and start
1145                  * an on-demand connection.
1146                  */
1147                 req->request = g_try_malloc0(req->request_len);
1148                 if (req->request == NULL)
1149                         return TRUE;
1150
1151                 memcpy(req->request, buf, req->request_len);
1152
1153                 req->name = g_try_malloc0(sizeof(query));
1154                 if (req->name == NULL) {
1155                         g_free(req->request);
1156                         return TRUE;
1157                 }
1158                 memcpy(req->name, query, sizeof(query));
1159
1160                 request_pending_list = g_slist_append(request_pending_list,
1161                                                                         req);
1162
1163                 connman_ondemand_start("", 300);
1164
1165                 return TRUE;
1166         }
1167
1168
1169         req->numserv = 0;
1170         req->timeout = g_timeout_add_seconds(5, request_timeout, req);
1171         request_list = g_slist_append(request_list, req);
1172
1173         return resolv(req, buf, query);
1174 }
1175
1176 static int create_dns_listener(int protocol)
1177 {
1178         GIOChannel *channel;
1179         const char *ifname = "lo", *proto;
1180         struct sockaddr_in sin;
1181         int sk, type;
1182
1183         DBG("");
1184
1185         switch (protocol) {
1186         case IPPROTO_UDP:
1187                 proto = "UDP";
1188                 type = SOCK_DGRAM;
1189                 break;
1190
1191         case IPPROTO_TCP:
1192                 proto = "TCP";
1193                 type = SOCK_STREAM;
1194                 break;
1195
1196         default:
1197                 return -EINVAL;
1198         }
1199
1200         sk = socket(AF_INET, type, protocol);
1201         if (sk < 0) {
1202                 connman_error("Failed to create %s listener socket", proto);
1203                 return -EIO;
1204         }
1205
1206         if (setsockopt(sk, SOL_SOCKET, SO_BINDTODEVICE,
1207                                         ifname, strlen(ifname) + 1) < 0) {
1208                 connman_error("Failed to bind %s listener interface", proto);
1209                 close(sk);
1210                 return -EIO;
1211         }
1212
1213         memset(&sin, 0, sizeof(sin));
1214         sin.sin_family = AF_INET;
1215         sin.sin_port = htons(53);
1216         sin.sin_addr.s_addr = inet_addr("127.0.0.1");
1217         sin.sin_addr.s_addr = htonl(INADDR_ANY);
1218
1219         if (bind(sk, (struct sockaddr *) &sin, sizeof(sin)) < 0) {
1220                 connman_error("Failed to bind %s listener socket", proto);
1221                 close(sk);
1222                 return -EIO;
1223         }
1224
1225         if (protocol == IPPROTO_TCP && listen(sk, 10) < 0) {
1226                 connman_error("Failed to listen on TCP socket");
1227                 close(sk);
1228                 return -EIO;
1229         }
1230
1231         channel = g_io_channel_unix_new(sk);
1232         if (channel == NULL) {
1233                 connman_error("Failed to create %s listener channel", proto);
1234                 close(sk);
1235                 return -EIO;
1236         }
1237
1238         g_io_channel_set_close_on_unref(channel, TRUE);
1239
1240         if (protocol == IPPROTO_TCP) {
1241                 tcp_listener_channel = channel;
1242                 tcp_listener_watch = g_io_add_watch(channel,
1243                                         G_IO_IN, tcp_listener_event, NULL);
1244         } else {
1245                 udp_listener_channel = channel;
1246                 udp_listener_watch = g_io_add_watch(channel,
1247                                         G_IO_IN, udp_listener_event, NULL);
1248         }
1249
1250         return 0;
1251 }
1252
1253 static void destroy_udp_listener(void)
1254 {
1255         DBG("");
1256
1257         if (udp_listener_watch > 0)
1258                 g_source_remove(udp_listener_watch);
1259
1260         g_io_channel_unref(udp_listener_channel);
1261 }
1262
1263 static void destroy_tcp_listener(void)
1264 {
1265         DBG("");
1266
1267         if (tcp_listener_watch > 0)
1268                 g_source_remove(tcp_listener_watch);
1269
1270         g_io_channel_unref(tcp_listener_channel);
1271 }
1272
1273 static int create_listener(void)
1274 {
1275         int err;
1276
1277         err = create_dns_listener(IPPROTO_UDP);
1278         if (err < 0)
1279                 return err;
1280
1281         err = create_dns_listener(IPPROTO_TCP);
1282         if (err < 0) {
1283                 destroy_udp_listener();
1284                 return err;
1285         }
1286
1287         connman_resolver_append("lo", NULL, "127.0.0.1");
1288
1289         return 0;
1290 }
1291
1292 static void destroy_listener(void)
1293 {
1294         GSList *list;
1295
1296         connman_resolver_remove_all("lo");
1297
1298         for (list = request_pending_list; list; list = list->next) {
1299                 struct request_data *req = list->data;
1300
1301                 DBG("Dropping pending request (id 0x%04x -> 0x%04x)",
1302                                                 req->srcid, req->dstid);
1303
1304                 g_free(req->resp);
1305                 g_free(req->request);
1306                 g_free(req->name);
1307                 g_free(req);
1308                 list->data = NULL;
1309         }
1310
1311         g_slist_free(request_pending_list);
1312         request_pending_list = NULL;
1313
1314         for (list = request_list; list; list = list->next) {
1315                 struct request_data *req = list->data;
1316
1317                 DBG("Dropping request (id 0x%04x -> 0x%04x)",
1318                                                 req->srcid, req->dstid);
1319
1320                 g_free(req->resp);
1321                 g_free(req->request);
1322                 g_free(req->name);
1323                 g_free(req);
1324                 list->data = NULL;
1325         }
1326
1327         g_slist_free(request_list);
1328         request_list = NULL;
1329
1330         destroy_tcp_listener();
1331         destroy_udp_listener();
1332 }
1333
1334 static int dnsproxy_init(void)
1335 {
1336         int err;
1337
1338         err = create_listener();
1339         if (err < 0)
1340                 return err;
1341
1342         err = connman_resolver_register(&dnsproxy_resolver);
1343         if (err < 0)
1344                 goto destroy;
1345
1346         err = connman_notifier_register(&dnsproxy_notifier);
1347         if (err < 0)
1348                 goto unregister;
1349
1350         return 0;
1351
1352 unregister:
1353         connman_resolver_unregister(&dnsproxy_resolver);
1354
1355 destroy:
1356         destroy_listener();
1357
1358         return err;
1359 }
1360
1361 static void dnsproxy_exit(void)
1362 {
1363         connman_notifier_unregister(&dnsproxy_notifier);
1364
1365         connman_resolver_unregister(&dnsproxy_resolver);
1366
1367         destroy_listener();
1368 }
1369
1370 CONNMAN_PLUGIN_DEFINE(dnsproxy, "DNS proxy resolver plugin", VERSION,
1371                  CONNMAN_PLUGIN_PRIORITY_DEFAULT, dnsproxy_init, dnsproxy_exit)