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
|
|
79 /* Ensure loopback is enabled (it should be enabled by default, by let's be sure) */
|
|
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
|
8629
|
138 mdns_getlength_RR_txt(void *rdata)
|
|
139 {
|
|
140 GSList *cur;
|
|
141 ResourceRecordTXTRDataNode *node;
|
|
142 int rdlength = 0;
|
|
143
|
|
144 for (cur = (GSList *)rdata; cur != NULL; cur = cur->next) {
|
|
145 node = (ResourceRecordTXTRDataNode *)cur->data;
|
|
146 rdlength += 1 + strlen(node->name);
|
|
147 if (node->value != NULL)
|
|
148 rdlength += 1 + strlen(node->value);
|
|
149 }
|
|
150
|
|
151 return rdlength;
|
|
152 }
|
|
153
|
|
154 static int
|
8612
|
155 mdns_getlength_RR(const ResourceRecord *rr)
|
|
156 {
|
|
157 int ret = 0;
|
|
158
|
|
159 ret += strlen(rr->name) + 2;
|
|
160 ret += 10;
|
|
161
|
|
162 switch (rr->type) {
|
|
163 case RENDEZVOUS_RRTYPE_PTR:
|
|
164 ret += strlen((const char *)rr->rdata) + 2;
|
|
165 break;
|
8629
|
166
|
|
167 case RENDEZVOUS_RRTYPE_TXT:
|
|
168 ret += mdns_getlength_RR_txt(rr->rdata);
|
|
169 break;
|
8612
|
170 }
|
|
171
|
|
172 return ret;
|
|
173 }
|
|
174
|
|
175 static int
|
|
176 mdns_put_name(char *data, int datalen, int offset, const char *name)
|
|
177 {
|
|
178 int i = 0;
|
|
179 char *b, *c;
|
|
180
|
|
181 b = (char *)name;
|
|
182 while ((c = strchr(b, '.'))) {
|
|
183 i += util_put8(&data[offset + i], c - b); /* Length of domain-name segment */
|
|
184 memcpy(&data[offset + i], b, c - b); /* Domain-name segment */
|
|
185 i += c - b; /* Increment the destination pointer */
|
|
186 b = c + 1;
|
|
187 }
|
|
188 i += util_put8(&data[offset + i], strlen(b)); /* Length of domain-name segment */
|
|
189 strcpy(&data[offset + i], b); /* Domain-name segment */
|
|
190 i += strlen(b) + 1; /* Increment the destination pointer */
|
|
191
|
|
192 return i;
|
|
193 }
|
|
194
|
|
195 static int
|
|
196 mdns_put_RR(char *data, int datalen, int offset, const ResourceRecord *rr)
|
|
197 {
|
|
198 int i = 0;
|
|
199
|
|
200 i += mdns_put_name(data, datalen, offset + i, rr->name);
|
|
201 i += util_put16(&data[offset + i], rr->type);
|
|
202 i += util_put16(&data[offset + i], rr->class);
|
|
203 i += util_put32(&data[offset + i], rr->ttl);
|
|
204
|
|
205 switch (rr->type) {
|
|
206 case RENDEZVOUS_RRTYPE_PTR:
|
8629
|
207 i += util_put16(&data[offset + i], strlen((const char *)rr->rdata) + 2);
|
8612
|
208 i += mdns_put_name(data, datalen, offset + i, (const char *)rr->rdata);
|
|
209 break;
|
8629
|
210
|
|
211 case RENDEZVOUS_RRTYPE_TXT: {
|
|
212 GSList *cur;
|
|
213 ResourceRecordTXTRDataNode *node;
|
|
214 int rdlength = mdns_getlength_RR_txt(rr->rdata);
|
|
215 int mylength;
|
|
216
|
|
217 i += util_put16(&data[offset + i], rdlength);
|
|
218 for (cur = (GSList *)rr->rdata; cur != NULL; cur = cur->next) {
|
|
219 node = (ResourceRecordTXTRDataNode *)cur->data;
|
|
220 mylength = 1 + strlen(node->name);
|
|
221 if (node->value)
|
|
222 mylength += 1 + strlen(node->value);
|
|
223 i += util_put8(&data[offset + i], mylength - 1);
|
|
224 memcpy(&data[offset + i], node->name, strlen(node->name));
|
|
225 i += strlen(node->name);
|
|
226 if (node->value) {
|
|
227 data[offset + i] = '=';
|
|
228 i++;
|
|
229 memcpy(&data[offset + i], node->value, strlen(node->value));
|
|
230 i += strlen(node->value);
|
|
231 }
|
|
232 }
|
|
233 } break;
|
8612
|
234 }
|
|
235
|
|
236 return i;
|
|
237 }
|
|
238
|
|
239 int
|
|
240 mdns_send_dns(int fd, const DNSPacket *dns)
|
|
241 {
|
|
242 int ret;
|
|
243 unsigned int datalen;
|
|
244 unsigned char *data;
|
|
245 int offset;
|
|
246 int i;
|
|
247
|
|
248 /* Calculate the length of the buffer we'll need to hold the DNS packet */
|
|
249 datalen = 0;
|
|
250
|
|
251 /* Header */
|
|
252 datalen += 12;
|
|
253
|
|
254 /* Questions */
|
|
255 for (i = 0; i < dns->header.numquestions; i++)
|
|
256 datalen += strlen(dns->questions[i].name) + 2 + 4;
|
|
257
|
|
258 /* Resource records */
|
|
259 for (i = 0; i < dns->header.numanswers; i++)
|
|
260 datalen += mdns_getlength_RR(&dns->answers[i]);
|
|
261 for (i = 0; i < dns->header.numauthority; i++)
|
|
262 datalen += mdns_getlength_RR(&dns->authority[i]);
|
|
263 for (i = 0; i < dns->header.numadditional; i++)
|
|
264 datalen += mdns_getlength_RR(&dns->additional[i]);
|
|
265
|
|
266 /* Allocate a buffer */
|
|
267 if (!(data = (unsigned char *)g_malloc(datalen))) {
|
|
268 return -ENOMEM;
|
|
269 }
|
|
270
|
|
271 /* Construct the datagram */
|
|
272 /* Header */
|
|
273 offset = 0;
|
|
274 offset += util_put16(&data[offset], dns->header.id); /* ID */
|
|
275 offset += util_put16(&data[offset], dns->header.flags);
|
|
276 offset += util_put16(&data[offset], dns->header.numquestions); /* QDCOUNT */
|
|
277 offset += util_put16(&data[offset], dns->header.numanswers); /* ANCOUNT */
|
|
278 offset += util_put16(&data[offset], dns->header.numauthority); /* NSCOUNT */
|
|
279 offset += util_put16(&data[offset], dns->header.numadditional); /* ARCOUNT */
|
|
280
|
|
281 /* Questions */
|
|
282 for (i = 0; i < dns->header.numquestions; i++) {
|
|
283 offset += mdns_put_name(data, datalen, offset, dns->questions[i].name); /* QNAME */
|
|
284 offset += util_put16(&data[offset], dns->questions[i].type); /* QTYPE */
|
|
285 offset += util_put16(&data[offset], dns->questions[i].class); /* QCLASS */
|
|
286 }
|
|
287
|
|
288 /* Resource records */
|
|
289 for (i = 0; i < dns->header.numanswers; i++)
|
|
290 offset += mdns_put_RR(data, datalen, offset, &dns->answers[i]);
|
|
291 for (i = 0; i < dns->header.numauthority; i++)
|
|
292 offset += mdns_put_RR(data, datalen, offset, &dns->authority[i]);
|
|
293 for (i = 0; i < dns->header.numadditional; i++)
|
|
294 offset += mdns_put_RR(data, datalen, offset, &dns->additional[i]);
|
|
295
|
|
296 /* Send the datagram */
|
|
297 ret = mdns_send_raw(fd, datalen, data);
|
|
298
|
|
299 g_free(data);
|
|
300
|
|
301 return ret;
|
|
302 }
|
|
303
|
8487
|
304 int
|
|
305 mdns_query(int fd, const char *domain)
|
|
306 {
|
8612
|
307 int ret;
|
|
308 DNSPacket *dns;
|
8487
|
309
|
|
310 if (strlen(domain) > 255) {
|
|
311 return -EINVAL;
|
|
312 }
|
|
313
|
8612
|
314 dns = (DNSPacket *)g_malloc(sizeof(DNSPacket));
|
|
315 dns->header.id = 0x0000;
|
|
316 dns->header.flags = 0x0000;
|
|
317 dns->header.numquestions = 0x0001;
|
|
318 dns->header.numanswers = 0x0000;
|
|
319 dns->header.numauthority = 0x0000;
|
|
320 dns->header.numadditional = 0x0000;
|
|
321
|
|
322 dns->questions = (Question *)g_malloc(1 * sizeof(Question));
|
|
323 dns->questions[0].name = g_strdup(domain);
|
|
324 dns->questions[0].type = RENDEZVOUS_RRTYPE_PTR;
|
|
325 dns->questions[0].class = 0x8001;
|
|
326
|
|
327 dns->answers = NULL;
|
|
328 dns->authority = NULL;
|
|
329 dns->additional = NULL;
|
|
330
|
|
331 mdns_send_dns(fd, dns);
|
|
332
|
|
333 mdns_free(dns);
|
|
334
|
|
335 return ret;
|
|
336 }
|
|
337
|
|
338 int
|
|
339 mdns_advertise_ptr(int fd, const char *name, const char *domain)
|
|
340 {
|
|
341 int ret;
|
|
342 DNSPacket *dns;
|
|
343
|
|
344 if ((strlen(name) > 255) || (strlen(domain) > 255)) {
|
|
345 return -EINVAL;
|
8487
|
346 }
|
|
347
|
8612
|
348 dns = (DNSPacket *)g_malloc(sizeof(DNSPacket));
|
|
349 dns->header.id = 0x0000;
|
|
350 dns->header.flags = 0x8400;
|
|
351 dns->header.numquestions = 0x0000;
|
|
352 dns->header.numanswers = 0x0001;
|
|
353 dns->header.numauthority = 0x0000;
|
|
354 dns->header.numadditional = 0x0000;
|
|
355 dns->questions = NULL;
|
8487
|
356
|
8612
|
357 dns->answers = (ResourceRecord *)g_malloc(1 * sizeof(ResourceRecord));
|
|
358 dns->answers[0].name = g_strdup(name);
|
|
359 dns->answers[0].type = RENDEZVOUS_RRTYPE_PTR;
|
|
360 dns->answers[0].class = 0x0001;
|
|
361 dns->answers[0].ttl = 0x00001c20;
|
8629
|
362 dns->answers[0].rdlength = 0x0000; /* Set automatically */
|
8612
|
363 dns->answers[0].rdata = (void *)g_strdup(domain);
|
|
364
|
|
365 dns->authority = NULL;
|
|
366 dns->additional = NULL;
|
8487
|
367
|
8612
|
368 mdns_send_dns(fd, dns);
|
|
369
|
|
370 mdns_free(dns);
|
8487
|
371
|
8612
|
372 return ret;
|
|
373 }
|
8487
|
374
|
8629
|
375 int
|
|
376 mdns_advertise_txt(int fd, const char *name, const GSList *rdata)
|
|
377 {
|
|
378 int ret;
|
|
379 DNSPacket *dns;
|
|
380
|
|
381 if ((strlen(name) > 255)) {
|
|
382 return -EINVAL;
|
|
383 }
|
|
384
|
|
385 dns = (DNSPacket *)g_malloc(sizeof(DNSPacket));
|
|
386 dns->header.id = 0x0000;
|
|
387 dns->header.flags = 0x8400;
|
|
388 dns->header.numquestions = 0x0000;
|
|
389 dns->header.numanswers = 0x0001;
|
|
390 dns->header.numauthority = 0x0000;
|
|
391 dns->header.numadditional = 0x0000;
|
|
392 dns->questions = NULL;
|
|
393
|
|
394 dns->answers = (ResourceRecord *)g_malloc(1 * sizeof(ResourceRecord));
|
|
395 dns->answers[0].name = g_strdup(name);
|
|
396 dns->answers[0].type = RENDEZVOUS_RRTYPE_TXT;
|
|
397 dns->answers[0].class = 0x0001;
|
|
398 dns->answers[0].ttl = 0x00001c20;
|
|
399 dns->answers[0].rdlength = 0x0000; /* Set automatically */
|
|
400 dns->answers[0].rdata = (void *)rdata;
|
|
401
|
|
402 dns->authority = NULL;
|
|
403 dns->additional = NULL;
|
|
404
|
|
405 mdns_send_dns(fd, dns);
|
|
406
|
|
407 /* The hash table should be freed by the caller of this function */
|
|
408 dns->answers[0].rdata = NULL;
|
|
409
|
|
410 mdns_free(dns);
|
|
411
|
|
412 return ret;
|
|
413 }
|
|
414
|
8612
|
415 /***************************************/
|
|
416 /* Functions for parsing mDNS messages */
|
|
417 /***************************************/
|
8487
|
418
|
|
419 /*
|
|
420 * XXX - Needs bounds checking!
|
|
421 *
|
|
422 * Read in a domain name from the given buffer starting at the given
|
|
423 * offset. This handles using domain name compression to jump around
|
|
424 * the data buffer, if needed.
|
|
425 *
|
|
426 * @return A null-terminated string representation of the domain name.
|
|
427 * This should be g_free'd when no longer needed.
|
|
428 */
|
|
429 static gchar *
|
|
430 mdns_read_name(const char *data, int datalen, int dataoffset)
|
|
431 {
|
|
432 GString *ret = g_string_new("");
|
|
433 unsigned char tmp;
|
|
434
|
|
435 while ((tmp = util_get8(&data[dataoffset])) != 0) {
|
|
436 dataoffset++;
|
|
437
|
|
438 if ((tmp & 0xc0) == 0) { /* First two bits are 00 */
|
|
439 if (*ret->str)
|
|
440 g_string_append_c(ret, '.');
|
|
441 g_string_append_len(ret, &data[dataoffset], tmp);
|
|
442 dataoffset += tmp;
|
|
443
|
|
444 } else if ((tmp & 0x40) == 0) { /* First two bits are 10 */
|
|
445 /* Reserved for future use */
|
|
446
|
|
447 } else if ((tmp & 0x80) == 1) { /* First two bits are 01 */
|
|
448 /* Reserved for future use */
|
|
449
|
|
450 } else { /* First two bits are 11 */
|
|
451 /* Jump to another position in the data */
|
|
452 dataoffset = util_get8(&data[dataoffset]);
|
|
453
|
|
454 }
|
|
455 }
|
|
456
|
|
457 return g_string_free(ret, FALSE);
|
|
458 }
|
|
459
|
|
460 /*
|
|
461 * XXX - Needs bounds checking!
|
|
462 *
|
|
463 * Determine how many bytes long a portion of the domain name is
|
|
464 * at the given offset. This does NOT jump around the data array
|
|
465 * in the case of domain name compression.
|
|
466 *
|
|
467 * @return The length of the portion of the domain name.
|
|
468 */
|
|
469 static int
|
|
470 mdns_read_name_len(const char *data, int datalen, int dataoffset)
|
|
471 {
|
|
472 int startoffset = dataoffset;
|
|
473 unsigned char tmp;
|
|
474
|
|
475 while ((tmp = util_get8(&data[dataoffset++])) != 0) {
|
|
476
|
|
477 if ((tmp & 0xc0) == 0) { /* First two bits are 00 */
|
|
478 dataoffset += tmp;
|
|
479
|
|
480 } else if ((tmp & 0x40) == 0) { /* First two bits are 10 */
|
|
481 /* Reserved for future use */
|
|
482
|
|
483 } else if ((tmp & 0x80) == 1) { /* First two bits are 01 */
|
|
484 /* Reserved for future use */
|
|
485
|
|
486 } else { /* First two bits are 11 */
|
|
487 /* End of this portion of the domain name */
|
|
488 dataoffset++;
|
|
489 break;
|
|
490
|
|
491 }
|
|
492 }
|
|
493
|
|
494 return dataoffset - startoffset;
|
|
495 }
|
|
496
|
|
497 /*
|
|
498 * XXX - Needs bounds checking!
|
|
499 *
|
|
500 */
|
|
501 static Question *
|
|
502 mdns_read_questions(int numquestions, const char *data, int datalen, int *offset)
|
|
503 {
|
|
504 Question *ret;
|
|
505 int i;
|
|
506
|
|
507 ret = (Question *)g_malloc0(numquestions * sizeof(Question));
|
|
508 for (i = 0; i < numquestions; i++) {
|
|
509 ret[i].name = mdns_read_name(data, 0, *offset);
|
|
510 *offset += mdns_read_name_len(data, 0, *offset);
|
|
511 ret[i].type = util_get16(&data[*offset]); /* QTYPE */
|
|
512 *offset += 2;
|
|
513 ret[i].class = util_get16(&data[*offset]); /* QCLASS */
|
|
514 *offset += 2;
|
|
515 }
|
|
516
|
|
517 return ret;
|
|
518 }
|
|
519
|
|
520 /*
|
|
521 * Read in a chunk of data, probably a buddy icon.
|
|
522 *
|
|
523 */
|
|
524 static unsigned char *
|
|
525 mdns_read_rr_rdata_null(const char *data, int datalen, int offset, unsigned short rdlength)
|
|
526 {
|
|
527 unsigned char *ret = NULL;
|
|
528
|
|
529 if (offset + rdlength > datalen)
|
|
530 return NULL;
|
|
531
|
|
532 ret = (unsigned char *)g_malloc(rdlength);
|
|
533 memcpy(ret, &data[offset], rdlength);
|
|
534
|
|
535 return ret;
|
|
536 }
|
|
537
|
|
538 /*
|
|
539 * XXX - Needs bounds checking!
|
|
540 *
|
|
541 */
|
|
542 static char *
|
|
543 mdns_read_rr_rdata_ptr(const char *data, int datalen, int offset)
|
|
544 {
|
|
545 char *ret = NULL;
|
|
546
|
|
547 ret = mdns_read_name(data, datalen, offset);
|
|
548
|
|
549 return ret;
|
|
550 }
|
|
551
|
|
552 /*
|
|
553 *
|
|
554 *
|
|
555 */
|
|
556 static GHashTable *
|
|
557 mdns_read_rr_rdata_txt(const char *data, int datalen, int offset, unsigned short rdlength)
|
|
558 {
|
|
559 GHashTable *ret = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
|
|
560 int endoffset = offset + rdlength;
|
|
561 unsigned char tmp;
|
|
562 char buf[256], *key, *value;
|
|
563
|
|
564 while (offset < endoffset) {
|
|
565 /* Read in the length of the next name/value pair */
|
|
566 tmp = util_get8(&data[offset]);
|
|
567 offset++;
|
|
568
|
|
569 /* Ensure packet is valid */
|
|
570 if (offset + tmp > endoffset)
|
|
571 break;
|
|
572
|
|
573 /* Read in the next name/value pair */
|
|
574 strncpy(buf, &data[offset], tmp);
|
|
575 offset += tmp;
|
|
576
|
|
577 if (buf[0] == '=') {
|
|
578 /* Name/value pairs beginning with = are silently ignored */
|
|
579 continue;
|
|
580 }
|
|
581
|
|
582 /* The value is a substring of buf, starting just after the = */
|
|
583 buf[tmp] = '\0';
|
|
584 value = strchr(buf, '=');
|
|
585 if (value != NULL) {
|
|
586 value[0] = '\0';
|
|
587 value++;
|
|
588 }
|
|
589
|
|
590 /* Make the key all lowercase */
|
|
591 key = g_utf8_strdown(buf, -1);
|
|
592 if (!g_hash_table_lookup(ret, key))
|
|
593 g_hash_table_insert(ret, key, g_strdup(value));
|
|
594 else
|
|
595 g_free(key);
|
|
596 }
|
|
597
|
|
598 return ret;
|
|
599 }
|
|
600
|
|
601 /*
|
8594
|
602 *
|
|
603 *
|
|
604 */
|
|
605 static ResourceRecordSRV *
|
|
606 mdns_read_rr_rdata_srv(const char *data, int datalen, int offset, unsigned short rdlength)
|
|
607 {
|
|
608 ResourceRecordSRV *ret = NULL;
|
|
609 int endoffset = offset + rdlength;
|
|
610
|
|
611 if (offset + 7 > endoffset)
|
|
612 return NULL;
|
|
613
|
|
614 ret = g_malloc(sizeof(ResourceRecordSRV));
|
|
615
|
|
616 /* Read in the priority */
|
|
617 ret->priority = util_get16(&data[offset]);
|
|
618 offset += 2;
|
|
619
|
|
620 /* Read in the weight */
|
|
621 ret->weight = util_get16(&data[offset]);
|
|
622 offset += 2;
|
|
623
|
|
624 /* Read in the port */
|
|
625 ret->port = util_get16(&data[offset]);
|
|
626 offset += 2;
|
|
627
|
|
628 /* Read in the target name */
|
|
629 /*
|
|
630 * XXX - RFC2782 says it's not supposed to be an alias...
|
|
631 * but it was in the packet capture I looked at from iChat.
|
|
632 */
|
|
633 ret->target = mdns_read_name(data, datalen, offset);
|
|
634
|
|
635 return ret;
|
|
636 }
|
|
637
|
|
638 /*
|
8487
|
639 * XXX - Needs bounds checking!
|
|
640 *
|
|
641 */
|
|
642 static ResourceRecord *
|
|
643 mdns_read_rr(int numrecords, const char *data, int datalen, int *offset)
|
|
644 {
|
|
645 ResourceRecord *ret;
|
|
646 int i;
|
|
647
|
|
648 ret = (ResourceRecord *)g_malloc0(numrecords * sizeof(ResourceRecord));
|
|
649 for (i = 0; i < numrecords; i++) {
|
|
650 ret[i].name = mdns_read_name(data, 0, *offset); /* NAME */
|
|
651 *offset += mdns_read_name_len(data, 0, *offset);
|
|
652 ret[i].type = util_get16(&data[*offset]); /* TYPE */
|
|
653 *offset += 2;
|
|
654 ret[i].class = util_get16(&data[*offset]); /* CLASS */
|
|
655 *offset += 2;
|
|
656 ret[i].ttl = util_get32(&data[*offset]); /* TTL */
|
|
657 *offset += 4;
|
|
658 ret[i].rdlength = util_get16(&data[*offset]); /* RDLENGTH */
|
|
659 *offset += 2;
|
|
660
|
|
661 /* RDATA */
|
|
662 switch (ret[i].type) {
|
|
663 case RENDEZVOUS_RRTYPE_NULL:
|
|
664 ret[i].rdata = mdns_read_rr_rdata_null(data, datalen, *offset, ret[i].rdlength);
|
|
665 break;
|
|
666
|
|
667 case RENDEZVOUS_RRTYPE_PTR:
|
|
668 ret[i].rdata = mdns_read_rr_rdata_ptr(data, datalen, *offset);
|
|
669 break;
|
|
670
|
|
671 case RENDEZVOUS_RRTYPE_TXT:
|
|
672 ret[i].rdata = mdns_read_rr_rdata_txt(data, datalen, *offset, ret[i].rdlength);
|
|
673 break;
|
|
674
|
8594
|
675 case RENDEZVOUS_RRTYPE_SRV:
|
|
676 ret[i].rdata = mdns_read_rr_rdata_srv(data, datalen, *offset, ret[i].rdlength);
|
|
677 break;
|
|
678
|
8487
|
679 default:
|
|
680 ret[i].rdata = NULL;
|
|
681 break;
|
|
682 }
|
|
683 *offset += ret[i].rdlength;
|
|
684 }
|
|
685
|
|
686 return ret;
|
|
687 }
|
|
688
|
|
689 /*
|
|
690 * XXX - Needs bounds checking!
|
|
691 *
|
|
692 */
|
|
693 DNSPacket *
|
|
694 mdns_read(int fd)
|
|
695 {
|
|
696 DNSPacket *ret = NULL;
|
|
697 int i; /* Current position in datagram */
|
8612
|
698 /* XXX - Find out what to use as a maximum incoming UDP packet size */
|
|
699 /* char data[512]; */
|
8487
|
700 char data[10096];
|
|
701 int datalen;
|
|
702 struct sockaddr_in addr;
|
|
703 socklen_t addrlen;
|
|
704
|
|
705 /* Read in an mDNS packet */
|
|
706 addrlen = sizeof(struct sockaddr_in);
|
|
707 if ((datalen = recvfrom(fd, data, sizeof(data), 0, (struct sockaddr *)&addr, &addrlen)) == -1) {
|
|
708 gaim_debug_error("mdns", "Error reading packet: %d\n", errno);
|
|
709 return NULL;
|
|
710 }
|
|
711
|
|
712 ret = (DNSPacket *)g_malloc0(sizeof(DNSPacket));
|
|
713
|
|
714 /* Parse the incoming packet, starting from 0 */
|
|
715 i = 0;
|
|
716
|
|
717 /* The header section */
|
|
718 ret->header.id = util_get16(&data[i]); /* ID */
|
|
719 i += 2;
|
|
720
|
|
721 /* For the flags, some bits must be 0 and some must be 1, the rest are ignored */
|
|
722 ret->header.flags = util_get16(&data[i]); /* Flags (QR, OPCODE, AA, TC, RD, RA, Z, AD, CD, and RCODE */
|
|
723 i += 2;
|
|
724 if ((ret->header.flags & 0x8000) == 0) {
|
|
725 /* QR should be 1 */
|
|
726 g_free(ret);
|
|
727 return NULL;
|
|
728 }
|
|
729 if ((ret->header.flags & 0x7800) != 0) {
|
|
730 /* OPCODE should be all 0's */
|
|
731 g_free(ret);
|
|
732 return NULL;
|
|
733 }
|
|
734
|
|
735 /* Read in the number of other things in the packet */
|
|
736 ret->header.numquestions = util_get16(&data[i]);
|
|
737 i += 2;
|
|
738 ret->header.numanswers = util_get16(&data[i]);
|
|
739 i += 2;
|
|
740 ret->header.numauthority = util_get16(&data[i]);
|
|
741 i += 2;
|
|
742 ret->header.numadditional = util_get16(&data[i]);
|
|
743 i += 2;
|
|
744
|
|
745 /* Read in all the questions */
|
|
746 ret->questions = mdns_read_questions(ret->header.numquestions, data, datalen, &i);
|
|
747
|
|
748 /* Read in all resource records */
|
|
749 ret->answers = mdns_read_rr(ret->header.numanswers, data, datalen, &i);
|
|
750
|
|
751 /* Read in all authority records */
|
|
752 ret->authority = mdns_read_rr(ret->header.numauthority, data, datalen, &i);
|
|
753
|
|
754 /* Read in all additional records */
|
|
755 ret->additional = mdns_read_rr(ret->header.numadditional, data, datalen, &i);
|
|
756
|
|
757 /* We should be at the end of the packet */
|
|
758 if (i != datalen) {
|
|
759 gaim_debug_error("mdns", "Finished parsing before end of DNS packet! Only parsed %d of %d bytes.", i, datalen);
|
|
760 g_free(ret);
|
|
761 return NULL;
|
|
762 }
|
|
763
|
|
764 return ret;
|
|
765 }
|
|
766
|
|
767 /**
|
|
768 * Free the rdata associated with a given resource record.
|
|
769 */
|
|
770 static void
|
|
771 mdns_free_rr_rdata(unsigned short type, void *rdata)
|
|
772 {
|
|
773 switch (type) {
|
|
774 case RENDEZVOUS_RRTYPE_NULL:
|
|
775 case RENDEZVOUS_RRTYPE_PTR:
|
|
776 g_free(rdata);
|
|
777 break;
|
|
778
|
|
779 case RENDEZVOUS_RRTYPE_TXT:
|
|
780 g_hash_table_destroy(rdata);
|
|
781 break;
|
8612
|
782
|
|
783 case RENDEZVOUS_RRTYPE_SRV:
|
|
784 g_free(((ResourceRecordSRV *)rdata)->target);
|
|
785 g_free(rdata);
|
|
786 break;
|
8487
|
787 }
|
|
788 }
|
|
789
|
|
790 /**
|
|
791 * Free a given question
|
|
792 */
|
|
793 static void
|
|
794 mdns_free_q(Question *q)
|
|
795 {
|
|
796 g_free(q->name);
|
|
797 }
|
|
798
|
|
799 /**
|
|
800 * Free a given resource record.
|
|
801 */
|
|
802 static void
|
|
803 mdns_free_rr(ResourceRecord *rr)
|
|
804 {
|
|
805 g_free(rr->name);
|
|
806 mdns_free_rr_rdata(rr->type, rr->rdata);
|
|
807 }
|
|
808
|
|
809 void
|
|
810 mdns_free(DNSPacket *dns)
|
|
811 {
|
|
812 int i;
|
|
813
|
|
814 for (i = 0; i < dns->header.numquestions; i++)
|
|
815 mdns_free_q(&dns->questions[i]);
|
|
816 for (i = 0; i < dns->header.numanswers; i++)
|
|
817 mdns_free_rr(&dns->answers[i]);
|
|
818 for (i = 0; i < dns->header.numauthority; i++)
|
|
819 mdns_free_rr(&dns->authority[i]);
|
|
820 for (i = 0; i < dns->header.numadditional; i++)
|
|
821 mdns_free_rr(&dns->additional[i]);
|
|
822
|
|
823 g_free(dns->questions);
|
|
824 g_free(dns->answers);
|
|
825 g_free(dns->authority);
|
|
826 g_free(dns->additional);
|
|
827 g_free(dns);
|
|
828 }
|