8487
|
1 /**
|
|
2 * @file mdns.c Multicast DNS connection code used by rendezvous.
|
|
3 *
|
|
4 * gaim
|
|
5 *
|
|
6 * Gaim is the legal property of its developers, whose names are too numerous
|
|
7 * to list here. Please refer to the COPYRIGHT file distributed with this
|
|
8 * source distribution.
|
|
9 *
|
|
10 * This program is free software; you can redistribute it and/or modify
|
|
11 * it under the terms of the GNU General Public License as published by
|
|
12 * the Free Software Foundation; either version 2 of the License, or
|
|
13 * (at your option) any later version.
|
|
14 *
|
|
15 * This program is distributed in the hope that it will be useful,
|
|
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
18 * GNU General Public License for more details.
|
|
19 *
|
|
20 * You should have received a copy of the GNU General Public License
|
|
21 * along with this program; if not, write to the Free Software
|
|
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
23 *
|
|
24 */
|
|
25
|
|
26 /*
|
|
27 * If you want to understand this, read RFC1035 and
|
8612
|
28 * draft-cheshire-dnsext-multicastdns.txt, and buy
|
|
29 * me a doughnut. thx k bye.
|
8487
|
30 */
|
|
31
|
|
32 /*
|
|
33 * XXX - THIS DOESN'T DO BOUNDS CHECKING!!! DON'T USE IT ON AN UNTRUSTED
|
|
34 * NETWORK UNTIL IT DOES!!! THERE ARE POSSIBLE REMOTE ACCESS VIA BUFFER
|
|
35 * OVERFLOW SECURITY HOLES!!!
|
|
36 */
|
|
37
|
8546
|
38 #include "internal.h"
|
8487
|
39 #include "debug.h"
|
|
40
|
|
41 #include "mdns.h"
|
|
42 #include "util.h"
|
|
43
|
8612
|
44 /******************************************/
|
|
45 /* Functions for connection establishment */
|
|
46 /******************************************/
|
|
47
|
8487
|
48 int
|
|
49 mdns_establish_socket()
|
|
50 {
|
|
51 int fd = -1;
|
|
52 struct sockaddr_in addr;
|
|
53 struct ip_mreq mreq;
|
|
54 unsigned char loop;
|
|
55 unsigned char ttl;
|
|
56 int reuseaddr;
|
|
57
|
|
58 gaim_debug_info("mdns", "Establishing multicast socket\n");
|
|
59
|
|
60 /* What's the difference between AF_INET and PF_INET? */
|
|
61 if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
|
|
62 gaim_debug_error("mdns", "Unable to create socket: %s\n", strerror(errno));
|
|
63 return -1;
|
|
64 }
|
|
65
|
|
66 /* Make the socket non-blocking (although it shouldn't matter) */
|
|
67 fcntl(fd, F_SETFL, O_NONBLOCK);
|
|
68
|
|
69 /* Bind the socket to a local IP and port */
|
|
70 addr.sin_family = AF_INET;
|
|
71 addr.sin_port = htons(5353);
|
|
72 addr.sin_addr.s_addr = INADDR_ANY;
|
|
73 if (bind(fd, (struct sockaddr *)&addr, sizeof(struct sockaddr_in)) < 0) {
|
|
74 gaim_debug_error("mdns", "Unable to bind socket to interface.\n");
|
|
75 close(fd);
|
|
76 return -1;
|
|
77 }
|
|
78
|
8631
|
79 /* Ensure loopback is enabled (it should be enabled by default, but let's be sure) */
|
8487
|
80 loop = 1;
|
|
81 if (setsockopt(fd, IPPROTO_IP, IP_MULTICAST_LOOP, &loop, sizeof(unsigned char)) == -1) {
|
|
82 gaim_debug_error("mdns", "Error calling setsockopt for IP_MULTICAST_LOOP\n");
|
|
83 }
|
|
84
|
|
85 /* Set TTL to 255--required by mDNS */
|
|
86 ttl = 255;
|
|
87 if (setsockopt(fd, IPPROTO_IP, IP_MULTICAST_TTL, &ttl, sizeof(unsigned char)) == -1) {
|
|
88 gaim_debug_error("mdns", "Error calling setsockopt for IP_MULTICAST_TTL\n");
|
|
89 close(fd);
|
|
90 return -1;
|
|
91 }
|
|
92
|
|
93 /* Join the .local multicast group */
|
|
94 mreq.imr_multiaddr.s_addr = inet_addr("224.0.0.251");
|
|
95 mreq.imr_interface.s_addr = htonl(INADDR_ANY);
|
|
96 if (setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP, &mreq, sizeof(struct ip_mreq)) == -1) {
|
|
97 gaim_debug_error("mdns", "Error calling setsockopt for IP_ADD_MEMBERSHIP\n");
|
|
98 close(fd);
|
|
99 return -1;
|
|
100 }
|
|
101
|
|
102 /* Make the local IP re-usable */
|
|
103 reuseaddr = 1;
|
|
104 if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &reuseaddr, sizeof(int)) == -1) {
|
|
105 gaim_debug_error("mdns", "Error calling setsockopt for SO_REUSEADDR: %s\n", strerror(errno));
|
|
106 }
|
|
107
|
|
108 return fd;
|
|
109 }
|
|
110
|
8612
|
111 static int
|
|
112 mdns_send_raw(int fd, unsigned int datalen, unsigned char *data)
|
|
113 {
|
|
114 struct sockaddr_in addr;
|
|
115 int n;
|
|
116
|
|
117 addr.sin_family = AF_INET;
|
|
118 addr.sin_port = htons(5353);
|
|
119 addr.sin_addr.s_addr = inet_addr("224.0.0.251");
|
|
120 n = sendto(fd, data, datalen, 0, (struct sockaddr *)&addr, sizeof(struct sockaddr_in));
|
|
121
|
|
122 if (n == -1) {
|
|
123 gaim_debug_error("mdns", "Error sending packet: %d\n", errno);
|
|
124 return -1;
|
|
125 } else if (n != datalen) {
|
|
126 gaim_debug_error("mdns", "Only sent %d of %d bytes of data.\n", n, datalen);
|
|
127 return -1;
|
|
128 }
|
|
129
|
|
130 return 0;
|
|
131 }
|
|
132
|
|
133 /***************************************/
|
|
134 /* Functions for sending mDNS messages */
|
|
135 /***************************************/
|
|
136
|
|
137 static int
|
8631
|
138 mdns_getlength_name(const void *name)
|
8629
|
139 {
|
8631
|
140 return strlen((const char *)name) + 2;
|
|
141 }
|
|
142
|
|
143 static int
|
|
144 mdns_getlength_RR_rdata(unsigned short type, const void *rdata)
|
|
145 {
|
8629
|
146 int rdlength = 0;
|
|
147
|
8631
|
148 switch (type) {
|
|
149 case RENDEZVOUS_RRTYPE_PTR:
|
|
150 rdlength = mdns_getlength_name(rdata);
|
|
151 break;
|
|
152
|
|
153 case RENDEZVOUS_RRTYPE_TXT: {
|
|
154 GSList *cur;
|
|
155 ResourceRecordRDataTXTNode *node;
|
|
156
|
|
157 for (cur = (GSList *)rdata; cur != NULL; cur = cur->next) {
|
|
158 node = (ResourceRecordRDataTXTNode *)cur->data;
|
|
159 rdlength += 1 + strlen(node->name);
|
|
160 if (node->value != NULL)
|
|
161 rdlength += 1 + strlen(node->value);
|
|
162 }
|
|
163 } break;
|
|
164
|
|
165 case RENDEZVOUS_RRTYPE_SRV:
|
|
166 rdlength = 6 + mdns_getlength_name(((const ResourceRecordRDataSRV *)rdata)->target);
|
|
167 break;
|
8629
|
168 }
|
|
169
|
|
170 return rdlength;
|
|
171 }
|
|
172
|
|
173 static int
|
8631
|
174 mdns_getlength_RR(ResourceRecord *rr)
|
8612
|
175 {
|
|
176 int ret = 0;
|
|
177
|
8631
|
178 rr->rdlength = mdns_getlength_RR_rdata(rr->type, rr->rdata);
|
|
179
|
8612
|
180 ret += strlen(rr->name) + 2;
|
|
181 ret += 10;
|
8631
|
182 ret += rr->rdlength;
|
8612
|
183
|
|
184 return ret;
|
|
185 }
|
|
186
|
|
187 static int
|
|
188 mdns_put_name(char *data, int datalen, int offset, const char *name)
|
|
189 {
|
|
190 int i = 0;
|
|
191 char *b, *c;
|
|
192
|
|
193 b = (char *)name;
|
|
194 while ((c = strchr(b, '.'))) {
|
|
195 i += util_put8(&data[offset + i], c - b); /* Length of domain-name segment */
|
|
196 memcpy(&data[offset + i], b, c - b); /* Domain-name segment */
|
|
197 i += c - b; /* Increment the destination pointer */
|
|
198 b = c + 1;
|
|
199 }
|
|
200 i += util_put8(&data[offset + i], strlen(b)); /* Length of domain-name segment */
|
|
201 strcpy(&data[offset + i], b); /* Domain-name segment */
|
|
202 i += strlen(b) + 1; /* Increment the destination pointer */
|
|
203
|
|
204 return i;
|
|
205 }
|
|
206
|
|
207 static int
|
|
208 mdns_put_RR(char *data, int datalen, int offset, const ResourceRecord *rr)
|
|
209 {
|
|
210 int i = 0;
|
|
211
|
|
212 i += mdns_put_name(data, datalen, offset + i, rr->name);
|
|
213 i += util_put16(&data[offset + i], rr->type);
|
|
214 i += util_put16(&data[offset + i], rr->class);
|
|
215 i += util_put32(&data[offset + i], rr->ttl);
|
8631
|
216 i += util_put16(&data[offset + i], rr->rdlength);
|
8612
|
217
|
|
218 switch (rr->type) {
|
|
219 case RENDEZVOUS_RRTYPE_PTR:
|
|
220 i += mdns_put_name(data, datalen, offset + i, (const char *)rr->rdata);
|
|
221 break;
|
8629
|
222
|
|
223 case RENDEZVOUS_RRTYPE_TXT: {
|
|
224 GSList *cur;
|
8631
|
225 ResourceRecordRDataTXTNode *node;
|
8629
|
226 int mylength;
|
|
227
|
|
228 for (cur = (GSList *)rr->rdata; cur != NULL; cur = cur->next) {
|
8631
|
229 node = (ResourceRecordRDataTXTNode *)cur->data;
|
8629
|
230 mylength = 1 + strlen(node->name);
|
|
231 if (node->value)
|
|
232 mylength += 1 + strlen(node->value);
|
|
233 i += util_put8(&data[offset + i], mylength - 1);
|
|
234 memcpy(&data[offset + i], node->name, strlen(node->name));
|
|
235 i += strlen(node->name);
|
|
236 if (node->value) {
|
|
237 data[offset + i] = '=';
|
|
238 i++;
|
|
239 memcpy(&data[offset + i], node->value, strlen(node->value));
|
|
240 i += strlen(node->value);
|
|
241 }
|
|
242 }
|
|
243 } break;
|
8631
|
244
|
|
245 case RENDEZVOUS_RRTYPE_SRV: {
|
|
246 ResourceRecordRDataSRV *srv = rr->rdata;
|
|
247 i += util_put16(&data[offset + i], 0);
|
|
248 i += util_put16(&data[offset + i], 0);
|
|
249 i += util_put16(&data[offset + i], srv->port);
|
|
250 i += mdns_put_name(data, datalen, offset + i, srv->target);
|
|
251 } break;
|
8612
|
252 }
|
|
253
|
|
254 return i;
|
|
255 }
|
|
256
|
|
257 int
|
|
258 mdns_send_dns(int fd, const DNSPacket *dns)
|
|
259 {
|
|
260 int ret;
|
|
261 unsigned int datalen;
|
|
262 unsigned char *data;
|
|
263 int offset;
|
|
264 int i;
|
|
265
|
|
266 /* Calculate the length of the buffer we'll need to hold the DNS packet */
|
|
267 datalen = 0;
|
|
268
|
|
269 /* Header */
|
|
270 datalen += 12;
|
|
271
|
|
272 /* Questions */
|
|
273 for (i = 0; i < dns->header.numquestions; i++)
|
8631
|
274 datalen += mdns_getlength_name(dns->questions[i].name) + 4;
|
8612
|
275
|
|
276 /* Resource records */
|
|
277 for (i = 0; i < dns->header.numanswers; i++)
|
|
278 datalen += mdns_getlength_RR(&dns->answers[i]);
|
|
279 for (i = 0; i < dns->header.numauthority; i++)
|
|
280 datalen += mdns_getlength_RR(&dns->authority[i]);
|
|
281 for (i = 0; i < dns->header.numadditional; i++)
|
|
282 datalen += mdns_getlength_RR(&dns->additional[i]);
|
|
283
|
|
284 /* Allocate a buffer */
|
|
285 if (!(data = (unsigned char *)g_malloc(datalen))) {
|
|
286 return -ENOMEM;
|
|
287 }
|
|
288
|
|
289 /* Construct the datagram */
|
|
290 /* Header */
|
|
291 offset = 0;
|
|
292 offset += util_put16(&data[offset], dns->header.id); /* ID */
|
|
293 offset += util_put16(&data[offset], dns->header.flags);
|
|
294 offset += util_put16(&data[offset], dns->header.numquestions); /* QDCOUNT */
|
|
295 offset += util_put16(&data[offset], dns->header.numanswers); /* ANCOUNT */
|
|
296 offset += util_put16(&data[offset], dns->header.numauthority); /* NSCOUNT */
|
|
297 offset += util_put16(&data[offset], dns->header.numadditional); /* ARCOUNT */
|
|
298
|
|
299 /* Questions */
|
|
300 for (i = 0; i < dns->header.numquestions; i++) {
|
|
301 offset += mdns_put_name(data, datalen, offset, dns->questions[i].name); /* QNAME */
|
|
302 offset += util_put16(&data[offset], dns->questions[i].type); /* QTYPE */
|
|
303 offset += util_put16(&data[offset], dns->questions[i].class); /* QCLASS */
|
|
304 }
|
|
305
|
|
306 /* Resource records */
|
|
307 for (i = 0; i < dns->header.numanswers; i++)
|
|
308 offset += mdns_put_RR(data, datalen, offset, &dns->answers[i]);
|
|
309 for (i = 0; i < dns->header.numauthority; i++)
|
|
310 offset += mdns_put_RR(data, datalen, offset, &dns->authority[i]);
|
|
311 for (i = 0; i < dns->header.numadditional; i++)
|
|
312 offset += mdns_put_RR(data, datalen, offset, &dns->additional[i]);
|
|
313
|
|
314 /* Send the datagram */
|
|
315 ret = mdns_send_raw(fd, datalen, data);
|
|
316
|
|
317 g_free(data);
|
|
318
|
|
319 return ret;
|
|
320 }
|
|
321
|
8487
|
322 int
|
|
323 mdns_query(int fd, const char *domain)
|
|
324 {
|
8612
|
325 int ret;
|
|
326 DNSPacket *dns;
|
8487
|
327
|
|
328 if (strlen(domain) > 255) {
|
|
329 return -EINVAL;
|
|
330 }
|
|
331
|
8612
|
332 dns = (DNSPacket *)g_malloc(sizeof(DNSPacket));
|
|
333 dns->header.id = 0x0000;
|
|
334 dns->header.flags = 0x0000;
|
|
335 dns->header.numquestions = 0x0001;
|
|
336 dns->header.numanswers = 0x0000;
|
|
337 dns->header.numauthority = 0x0000;
|
|
338 dns->header.numadditional = 0x0000;
|
|
339
|
|
340 dns->questions = (Question *)g_malloc(1 * sizeof(Question));
|
|
341 dns->questions[0].name = g_strdup(domain);
|
|
342 dns->questions[0].type = RENDEZVOUS_RRTYPE_PTR;
|
|
343 dns->questions[0].class = 0x8001;
|
|
344
|
|
345 dns->answers = NULL;
|
|
346 dns->authority = NULL;
|
|
347 dns->additional = NULL;
|
|
348
|
|
349 mdns_send_dns(fd, dns);
|
|
350
|
|
351 mdns_free(dns);
|
|
352
|
|
353 return ret;
|
|
354 }
|
|
355
|
|
356 int
|
|
357 mdns_advertise_ptr(int fd, const char *name, const char *domain)
|
|
358 {
|
|
359 int ret;
|
|
360 DNSPacket *dns;
|
|
361
|
|
362 if ((strlen(name) > 255) || (strlen(domain) > 255)) {
|
|
363 return -EINVAL;
|
8487
|
364 }
|
|
365
|
8612
|
366 dns = (DNSPacket *)g_malloc(sizeof(DNSPacket));
|
|
367 dns->header.id = 0x0000;
|
|
368 dns->header.flags = 0x8400;
|
|
369 dns->header.numquestions = 0x0000;
|
|
370 dns->header.numanswers = 0x0001;
|
|
371 dns->header.numauthority = 0x0000;
|
|
372 dns->header.numadditional = 0x0000;
|
|
373 dns->questions = NULL;
|
8487
|
374
|
8612
|
375 dns->answers = (ResourceRecord *)g_malloc(1 * sizeof(ResourceRecord));
|
|
376 dns->answers[0].name = g_strdup(name);
|
|
377 dns->answers[0].type = RENDEZVOUS_RRTYPE_PTR;
|
8631
|
378 dns->answers[0].class = 0x8001;
|
8612
|
379 dns->answers[0].ttl = 0x00001c20;
|
8629
|
380 dns->answers[0].rdlength = 0x0000; /* Set automatically */
|
8612
|
381 dns->answers[0].rdata = (void *)g_strdup(domain);
|
|
382
|
|
383 dns->authority = NULL;
|
|
384 dns->additional = NULL;
|
8487
|
385
|
8612
|
386 mdns_send_dns(fd, dns);
|
|
387
|
|
388 mdns_free(dns);
|
8487
|
389
|
8612
|
390 return ret;
|
|
391 }
|
8487
|
392
|
8629
|
393 int
|
|
394 mdns_advertise_txt(int fd, const char *name, const GSList *rdata)
|
|
395 {
|
|
396 int ret;
|
|
397 DNSPacket *dns;
|
|
398
|
|
399 if ((strlen(name) > 255)) {
|
|
400 return -EINVAL;
|
|
401 }
|
|
402
|
|
403 dns = (DNSPacket *)g_malloc(sizeof(DNSPacket));
|
|
404 dns->header.id = 0x0000;
|
|
405 dns->header.flags = 0x8400;
|
|
406 dns->header.numquestions = 0x0000;
|
|
407 dns->header.numanswers = 0x0001;
|
|
408 dns->header.numauthority = 0x0000;
|
|
409 dns->header.numadditional = 0x0000;
|
|
410 dns->questions = NULL;
|
|
411
|
|
412 dns->answers = (ResourceRecord *)g_malloc(1 * sizeof(ResourceRecord));
|
|
413 dns->answers[0].name = g_strdup(name);
|
|
414 dns->answers[0].type = RENDEZVOUS_RRTYPE_TXT;
|
8631
|
415 dns->answers[0].class = 0x8001;
|
8629
|
416 dns->answers[0].ttl = 0x00001c20;
|
|
417 dns->answers[0].rdlength = 0x0000; /* Set automatically */
|
|
418 dns->answers[0].rdata = (void *)rdata;
|
|
419
|
|
420 dns->authority = NULL;
|
|
421 dns->additional = NULL;
|
|
422
|
|
423 mdns_send_dns(fd, dns);
|
|
424
|
8631
|
425 /* The rdata should be freed by the caller of this function */
|
|
426 dns->answers[0].rdata = NULL;
|
|
427
|
|
428 mdns_free(dns);
|
|
429
|
|
430 return ret;
|
|
431 }
|
|
432
|
|
433 int
|
|
434 mdns_advertise_srv(int fd, const char *name, unsigned short port, const char *target)
|
|
435 {
|
|
436 int ret;
|
|
437 DNSPacket *dns;
|
|
438 ResourceRecordRDataSRV *rdata;
|
|
439
|
|
440 if ((strlen(target) > 255)) {
|
|
441 return -EINVAL;
|
|
442 }
|
|
443
|
|
444 rdata = g_malloc(sizeof(ResourceRecordRDataSRV));
|
|
445 rdata->port = port;
|
|
446 rdata->target = target;
|
|
447
|
|
448 dns = (DNSPacket *)g_malloc(sizeof(DNSPacket));
|
|
449 dns->header.id = 0x0000;
|
|
450 dns->header.flags = 0x8400;
|
|
451 dns->header.numquestions = 0x0000;
|
|
452 dns->header.numanswers = 0x0001;
|
|
453 dns->header.numauthority = 0x0000;
|
|
454 dns->header.numadditional = 0x0000;
|
|
455 dns->questions = NULL;
|
|
456
|
|
457 dns->answers = (ResourceRecord *)g_malloc(1 * sizeof(ResourceRecord));
|
|
458 dns->answers[0].name = g_strdup(name);
|
|
459 dns->answers[0].type = RENDEZVOUS_RRTYPE_SRV;
|
|
460 dns->answers[0].class = 0x8001;
|
|
461 dns->answers[0].ttl = 0x00001c20;
|
|
462 dns->answers[0].rdlength = 0x0000; /* Set automatically */
|
|
463 dns->answers[0].rdata = rdata;
|
|
464
|
|
465 dns->authority = NULL;
|
|
466 dns->additional = NULL;
|
|
467
|
|
468 mdns_send_dns(fd, dns);
|
|
469
|
|
470 g_free(dns->answers[0].rdata);
|
8629
|
471 dns->answers[0].rdata = NULL;
|
|
472
|
|
473 mdns_free(dns);
|
|
474
|
|
475 return ret;
|
|
476 }
|
|
477
|
8612
|
478 /***************************************/
|
|
479 /* Functions for parsing mDNS messages */
|
|
480 /***************************************/
|
8487
|
481
|
|
482 /*
|
|
483 * XXX - Needs bounds checking!
|
8631
|
484 * XXX - Also make sure you don't backtrack and infinitely loop.
|
8487
|
485 *
|
|
486 * Read in a domain name from the given buffer starting at the given
|
|
487 * offset. This handles using domain name compression to jump around
|
|
488 * the data buffer, if needed.
|
|
489 *
|
|
490 * @return A null-terminated string representation of the domain name.
|
|
491 * This should be g_free'd when no longer needed.
|
|
492 */
|
|
493 static gchar *
|
|
494 mdns_read_name(const char *data, int datalen, int dataoffset)
|
|
495 {
|
|
496 GString *ret = g_string_new("");
|
|
497 unsigned char tmp;
|
|
498
|
|
499 while ((tmp = util_get8(&data[dataoffset])) != 0) {
|
|
500 dataoffset++;
|
|
501
|
|
502 if ((tmp & 0xc0) == 0) { /* First two bits are 00 */
|
|
503 if (*ret->str)
|
|
504 g_string_append_c(ret, '.');
|
|
505 g_string_append_len(ret, &data[dataoffset], tmp);
|
|
506 dataoffset += tmp;
|
|
507
|
|
508 } else if ((tmp & 0x40) == 0) { /* First two bits are 10 */
|
|
509 /* Reserved for future use */
|
|
510
|
|
511 } else if ((tmp & 0x80) == 1) { /* First two bits are 01 */
|
|
512 /* Reserved for future use */
|
|
513
|
|
514 } else { /* First two bits are 11 */
|
|
515 /* Jump to another position in the data */
|
|
516 dataoffset = util_get8(&data[dataoffset]);
|
|
517
|
|
518 }
|
|
519 }
|
|
520
|
|
521 return g_string_free(ret, FALSE);
|
|
522 }
|
|
523
|
|
524 /*
|
|
525 * XXX - Needs bounds checking!
|
|
526 *
|
|
527 * Determine how many bytes long a portion of the domain name is
|
|
528 * at the given offset. This does NOT jump around the data array
|
|
529 * in the case of domain name compression.
|
|
530 *
|
|
531 * @return The length of the portion of the domain name.
|
|
532 */
|
|
533 static int
|
|
534 mdns_read_name_len(const char *data, int datalen, int dataoffset)
|
|
535 {
|
|
536 int startoffset = dataoffset;
|
|
537 unsigned char tmp;
|
|
538
|
|
539 while ((tmp = util_get8(&data[dataoffset++])) != 0) {
|
|
540
|
|
541 if ((tmp & 0xc0) == 0) { /* First two bits are 00 */
|
|
542 dataoffset += tmp;
|
|
543
|
|
544 } else if ((tmp & 0x40) == 0) { /* First two bits are 10 */
|
|
545 /* Reserved for future use */
|
|
546
|
|
547 } else if ((tmp & 0x80) == 1) { /* First two bits are 01 */
|
|
548 /* Reserved for future use */
|
|
549
|
|
550 } else { /* First two bits are 11 */
|
|
551 /* End of this portion of the domain name */
|
|
552 dataoffset++;
|
|
553 break;
|
|
554
|
|
555 }
|
|
556 }
|
|
557
|
|
558 return dataoffset - startoffset;
|
|
559 }
|
|
560
|
|
561 /*
|
|
562 * XXX - Needs bounds checking!
|
|
563 *
|
|
564 */
|
|
565 static Question *
|
|
566 mdns_read_questions(int numquestions, const char *data, int datalen, int *offset)
|
|
567 {
|
|
568 Question *ret;
|
|
569 int i;
|
|
570
|
|
571 ret = (Question *)g_malloc0(numquestions * sizeof(Question));
|
|
572 for (i = 0; i < numquestions; i++) {
|
|
573 ret[i].name = mdns_read_name(data, 0, *offset);
|
|
574 *offset += mdns_read_name_len(data, 0, *offset);
|
|
575 ret[i].type = util_get16(&data[*offset]); /* QTYPE */
|
|
576 *offset += 2;
|
|
577 ret[i].class = util_get16(&data[*offset]); /* QCLASS */
|
|
578 *offset += 2;
|
|
579 }
|
|
580
|
|
581 return ret;
|
|
582 }
|
|
583
|
|
584 /*
|
|
585 * Read in a chunk of data, probably a buddy icon.
|
|
586 *
|
|
587 */
|
|
588 static unsigned char *
|
|
589 mdns_read_rr_rdata_null(const char *data, int datalen, int offset, unsigned short rdlength)
|
|
590 {
|
|
591 unsigned char *ret = NULL;
|
|
592
|
|
593 if (offset + rdlength > datalen)
|
|
594 return NULL;
|
|
595
|
|
596 ret = (unsigned char *)g_malloc(rdlength);
|
|
597 memcpy(ret, &data[offset], rdlength);
|
|
598
|
|
599 return ret;
|
|
600 }
|
|
601
|
|
602 /*
|
|
603 * XXX - Needs bounds checking!
|
|
604 *
|
|
605 */
|
|
606 static char *
|
|
607 mdns_read_rr_rdata_ptr(const char *data, int datalen, int offset)
|
|
608 {
|
|
609 char *ret = NULL;
|
|
610
|
|
611 ret = mdns_read_name(data, datalen, offset);
|
|
612
|
|
613 return ret;
|
|
614 }
|
|
615
|
|
616 /*
|
|
617 *
|
|
618 *
|
|
619 */
|
|
620 static GHashTable *
|
|
621 mdns_read_rr_rdata_txt(const char *data, int datalen, int offset, unsigned short rdlength)
|
|
622 {
|
|
623 GHashTable *ret = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
|
|
624 int endoffset = offset + rdlength;
|
|
625 unsigned char tmp;
|
|
626 char buf[256], *key, *value;
|
|
627
|
|
628 while (offset < endoffset) {
|
|
629 /* Read in the length of the next name/value pair */
|
|
630 tmp = util_get8(&data[offset]);
|
|
631 offset++;
|
|
632
|
|
633 /* Ensure packet is valid */
|
|
634 if (offset + tmp > endoffset)
|
|
635 break;
|
|
636
|
|
637 /* Read in the next name/value pair */
|
|
638 strncpy(buf, &data[offset], tmp);
|
|
639 offset += tmp;
|
|
640
|
|
641 if (buf[0] == '=') {
|
|
642 /* Name/value pairs beginning with = are silently ignored */
|
|
643 continue;
|
|
644 }
|
|
645
|
|
646 /* The value is a substring of buf, starting just after the = */
|
|
647 buf[tmp] = '\0';
|
|
648 value = strchr(buf, '=');
|
|
649 if (value != NULL) {
|
|
650 value[0] = '\0';
|
|
651 value++;
|
|
652 }
|
|
653
|
|
654 /* Make the key all lowercase */
|
|
655 key = g_utf8_strdown(buf, -1);
|
|
656 if (!g_hash_table_lookup(ret, key))
|
|
657 g_hash_table_insert(ret, key, g_strdup(value));
|
|
658 else
|
|
659 g_free(key);
|
|
660 }
|
|
661
|
|
662 return ret;
|
|
663 }
|
|
664
|
|
665 /*
|
8594
|
666 *
|
|
667 *
|
|
668 */
|
|
669 static ResourceRecordSRV *
|
|
670 mdns_read_rr_rdata_srv(const char *data, int datalen, int offset, unsigned short rdlength)
|
|
671 {
|
|
672 ResourceRecordSRV *ret = NULL;
|
|
673 int endoffset = offset + rdlength;
|
|
674
|
|
675 if (offset + 7 > endoffset)
|
|
676 return NULL;
|
|
677
|
|
678 ret = g_malloc(sizeof(ResourceRecordSRV));
|
|
679
|
|
680 /* Read in the priority */
|
|
681 ret->priority = util_get16(&data[offset]);
|
|
682 offset += 2;
|
|
683
|
|
684 /* Read in the weight */
|
|
685 ret->weight = util_get16(&data[offset]);
|
|
686 offset += 2;
|
|
687
|
|
688 /* Read in the port */
|
|
689 ret->port = util_get16(&data[offset]);
|
|
690 offset += 2;
|
|
691
|
|
692 /* Read in the target name */
|
|
693 /*
|
|
694 * XXX - RFC2782 says it's not supposed to be an alias...
|
|
695 * but it was in the packet capture I looked at from iChat.
|
|
696 */
|
|
697 ret->target = mdns_read_name(data, datalen, offset);
|
|
698
|
|
699 return ret;
|
|
700 }
|
|
701
|
|
702 /*
|
8487
|
703 * XXX - Needs bounds checking!
|
|
704 *
|
|
705 */
|
|
706 static ResourceRecord *
|
|
707 mdns_read_rr(int numrecords, const char *data, int datalen, int *offset)
|
|
708 {
|
|
709 ResourceRecord *ret;
|
|
710 int i;
|
|
711
|
|
712 ret = (ResourceRecord *)g_malloc0(numrecords * sizeof(ResourceRecord));
|
|
713 for (i = 0; i < numrecords; i++) {
|
|
714 ret[i].name = mdns_read_name(data, 0, *offset); /* NAME */
|
|
715 *offset += mdns_read_name_len(data, 0, *offset);
|
|
716 ret[i].type = util_get16(&data[*offset]); /* TYPE */
|
|
717 *offset += 2;
|
|
718 ret[i].class = util_get16(&data[*offset]); /* CLASS */
|
|
719 *offset += 2;
|
|
720 ret[i].ttl = util_get32(&data[*offset]); /* TTL */
|
|
721 *offset += 4;
|
|
722 ret[i].rdlength = util_get16(&data[*offset]); /* RDLENGTH */
|
|
723 *offset += 2;
|
|
724
|
|
725 /* RDATA */
|
|
726 switch (ret[i].type) {
|
|
727 case RENDEZVOUS_RRTYPE_NULL:
|
|
728 ret[i].rdata = mdns_read_rr_rdata_null(data, datalen, *offset, ret[i].rdlength);
|
|
729 break;
|
|
730
|
|
731 case RENDEZVOUS_RRTYPE_PTR:
|
|
732 ret[i].rdata = mdns_read_rr_rdata_ptr(data, datalen, *offset);
|
|
733 break;
|
|
734
|
|
735 case RENDEZVOUS_RRTYPE_TXT:
|
|
736 ret[i].rdata = mdns_read_rr_rdata_txt(data, datalen, *offset, ret[i].rdlength);
|
|
737 break;
|
|
738
|
8594
|
739 case RENDEZVOUS_RRTYPE_SRV:
|
|
740 ret[i].rdata = mdns_read_rr_rdata_srv(data, datalen, *offset, ret[i].rdlength);
|
|
741 break;
|
|
742
|
8487
|
743 default:
|
|
744 ret[i].rdata = NULL;
|
|
745 break;
|
|
746 }
|
|
747 *offset += ret[i].rdlength;
|
|
748 }
|
|
749
|
|
750 return ret;
|
|
751 }
|
|
752
|
|
753 /*
|
|
754 * XXX - Needs bounds checking!
|
|
755 *
|
|
756 */
|
|
757 DNSPacket *
|
|
758 mdns_read(int fd)
|
|
759 {
|
|
760 DNSPacket *ret = NULL;
|
|
761 int i; /* Current position in datagram */
|
8612
|
762 /* XXX - Find out what to use as a maximum incoming UDP packet size */
|
|
763 /* char data[512]; */
|
8487
|
764 char data[10096];
|
|
765 int datalen;
|
|
766 struct sockaddr_in addr;
|
|
767 socklen_t addrlen;
|
|
768
|
|
769 /* Read in an mDNS packet */
|
|
770 addrlen = sizeof(struct sockaddr_in);
|
|
771 if ((datalen = recvfrom(fd, data, sizeof(data), 0, (struct sockaddr *)&addr, &addrlen)) == -1) {
|
|
772 gaim_debug_error("mdns", "Error reading packet: %d\n", errno);
|
|
773 return NULL;
|
|
774 }
|
|
775
|
|
776 ret = (DNSPacket *)g_malloc0(sizeof(DNSPacket));
|
|
777
|
|
778 /* Parse the incoming packet, starting from 0 */
|
|
779 i = 0;
|
|
780
|
|
781 /* The header section */
|
|
782 ret->header.id = util_get16(&data[i]); /* ID */
|
|
783 i += 2;
|
|
784
|
|
785 /* For the flags, some bits must be 0 and some must be 1, the rest are ignored */
|
|
786 ret->header.flags = util_get16(&data[i]); /* Flags (QR, OPCODE, AA, TC, RD, RA, Z, AD, CD, and RCODE */
|
|
787 i += 2;
|
|
788 if ((ret->header.flags & 0x8000) == 0) {
|
|
789 /* QR should be 1 */
|
|
790 g_free(ret);
|
|
791 return NULL;
|
|
792 }
|
|
793 if ((ret->header.flags & 0x7800) != 0) {
|
|
794 /* OPCODE should be all 0's */
|
|
795 g_free(ret);
|
|
796 return NULL;
|
|
797 }
|
|
798
|
|
799 /* Read in the number of other things in the packet */
|
|
800 ret->header.numquestions = util_get16(&data[i]);
|
|
801 i += 2;
|
|
802 ret->header.numanswers = util_get16(&data[i]);
|
|
803 i += 2;
|
|
804 ret->header.numauthority = util_get16(&data[i]);
|
|
805 i += 2;
|
|
806 ret->header.numadditional = util_get16(&data[i]);
|
|
807 i += 2;
|
|
808
|
|
809 /* Read in all the questions */
|
|
810 ret->questions = mdns_read_questions(ret->header.numquestions, data, datalen, &i);
|
|
811
|
|
812 /* Read in all resource records */
|
|
813 ret->answers = mdns_read_rr(ret->header.numanswers, data, datalen, &i);
|
|
814
|
|
815 /* Read in all authority records */
|
|
816 ret->authority = mdns_read_rr(ret->header.numauthority, data, datalen, &i);
|
|
817
|
|
818 /* Read in all additional records */
|
|
819 ret->additional = mdns_read_rr(ret->header.numadditional, data, datalen, &i);
|
|
820
|
|
821 /* We should be at the end of the packet */
|
|
822 if (i != datalen) {
|
|
823 gaim_debug_error("mdns", "Finished parsing before end of DNS packet! Only parsed %d of %d bytes.", i, datalen);
|
|
824 g_free(ret);
|
|
825 return NULL;
|
|
826 }
|
|
827
|
|
828 return ret;
|
|
829 }
|
|
830
|
|
831 /**
|
|
832 * Free the rdata associated with a given resource record.
|
|
833 */
|
|
834 static void
|
|
835 mdns_free_rr_rdata(unsigned short type, void *rdata)
|
|
836 {
|
|
837 switch (type) {
|
|
838 case RENDEZVOUS_RRTYPE_NULL:
|
|
839 case RENDEZVOUS_RRTYPE_PTR:
|
|
840 g_free(rdata);
|
|
841 break;
|
|
842
|
|
843 case RENDEZVOUS_RRTYPE_TXT:
|
|
844 g_hash_table_destroy(rdata);
|
|
845 break;
|
8612
|
846
|
|
847 case RENDEZVOUS_RRTYPE_SRV:
|
|
848 g_free(((ResourceRecordSRV *)rdata)->target);
|
|
849 g_free(rdata);
|
|
850 break;
|
8487
|
851 }
|
|
852 }
|
|
853
|
|
854 /**
|
|
855 * Free a given question
|
|
856 */
|
|
857 static void
|
|
858 mdns_free_q(Question *q)
|
|
859 {
|
|
860 g_free(q->name);
|
|
861 }
|
|
862
|
|
863 /**
|
|
864 * Free a given resource record.
|
|
865 */
|
|
866 static void
|
|
867 mdns_free_rr(ResourceRecord *rr)
|
|
868 {
|
|
869 g_free(rr->name);
|
8631
|
870 if (rr->rdata != NULL)
|
|
871 mdns_free_rr_rdata(rr->type, rr->rdata);
|
8487
|
872 }
|
|
873
|
|
874 void
|
|
875 mdns_free(DNSPacket *dns)
|
|
876 {
|
|
877 int i;
|
|
878
|
|
879 for (i = 0; i < dns->header.numquestions; i++)
|
|
880 mdns_free_q(&dns->questions[i]);
|
|
881 for (i = 0; i < dns->header.numanswers; i++)
|
|
882 mdns_free_rr(&dns->answers[i]);
|
|
883 for (i = 0; i < dns->header.numauthority; i++)
|
|
884 mdns_free_rr(&dns->authority[i]);
|
|
885 for (i = 0; i < dns->header.numadditional; i++)
|
|
886 mdns_free_rr(&dns->additional[i]);
|
|
887
|
|
888 g_free(dns->questions);
|
|
889 g_free(dns->answers);
|
|
890 g_free(dns->authority);
|
|
891 g_free(dns->additional);
|
|
892 g_free(dns);
|
|
893 }
|