1 /* 2 * Copyright (C) 2014 John Crispin <blogic@openwrt.org> 3 * 4 * This program is free software; you can redistribute it and/or modify 5 * it under the terms of the GNU Lesser General Public License version 2.1 6 * as published by the Free Software Foundation 7 * 8 * This program is distributed in the hope that it will be useful, 9 * but WITHOUT ANY WARRANTY; without even the implied warranty of 10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 11 * GNU General Public License for more details. 12 */ 13 14 #include <sys/types.h> 15 #include <sys/stat.h> 16 17 #include <fcntl.h> 18 #include <ifaddrs.h> 19 #include <time.h> 20 #include <stdio.h> 21 #include <unistd.h> 22 #include <sys/types.h> 23 #include <sys/socket.h> 24 #include <netinet/in.h> 25 #include <arpa/inet.h> 26 #include <arpa/nameser.h> 27 #include <resolv.h> 28 #include <stdlib.h> 29 #include <string.h> 30 31 #include <libubox/uloop.h> 32 #include <libubox/usock.h> 33 #include <libubox/utils.h> 34 35 #include "announce.h" 36 #include "util.h" 37 #include "dns.h" 38 #include "cache.h" 39 #include "service.h" 40 #include "interface.h" 41 42 static char name_buffer[MAX_NAME_LEN + 1]; 43 static char dns_buffer[MAX_NAME_LEN]; 44 static struct blob_buf ans_buf; 45 46 const char* 47 dns_type_string(uint16_t type) 48 { 49 static const struct { 50 uint16_t type; 51 char str[5]; 52 } type_str[] = { 53 { TYPE_A, "A" }, 54 { TYPE_AAAA, "AAAA" }, 55 { TYPE_PTR, "PTR" }, 56 { TYPE_TXT, "TXT" }, 57 { TYPE_SRV, "SRV" }, 58 { TYPE_ANY, "ANY" }, 59 }; 60 int i; 61 62 for (i = 0; i < ARRAY_SIZE(type_str); i++) { 63 if (type == type_str[i].type) 64 return type_str[i].str; 65 } 66 67 return "N/A"; 68 } 69 70 void 71 dns_send_question(struct interface *iface, struct sockaddr *to, 72 const char *question, int type, int multicast) 73 { 74 static struct dns_header h; 75 static struct dns_question q; 76 static struct iovec iov[] = { 77 { 78 .iov_base = &h, 79 .iov_len = sizeof(h), 80 }, 81 { 82 .iov_base = dns_buffer, 83 }, 84 { 85 .iov_base = &q, 86 .iov_len = sizeof(q), 87 } 88 }; 89 int len; 90 91 h.questions = cpu_to_be16(1); 92 q.class = cpu_to_be16((multicast ? 0 : CLASS_UNICAST) | 1); 93 q.type = cpu_to_be16(type); 94 95 len = dn_comp(question, (void *) dns_buffer, sizeof(dns_buffer), NULL, NULL); 96 if (len < 1) 97 return; 98 99 iov[1].iov_len = len; 100 101 DBG(1, "Q <- %s %s\n", dns_type_string(type), question); 102 if (interface_send_packet(iface, to, iov, ARRAY_SIZE(iov)) < 0) 103 perror("failed to send question"); 104 } 105 106 107 struct dns_reply { 108 int type; 109 struct dns_answer a; 110 uint16_t rdlength; 111 uint8_t *rdata; 112 char *buffer; 113 }; 114 115 static int dns_answer_cnt; 116 117 void 118 dns_init_answer(void) 119 { 120 dns_answer_cnt = 0; 121 blob_buf_init(&ans_buf, 0); 122 } 123 124 void 125 dns_add_answer(int type, const uint8_t *rdata, uint16_t rdlength, int ttl) 126 { 127 struct blob_attr *attr; 128 struct dns_answer *a; 129 130 attr = blob_new(&ans_buf, 0, sizeof(*a) + rdlength); 131 a = blob_data(attr); 132 a->type = cpu_to_be16(type); 133 a->class = cpu_to_be16(1); 134 a->ttl = cpu_to_be32(ttl); 135 a->rdlength = cpu_to_be16(rdlength); 136 memcpy(a + 1, rdata, rdlength); 137 138 dns_answer_cnt++; 139 } 140 141 void 142 dns_send_answer(struct interface *iface, struct sockaddr *to, const char *answer) 143 { 144 uint8_t buffer[256]; 145 struct blob_attr *attr; 146 struct dns_header h = { 0 }; 147 struct iovec *iov; 148 int answer_len, rem; 149 int n_iov = 0; 150 151 if (!dns_answer_cnt) 152 return; 153 154 h.answers = cpu_to_be16(dns_answer_cnt); 155 h.flags = cpu_to_be16(0x8400); 156 157 iov = alloca(sizeof(struct iovec) * ((dns_answer_cnt * 2) + 1)); 158 159 iov[n_iov].iov_base = &h; 160 iov[n_iov].iov_len = sizeof(struct dns_header); 161 n_iov++; 162 163 answer_len = dn_comp(answer, buffer, sizeof(buffer), NULL, NULL); 164 if (answer_len < 1) 165 return; 166 167 blob_for_each_attr(attr, ans_buf.head, rem) { 168 struct dns_answer *a = blob_data(attr); 169 170 iov[n_iov].iov_base = buffer; 171 iov[n_iov].iov_len = answer_len; 172 n_iov++; 173 174 iov[n_iov].iov_base = blob_data(attr); 175 iov[n_iov].iov_len = blob_len(attr); 176 n_iov++; 177 178 DBG(1, "A <- %s %s\n", dns_type_string(be16_to_cpu(a->type)), answer); 179 } 180 181 if (interface_send_packet(iface, to, iov, n_iov) < 0) 182 perror("failed to send answer"); 183 } 184 185 void 186 dns_reply_a(struct interface *iface, struct sockaddr *to, int ttl) 187 { 188 struct ifaddrs *ifap, *ifa; 189 struct sockaddr_in *sa; 190 struct sockaddr_in6 *sa6; 191 192 getifaddrs(&ifap); 193 194 dns_init_answer(); 195 for (ifa = ifap; ifa; ifa = ifa->ifa_next) { 196 if (strcmp(ifa->ifa_name, iface->name)) 197 continue; 198 if (ifa->ifa_addr->sa_family == AF_INET) { 199 sa = (struct sockaddr_in *) ifa->ifa_addr; 200 dns_add_answer(TYPE_A, (uint8_t *) &sa->sin_addr, 4, ttl); 201 } 202 if (ifa->ifa_addr->sa_family == AF_INET6) { 203 uint8_t ll_prefix[] = {0xfe, 0x80 }; 204 sa6 = (struct sockaddr_in6 *) ifa->ifa_addr; 205 if (!memcmp(&sa6->sin6_addr, &ll_prefix, 2)) 206 dns_add_answer(TYPE_AAAA, (uint8_t *) &sa6->sin6_addr, 16, ttl); 207 } 208 } 209 dns_send_answer(iface, to, mdns_hostname_local); 210 211 freeifaddrs(ifap); 212 } 213 214 static int 215 scan_name(const uint8_t *buffer, int len) 216 { 217 int offset = 0; 218 219 while (len && (*buffer != '\0')) { 220 int l = *buffer; 221 222 if (IS_COMPRESSED(l)) 223 return offset + 2; 224 225 len -= l + 1; 226 offset += l + 1; 227 buffer += l + 1; 228 } 229 230 if (!len || !offset || (*buffer != '\0')) 231 return -1; 232 233 return offset + 1; 234 } 235 236 static struct dns_header* 237 dns_consume_header(uint8_t **data, int *len) 238 { 239 struct dns_header *h = (struct dns_header *) *data; 240 241 if (*len < sizeof(struct dns_header)) 242 return NULL; 243 244 h->id = be16_to_cpu(h->id); 245 h->flags = be16_to_cpu(h->flags); 246 h->questions = be16_to_cpu(h->questions); 247 h->answers = be16_to_cpu(h->answers); 248 h->authority = be16_to_cpu(h->authority); 249 h->additional = be16_to_cpu(h->additional); 250 251 *len -= sizeof(struct dns_header); 252 *data += sizeof(struct dns_header); 253 254 return h; 255 } 256 257 static struct dns_question* 258 dns_consume_question(uint8_t **data, int *len) 259 { 260 struct dns_question *q = (struct dns_question *) *data; 261 262 if (*len < sizeof(struct dns_question)) 263 return NULL; 264 265 q->type = be16_to_cpu(q->type); 266 q->class = be16_to_cpu(q->class); 267 268 *len -= sizeof(struct dns_question); 269 *data += sizeof(struct dns_question); 270 271 return q; 272 } 273 274 static struct dns_answer* 275 dns_consume_answer(uint8_t **data, int *len) 276 { 277 struct dns_answer *a = (struct dns_answer *) *data; 278 279 if (*len < sizeof(struct dns_answer)) 280 return NULL; 281 282 a->type = be16_to_cpu(a->type); 283 a->class = be16_to_cpu(a->class); 284 a->ttl = be32_to_cpu(a->ttl); 285 a->rdlength = be16_to_cpu(a->rdlength); 286 287 *len -= sizeof(struct dns_answer); 288 *data += sizeof(struct dns_answer); 289 290 return a; 291 } 292 293 static char * 294 dns_consume_name(const uint8_t *base, int blen, uint8_t **data, int *len) 295 { 296 int nlen = scan_name(*data, *len); 297 298 if (nlen < 1) 299 return NULL; 300 301 if (dn_expand(base, base + blen, *data, name_buffer, MAX_NAME_LEN) < 0) { 302 perror("dns_consume_name/dn_expand"); 303 return NULL; 304 } 305 306 *len -= nlen; 307 *data += nlen; 308 309 return name_buffer; 310 } 311 312 static int parse_answer(struct interface *iface, struct sockaddr *from, 313 uint8_t *buffer, int len, uint8_t **b, int *rlen, 314 int cache) 315 { 316 char *name = dns_consume_name(buffer, len, b, rlen); 317 struct dns_answer *a; 318 uint8_t *rdata; 319 320 if (!name) { 321 fprintf(stderr, "dropping: bad question\n"); 322 return -1; 323 } 324 325 a = dns_consume_answer(b, rlen); 326 if (!a) { 327 fprintf(stderr, "dropping: bad question\n"); 328 return -1; 329 } 330 331 if ((a->class & ~CLASS_FLUSH) != CLASS_IN) 332 return -1; 333 334 rdata = *b; 335 if (a->rdlength > *rlen) { 336 fprintf(stderr, "dropping: bad question\n"); 337 return -1; 338 } 339 340 *rlen -= a->rdlength; 341 *b += a->rdlength; 342 343 if (cache) 344 cache_answer(iface, from, buffer, len, name, a, rdata, a->class & CLASS_FLUSH); 345 346 return 0; 347 } 348 349 static void 350 parse_question(struct interface *iface, struct sockaddr *from, char *name, struct dns_question *q) 351 { 352 struct sockaddr *to = NULL; 353 char *host; 354 355 /* TODO: Multicast if more than one quarter of TTL has passed */ 356 if (q->class & CLASS_UNICAST) { 357 to = from; 358 if (iface->multicast) 359 iface = iface->peer; 360 } 361 362 DBG(1, "Q -> %s %s\n", dns_type_string(q->type), name); 363 364 switch (q->type) { 365 case TYPE_ANY: 366 if (!strcmp(name, mdns_hostname_local)) { 367 dns_reply_a(iface, to, announce_ttl); 368 service_reply(iface, to, NULL, NULL, announce_ttl); 369 } 370 break; 371 372 case TYPE_PTR: 373 if (!strcmp(name, C_DNS_SD)) { 374 dns_reply_a(iface, to, announce_ttl); 375 service_announce_services(iface, to, announce_ttl); 376 } else { 377 if (name[0] == '_') { 378 service_reply(iface, to, NULL, name, announce_ttl); 379 } else { 380 /* First dot separates instance name from the rest */ 381 char *dot = strchr(name, '.'); 382 383 if (dot) { 384 *dot = '\0'; 385 service_reply(iface, to, name, dot + 1, announce_ttl); 386 *dot = '.'; 387 } 388 } 389 } 390 break; 391 392 case TYPE_AAAA: 393 case TYPE_A: 394 host = strstr(name, ".local"); 395 if (host) 396 *host = '\0'; 397 if (!strcmp(umdns_host_label, name)) 398 dns_reply_a(iface, to, announce_ttl); 399 break; 400 }; 401 } 402 403 void 404 dns_handle_packet(struct interface *iface, struct sockaddr *from, uint16_t port, uint8_t *buffer, int len) 405 { 406 struct dns_header *h; 407 uint8_t *b = buffer; 408 int rlen = len; 409 410 h = dns_consume_header(&b, &rlen); 411 if (!h) { 412 fprintf(stderr, "dropping: bad header\n"); 413 return; 414 } 415 416 if (h->questions && !iface->multicast && port != MCAST_PORT) 417 /* silently drop unicast questions that dont originate from port 5353 */ 418 return; 419 420 while (h->questions-- > 0) { 421 char *name = dns_consume_name(buffer, len, &b, &rlen); 422 struct dns_question *q; 423 424 if (!name) { 425 fprintf(stderr, "dropping: bad name\n"); 426 return; 427 } 428 429 q = dns_consume_question(&b, &rlen); 430 if (!q) { 431 fprintf(stderr, "dropping: bad question\n"); 432 return; 433 } 434 435 if (!(h->flags & FLAG_RESPONSE)) 436 parse_question(iface, from, name, q); 437 } 438 439 if (!(h->flags & FLAG_RESPONSE)) 440 return; 441 442 while (h->answers-- > 0) 443 if (parse_answer(iface, from, buffer, len, &b, &rlen, 1)) 444 return; 445 446 while (h->authority-- > 0) 447 if (parse_answer(iface, from, buffer, len, &b, &rlen, 1)) 448 return; 449 450 while (h->additional-- > 0) 451 if (parse_answer(iface, from, buffer, len, &b, &rlen, 1)) 452 return; 453 454 } 455
This page was automatically generated by LXR 0.3.1. • OpenWrt