?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Use BIND's resolver in libc.
[dragonfly.git] / contrib / bind-9.3 / lib / bind / resolv / res_mkupdate.c
bloba135bf05477195aa66b44073f8a4fdc2865b98be
1 /*
2 * Copyright (c) 2004 by Internet Systems Consortium, Inc. ("ISC")
3 * Copyright (c) 1996-1999 by Internet Software Consortium.
4 *
5 * Permission to use, copy, modify, and distribute this software for any
6 * purpose with or without fee is hereby granted, provided that the above
7 * copyright notice and this permission notice appear in all copies.
8 *
9 * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
10 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR
12 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
15 * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16 */
17
18 /*
19 * Based on the Dynamic DNS reference implementation by Viraj Bais
20 * <viraj_bais@ccm.fm.intel.com>
21 */
22
23 #if !defined(lint) && !defined(SABER)
24 static const char rcsid[] = "$Id: res_mkupdate.c,v 1.1.2.1.4.5 2005/10/14 05:43:47 marka Exp $";
25 #endif /* not lint */
26
27 #include "port_before.h"
28
29 #include <sys/types.h>
30 #include <sys/param.h>
31
32 #include <netinet/in.h>
33 #include <arpa/nameser.h>
34 #include <arpa/inet.h>
35
36 #include <errno.h>
37 #include <limits.h>
38 #include <netdb.h>
39 #include <resolv.h>
40 #include <res_update.h>
41 #include <stdio.h>
42 #include <stdlib.h>
43 #include <string.h>
44 #include <unistd.h>
45 #include <ctype.h>
46
47 #ifdef _LIBC
48 #include "isc/list.h"
49 #endif
50 #include "port_after.h"
51
52 /* Options. Leave them on. */
53 #define DEBUG
54 #define MAXPORT 1024
55
56 static int getnum_str(u_char **, u_char *);
57 static int gethexnum_str(u_char **, u_char *);
58 static int getword_str(char *, int, u_char **, u_char *);
59 static int getstr_str(char *, int, u_char **, u_char *);
60
61 #define ShrinkBuffer(x) if ((buflen -= x) < 0) return (-2);
62
63 /* Forward. */
64 #ifdef _LIBC
65 static
66 #endif
67 int res_protocolnumber(const char *);
68 #ifdef _LIBC
69 static
70 #endif
71 int res_servicenumber(const char *);
72
73 /*
74 * Form update packets.
75 * Returns the size of the resulting packet if no error
76 * On error,
77 * returns -1 if error in reading a word/number in rdata
78 * portion for update packets
79 * -2 if length of buffer passed is insufficient
80 * -3 if zone section is not the first section in
81 * the linked list, or section order has a problem
82 * -4 on a number overflow
83 * -5 unknown operation or no records
84 */
85 int
86 res_nmkupdate(res_state statp, ns_updrec *rrecp_in, u_char *buf, int buflen) {
87 ns_updrec *rrecp_start = rrecp_in;
88 HEADER *hp;
89 u_char *cp, *sp2, *startp, *endp;
90 int n, i, soanum, multiline;
91 ns_updrec *rrecp;
92 struct in_addr ina;
93 struct in6_addr in6a;
94 char buf2[MAXDNAME];
95 u_char buf3[MAXDNAME];
96 int section, numrrs = 0, counts[ns_s_max];
97 u_int16_t rtype, rclass;
98 u_int32_t n1, rttl;
99 u_char *dnptrs[20], **dpp, **lastdnptr;
100 #ifndef _LIBC
101 int siglen;
102 #endif
103 int keylen, certlen;
104
105 /*
106 * Initialize header fields.
107 */
108 if ((buf == NULL) || (buflen < HFIXEDSZ))
109 return (-1);
110 memset(buf, 0, HFIXEDSZ);
111 hp = (HEADER *) buf;
112 hp->id = htons(++statp->id);
113 hp->opcode = ns_o_update;
114 hp->rcode = NOERROR;
115 cp = buf + HFIXEDSZ;
116 buflen -= HFIXEDSZ;
117 dpp = dnptrs;
118 *dpp++ = buf;
119 *dpp++ = NULL;
120 lastdnptr = dnptrs + sizeof dnptrs / sizeof dnptrs[0];
121
122 if (rrecp_start == NULL)
123 return (-5);
124 else if (rrecp_start->r_section != S_ZONE)
125 return (-3);
126
127 memset(counts, 0, sizeof counts);
128 for (rrecp = rrecp_start; rrecp; rrecp = NEXT(rrecp, r_glink)) {
129 numrrs++;
130 section = rrecp->r_section;
131 if (section < 0 || section >= ns_s_max)
132 return (-1);
133 counts[section]++;
134 for (i = section + 1; i < ns_s_max; i++)
135 if (counts[i])
136 return (-3);
137 rtype = rrecp->r_type;
138 rclass = rrecp->r_class;
139 rttl = rrecp->r_ttl;
140 /* overload class and type */
141 if (section == S_PREREQ) {
142 rttl = 0;
143 switch (rrecp->r_opcode) {
144 case YXDOMAIN:
145 rclass = C_ANY;
146 rtype = T_ANY;
147 rrecp->r_size = 0;
148 break;
149 case NXDOMAIN:
150 rclass = C_NONE;
151 rtype = T_ANY;
152 rrecp->r_size = 0;
153 break;
154 case NXRRSET:
155 rclass = C_NONE;
156 rrecp->r_size = 0;
157 break;
158 case YXRRSET:
159 if (rrecp->r_size == 0)
160 rclass = C_ANY;
161 break;
162 default:
163 fprintf(stderr,
164 "res_mkupdate: incorrect opcode: %d\n",
165 rrecp->r_opcode);
166 fflush(stderr);
167 return (-1);
168 }
169 } else if (section == S_UPDATE) {
170 switch (rrecp->r_opcode) {
171 case DELETE:
172 rclass = rrecp->r_size == 0 ? C_ANY : C_NONE;
173 break;
174 case ADD:
175 break;
176 default:
177 fprintf(stderr,
178 "res_mkupdate: incorrect opcode: %d\n",
179 rrecp->r_opcode);
180 fflush(stderr);
181 return (-1);
182 }
183 }
184
185 /*
186 * XXX appending default domain to owner name is omitted,
187 * fqdn must be provided
188 */
189 if ((n = dn_comp(rrecp->r_dname, cp, buflen, dnptrs,
190 lastdnptr)) < 0)
191 return (-1);
192 cp += n;
193 ShrinkBuffer(n + 2*INT16SZ);
194 PUTSHORT(rtype, cp);
195 PUTSHORT(rclass, cp);
196 if (section == S_ZONE) {
197 if (numrrs != 1 || rrecp->r_type != T_SOA)
198 return (-3);
199 continue;
200 }
201 ShrinkBuffer(INT32SZ + INT16SZ);
202 PUTLONG(rttl, cp);
203 sp2 = cp; /* save pointer to length byte */
204 cp += INT16SZ;
205 if (rrecp->r_size == 0) {
206 if (section == S_UPDATE && rclass != C_ANY)
207 return (-1);
208 else {
209 PUTSHORT(0, sp2);
210 continue;
211 }
212 }
213 startp = rrecp->r_data;
214 endp = startp + rrecp->r_size - 1;
215 /* XXX this should be done centrally. */
216 switch (rrecp->r_type) {
217 case T_A:
218 if (!getword_str(buf2, sizeof buf2, &startp, endp))
219 return (-1);
220 if (!inet_aton(buf2, &ina))
221 return (-1);
222 n1 = ntohl(ina.s_addr);
223 ShrinkBuffer(INT32SZ);
224 PUTLONG(n1, cp);
225 break;
226 case T_CNAME:
227 case T_MB:
228 case T_MG:
229 case T_MR:
230 case T_NS:
231 case T_PTR:
232 case ns_t_dname:
233 if (!getword_str(buf2, sizeof buf2, &startp, endp))
234 return (-1);
235 n = dn_comp(buf2, cp, buflen, dnptrs, lastdnptr);
236 if (n < 0)
237 return (-1);
238 cp += n;
239 ShrinkBuffer(n);
240 break;
241 case T_MINFO:
242 case T_SOA:
243 case T_RP:
244 for (i = 0; i < 2; i++) {
245 if (!getword_str(buf2, sizeof buf2, &startp,
246 endp))
247 return (-1);
248 n = dn_comp(buf2, cp, buflen,
249 dnptrs, lastdnptr);
250 if (n < 0)
251 return (-1);
252 cp += n;
253 ShrinkBuffer(n);
254 }
255 if (rrecp->r_type == T_SOA) {
256 ShrinkBuffer(5 * INT32SZ);
257 while (isspace(*startp) || !*startp)
258 startp++;
259 if (*startp == '(') {
260 multiline = 1;
261 startp++;
262 } else
263 multiline = 0;
264 /* serial, refresh, retry, expire, minimum */
265 for (i = 0; i < 5; i++) {
266 soanum = getnum_str(&startp, endp);
267 if (soanum < 0)
268 return (-1);
269 PUTLONG(soanum, cp);
270 }
271 if (multiline) {
272 while (isspace(*startp) || !*startp)
273 startp++;
274 if (*startp != ')')
275 return (-1);
276 }
277 }
278 break;
279 case T_MX:
280 case T_AFSDB:
281 case T_RT:
282 n = getnum_str(&startp, endp);
283 if (n < 0)
284 return (-1);
285 ShrinkBuffer(INT16SZ);
286 PUTSHORT(n, cp);
287 if (!getword_str(buf2, sizeof buf2, &startp, endp))
288 return (-1);
289 n = dn_comp(buf2, cp, buflen, dnptrs, lastdnptr);
290 if (n < 0)
291 return (-1);
292 cp += n;
293 ShrinkBuffer(n);
294 break;
295 case T_SRV:
296 n = getnum_str(&startp, endp);
297 if (n < 0)
298 return (-1);
299 ShrinkBuffer(INT16SZ);
300 PUTSHORT(n, cp);
301
302 n = getnum_str(&startp, endp);
303 if (n < 0)
304 return (-1);
305 ShrinkBuffer(INT16SZ);
306 PUTSHORT(n, cp);
307
308 n = getnum_str(&startp, endp);
309 if (n < 0)
310 return (-1);
311 ShrinkBuffer(INT16SZ);
312 PUTSHORT(n, cp);
313
314 if (!getword_str(buf2, sizeof buf2, &startp, endp))
315 return (-1);
316 n = dn_comp(buf2, cp, buflen, NULL, NULL);
317 if (n < 0)
318 return (-1);
319 cp += n;
320 ShrinkBuffer(n);
321 break;
322 case T_PX:
323 n = getnum_str(&startp, endp);
324 if (n < 0)
325 return (-1);
326 PUTSHORT(n, cp);
327 ShrinkBuffer(INT16SZ);
328 for (i = 0; i < 2; i++) {
329 if (!getword_str(buf2, sizeof buf2, &startp,
330 endp))
331 return (-1);
332 n = dn_comp(buf2, cp, buflen, dnptrs,
333 lastdnptr);
334 if (n < 0)
335 return (-1);
336 cp += n;
337 ShrinkBuffer(n);
338 }
339 break;
340 case T_WKS: {
341 char bm[MAXPORT/8];
342 unsigned int maxbm = 0;
343
344 if (!getword_str(buf2, sizeof buf2, &startp, endp))
345 return (-1);
346 if (!inet_aton(buf2, &ina))
347 return (-1);
348 n1 = ntohl(ina.s_addr);
349 ShrinkBuffer(INT32SZ);
350 PUTLONG(n1, cp);
351
352 if (!getword_str(buf2, sizeof buf2, &startp, endp))
353 return (-1);
354 if ((i = res_protocolnumber(buf2)) < 0)
355 return (-1);
356 ShrinkBuffer(1);
357 *cp++ = i & 0xff;
358
359 for (i = 0; i < MAXPORT/8 ; i++)
360 bm[i] = 0;
361
362 while (getword_str(buf2, sizeof buf2, &startp, endp)) {
363 if ((n = res_servicenumber(buf2)) <= 0)
364 return (-1);
365
366 if (n < MAXPORT) {
367 bm[n/8] |= (0x80>>(n%8));
368 if ((unsigned)n > maxbm)
369 maxbm = n;
370 } else
371 return (-1);
372 }
373 maxbm = maxbm/8 + 1;
374 ShrinkBuffer(maxbm);
375 memcpy(cp, bm, maxbm);
376 cp += maxbm;
377 break;
378 }
379 case T_HINFO:
380 for (i = 0; i < 2; i++) {
381 if ((n = getstr_str(buf2, sizeof buf2,
382 &startp, endp)) < 0)
383 return (-1);
384 if (n > 255)
385 return (-1);
386 ShrinkBuffer(n+1);
387 *cp++ = n;
388 memcpy(cp, buf2, n);
389 cp += n;
390 }
391 break;
392 case T_TXT:
393 for (;;) {
394 if ((n = getstr_str(buf2, sizeof buf2,
395 &startp, endp)) < 0) {
396 if (cp != (sp2 + INT16SZ))
397 break;
398 return (-1);
399 }
400 if (n > 255)
401 return (-1);
402 ShrinkBuffer(n+1);
403 *cp++ = n;
404 memcpy(cp, buf2, n);
405 cp += n;
406 }
407 break;
408 case T_X25:
409 /* RFC 1183 */
410 if ((n = getstr_str(buf2, sizeof buf2, &startp,
411 endp)) < 0)
412 return (-1);
413 if (n > 255)
414 return (-1);
415 ShrinkBuffer(n+1);
416 *cp++ = n;
417 memcpy(cp, buf2, n);
418 cp += n;
419 break;
420 case T_ISDN:
421 /* RFC 1183 */
422 if ((n = getstr_str(buf2, sizeof buf2, &startp,
423 endp)) < 0)
424 return (-1);
425 if ((n > 255) || (n == 0))
426 return (-1);
427 ShrinkBuffer(n+1);
428 *cp++ = n;
429 memcpy(cp, buf2, n);
430 cp += n;
431 if ((n = getstr_str(buf2, sizeof buf2, &startp,
432 endp)) < 0)
433 n = 0;
434 if (n > 255)
435 return (-1);
436 ShrinkBuffer(n+1);
437 *cp++ = n;
438 memcpy(cp, buf2, n);
439 cp += n;
440 break;
441 case T_NSAP:
442 if ((n = inet_nsap_addr((char *)startp, (u_char *)buf2, sizeof(buf2))) != 0) {
443 ShrinkBuffer(n);
444 memcpy(cp, buf2, n);
445 cp += n;
446 } else {
447 return (-1);
448 }
449 break;
450 case T_LOC:
451 if ((n = loc_aton((char *)startp, (u_char *)buf2)) != 0) {
452 ShrinkBuffer(n);
453 memcpy(cp, buf2, n);
454 cp += n;
455 } else
456 return (-1);
457 break;
458 case ns_t_sig:
459 #ifdef _LIBC
460 return (-1);
461 #else
462 {
463 int sig_type, success, dateerror;
464 u_int32_t exptime, timesigned;
465
466 /* type */
467 if ((n = getword_str(buf2, sizeof buf2,
468 &startp, endp)) < 0)
469 return (-1);
470 sig_type = sym_ston(__p_type_syms, buf2, &success);
471 if (!success || sig_type == ns_t_any)
472 return (-1);
473 ShrinkBuffer(INT16SZ);
474 PUTSHORT(sig_type, cp);
475 /* alg */
476 n = getnum_str(&startp, endp);
477 if (n < 0)
478 return (-1);
479 ShrinkBuffer(1);
480 *cp++ = n;
481 /* labels */
482 n = getnum_str(&startp, endp);
483 if (n <= 0 || n > 255)
484 return (-1);
485 ShrinkBuffer(1);
486 *cp++ = n;
487 /* ottl & expire */
488 if (!getword_str(buf2, sizeof buf2, &startp, endp))
489 return (-1);
490 exptime = ns_datetosecs(buf2, &dateerror);
491 if (!dateerror) {
492 ShrinkBuffer(INT32SZ);
493 PUTLONG(rttl, cp);
494 }
495 else {
496 char *ulendp;
497 u_int32_t ottl;
498
499 errno = 0;
500 ottl = strtoul(buf2, &ulendp, 10);
501 if (errno != 0 ||
502 (ulendp != NULL && *ulendp != '\0'))
503 return (-1);
504 ShrinkBuffer(INT32SZ);
505 PUTLONG(ottl, cp);
506 if (!getword_str(buf2, sizeof buf2, &startp,
507 endp))
508 return (-1);
509 exptime = ns_datetosecs(buf2, &dateerror);
510 if (dateerror)
511 return (-1);
512 }
513 /* expire */
514 ShrinkBuffer(INT32SZ);
515 PUTLONG(exptime, cp);
516 /* timesigned */
517 if (!getword_str(buf2, sizeof buf2, &startp, endp))
518 return (-1);
519 timesigned = ns_datetosecs(buf2, &dateerror);
520 if (!dateerror) {
521 ShrinkBuffer(INT32SZ);
522 PUTLONG(timesigned, cp);
523 }
524 else
525 return (-1);
526 /* footprint */
527 n = getnum_str(&startp, endp);
528 if (n < 0)
529 return (-1);
530 ShrinkBuffer(INT16SZ);
531 PUTSHORT(n, cp);
532 /* signer name */
533 if (!getword_str(buf2, sizeof buf2, &startp, endp))
534 return (-1);
535 n = dn_comp(buf2, cp, buflen, dnptrs, lastdnptr);
536 if (n < 0)
537 return (-1);
538 cp += n;
539 ShrinkBuffer(n);
540 /* sig */
541 if ((n = getword_str(buf2, sizeof buf2,
542 &startp, endp)) < 0)
543 return (-1);
544 siglen = b64_pton(buf2, buf3, sizeof(buf3));
545 if (siglen < 0)
546 return (-1);
547 ShrinkBuffer(siglen);
548 memcpy(cp, buf3, siglen);
549 cp += siglen;
550 break;
551 }
552 #endif
553 case ns_t_key:
554 /* flags */
555 n = gethexnum_str(&startp, endp);
556 if (n < 0)
557 return (-1);
558 ShrinkBuffer(INT16SZ);
559 PUTSHORT(n, cp);
560 /* proto */
561 n = getnum_str(&startp, endp);
562 if (n < 0)
563 return (-1);
564 ShrinkBuffer(1);
565 *cp++ = n;
566 /* alg */
567 n = getnum_str(&startp, endp);
568 if (n < 0)
569 return (-1);
570 ShrinkBuffer(1);
571 *cp++ = n;
572 /* key */
573 if ((n = getword_str(buf2, sizeof buf2,
574 &startp, endp)) < 0)
575 return (-1);
576 keylen = b64_pton(buf2, buf3, sizeof(buf3));
577 if (keylen < 0)
578 return (-1);
579 ShrinkBuffer(keylen);
580 memcpy(cp, buf3, keylen);
581 cp += keylen;
582 break;
583 case ns_t_nxt:
584 {
585 int success, nxt_type;
586 u_char data[32];
587 int maxtype;
588
589 /* next name */
590 if (!getword_str(buf2, sizeof buf2, &startp, endp))
591 return (-1);
592 n = dn_comp(buf2, cp, buflen, NULL, NULL);
593 if (n < 0)
594 return (-1);
595 cp += n;
596 ShrinkBuffer(n);
597 maxtype = 0;
598 memset(data, 0, sizeof data);
599 for (;;) {
600 if (!getword_str(buf2, sizeof buf2, &startp,
601 endp))
602 break;
603 nxt_type = sym_ston(__p_type_syms, buf2,
604 &success);
605 if (!success || !ns_t_rr_p(nxt_type))
606 return (-1);
607 NS_NXT_BIT_SET(nxt_type, data);
608 if (nxt_type > maxtype)
609 maxtype = nxt_type;
610 }
611 n = maxtype/NS_NXT_BITS+1;
612 ShrinkBuffer(n);
613 memcpy(cp, data, n);
614 cp += n;
615 break;
616 }
617 case ns_t_cert:
618 /* type */
619 n = getnum_str(&startp, endp);
620 if (n < 0)
621 return (-1);
622 ShrinkBuffer(INT16SZ);
623 PUTSHORT(n, cp);
624 /* key tag */
625 n = getnum_str(&startp, endp);
626 if (n < 0)
627 return (-1);
628 ShrinkBuffer(INT16SZ);
629 PUTSHORT(n, cp);
630 /* alg */
631 n = getnum_str(&startp, endp);
632 if (n < 0)
633 return (-1);
634 ShrinkBuffer(1);
635 *cp++ = n;
636 /* cert */
637 if ((n = getword_str(buf2, sizeof buf2,
638 &startp, endp)) < 0)
639 return (-1);
640 certlen = b64_pton(buf2, buf3, sizeof(buf3));
641 if (certlen < 0)
642 return (-1);
643 ShrinkBuffer(certlen);
644 memcpy(cp, buf3, certlen);
645 cp += certlen;
646 break;
647 case ns_t_aaaa:
648 if (!getword_str(buf2, sizeof buf2, &startp, endp))
649 return (-1);
650 if (inet_pton(AF_INET6, buf2, &in6a) <= 0)
651 return (-1);
652 ShrinkBuffer(NS_IN6ADDRSZ);
653 memcpy(cp, &in6a, NS_IN6ADDRSZ);
654 cp += NS_IN6ADDRSZ;
655 break;
656 case ns_t_naptr:
657 /* Order Preference Flags Service Replacement Regexp */
658 /* Order */
659 n = getnum_str(&startp, endp);
660 if (n < 0 || n > 65535)
661 return (-1);
662 ShrinkBuffer(INT16SZ);
663 PUTSHORT(n, cp);
664 /* Preference */
665 n = getnum_str(&startp, endp);
666 if (n < 0 || n > 65535)
667 return (-1);
668 ShrinkBuffer(INT16SZ);
669 PUTSHORT(n, cp);
670 /* Flags */
671 if ((n = getstr_str(buf2, sizeof buf2,
672 &startp, endp)) < 0) {
673 return (-1);
674 }
675 if (n > 255)
676 return (-1);
677 ShrinkBuffer(n+1);
678 *cp++ = n;
679 memcpy(cp, buf2, n);
680 cp += n;
681 /* Service Classes */
682 if ((n = getstr_str(buf2, sizeof buf2,
683 &startp, endp)) < 0) {
684 return (-1);
685 }
686 if (n > 255)
687 return (-1);
688 ShrinkBuffer(n+1);
689 *cp++ = n;
690 memcpy(cp, buf2, n);
691 cp += n;
692 /* Pattern */
693 if ((n = getstr_str(buf2, sizeof buf2,
694 &startp, endp)) < 0) {
695 return (-1);
696 }
697 if (n > 255)
698 return (-1);
699 ShrinkBuffer(n+1);
700 *cp++ = n;
701 memcpy(cp, buf2, n);
702 cp += n;
703 /* Replacement */
704 if (!getword_str(buf2, sizeof buf2, &startp, endp))
705 return (-1);
706 n = dn_comp(buf2, cp, buflen, NULL, NULL);
707 if (n < 0)
708 return (-1);
709 cp += n;
710 ShrinkBuffer(n);
711 break;
712 default:
713 return (-1);
714 } /*switch*/
715 n = (u_int16_t)((cp - sp2) - INT16SZ);
716 PUTSHORT(n, sp2);
717 } /*for*/
718
719 hp->qdcount = htons(counts[0]);
720 hp->ancount = htons(counts[1]);
721 hp->nscount = htons(counts[2]);
722 hp->arcount = htons(counts[3]);
723 return (cp - buf);
724 }
725
726 /*
727 * Get a whitespace delimited word from a string (not file)
728 * into buf. modify the start pointer to point after the
729 * word in the string.
730 */
731 static int
732 getword_str(char *buf, int size, u_char **startpp, u_char *endp) {
733 char *cp;
734 int c;
735
736 for (cp = buf; *startpp <= endp; ) {
737 c = **startpp;
738 if (isspace(c) || c == '\0') {
739 if (cp != buf) /* trailing whitespace */
740 break;
741 else { /* leading whitespace */
742 (*startpp)++;
743 continue;
744 }
745 }
746 (*startpp)++;
747 if (cp >= buf+size-1)
748 break;
749 *cp++ = (u_char)c;
750 }
751 *cp = '\0';
752 return (cp != buf);
753 }
754
755 /*
756 * get a white spae delimited string from memory. Process quoted strings
757 * and \DDD escapes. Return length or -1 on error. Returned string may
758 * contain nulls.
759 */
760 static char digits[] = "0123456789";
761 static int
762 getstr_str(char *buf, int size, u_char **startpp, u_char *endp) {
763 char *cp;
764 int c, c1 = 0;
765 int inquote = 0;
766 int seen_quote = 0;
767 int escape = 0;
768 int dig = 0;
769
770 for (cp = buf; *startpp <= endp; ) {
771 if ((c = **startpp) == '\0')
772 break;
773 /* leading white space */
774 if ((cp == buf) && !seen_quote && isspace(c)) {
775 (*startpp)++;
776 continue;
777 }
778
779 switch (c) {
780 case '\\':
781 if (!escape) {
782 escape = 1;
783 dig = 0;
784 c1 = 0;
785 (*startpp)++;
786 continue;
787 }
788 goto do_escape;
789 case '"':
790 if (!escape) {
791 inquote = !inquote;
792 seen_quote = 1;
793 (*startpp)++;
794 continue;
795 }
796 /* fall through */
797 default:
798 do_escape:
799 if (escape) {
800 switch (c) {
801 case '0':
802 case '1':
803 case '2':
804 case '3':
805 case '4':
806 case '5':
807 case '6':
808 case '7':
809 case '8':
810 case '9':
811 c1 = c1 * 10 +
812 (strchr(digits, c) - digits);
813
814 if (++dig == 3) {
815 c = c1 &0xff;
816 break;
817 }
818 (*startpp)++;
819 continue;
820 }
821 escape = 0;
822 } else if (!inquote && isspace(c))
823 goto done;
824 if (cp >= buf+size-1)
825 goto done;
826 *cp++ = (u_char)c;
827 (*startpp)++;
828 }
829 }
830 done:
831 *cp = '\0';
832 return ((cp == buf)? (seen_quote? 0: -1): (cp - buf));
833 }
834 /*
835 * Get a whitespace delimited base 16 number from a string (not file) into buf
836 * update the start pointer to point after the number in the string.
837 */
838 static int
839 gethexnum_str(u_char **startpp, u_char *endp) {
840 int c, n;
841 int seendigit = 0;
842 int m = 0;
843
844 if (*startpp + 2 >= endp || strncasecmp((char *)*startpp, "0x", 2) != 0)
845 return getnum_str(startpp, endp);
846 (*startpp)+=2;
847 for (n = 0; *startpp <= endp; ) {
848 c = **startpp;
849 if (isspace(c) || c == '\0') {
850 if (seendigit) /* trailing whitespace */
851 break;
852 else { /* leading whitespace */
853 (*startpp)++;
854 continue;
855 }
856 }
857 if (c == ';') {
858 while ((*startpp <= endp) &&
859 ((c = **startpp) != '\n'))
860 (*startpp)++;
861 if (seendigit)
862 break;
863 continue;
864 }
865 if (!isxdigit(c)) {
866 if (c == ')' && seendigit) {
867 (*startpp)--;
868 break;
869 }
870 return (-1);
871 }
872 (*startpp)++;
873 if (isdigit(c))
874 n = n * 16 + (c - '0');
875 else
876 n = n * 16 + (tolower(c) - 'a' + 10);
877 seendigit = 1;
878 }
879 return (n + m);
880 }
881
882 /*
883 * Get a whitespace delimited base 10 number from a string (not file) into buf
884 * update the start pointer to point after the number in the string.
885 */
886 static int
887 getnum_str(u_char **startpp, u_char *endp) {
888 int c, n;
889 int seendigit = 0;
890 int m = 0;
891
892 for (n = 0; *startpp <= endp; ) {
893 c = **startpp;
894 if (isspace(c) || c == '\0') {
895 if (seendigit) /* trailing whitespace */
896 break;
897 else { /* leading whitespace */
898 (*startpp)++;
899 continue;
900 }
901 }
902 if (c == ';') {
903 while ((*startpp <= endp) &&
904 ((c = **startpp) != '\n'))
905 (*startpp)++;
906 if (seendigit)
907 break;
908 continue;
909 }
910 if (!isdigit(c)) {
911 if (c == ')' && seendigit) {
912 (*startpp)--;
913 break;
914 }
915 return (-1);
916 }
917 (*startpp)++;
918 n = n * 10 + (c - '0');
919 seendigit = 1;
920 }
921 return (n + m);
922 }
923
924 /*
925 * Allocate a resource record buffer & save rr info.
926 */
927 ns_updrec *
928 res_mkupdrec(int section, const char *dname,
929 u_int class, u_int type, u_long ttl) {
930 ns_updrec *rrecp = (ns_updrec *)calloc(1, sizeof(ns_updrec));
931
932 if (!rrecp || !(rrecp->r_dname = strdup(dname))) {
933 if (rrecp)
934 free((char *)rrecp);
935 return (NULL);
936 }
937 INIT_LINK(rrecp, r_link);
938 INIT_LINK(rrecp, r_glink);
939 rrecp->r_class = (ns_class)class;
940 rrecp->r_type = (ns_type)type;
941 rrecp->r_ttl = ttl;
942 rrecp->r_section = (ns_sect)section;
943 return (rrecp);
944 }
945
946 /*
947 * Free a resource record buffer created by res_mkupdrec.
948 */
949 void
950 res_freeupdrec(ns_updrec *rrecp) {
951 /* Note: freeing r_dp is the caller's responsibility. */
952 if (rrecp->r_dname != NULL)
953 free(rrecp->r_dname);
954 free(rrecp);
955 }
956
957 struct valuelist {
958 struct valuelist * next;
959 struct valuelist * prev;
960 char * name;
961 char * proto;
962 int port;
963 };
964 static struct valuelist *servicelist, *protolist;
965
966 static void
967 res_buildservicelist() {
968 struct servent *sp;
969 struct valuelist *slp;
970
971 #ifdef MAYBE_HESIOD
972 setservent(0);
973 #else
974 setservent(1);
975 #endif
976 while ((sp = getservent()) != NULL) {
977 slp = (struct valuelist *)malloc(sizeof(struct valuelist));
978 if (!slp)
979 break;
980 slp->name = strdup(sp->s_name);
981 slp->proto = strdup(sp->s_proto);
982 if ((slp->name == NULL) || (slp->proto == NULL)) {
983 if (slp->name) free(slp->name);
984 if (slp->proto) free(slp->proto);
985 free(slp);
986 break;
987 }
988 slp->port = ntohs((u_int16_t)sp->s_port); /* host byt order */
989 slp->next = servicelist;
990 slp->prev = NULL;
991 if (servicelist)
992 servicelist->prev = slp;
993 servicelist = slp;
994 }
995 endservent();
996 }
997
998 #ifndef _LIBC
999 void
1000 res_destroyservicelist() {
1001 struct valuelist *slp, *slp_next;
1002
1003 for (slp = servicelist; slp != NULL; slp = slp_next) {
1004 slp_next = slp->next;
1005 free(slp->name);
1006 free(slp->proto);
1007 free(slp);
1008 }
1009 servicelist = (struct valuelist *)0;
1010 }
1011 #endif
1012
1013 void
1014 res_buildprotolist(void) {
1015 struct protoent *pp;
1016 struct valuelist *slp;
1017
1018 #ifdef MAYBE_HESIOD
1019 setprotoent(0);
1020 #else
1021 setprotoent(1);
1022 #endif
1023 while ((pp = getprotoent()) != NULL) {
1024 slp = (struct valuelist *)malloc(sizeof(struct valuelist));
1025 if (!slp)
1026 break;
1027 slp->name = strdup(pp->p_name);
1028 if (slp->name == NULL) {
1029 free(slp);
1030 break;
1031 }
1032 slp->port = pp->p_proto; /* host byte order */
1033 slp->next = protolist;
1034 slp->prev = NULL;
1035 if (protolist)
1036 protolist->prev = slp;
1037 protolist = slp;
1038 }
1039 endprotoent();
1040 }
1041
1042 #ifndef _LIBC
1043 void
1044 res_destroyprotolist(void) {
1045 struct valuelist *plp, *plp_next;
1046
1047 for (plp = protolist; plp != NULL; plp = plp_next) {
1048 plp_next = plp->next;
1049 free(plp->name);
1050 free(plp);
1051 }
1052 protolist = (struct valuelist *)0;
1053 }
1054 #endif
1055
1056 static int
1057 findservice(const char *s, struct valuelist **list) {
1058 struct valuelist *lp = *list;
1059 int n;
1060
1061 for (; lp != NULL; lp = lp->next)
1062 if (strcasecmp(lp->name, s) == 0) {
1063 if (lp != *list) {
1064 lp->prev->next = lp->next;
1065 if (lp->next)
1066 lp->next->prev = lp->prev;
1067 (*list)->prev = lp;
1068 lp->next = *list;
1069 *list = lp;
1070 }
1071 return (lp->port); /* host byte order */
1072 }
1073 if (sscanf(s, "%d", &n) != 1 || n <= 0)
1074 n = -1;
1075 return (n);
1076 }
1077
1078 /*
1079 * Convert service name or (ascii) number to int.
1080 */
1081 #ifdef _LIBC
1082 static
1083 #endif
1084 int
1085 res_servicenumber(const char *p) {
1086 if (servicelist == (struct valuelist *)0)
1087 res_buildservicelist();
1088 return (findservice(p, &servicelist));
1089 }
1090
1091 /*
1092 * Convert protocol name or (ascii) number to int.
1093 */
1094 #ifdef _LIBC
1095 static
1096 #endif
1097 int
1098 res_protocolnumber(const char *p) {
1099 if (protolist == (struct valuelist *)0)
1100 res_buildprotolist();
1101 return (findservice(p, &protolist));
1102 }
1103
1104 #ifndef _LIBC
1105 static struct servent *
1106 cgetservbyport(u_int16_t port, const char *proto) { /* Host byte order. */
1107 struct valuelist **list = &servicelist;
1108 struct valuelist *lp = *list;
1109 static struct servent serv;
1110
1111 port = ntohs(port);
1112 for (; lp != NULL; lp = lp->next) {
1113 if (port != (u_int16_t)lp->port) /* Host byte order. */
1114 continue;
1115 if (strcasecmp(lp->proto, proto) == 0) {
1116 if (lp != *list) {
1117 lp->prev->next = lp->next;
1118 if (lp->next)
1119 lp->next->prev = lp->prev;
1120 (*list)->prev = lp;
1121 lp->next = *list;
1122 *list = lp;
1123 }
1124 serv.s_name = lp->name;
1125 serv.s_port = htons((u_int16_t)lp->port);
1126 serv.s_proto = lp->proto;
1127 return (&serv);
1128 }
1129 }
1130 return (0);
1131 }
1132
1133 static struct protoent *
1134 cgetprotobynumber(int proto) { /* Host byte order. */
1135 struct valuelist **list = &protolist;
1136 struct valuelist *lp = *list;
1137 static struct protoent prot;
1138
1139 for (; lp != NULL; lp = lp->next)
1140 if (lp->port == proto) { /* Host byte order. */
1141 if (lp != *list) {
1142 lp->prev->next = lp->next;
1143 if (lp->next)
1144 lp->next->prev = lp->prev;
1145 (*list)->prev = lp;
1146 lp->next = *list;
1147 *list = lp;
1148 }
1149 prot.p_name = lp->name;
1150 prot.p_proto = lp->port; /* Host byte order. */
1151 return (&prot);
1152 }
1153 return (0);
1154 }
1155
1156 const char *
1157 res_protocolname(int num) {
1158 static char number[8];
1159 struct protoent *pp;
1160
1161 if (protolist == (struct valuelist *)0)
1162 res_buildprotolist();
1163 pp = cgetprotobynumber(num);
1164 if (pp == 0) {
1165 (void) sprintf(number, "%d", num);
1166 return (number);
1167 }
1168 return (pp->p_name);
1169 }
1170
1171 const char *
1172 res_servicename(u_int16_t port, const char *proto) { /* Host byte order. */
1173 static char number[8];
1174 struct servent *ss;
1175
1176 if (servicelist == (struct valuelist *)0)
1177 res_buildservicelist();
1178 ss = cgetservbyport(htons(port), proto);
1179 if (ss == 0) {
1180 (void) sprintf(number, "%d", port);
1181 return (number);
1182 }
1183 return (ss->s_name);
1184 }
1185 #endif
DragonFly BSD