Incorporated from BIND-4.9.3-BETA26.
[kopensolaris-gnu/glibc.git] / resolv / gethnamaddr.c
1 /*
2  * ++Copyright++ 1985, 1988, 1993
3  * -
4  * Copyright (c) 1985, 1988, 1993
5  *    The Regents of the University of California.  All rights reserved.
6  * 
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  * 2. Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  * 3. All advertising materials mentioning features or use of this software
16  *    must display the following acknowledgement:
17  *      This product includes software developed by the University of
18  *      California, Berkeley and its contributors.
19  * 4. Neither the name of the University nor the names of its contributors
20  *    may be used to endorse or promote products derived from this software
21  *    without specific prior written permission.
22  * 
23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33  * SUCH DAMAGE.
34  * -
35  * Portions Copyright (c) 1993 by Digital Equipment Corporation.
36  * 
37  * Permission to use, copy, modify, and distribute this software for any
38  * purpose with or without fee is hereby granted, provided that the above
39  * copyright notice and this permission notice appear in all copies, and that
40  * the name of Digital Equipment Corporation not be used in advertising or
41  * publicity pertaining to distribution of the document or software without
42  * specific, written prior permission.
43  * 
44  * THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL
45  * WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES
46  * OF MERCHANTABILITY AND FITNESS.   IN NO EVENT SHALL DIGITAL EQUIPMENT
47  * CORPORATION BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
48  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
49  * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
50  * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
51  * SOFTWARE.
52  * -
53  * --Copyright--
54  */
55
56 #if defined(LIBC_SCCS) && !defined(lint)
57 static char sccsid[] = "@(#)gethostnamadr.c     8.1 (Berkeley) 6/4/93";
58 static char rcsid[] = "$Id$";
59 #endif /* LIBC_SCCS and not lint */
60
61 #include <sys/param.h>
62 #include <sys/socket.h>
63 #include <netinet/in.h>
64 #include <arpa/inet.h>
65 #include <arpa/nameser.h>
66
67 #include <stdio.h>
68 #include <netdb.h>
69 #include <resolv.h>
70 #include <ctype.h>
71 #include <errno.h>
72 #include <syslog.h>
73
74 #ifndef LOG_AUTH
75 # define LOG_AUTH 0
76 #endif
77
78 #define MULTI_PTRS_ARE_ALIASES 1        /* XXX - experimental */
79
80 #if defined(BSD) && (BSD >= 199103)
81 # include <string.h>
82 #else
83 # include "../conf/portability.h"
84 #endif
85 #if defined(USE_OPTIONS_H)
86 # include <../conf/options.h>
87 #endif
88
89 #define MAXALIASES      35
90 #define MAXADDRS        35
91
92 static const char AskedForGot[] =
93                           "gethostby*.getanswer: asked for \"%s\", got \"%s\"";
94
95 static char *h_addr_ptrs[MAXADDRS + 1];
96 static struct hostent *gethostbyname_ipv4 __P((const char *));
97
98 static struct hostent host;
99 static char *host_aliases[MAXALIASES];
100 static char hostbuf[8*1024];
101 static struct in_addr host_addr;
102 static FILE *hostf = NULL;
103 static int stayopen = 0;
104
105 #ifdef RESOLVSORT
106 static void addrsort __P((char **, int));
107 #endif
108
109 #if PACKETSZ > 1024
110 #define MAXPACKET       PACKETSZ
111 #else
112 #define MAXPACKET       1024
113 #endif
114
115 typedef union {
116     HEADER hdr;
117     u_char buf[MAXPACKET];
118 } querybuf;
119
120 typedef union {
121     int32_t al;
122     char ac;
123 } align;
124
125 extern int h_errno;
126
127 #ifdef DEBUG
128 static void
129 dprintf(msg, num)
130         char *msg;
131         int num;
132 {
133         if (_res.options & RES_DEBUG) {
134                 int save = errno;
135
136                 printf(msg, num);
137                 errno = save;
138         }
139 }
140 #else
141 # define dprintf(msg, num) /*nada*/
142 #endif
143
144 static struct hostent *
145 getanswer(answer, anslen, qname, qclass, qtype)
146         const querybuf *answer;
147         int anslen;
148         const char *qname;
149         int qclass, qtype;
150 {
151         register const HEADER *hp;
152         register const u_char *cp;
153         register int n;
154         const u_char *eom;
155         char *bp, **ap, **hap;
156         int type, class, buflen, ancount, qdcount;
157         int haveanswer, had_error;
158         int toobig = 0;
159         char tbuf[MAXDNAME+1];
160         const char *tname;
161
162         tname = qname;
163         host.h_name = NULL;
164         eom = answer->buf + anslen;
165         /*
166          * find first satisfactory answer
167          */
168         hp = &answer->hdr;
169         ancount = ntohs(hp->ancount);
170         qdcount = ntohs(hp->qdcount);
171         bp = hostbuf;
172         buflen = sizeof hostbuf;
173         cp = answer->buf + HFIXEDSZ;
174         if (qdcount != 1) {
175                 h_errno = NO_RECOVERY;
176                 return (NULL);
177         }
178         if ((n = dn_expand(answer->buf, eom, cp, bp, buflen)) < 0) {
179                 h_errno = NO_RECOVERY;
180                 return (NULL);
181         }
182         cp += n + QFIXEDSZ;
183         if (qtype == T_A) {
184                 /* res_send() has already verified that the query name is the
185                  * same as the one we sent; this just gets the expanded name
186                  * (i.e., with the succeeding search-domain tacked on).
187                  */
188                 n = strlen(bp) + 1;             /* for the \0 */
189                 host.h_name = bp;
190                 bp += n;
191                 buflen -= n;
192                 /* The qname can be abbreviated, but h_name is now absolute. */
193                 qname = host.h_name;
194         }
195         ap = host_aliases;
196         *ap = NULL;
197         host.h_aliases = host_aliases;
198         hap = h_addr_ptrs;
199         *hap = NULL;
200 #if BSD >= 43 || defined(h_addr)        /* new-style hostent structure */
201         host.h_addr_list = h_addr_ptrs;
202 #endif
203         haveanswer = 0;
204         had_error = 0;
205         while (ancount-- > 0 && cp < eom && !had_error) {
206                 n = dn_expand(answer->buf, eom, cp, bp, buflen);
207                 if (n < 0) {
208                         had_error++;
209                         continue;
210                 }
211                 cp += n;                        /* name */
212                 type = _getshort(cp);
213                 cp += INT16SZ;                  /* type */
214                 class = _getshort(cp);
215                 cp += INT16SZ + INT32SZ;        /* class, TTL */
216                 n = _getshort(cp);
217                 cp += INT16SZ;                  /* len */
218                 if (class != qclass) {
219                         /* XXX - debug? syslog? */
220                         cp += n;
221                         continue;               /* XXX - had_error++ ? */
222                 }
223                 if (qtype == T_A && type == T_CNAME) {
224                         if (ap >= &host_aliases[MAXALIASES-1])
225                                 continue;
226                         n = dn_expand(answer->buf, eom, cp, tbuf, sizeof tbuf);
227                         if (n < 0) {
228                                 had_error++;
229                                 continue;
230                         }
231                         cp += n;
232                         if (host.h_name && strcasecmp(host.h_name, bp) != 0) {
233                                 syslog(LOG_NOTICE|LOG_AUTH,
234                 "gethostby*.getanswer: asked for \"%s\", got CNAME for \"%s\"",
235                                        host.h_name, bp);
236                                 continue;       /* XXX - had_error++ ? */
237                         }
238                         /* Store alias. */
239                         *ap++ = bp;
240                         n = strlen(bp) + 1;     /* for the \0 */
241                         bp += n;
242                         buflen -= n;
243                         /* Get canonical name. */
244                         n = strlen(tbuf) + 1;   /* for the \0 */
245                         if (n > buflen) {
246                                 had_error++;
247                                 continue;
248                         }
249                         strcpy(bp, tbuf);
250                         host.h_name = bp;
251                         bp += n;
252                         buflen -= n;
253                         continue;
254                 }
255                 if (qtype == T_PTR && type == T_CNAME) {
256                         n = dn_expand(answer->buf, eom, cp, tbuf, sizeof tbuf);
257                         if (n < 0) {
258                                 had_error++;
259                                 continue;
260                         }
261                         cp += n;
262                         /* Get canonical name. */
263                         n = strlen(tbuf) + 1;   /* for the \0 */
264                         if (n > buflen) {
265                                 had_error++;
266                                 continue;
267                         }
268                         strcpy(bp, tbuf);
269                         tname = bp;
270                         bp += n;
271                         buflen -= n;
272                         continue;
273                 }
274                 if (type != qtype) {
275                         syslog(LOG_NOTICE|LOG_AUTH,
276                "gethostby*.getanswer: asked for \"%s %s %s\", got type \"%s\"",
277                                qname, p_class(qclass), p_type(qtype),
278                                p_type(type));
279                         cp += n;
280                         continue;               /* XXX - had_error++ ? */
281                 }
282                 switch (type) {
283                 case T_PTR:
284                         if (strcasecmp(tname, bp) != 0) {
285                                 syslog(LOG_NOTICE|LOG_AUTH,
286                                        AskedForGot, qname, bp);
287                                 cp += n;
288                                 continue;       /* XXX - had_error++ ? */
289                         }
290                         n = dn_expand(answer->buf, eom, cp, bp, buflen);
291                         if (n < 0) {
292                                 had_error++;
293                                 break;
294                         }
295 #if MULTI_PTRS_ARE_ALIASES
296                         cp += n;
297                         if (!haveanswer)
298                                 host.h_name = bp;
299                         else if (ap < &host_aliases[MAXALIASES-1])
300                                 *ap++ = bp;
301                         else
302                                 n = -1;
303                         if (n != -1) {
304                                 n = strlen(bp) + 1;     /* for the \0 */
305                                 bp += n;
306                                 buflen -= n;
307                         }
308                         break;
309 #else
310                         host.h_name = bp;
311                         h_errno = NETDB_SUCCESS;
312                         return (&host);
313 #endif
314                 case T_A:
315                         if (strcasecmp(host.h_name, bp) != 0) {
316                                 syslog(LOG_NOTICE|LOG_AUTH,
317                                        AskedForGot, host.h_name, bp);
318                                 cp += n;
319                                 continue;       /* XXX - had_error++ ? */
320                         }
321                         if (haveanswer) {
322                                 if (n != host.h_length) {
323                                         cp += n;
324                                         continue;
325                                 }
326                         } else {
327                                 register int nn;
328
329                                 host.h_length = n;
330                                 host.h_addrtype = (class == C_IN)
331                                                   ? AF_INET
332                                                   : AF_UNSPEC;
333                                 host.h_name = bp;
334                                 nn = strlen(bp) + 1;    /* for the \0 */
335                                 bp += nn;
336                                 buflen -= nn;
337                         }
338
339                         bp += sizeof(align) - ((u_long)bp % sizeof(align));
340
341                         if (bp + n >= &hostbuf[sizeof hostbuf]) {
342                                 dprintf("size (%d) too big\n", n);
343                                 had_error++;
344                                 continue;
345                         }
346                         if (hap >= &h_addr_ptrs[MAXADDRS-1]) {
347                                 if (!toobig++)
348                                         dprintf("Too many addresses (%d)\n",
349                                                 MAXADDRS);
350                                 cp += n;
351                                 continue;
352                         }
353                         bcopy(cp, *hap++ = bp, n);
354                         bp += n;
355                         cp += n;
356                         break;
357                 default:
358                         dprintf("Impossible condition (type=%d)\n", type);
359                         h_errno = NO_RECOVERY;
360                         return (NULL);
361                 } /*switch*/
362                 if (!had_error)
363                         haveanswer++;
364         } /*while*/
365         if (haveanswer) {
366                 *ap = NULL;
367                 *hap = NULL;
368 # if defined(RESOLVSORT)
369                 /*
370                  * Note: we sort even if host can take only one address
371                  * in its return structures - should give it the "best"
372                  * address in that case, not some random one
373                  */
374                 if (_res.nsort && haveanswer > 1 &&
375                     qclass == C_IN && qtype == T_A)
376                         addrsort(h_addr_ptrs, haveanswer);
377 # endif /*RESOLVSORT*/
378 #if BSD >= 43 || defined(h_addr)        /* new-style hostent structure */
379                 /* nothing */
380 #else
381                 host.h_addr = h_addr_ptrs[0];
382 #endif /*BSD*/
383                 if (!host.h_name) {
384                         n = strlen(qname) + 1;  /* for the \0 */
385                         strcpy(bp, qname);
386                         host.h_name = bp;
387                 }
388                 h_errno = NETDB_SUCCESS;
389                 return (&host);
390         } else {
391                 h_errno = TRY_AGAIN;
392                 return (NULL);
393         }
394 }
395
396 struct hostent *
397 gethostbyname(name)
398         const char *name;
399 {
400         struct hostent *hp;
401
402 #if defined(AF_INET6) && defined(RES_TRY_INET6)
403         if (_res.options & RES_TRY_INET6) {
404                 hp = gethostbyname2(name, AF_INET6);
405                 if (hp)
406                         return (hp);
407         }
408 #endif
409         return (gethostbyname2(name, AF_INET));
410 }
411
412 struct hostent *
413 gethostbyname2(name, af)
414         const char *name;
415         int af;
416 {
417         switch (af) {
418         case AF_INET:
419                 return (gethostbyname_ipv4(name));
420         }
421         errno = EAFNOSUPPORT;
422         h_errno = NETDB_INTERNAL;
423         return (NULL);
424 }
425
426 static struct hostent *
427 gethostbyname_ipv4(name)
428         const char *name;
429 {
430         querybuf buf;
431         register const char *cp;
432         int n;
433         extern struct hostent *_gethtbyname();
434
435         if ((_res.options & RES_INIT) == 0 && res_init() == -1) {
436                 h_errno = NETDB_INTERNAL;
437                 return (NULL);
438         }
439
440         /*
441          * if there aren't any dots, it could be a user-level alias.
442          * this is also done in res_query() since we are not the only
443          * function that looks up host names.
444          */
445         if (!strchr(name, '.') && (cp = __hostalias(name)))
446                 name = cp;
447
448         /*
449          * disallow names consisting only of digits/dots, unless
450          * they end in a dot.
451          */
452         if (isdigit(name[0]))
453                 for (cp = name;; ++cp) {
454                         if (!*cp) {
455                                 if (*--cp == '.')
456                                         break;
457                                 /*
458                                  * All-numeric, no dot at the end.
459                                  * Fake up a hostent as if we'd actually
460                                  * done a lookup.
461                                  */
462                                 if (!inet_aton(name, &host_addr)) {
463                                         h_errno = HOST_NOT_FOUND;
464                                         return (NULL);
465                                 }
466                                 strncpy(hostbuf, name, MAXDNAME);
467                                 hostbuf[MAXDNAME] = '\0';
468                                 host.h_name = hostbuf;
469                                 host.h_aliases = host_aliases;
470                                 host_aliases[0] = NULL;
471                                 host.h_addrtype = AF_INET;
472                                 host.h_length = INT32SZ;
473                                 h_addr_ptrs[0] = (char *)&host_addr;
474                                 h_addr_ptrs[1] = NULL;
475 #if BSD >= 43 || defined(h_addr)        /* new-style hostent structure */
476                                 host.h_addr_list = h_addr_ptrs;
477 #else
478                                 host.h_addr = h_addr_ptrs[0];
479 #endif
480                                 h_errno = NETDB_SUCCESS;
481                                 return (&host);
482                         }
483                         if (!isdigit(*cp) && *cp != '.') 
484                                 break;
485                 }
486
487         if ((n = res_search(name, C_IN, T_A, buf.buf, sizeof(buf))) < 0) {
488                 dprintf("res_search failed (%d)\n", n);
489                 if (errno == ECONNREFUSED)
490                         return (_gethtbyname(name));
491                 return (NULL);
492         }
493         return (getanswer(&buf, n, name, C_IN, T_A));
494 }
495
496 struct hostent *
497 gethostbyaddr(addr, len, type)
498         const char *addr;
499         int len, type;
500 {
501         int n;
502         querybuf buf;
503         register struct hostent *hp;
504         char qbuf[MAXDNAME+1];
505 #ifdef SUNSECURITY
506         register struct hostent *rhp;
507         char **haddr;
508         u_long old_options;
509         char hname2[MAXDNAME+1];
510 #endif /*SUNSECURITY*/
511         extern struct hostent *_gethtbyaddr();
512         
513         if ((_res.options & RES_INIT) == 0 && res_init() == -1) {
514                 h_errno = NETDB_INTERNAL;
515                 return (NULL);
516         }
517         if (type != AF_INET) {
518                 errno = EAFNOSUPPORT;
519                 h_errno = NETDB_INTERNAL;
520                 return (NULL);
521         }
522         (void)sprintf(qbuf, "%u.%u.%u.%u.in-addr.arpa",
523                 ((unsigned)addr[3] & 0xff),
524                 ((unsigned)addr[2] & 0xff),
525                 ((unsigned)addr[1] & 0xff),
526                 ((unsigned)addr[0] & 0xff));
527         n = res_query(qbuf, C_IN, T_PTR, (u_char *)buf.buf, sizeof buf.buf);
528         if (n < 0) {
529                 dprintf("res_query failed (%d)\n", n);
530                 if (errno == ECONNREFUSED)
531                         return (_gethtbyaddr(addr, len, type));
532                 return (NULL);
533         }
534         if (!(hp = getanswer(&buf, n, qbuf, C_IN, T_PTR)))
535                 return (NULL);  /* h_errno was set by getanswer() */
536 #ifdef SUNSECURITY
537         /*
538          * turn off search as the name should be absolute,
539          * 'localhost' should be matched by defnames
540          */
541         strncpy(hname2, hp->h_name, MAXDNAME);
542         hname2[MAXDNAME] = '\0';
543         old_options = _res.options;
544         _res.options &= ~RES_DNSRCH;
545         _res.options |= RES_DEFNAMES;
546         if (!(rhp = gethostbyname(hname2))) {
547                 syslog(LOG_NOTICE|LOG_AUTH,
548                        "gethostbyaddr: No A record for %s (verifying [%s])",
549                        hname2, inet_ntoa(*((struct in_addr *)addr)));
550                 _res.options = old_options;
551                 h_errno = HOST_NOT_FOUND;
552                 return (NULL);
553         }
554         _res.options = old_options;
555         for (haddr = rhp->h_addr_list; *haddr; haddr++)
556                 if (!memcmp(*haddr, addr, INADDRSZ))
557                         break;
558         if (!*haddr) {
559                 syslog(LOG_NOTICE|LOG_AUTH,
560                        "gethostbyaddr: A record of %s != PTR record [%s]",
561                        hname2, inet_ntoa(*((struct in_addr *)addr)));
562                 h_errno = HOST_NOT_FOUND;
563                 return (NULL);
564         }
565 #endif /*SUNSECURITY*/
566         hp->h_addrtype = type;
567         hp->h_length = len;
568         h_addr_ptrs[0] = (char *)&host_addr;
569         h_addr_ptrs[1] = NULL;
570         host_addr = *(struct in_addr *)addr;
571         h_errno = NETDB_SUCCESS;
572         return (hp);
573 }
574
575 void
576 _sethtent(f)
577         int f;
578 {
579         if (!hostf)
580                 hostf = fopen(_PATH_HOSTS, "r" );
581         else
582                 rewind(hostf);
583         stayopen = f;
584 }
585
586 void
587 _endhtent()
588 {
589         if (hostf && !stayopen) {
590                 (void) fclose(hostf);
591                 hostf = NULL;
592         }
593 }
594
595 struct hostent *
596 _gethtent()
597 {
598         char *p;
599         register char *cp, **q;
600
601         if (!hostf && !(hostf = fopen(_PATH_HOSTS, "r" ))) {
602                 h_errno = NETDB_INTERNAL;
603                 return (NULL);
604         }
605 again:
606         if (!(p = fgets(hostbuf, sizeof hostbuf, hostf))) {
607                 h_errno = HOST_NOT_FOUND;
608                 return (NULL);
609         }
610         if (*p == '#')
611                 goto again;
612         if (!(cp = strpbrk(p, "#\n")))
613                 goto again;
614         *cp = '\0';
615         if (!(cp = strpbrk(p, " \t")))
616                 goto again;
617         *cp++ = '\0';
618         /* THIS STUFF IS INTERNET SPECIFIC */
619         if (!inet_aton(p, &host_addr))
620                 goto again;
621         h_addr_ptrs[0] = (char *)&host_addr;
622         h_addr_ptrs[1] = NULL;
623 #if BSD >= 43 || defined(h_addr)        /* new-style hostent structure */
624         host.h_addr_list = h_addr_ptrs;
625 #else
626         host.h_addr = h_addr_ptrs[0];
627 #endif
628         host.h_length = INT32SZ;
629         host.h_addrtype = AF_INET;
630         while (*cp == ' ' || *cp == '\t')
631                 cp++;
632         host.h_name = cp;
633         q = host.h_aliases = host_aliases;
634         if (cp = strpbrk(cp, " \t"))
635                 *cp++ = '\0';
636         while (cp && *cp) {
637                 if (*cp == ' ' || *cp == '\t') {
638                         cp++;
639                         continue;
640                 }
641                 if (q < &host_aliases[MAXALIASES - 1])
642                         *q++ = cp;
643                 if (cp = strpbrk(cp, " \t"))
644                         *cp++ = '\0';
645         }
646         *q = NULL;
647         h_errno = NETDB_SUCCESS;
648         return (&host);
649 }
650
651 struct hostent *
652 _gethtbyname(name)
653         char *name;
654 {
655         register struct hostent *p;
656         register char **cp;
657         
658         _sethtent(0);
659         while (p = _gethtent()) {
660                 if (strcasecmp(p->h_name, name) == 0)
661                         break;
662                 for (cp = p->h_aliases; *cp != 0; cp++)
663                         if (strcasecmp(*cp, name) == 0)
664                                 goto found;
665         }
666 found:
667         _endhtent();
668         return (p);
669 }
670
671 struct hostent *
672 _gethtbyaddr(addr, len, type)
673         const char *addr;
674         int len, type;
675 {
676         register struct hostent *p;
677
678         _sethtent(0);
679         while (p = _gethtent())
680                 if (p->h_addrtype == type && !bcmp(p->h_addr, addr, len))
681                         break;
682         _endhtent();
683         return (p);
684 }
685
686 #ifdef RESOLVSORT
687 static void
688 addrsort(ap, num)
689         char **ap;
690         int num;
691 {
692         int i, j;
693         char **p;
694         short aval[MAXADDRS];
695         int needsort = 0;
696
697         p = ap;
698         for (i = 0; i < num; i++, p++) {
699             for (j = 0 ; (unsigned)j < _res.nsort; j++)
700                 if (_res.sort_list[j].addr.s_addr == 
701                     (((struct in_addr *)(*p))->s_addr & _res.sort_list[j].mask))
702                         break;
703             aval[i] = j;
704             if (needsort == 0 && i > 0 && j < aval[i-1])
705                 needsort = i;
706         }
707         if (!needsort)
708             return;
709
710         while (needsort < num) {
711             for (j = needsort - 1; j >= 0; j--) {
712                 if (aval[j] > aval[j+1]) {
713                     char *hp;
714
715                     i = aval[j];
716                     aval[j] = aval[j+1];
717                     aval[j+1] = i;
718
719                     hp = ap[j];
720                     ap[j] = ap[j+1];
721                     ap[j+1] = hp;
722
723                 } else
724                     break;
725             }
726             needsort++;
727         }
728 }
729 #endif
730
731 #if defined(BSD43_BSD43_NFS) || defined(sun)
732 /* some libc's out there are bound internally to these names (UMIPS) */
733 void
734 ht_sethostent(stayopen)
735         int stayopen;
736 {
737         _sethtent(stayopen);
738 }
739
740 void
741 ht_endhostent()
742 {
743         _endhtent();
744 }
745
746 struct hostent *
747 ht_gethostbyname(name)
748         char *name;
749 {
750         return (_gethtbyname(name));
751 }
752
753 struct hostent *
754 ht_gethostbyaddr(addr, len, type)
755         const char *addr;
756         int len, type;
757 {
758         return (_gethtbyaddr(addr, len, type));
759 }
760
761 struct hostent *
762 gethostent()
763 {
764         return (_gethtent());
765 }
766
767 void
768 dns_service()
769 {
770         return;
771 }
772
773 #undef dn_skipname
774 dn_skipname(comp_dn, eom)
775         const u_char *comp_dn, *eom;
776 {
777         return (__dn_skipname(comp_dn, eom));
778 }
779 #endif /*old-style libc with yp junk in it*/