5 * Copyright (C) 2007-2010 Intel Corporation. All rights reserved.
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.
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.
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
30 #include <arpa/inet.h>
31 #include <netinet/in.h>
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>
41 #if __BYTE_ORDER == __LITTLE_ENDIAN
56 } __attribute__ ((packed));
57 #elif __BYTE_ORDER == __BIG_ENDIAN
72 } __attribute__ ((packed));
74 #error "Unknown byte order"
87 struct sockaddr_in sin;
99 static GSList *server_list = NULL;
100 static GSList *request_list = NULL;
101 static guint16 request_id = 0x0000;
103 static GIOChannel *listener_channel = NULL;
104 static guint listener_watch = 0;
106 static struct request_data *find_request(guint16 id)
110 for (list = request_list; list; list = list->next) {
111 struct request_data *req = list->data;
113 if (req->dstid == id || req->altid == id)
120 static struct server_data *find_server(const char *interface,
121 const char *domain, const char *server)
125 DBG("interface %s server %s", interface, server);
127 for (list = server_list; list; list = list->next) {
128 struct server_data *data = list->data;
130 if (data->interface == NULL || data->server == NULL)
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)
141 if (g_str_equal(data->domain, domain) == TRUE)
149 static gboolean server_event(GIOChannel *channel, GIOCondition condition,
152 struct server_data *data = user_data;
153 struct request_data *req;
154 unsigned char buf[4096];
155 struct domain_hdr *hdr = (void *) &buf;
158 if (condition & (G_IO_NVAL | G_IO_ERR | G_IO_HUP)) {
159 connman_error("Error with server channel");
164 sk = g_io_channel_unix_get_fd(channel);
166 len = recv(sk, buf, sizeof(buf), 0);
170 DBG("Received %d bytes (id 0x%04x)", len, buf[0] | buf[1] << 8);
172 req = find_request(buf[0] | buf[1] << 8);
176 DBG("id 0x%04x rcode %d", hdr->id, hdr->rcode);
178 buf[0] = req->srcid & 0xff;
179 buf[1] = req->srcid >> 8;
183 if (hdr->rcode == 0 || req->resp == NULL) {
187 req->resp = g_try_malloc(len);
188 if (req->resp == NULL)
191 memcpy(req->resp, buf, len);
195 if (hdr->rcode > 0 && req->numresp < req->numserv)
198 if (req->timeout > 0)
199 g_source_remove(req->timeout);
201 request_list = g_slist_remove(request_list, req);
203 sk = g_io_channel_unix_get_fd(listener_channel);
205 err = sendto(sk, req->resp, req->resplen, 0,
206 (struct sockaddr *) &req->sin, req->len);
214 static struct server_data *create_server(const char *interface,
215 const char *domain, const char *server)
217 struct server_data *data;
218 struct sockaddr_in sin;
221 DBG("interface %s server %s", interface, server);
223 sk = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
225 connman_error("Failed to create server %s socket", server);
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 "
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);
245 if (connect(sk, (struct sockaddr *) &sin, sizeof(sin)) < 0) {
246 connman_error("Failed to connect server %s", server);
251 data = g_try_new0(struct server_data, 1);
253 connman_error("Failed to allocate server %s data", server);
258 data->channel = g_io_channel_unix_new(sk);
259 if (data->channel == NULL) {
260 connman_error("Failed to create server %s channel", server);
266 g_io_channel_set_close_on_unref(data->channel, TRUE);
268 data->watch = g_io_add_watch(data->channel, G_IO_IN,
271 data->interface = g_strdup(interface);
272 data->domain = g_strdup(domain);
273 data->server = g_strdup(server);
275 /* Enable new servers by default */
276 data->enabled = TRUE;
278 connman_info("Adding DNS server %s", data->server);
283 static void destroy_server(struct server_data *data)
285 DBG("interface %s server %s", data->interface, data->server);
288 g_source_remove(data->watch);
290 g_io_channel_unref(data->channel);
292 connman_info("Removing DNS server %s", data->server);
294 g_free(data->server);
295 g_free(data->domain);
296 g_free(data->interface);
300 static int dnsproxy_append(const char *interface, const char *domain,
303 struct server_data *data;
305 DBG("interface %s server %s", interface, server);
307 if (g_str_equal(server, "127.0.0.1") == TRUE)
310 data = create_server(interface, domain, server);
314 server_list = g_slist_append(server_list, data);
319 static int dnsproxy_remove(const char *interface, const char *domain,
322 struct server_data *data;
324 DBG("interface %s server %s", interface, server);
326 if (g_str_equal(server, "127.0.0.1") == TRUE)
329 data = find_server(interface, domain, server);
333 server_list = g_slist_remove(server_list, data);
335 destroy_server(data);
340 static struct connman_resolver dnsproxy_resolver = {
342 .priority = CONNMAN_RESOLVER_PRIORITY_HIGH,
343 .append = dnsproxy_append,
344 .remove = dnsproxy_remove,
347 static void dnsproxy_offline_mode(connman_bool_t enabled)
351 DBG("enabled %d", enabled);
353 for (list = server_list; list; list = list->next) {
354 struct server_data *data = list->data;
356 if (enabled == FALSE) {
357 connman_info("Enabling DNS server %s", data->server);
358 data->enabled = TRUE;
360 connman_info("Disabling DNS server %s", data->server);
361 data->enabled = FALSE;
366 static void dnsproxy_default_changed(struct connman_service *service)
371 DBG("service %p", service);
373 if (service == NULL) {
374 /* When no services are active, then disable DNS proxying */
375 dnsproxy_offline_mode(TRUE);
379 interface = connman_service_get_interface(service);
380 if (interface == NULL)
383 for (list = server_list; list; list = list->next) {
384 struct server_data *data = list->data;
386 if (g_strcmp0(data->interface, interface) == 0) {
387 connman_info("Enabling DNS server %s", data->server);
388 data->enabled = TRUE;
390 connman_info("Disabling DNS server %s", data->server);
391 data->enabled = FALSE;
398 static struct connman_notifier dnsproxy_notifier = {
400 .default_changed = dnsproxy_default_changed,
401 .offline_mode = dnsproxy_offline_mode,
404 static unsigned char opt_edns0_type[2] = { 0x00, 0x29 };
406 static int parse_request(unsigned char *buf, int len,
407 char *name, unsigned int size)
409 struct domain_hdr *hdr = (void *) buf;
410 uint16_t qdcount = ntohs(hdr->qdcount);
411 uint16_t arcount = ntohs(hdr->arcount);
413 char *last_label = NULL;
414 unsigned int remain, used = 0;
419 DBG("id 0x%04x qr %d opcode %d qdcount %d arcount %d",
420 hdr->id, hdr->qr, hdr->opcode,
423 if (hdr->qr != 0 || qdcount != 1)
426 memset(name, 0, size);
428 ptr = buf + sizeof(struct domain_hdr);
429 remain = len - sizeof(struct domain_hdr);
435 last_label = (char *) (ptr + 1);
439 if (used + len + 1 > size)
442 strncat(name, (char *) (ptr + 1), len);
451 if (last_label && arcount && remain >= 9 && last_label[4] == 0 &&
452 !memcmp(last_label + 5, opt_edns0_type, 2)) {
453 uint16_t edns0_bufsize;
455 edns0_bufsize = last_label[7] << 8 | last_label[8];
457 DBG("EDNS0 buffer size %u", edns0_bufsize);
459 /* This is an evil hack until full TCP support has been
462 * Somtimes the EDNS0 request gets send with a too-small
463 * buffer size. Since glibc doesn't seem to crash when it
464 * gets a response biffer then it requested, just bump
465 * the buffer size up to 4KiB.
467 if (edns0_bufsize < 0x1000) {
468 last_label[7] = 0x10;
469 last_label[8] = 0x00;
473 DBG("query %s", name);
478 static void send_response(int sk, unsigned char *buf, int len,
479 const struct sockaddr *to, socklen_t tolen)
481 struct domain_hdr *hdr = (void *) buf;
487 DBG("id 0x%04x qr %d opcode %d", hdr->id, hdr->qr, hdr->opcode);
496 err = sendto(sk, buf, len, 0, to, tolen);
499 static int append_query(unsigned char *buf, unsigned int size,
500 const char *query, const char *domain)
502 unsigned char *ptr = buf;
505 DBG("query %s domain %s", query, domain);
507 offset = (char *) query;
508 while (offset != NULL) {
511 tmp = strchr(offset, '.');
513 if (strlen(offset) == 0)
515 *ptr = strlen(offset);
516 memcpy(ptr + 1, offset, strlen(offset));
517 ptr += strlen(offset) + 1;
522 memcpy(ptr + 1, offset, tmp - offset);
523 ptr += tmp - offset + 1;
528 offset = (char *) domain;
529 while (offset != NULL) {
532 tmp = strchr(offset, '.');
534 if (strlen(offset) == 0)
536 *ptr = strlen(offset);
537 memcpy(ptr + 1, offset, strlen(offset));
538 ptr += strlen(offset) + 1;
543 memcpy(ptr + 1, offset, tmp - offset);
544 ptr += tmp - offset + 1;
554 static gboolean request_timeout(gpointer user_data)
556 struct request_data *req = user_data;
558 DBG("id 0x%04x", req->srcid);
560 request_list = g_slist_remove(request_list, req);
562 if (req->resplen > 0 && req->resp != NULL) {
565 sk = g_io_channel_unix_get_fd(listener_channel);
567 err = sendto(sk, req->resp, req->resplen, 0,
568 (struct sockaddr *) &req->sin, req->len);
577 static gboolean listener_event(GIOChannel *channel, GIOCondition condition,
581 unsigned char buf[768];
583 struct request_data *req;
584 struct sockaddr_in sin;
585 socklen_t size = sizeof(sin);
588 if (condition & (G_IO_NVAL | G_IO_ERR | G_IO_HUP)) {
589 connman_error("Error with listener channel");
594 sk = g_io_channel_unix_get_fd(channel);
596 memset(&sin, 0, sizeof(sin));
597 len = recvfrom(sk, buf, sizeof(buf), 0,
598 (struct sockaddr *) &sin, &size);
602 DBG("Received %d bytes (id 0x%04x)", len, buf[0] | buf[1] << 8);
604 err = parse_request(buf, len, query, sizeof(query));
605 if (err < 0 || g_slist_length(server_list) == 0) {
606 send_response(sk, buf, len, (struct sockaddr *) &sin, size);
610 req = g_try_new0(struct request_data, 1);
614 memcpy(&req->sin, &sin, sizeof(sin));
618 if (request_id == 0x0000 || request_id == 0xffff)
621 req->srcid = buf[0] | (buf[1] << 8);
622 req->dstid = request_id;
623 req->altid = request_id + 1;
625 buf[0] = req->dstid & 0xff;
626 buf[1] = req->dstid >> 8;
628 request_list = g_slist_append(request_list, req);
631 req->timeout = g_timeout_add_seconds(5, request_timeout, req);
633 for (list = server_list; list; list = list->next) {
634 struct server_data *data = list->data;
636 DBG("server %s domain %s enabled %d",
637 data->server, data->domain, data->enabled);
639 if (data->enabled == FALSE)
642 sk = g_io_channel_unix_get_fd(data->channel);
644 err = send(sk, buf, len, 0);
648 if (data->domain != NULL) {
649 unsigned char alt[1024];
650 struct domain_hdr *hdr = (void *) &alt;
653 domlen = strlen(data->domain) + 1;
657 alt[0] = req->altid & 0xff;
658 alt[1] = req->altid >> 8;
660 memcpy(alt + 2, buf + 2, 10);
661 hdr->qdcount = htons(1);
663 altlen = append_query(alt + 12, sizeof(alt) - 12,
664 query, data->domain);
670 memcpy(alt + altlen, buf + altlen - domlen,
671 len - altlen + domlen);
673 err = send(sk, alt, len + domlen + 1, 0);
682 static int create_listener(void)
684 const char *ifname = "lo";
685 struct sockaddr_in sin;
690 sk = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
692 connman_error("Failed to create listener socket");
696 //setsockopt(sk, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
697 //setsockopt(sk, SOL_IP, IP_PKTINFO, &opt, sizeof(opt));
699 if (setsockopt(sk, SOL_SOCKET, SO_BINDTODEVICE,
700 ifname, strlen(ifname) + 1) < 0) {
701 connman_error("Failed to bind listener interface");
706 memset(&sin, 0, sizeof(sin));
707 sin.sin_family = AF_INET;
708 sin.sin_port = htons(53);
709 sin.sin_addr.s_addr = inet_addr("127.0.0.1");
710 //sin.sin_addr.s_addr = INADDR_ANY;
712 if (bind(sk, (struct sockaddr *) &sin, sizeof(sin)) < 0) {
713 connman_error("Failed to bind listener socket");
718 listener_channel = g_io_channel_unix_new(sk);
719 if (listener_channel == NULL) {
720 connman_error("Failed to create listener channel");
725 g_io_channel_set_close_on_unref(listener_channel, TRUE);
727 listener_watch = g_io_add_watch(listener_channel, G_IO_IN,
728 listener_event, NULL);
730 connman_resolver_append("lo", NULL, "127.0.0.1");
735 static void destroy_listener(void)
741 connman_resolver_remove_all("lo");
743 if (listener_watch > 0)
744 g_source_remove(listener_watch);
746 for (list = request_list; list; list = list->next) {
747 struct request_data *req = list->data;
749 DBG("Dropping request (id 0x%04x -> 0x%04x)",
750 req->srcid, req->dstid);
757 g_slist_free(request_list);
760 g_io_channel_unref(listener_channel);
763 static int dnsproxy_init(void)
767 err = create_listener();
771 err = connman_resolver_register(&dnsproxy_resolver);
775 err = connman_notifier_register(&dnsproxy_notifier);
782 connman_resolver_unregister(&dnsproxy_resolver);
790 static void dnsproxy_exit(void)
792 connman_notifier_unregister(&dnsproxy_notifier);
794 connman_resolver_unregister(&dnsproxy_resolver);
799 CONNMAN_PLUGIN_DEFINE(dnsproxy, "DNS proxy resolver plugin", VERSION,
800 CONNMAN_PLUGIN_PRIORITY_DEFAULT, dnsproxy_init, dnsproxy_exit)