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 uint16_t *swap = (uint16_t *) h; 241 int endianess = 6; 242 243 if (*len < sizeof(struct dns_header)) 244 return NULL; 245 246 while (endianess--) { 247 *swap = be16_to_cpu(*swap); 248 swap++; 249 } 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 uint16_t *swap = (uint16_t *) q; 262 int endianess = 2; 263 264 if (*len < sizeof(struct dns_question)) 265 return NULL; 266 267 while (endianess--) { 268 *swap = be16_to_cpu(*swap); 269 swap++; 270 } 271 272 *len -= sizeof(struct dns_question); 273 *data += sizeof(struct dns_question); 274 275 return q; 276 } 277 278 static struct dns_answer* 279 dns_consume_answer(uint8_t **data, int *len) 280 { 281 struct dns_answer *a = (struct dns_answer *) *data; 282 283 if (*len < sizeof(struct dns_answer)) 284 return NULL; 285 286 a->type = be16_to_cpu(a->type); 287 a->class = be16_to_cpu(a->class); 288 a->ttl = be32_to_cpu(a->ttl); 289 a->rdlength = be16_to_cpu(a->rdlength); 290 291 *len -= sizeof(struct dns_answer); 292 *data += sizeof(struct dns_answer); 293 294 return a; 295 } 296 297 static char * 298 dns_consume_name(const uint8_t *base, int blen, uint8_t **data, int *len) 299 { 300 int nlen = scan_name(*data, *len); 301 302 if (nlen < 1) 303 return NULL; 304 305 if (dn_expand(base, base + blen, *data, name_buffer, MAX_NAME_LEN) < 0) { 306 perror("dns_consume_name/dn_expand"); 307 return NULL; 308 } 309 310 *len -= nlen; 311 *data += nlen; 312 313 return name_buffer; 314 } 315 316 static int parse_answer(struct interface *iface, struct sockaddr *from, 317 uint8_t *buffer, int len, uint8_t **b, int *rlen, 318 int cache) 319 { 320 char *name = dns_consume_name(buffer, len, b, rlen); 321 struct dns_answer *a; 322 uint8_t *rdata; 323 324 if (!name) { 325 fprintf(stderr, "dropping: bad question\n"); 326 return -1; 327 } 328 329 a = dns_consume_answer(b, rlen); 330 if (!a) { 331 fprintf(stderr, "dropping: bad question\n"); 332 return -1; 333 } 334 335 if ((a->class & ~CLASS_FLUSH) != CLASS_IN) 336 return -1; 337 338 rdata = *b; 339 if (a->rdlength > *rlen) { 340 fprintf(stderr, "dropping: bad question\n"); 341 return -1; 342 } 343 344 *rlen -= a->rdlength; 345 *b += a->rdlength; 346 347 if (cache) 348 cache_answer(iface, from, buffer, len, name, a, rdata, a->class & CLASS_FLUSH); 349 350 return 0; 351 } 352 353 static void 354 parse_question(struct interface *iface, struct sockaddr *from, char *name, struct dns_question *q) 355 { 356 struct sockaddr *to = NULL; 357 char *host; 358 359 /* TODO: Multicast if more than one quarter of TTL has passed */ 360 if (q->class & CLASS_UNICAST) { 361 to = from; 362 if (iface->multicast) 363 iface = iface->peer; 364 } 365 366 DBG(1, "Q -> %s %s\n", dns_type_string(q->type), name); 367 368 switch (q->type) { 369 case TYPE_ANY: 370 if (!strcmp(name, mdns_hostname_local)) { 371 dns_reply_a(iface, to, announce_ttl); 372 service_reply(iface, to, NULL, NULL, announce_ttl); 373 } 374 break; 375 376 case TYPE_PTR: 377 if (!strcmp(name, C_DNS_SD)) { 378 dns_reply_a(iface, to, announce_ttl); 379 service_announce_services(iface, to, announce_ttl); 380 } else { 381 if (name[0] == '_') { 382 service_reply(iface, to, NULL, name, announce_ttl); 383 } else { 384 /* First dot separates instance name from the rest */ 385 char *dot = strchr(name, '.'); 386 387 if (dot) { 388 *dot = '\0'; 389 service_reply(iface, to, name, dot + 1, announce_ttl); 390 *dot = '.'; 391 } 392 } 393 } 394 break; 395 396 case TYPE_AAAA: 397 case TYPE_A: 398 host = strstr(name, ".local"); 399 if (host) 400 *host = '\0'; 401 if (!strcmp(umdns_host_label, name)) 402 dns_reply_a(iface, to, announce_ttl); 403 break; 404 }; 405 } 406 407 void 408 dns_handle_packet(struct interface *iface, struct sockaddr *from, uint16_t port, uint8_t *buffer, int len) 409 { 410 struct dns_header *h; 411 uint8_t *b = buffer; 412 int rlen = len; 413 414 h = dns_consume_header(&b, &rlen); 415 if (!h) { 416 fprintf(stderr, "dropping: bad header\n"); 417 return; 418 } 419 420 if (h->questions && !iface->multicast && port != MCAST_PORT) 421 /* silently drop unicast questions that dont originate from port 5353 */ 422 return; 423 424 while (h->questions-- > 0) { 425 char *name = dns_consume_name(buffer, len, &b, &rlen); 426 struct dns_question *q; 427 428 if (!name) { 429 fprintf(stderr, "dropping: bad name\n"); 430 return; 431 } 432 433 q = dns_consume_question(&b, &rlen); 434 if (!q) { 435 fprintf(stderr, "dropping: bad question\n"); 436 return; 437 } 438 439 if (!(h->flags & FLAG_RESPONSE)) 440 parse_question(iface, from, name, q); 441 } 442 443 if (!(h->flags & FLAG_RESPONSE)) 444 return; 445 446 while (h->answers-- > 0) 447 if (parse_answer(iface, from, buffer, len, &b, &rlen, 1)) 448 return; 449 450 while (h->authority-- > 0) 451 if (parse_answer(iface, from, buffer, len, &b, &rlen, 1)) 452 return; 453 454 while (h->additional-- > 0) 455 if (parse_answer(iface, from, buffer, len, &b, &rlen, 1)) 456 return; 457 458 } 459
This page was automatically generated by LXR 0.3.1. • OpenWrt