projects / openwrt.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Added udp-broadcast-relay, corrected missing Makefile lines for tinyproxy
[openwrt.git] / openwrt / package / mtr / patches / 501-dns.patch
1 diff -Naur mtr-0.69.old/dns.c mtr-0.69.new/dns.c
2 --- mtr-0.69.old/dns.c 2005-01-11 09:32:42.000000000 +0100
3 +++ mtr-0.69.new/dns.c 2005-10-03 21:31:27.000000000 +0200
4 @@ -853,6 +853,507 @@
5 fputs("\r",stderr);
6 }
7
8 +#ifdef __UCLIBC__
9 +
10 +static const char digits[] = "0123456789";
11 +#define __set_errno(e) (errno = (e))
12 +
13 +#define NS_PUT16(s, cp) do { \
14 + register u_int16_t t_s = (u_int16_t)(s); \
15 + register u_char *t_cp = (u_char *)(cp); \
16 + *t_cp++ = t_s >> 8; \
17 + *t_cp = t_s; \
18 + (cp) += NS_INT16SZ; \
19 +} while (0)
20 +
21 +
22 +
23 +#define NS_PUT32(l, cp) do { \
24 + register u_int32_t t_l = (u_int32_t)(l); \
25 + register u_char *t_cp = (u_char *)(cp); \
26 + *t_cp++ = t_l >> 24; \
27 + *t_cp++ = t_l >> 16; \
28 + *t_cp++ = t_l >> 8; \
29 + *t_cp = t_l; \
30 + (cp) += NS_INT32SZ; \
31 +} while (0)
32 +
33 +
34 +void
35 +ns_put16(u_int src, u_char *dst) {
36 + NS_PUT16(src, dst);
37 +}
38 +
39 +void
40 +ns_put32(u_long src, u_char *dst) {
41 + NS_PUT32(src, dst);
42 +}
43 +
44 +void __putshort(u_int16_t src, u_char *dst) { ns_put16(src, dst); }
45 +void __putlong(u_int32_t src, u_char *dst) { ns_put32(src, dst); }
46 +
47 +int
48 +mklower(int ch) {
49 + if (ch >= 0x41 && ch <= 0x5A)
50 + return (ch + 0x20);
51 + return (ch);
52 +}
53 +
54 +
55 +static int
56 +dn_find(const u_char *domain, const u_char *msg,
57 + const u_char * const *dnptrs,
58 + const u_char * const *lastdnptr)
59 +{
60 + const u_char *dn, *cp, *sp;
61 + const u_char * const *cpp;
62 + u_int n;
63 +
64 + for (cpp = dnptrs; cpp < lastdnptr; cpp++) {
65 + sp = *cpp;
66 + /*
67 + * terminate search on:
68 + * root label
69 + * compression pointer
70 + * unusable offset
71 + */
72 + while (*sp != 0 && (*sp & NS_CMPRSFLGS) == 0 &&
73 + (sp - msg) < 0x4000) {
74 + dn = domain;
75 + cp = sp;
76 + while ((n = *cp++) != 0) {
77 + /*
78 + * check for indirection
79 + */
80 + switch (n & NS_CMPRSFLGS) {
81 + case 0: /* normal case, n == len */
82 + if (n != *dn++)
83 + goto next;
84 + for ((void)NULL; n > 0; n--)
85 + if (mklower(*dn++) !=
86 + mklower(*cp++))
87 + goto next;
88 + /* Is next root for both ? */
89 + if (*dn == '\0' && *cp == '\0')
90 + return (sp - msg);
91 + if (*dn)
92 + continue;
93 + goto next;
94 +
95 + case NS_CMPRSFLGS: /* indirection */
96 + cp = msg + (((n & 0x3f) << 8) | *cp);
97 + break;
98 +
99 + default: /* illegal type */
100 + __set_errno (EMSGSIZE);
101 + return (-1);
102 + }
103 + }
104 + next:
105 + sp += *sp + 1;
106 + }
107 + }
108 + __set_errno (ENOENT);
109 + return (-1);
110 +}
111 +
112 +
113 +int
114 +ns_name_pack(const u_char *src, u_char *dst, int dstsiz,
115 + const u_char **dnptrs, const u_char **lastdnptr)
116 +{
117 + u_char *dstp;
118 + const u_char **cpp, **lpp, *eob, *msg;
119 + const u_char *srcp;
120 + int n, l, first = 1;
121 +
122 + srcp = src;
123 + dstp = dst;
124 + eob = dstp + dstsiz;
125 + lpp = cpp = NULL;
126 + if (dnptrs != NULL) {
127 + if ((msg = *dnptrs++) != NULL) {
128 + for (cpp = dnptrs; *cpp != NULL; cpp++)
129 + (void)NULL;
130 + lpp = cpp; /* end of list to search */
131 + }
132 + } else
133 + msg = NULL;
134 +
135 + /* make sure the domain we are about to add is legal */
136 + l = 0;
137 + do {
138 + n = *srcp;
139 + if ((n & NS_CMPRSFLGS) != 0 && n != 0x41) {
140 + __set_errno (EMSGSIZE);
141 + return (-1);
142 + }
143 + if (n == 0x41)
144 + n = *++srcp / 8;
145 + l += n + 1;
146 + if (l > MAXCDNAME) {
147 + __set_errno (EMSGSIZE);
148 + return (-1);
149 + }
150 + srcp += n + 1;
151 + } while (n != 0);
152 +
153 + /* from here on we need to reset compression pointer array on error */
154 + srcp = src;
155 + do {
156 + /* Look to see if we can use pointers. */
157 + n = *srcp;
158 + if (n != 0 && n != 0x41 && msg != NULL) {
159 + l = dn_find(srcp, msg, (const u_char * const *)dnptrs,
160 + (const u_char * const *)lpp);
161 + if (l >= 0) {
162 + if (dstp + 1 >= eob) {
163 + goto cleanup;
164 + }
165 + *dstp++ = (l >> 8) | NS_CMPRSFLGS;
166 + *dstp++ = l % 256;
167 + return (dstp - dst);
168 + }
169 + /* Not found, save it. */
170 + if (lastdnptr != NULL && cpp < lastdnptr - 1 &&
171 + (dstp - msg) < 0x4000 && first) {
172 + *cpp++ = dstp;
173 + *cpp = NULL;
174 + first = 0;
175 + }
176 + }
177 + /* copy label to buffer */
178 + if ((n & NS_CMPRSFLGS) != 0 && n != 0x41) { /* Should not happen. */
179 + goto cleanup;
180 + }
181 + if (n == 0x41) {
182 + n = *++srcp / 8;
183 + if (dstp + 1 >= eob)
184 + goto cleanup;
185 + *dstp++ = 0x41;
186 + }
187 + if (dstp + 1 + n >= eob) {
188 + goto cleanup;
189 + }
190 + memcpy(dstp, srcp, n + 1);
191 + srcp += n + 1;
192 + dstp += n + 1;
193 + } while (n != 0);
194 +
195 + if (dstp > eob) {
196 +cleanup:
197 + if (msg != NULL)
198 + *lpp = NULL;
199 + __set_errno (EMSGSIZE);
200 + return (-1);
201 + }
202 + return (dstp - dst);
203 +}
204 +
205 +
206 +int
207 +ns_name_pton(const char *src, u_char *dst, size_t dstsiz) {
208 + u_char *label, *bp, *eom;
209 + int c, n, escaped;
210 + char *cp;
211 +
212 + escaped = 0;
213 + bp = dst;
214 + eom = dst + dstsiz;
215 + label = bp++;
216 +
217 + while ((c = *src++) != 0) {
218 + if (escaped) {
219 + if ((cp = strchr(digits, c)) != NULL) {
220 + n = (cp - digits) * 100;
221 + if ((c = *src++) == 0 ||
222 + (cp = strchr(digits, c)) == NULL) {
223 + __set_errno (EMSGSIZE);
224 + return (-1);
225 + }
226 + n += (cp - digits) * 10;
227 + if ((c = *src++) == 0 ||
228 + (cp = strchr(digits, c)) == NULL) {
229 + __set_errno (EMSGSIZE);
230 + return (-1);
231 + }
232 + n += (cp - digits);
233 + if (n > 255) {
234 + __set_errno (EMSGSIZE);
235 + return (-1);
236 + }
237 + c = n;
238 + } else if (c == '[' && label == bp - 1 && *src == 'x') {
239 + /* Theoretically we would have to handle \[o
240 + as well but we do not since we do not need
241 + it internally. */
242 + *label = 0x41;
243 + label = bp++;
244 + ++src;
245 + while (isxdigit (*src)) {
246 + n = *src > '9' ? *src - 'a' + 10 : *src - '0';
247 + ++src;
248 + if (! isxdigit(*src)) {
249 + __set_errno (EMSGSIZE);
250 + return (-1);
251 + }
252 + n <<= 4;
253 + n += *src > '9' ? *src - 'a' + 10 : *src - '0';
254 + if (bp + 1 >= eom) {
255 + __set_errno (EMSGSIZE);
256 + return (-1);
257 + }
258 + *bp++ = n;
259 + ++src;
260 + }
261 + *label = (bp - label - 1) * 8;
262 + if (*src++ != ']' || *src++ != '.') {
263 + __set_errno (EMSGSIZE);
264 + return (-1);
265 + }
266 + escaped = 0;
267 + label = bp++;
268 + if (bp >= eom) {
269 + __set_errno (EMSGSIZE);
270 + return (-1);
271 + }
272 + continue;
273 + }
274 + escaped = 0;
275 + } else if (c == '\\') {
276 + escaped = 1;
277 + continue;
278 + } else if (c == '.') {
279 + c = (bp - label - 1);
280 + if ((c & NS_CMPRSFLGS) != 0) { /* Label too big. */
281 + __set_errno (EMSGSIZE);
282 + return (-1);
283 + }
284 + if (label >= eom) {
285 + __set_errno (EMSGSIZE);
286 + return (-1);
287 + }
288 + *label = c;
289 + /* Fully qualified ? */
290 + if (*src == '\0') {
291 + if (c != 0) {
292 + if (bp >= eom) {
293 + __set_errno (EMSGSIZE);
294 + return (-1);
295 + }
296 + *bp++ = '\0';
297 + }
298 + if ((bp - dst) > MAXCDNAME) {
299 + __set_errno (EMSGSIZE);
300 + return (-1);
301 + }
302 + return (1);
303 + }
304 + if (c == 0 || *src == '.') {
305 + __set_errno (EMSGSIZE);
306 + return (-1);
307 + }
308 + label = bp++;
309 + continue;
310 + }
311 + if (bp >= eom) {
312 + __set_errno (EMSGSIZE);
313 + return (-1);
314 + }
315 + *bp++ = (u_char)c;
316 + }
317 + c = (bp - label - 1);
318 + if ((c & NS_CMPRSFLGS) != 0) { /* Label too big. */
319 + __set_errno (EMSGSIZE);
320 + return (-1);
321 + }
322 + if (label >= eom) {
323 + __set_errno (EMSGSIZE);
324 + return (-1);
325 + }
326 + *label = c;
327 + if (c != 0) {
328 + if (bp >= eom) {
329 + __set_errno (EMSGSIZE);
330 + return (-1);
331 + }
332 + *bp++ = 0;
333 + }
334 + if ((bp - dst) > MAXCDNAME) { /* src too big */
335 + __set_errno (EMSGSIZE);
336 + return (-1);
337 + }
338 + return (0);
339 +}
340 +
341 +
342 +
343 +int
344 +ns_name_compress(const char *src, u_char *dst, size_t dstsiz,
345 + const u_char **dnptrs, const u_char **lastdnptr)
346 +{
347 + u_char tmp[NS_MAXCDNAME];
348 +
349 + if (ns_name_pton(src, tmp, sizeof tmp) == -1)
350 + return (-1);
351 + return (ns_name_pack(tmp, dst, dstsiz, dnptrs, lastdnptr));
352 +}
353 +
354 +
355 +int
356 +dn_comp(const char *src, u_char *dst, int dstsiz,
357 + u_char **dnptrs, u_char **lastdnptr)
358 +{
359 + return (ns_name_compress(src, dst, (size_t)dstsiz,
360 + (const u_char **)dnptrs,
361 + (const u_char **)lastdnptr));
362 +}
363 +
364 +
365 +
366 +
367 +int
368 +res_nmkquery(res_state statp,
369 + int op, /* opcode of query */
370 + const char *dname, /* domain name */
371 + int class, int type, /* class and type of query */
372 + const u_char *data, /* resource record data */
373 + int datalen, /* length of data */
374 + const u_char *newrr_in, /* new rr for modify or append */
375 + u_char *buf, /* buffer to put query */
376 + int buflen) /* size of buffer */
377 +{
378 + register HEADER *hp;
379 + register u_char *cp;
380 + register int n;
381 + u_char *dnptrs[20], **dpp, **lastdnptr;
382 +
383 +#ifdef DEBUG
384 + if (statp->options & RES_DEBUG)
385 + printf(";; res_nmkquery(%s, %s, %s, %s)\n",
386 + _res_opcodes[op], dname, p_class(class), p_type(type));
387 +#endif
388 + /*
389 + * Initialize header fields.
390 + */
391 + if ((buf == NULL) || (buflen < HFIXEDSZ))
392 + return (-1);
393 + memset(buf, 0, HFIXEDSZ);
394 + hp = (HEADER *) buf;
395 + /* We randomize the IDs every time. The old code just
396 + incremented by one after the initial randomization which
397 + still predictable if the application does multiple
398 + requests. */
399 +#if 0
400 + hp->id = htons(++statp->id);
401 +#else
402 + hp->id = htons(statp->id);
403 + int randombits;
404 + do
405 + {
406 +#ifdef RANDOM_BITS
407 + RANDOM_BITS (randombits);
408 +#else
409 + struct timeval tv;
410 + gettimeofday (&tv, NULL);
411 + randombits = (tv.tv_sec << 8) ^ tv.tv_usec;
412 +#endif
413 + }
414 + while ((randombits & 0xffff) == 0);
415 + statp->id = (statp->id + randombits) & 0xffff;
416 +#endif
417 + hp->opcode = op;
418 + hp->rd = (statp->options & RES_RECURSE) != 0;
419 + hp->rcode = NOERROR;
420 + cp = buf + HFIXEDSZ;
421 + buflen -= HFIXEDSZ;
422 + dpp = dnptrs;
423 + *dpp++ = buf;
424 + *dpp++ = NULL;
425 + lastdnptr = dnptrs + sizeof dnptrs / sizeof dnptrs[0];
426 + /*
427 + * perform opcode specific processing
428 + */
429 + switch (op) {
430 + case QUERY: /*FALLTHROUGH*/
431 + case NS_NOTIFY_OP:
432 + if ((buflen -= QFIXEDSZ) < 0)
433 + return (-1);
434 + if ((n = dn_comp(dname, cp, buflen, dnptrs, lastdnptr)) < 0)
435 + return (-1);
436 + cp += n;
437 + buflen -= n;
438 + __putshort(type, cp);
439 + cp += INT16SZ;
440 + __putshort(class, cp);
441 + cp += INT16SZ;
442 + hp->qdcount = htons(1);
443 + if (op == QUERY || data == NULL)
444 + break;
445 + /*
446 + * Make an additional record for completion domain.
447 + */
448 + buflen -= RRFIXEDSZ;
449 + n = dn_comp((char *)data, cp, buflen, dnptrs, lastdnptr);
450 + if (n < 0)
451 + return (-1);
452 + cp += n;
453 + buflen -= n;
454 + __putshort(T_NULL, cp);
455 + cp += INT16SZ;
456 + __putshort(class, cp);
457 + cp += INT16SZ;
458 + __putlong(0, cp);
459 + cp += INT32SZ;
460 + __putshort(0, cp);
461 + cp += INT16SZ;
462 + hp->arcount = htons(1);
463 + break;
464 +
465 + case IQUERY:
466 + /*
467 + * Initialize answer section
468 + */
469 + if (buflen < 1 + RRFIXEDSZ + datalen)
470 + return (-1);
471 + *cp++ = '\0'; /* no domain name */
472 + __putshort(type, cp);
473 + cp += INT16SZ;
474 + __putshort(class, cp);
475 + cp += INT16SZ;
476 + __putlong(0, cp);
477 + cp += INT32SZ;
478 + __putshort(datalen, cp);
479 + cp += INT16SZ;
480 + if (datalen) {
481 + memcpy(cp, data, datalen);
482 + cp += datalen;
483 + }
484 + hp->ancount = htons(1);
485 + break;
486 +
487 + default:
488 + return (-1);
489 + }
490 + return (cp - buf);
491 +}
492 +
493 +int
494 +res_mkquery(int op, /* opcode of query */
495 + const char *dname, /* domain name */
496 + int class, int type, /* class and type of query */
497 + const u_char *data, /* resource record data */
498 + int datalen, /* length of data */
499 + const u_char *newrr_in, /* new rr for modify or append */
500 + u_char *buf, /* buffer to put query */
501 + int buflen) /* size of buffer */
502 +{
503 + return (res_nmkquery(&_res, op, dname, class, type,
504 + data, datalen,
505 + newrr_in, buf, buflen));
506 +}
507 +
508 +#endif
509
510 void dorequest(char *s,int type,word id)
511 {
Personal OpenWRT clone
This page took 0.062454 seconds and 5 git commands to generate.