BSD 4_3_Net_2 release

[unix-history] / usr / src / lib / libc / net / gethostnamadr.c

diff --git a/usr/src/lib/libc/net/gethostnamadr.c b/usr/src/lib/libc/net/gethostnamadr.c
index 57d4be4..a451cb8 100644 (file)
--- a/usr/src/lib/libc/net/gethostnamadr.c
+++ b/usr/src/lib/libc/net/gethostnamadr.c
@@ -1,88 +1,433 @@
-/*     gethostnamadr.c 4.4     84/01/31        */
+/*
+ * Copyright (c) 1985, 1988 Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *     This product includes software developed by the University of
+ *     California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */

 
 

-#include <stdio.h>
+#if defined(LIBC_SCCS) && !defined(lint)
+static char sccsid[] = "@(#)gethostnamadr.c    6.45 (Berkeley) 2/24/91";
+#endif /* LIBC_SCCS and not lint */
+
+#include <sys/param.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <arpa/nameser.h>

 #include <netdb.h>
 #include <netdb.h>

-#include <sys/file.h>
-#include <ndbm.h>
+#include <resolv.h>
+#include <stdio.h>
+#include <ctype.h>
+#include <errno.h>
+#include <string.h>

 
 #define        MAXALIASES      35
 
 #define        MAXALIASES      35

+#define        MAXADDRS        35
+
+static char *h_addr_ptrs[MAXADDRS + 1];

 
 

-static char HOSTDB[] = "/etc/hosts";
-DBM *_host_db = (DBM *)NULL;

 static struct hostent host;
 static char *host_aliases[MAXALIASES];
 static char hostbuf[BUFSIZ+1];
 static struct hostent host;
 static char *host_aliases[MAXALIASES];
 static char hostbuf[BUFSIZ+1];

-int _host_stayopen;    /* set by sethostent(), cleared by endhostent() */
+static struct in_addr host_addr;
+static FILE *hostf = NULL;
+static char hostaddr[MAXADDRS];
+static char *host_addrs[2];
+static int stayopen = 0;
+char *strpbrk();
+
+#if PACKETSZ > 1024
+#define        MAXPACKET       PACKETSZ
+#else
+#define        MAXPACKET       1024
+#endif
+
+typedef union {
+    HEADER hdr;
+    u_char buf[MAXPACKET];
+} querybuf;
+
+typedef union {
+    long al;
+    char ac;
+} align;
+
+int h_errno;

 
 static struct hostent *
 
 static struct hostent *

-fetchhost(key)
-       datum key;
+getanswer(answer, anslen, iquery)
+       querybuf *answer;
+       int anslen;
+       int iquery;

 {
 {

-        register char *cp, *tp, **ap;
-       register int naliases;
-
-        if (key.dptr == 0)
-                return ((struct hostent *)NULL);
-       key = dbmfetch(_host_db, key);
-       if (key.dptr == 0)
-                return ((struct hostent *)NULL);
-        cp = key.dptr;
-       tp = hostbuf;
-       host.h_name = tp;
-       while (*tp++ = *cp++)
-               ;
-       naliases = *(int *)cp; cp += sizeof (int);
-       for (ap = host_aliases; naliases > 0; naliases--) {
-               *ap++ = tp;
-               while (*tp++ = *cp++)
-                       ;
+       register HEADER *hp;
+       register u_char *cp;
+       register int n;
+       u_char *eom;
+       char *bp, **ap;
+       int type, class, buflen, ancount, qdcount;
+       int haveanswer, getclass = C_ANY;
+       char **hap;
+
+       eom = answer->buf + anslen;
+       /*
+        * find first satisfactory answer
+        */
+       hp = &answer->hdr;
+       ancount = ntohs(hp->ancount);
+       qdcount = ntohs(hp->qdcount);
+       bp = hostbuf;
+       buflen = sizeof(hostbuf);
+       cp = answer->buf + sizeof(HEADER);
+       if (qdcount) {
+               if (iquery) {
+                       if ((n = dn_expand((u_char *)answer->buf,
+                           (u_char *)eom, (u_char *)cp, (u_char *)bp,
+                           buflen)) < 0) {
+                               h_errno = NO_RECOVERY;
+                               return ((struct hostent *) NULL);
+                       }
+                       cp += n + QFIXEDSZ;
+                       host.h_name = bp;
+                       n = strlen(bp) + 1;
+                       bp += n;
+                       buflen -= n;
+               } else
+                       cp += __dn_skipname(cp, eom) + QFIXEDSZ;
+               while (--qdcount > 0)
+                       cp += __dn_skipname(cp, eom) + QFIXEDSZ;
+       } else if (iquery) {
+               if (hp->aa)
+                       h_errno = HOST_NOT_FOUND;
+               else
+                       h_errno = TRY_AGAIN;
+               return ((struct hostent *) NULL);

        }
        }

-       *ap = (char *)NULL;
+       ap = host_aliases;
+       *ap = NULL;

        host.h_aliases = host_aliases;
        host.h_aliases = host_aliases;

-       host.h_addrtype = *(int *)cp; cp += sizeof (int);
-       host.h_length = *(int *)cp; cp += sizeof (int);
-       host.h_addr = tp;
-       bcopy(cp, tp, host.h_length);
-        return (&host);
+       hap = h_addr_ptrs;
+       *hap = NULL;
+#if BSD >= 43 || defined(h_addr)       /* new-style hostent structure */
+       host.h_addr_list = h_addr_ptrs;
+#endif
+       haveanswer = 0;
+       while (--ancount >= 0 && cp < eom) {
+               if ((n = dn_expand((u_char *)answer->buf, (u_char *)eom,
+                   (u_char *)cp, (u_char *)bp, buflen)) < 0)
+                       break;
+               cp += n;
+               type = _getshort(cp);
+               cp += sizeof(u_short);
+               class = _getshort(cp);
+               cp += sizeof(u_short) + sizeof(u_long);
+               n = _getshort(cp);
+               cp += sizeof(u_short);
+               if (type == T_CNAME) {
+                       cp += n;
+                       if (ap >= &host_aliases[MAXALIASES-1])
+                               continue;
+                       *ap++ = bp;
+                       n = strlen(bp) + 1;
+                       bp += n;
+                       buflen -= n;
+                       continue;
+               }
+               if (iquery && type == T_PTR) {
+                       if ((n = dn_expand((u_char *)answer->buf,
+                           (u_char *)eom, (u_char *)cp, (u_char *)bp,
+                           buflen)) < 0) {
+                               cp += n;
+                               continue;
+                       }
+                       cp += n;
+                       host.h_name = bp;
+                       return(&host);
+               }
+               if (iquery || type != T_A)  {
+#ifdef DEBUG
+                       if (_res.options & RES_DEBUG)
+                               printf("unexpected answer type %d, size %d\n",
+                                       type, n);
+#endif
+                       cp += n;
+                       continue;
+               }
+               if (haveanswer) {
+                       if (n != host.h_length) {
+                               cp += n;
+                               continue;
+                       }
+                       if (class != getclass) {
+                               cp += n;
+                               continue;
+                       }
+               } else {
+                       host.h_length = n;
+                       getclass = class;
+                       host.h_addrtype = (class == C_IN) ? AF_INET : AF_UNSPEC;
+                       if (!iquery) {
+                               host.h_name = bp;
+                               bp += strlen(bp) + 1;
+                       }
+               }
+
+               bp += sizeof(align) - ((u_long)bp % sizeof(align));
+
+               if (bp + n >= &hostbuf[sizeof(hostbuf)]) {
+#ifdef DEBUG
+                       if (_res.options & RES_DEBUG)
+                               printf("size (%d) too big\n", n);
+#endif
+                       break;
+               }
+               bcopy(cp, *hap++ = bp, n);
+               bp +=n;
+               cp += n;
+               haveanswer++;
+       }
+       if (haveanswer) {
+               *ap = NULL;
+#if BSD >= 43 || defined(h_addr)       /* new-style hostent structure */
+               *hap = NULL;
+#else
+               host.h_addr = h_addr_ptrs[0];
+#endif
+               return (&host);
+       } else {
+               h_errno = TRY_AGAIN;
+               return ((struct hostent *) NULL);
+       }

 }
 
 struct hostent *
 }
 
 struct hostent *

-gethostbyname(nam)
-       char *nam;
+gethostbyname(name)
+       char *name;

 {
 {

-        datum key;
-       register struct hostent *hp;
+       querybuf buf;
+       register char *cp;
+       int n;
+       extern struct hostent *_gethtbyname();
+
+       /*
+        * disallow names consisting only of digits/dots, unless
+        * they end in a dot.
+        */
+       if (isdigit(name[0]))
+               for (cp = name;; ++cp) {
+                       if (!*cp) {
+                               if (*--cp == '.')
+                                       break;
+                               /*
+                                * All-numeric, no dot at the end.
+                                * Fake up a hostent as if we'd actually
+                                * done a lookup.  What if someone types
+                                * 255.255.255.255?  The test below will
+                                * succeed spuriously... ???
+                                */
+                               if ((host_addr.s_addr = inet_addr(name)) == -1) {
+                                       h_errno = HOST_NOT_FOUND;
+                                       return((struct hostent *) NULL);
+                               }
+                               host.h_name = name;
+                               host.h_aliases = host_aliases;
+                               host_aliases[0] = NULL;
+                               host.h_addrtype = AF_INET;
+                               host.h_length = sizeof(u_long);
+                               h_addr_ptrs[0] = (char *)&host_addr;
+                               h_addr_ptrs[1] = (char *)0;
+#if BSD >= 43 || defined(h_addr)       /* new-style hostent structure */
+                               host.h_addr_list = h_addr_ptrs;
+#else
+                               host.h_addr = h_addr_ptrs[0];
+#endif
+                               return (&host);
+                       }
+                       if (!isdigit(*cp) && *cp != '.') 
+                               break;
+               }

 
 

-       if ((_host_db == (DBM *)NULL)
-         && ((_host_db = ndbmopen(HOSTDB, O_RDONLY)) == (DBM *)NULL))
-                return ((struct hostent *)NULL);
-        key.dptr = nam;
-        key.dsize = strlen(nam);
-       hp = fetchhost(key);
-       if (!_host_stayopen) {
-               ndbmclose(_host_db);
-               _host_db = (DBM *)NULL;
+       if ((n = res_search(name, C_IN, T_A, buf.buf, sizeof(buf))) < 0) {
+#ifdef DEBUG
+               if (_res.options & RES_DEBUG)
+                       printf("res_search failed\n");
+#endif
+               if (errno == ECONNREFUSED)
+                       return (_gethtbyname(name));
+               else
+                       return ((struct hostent *) NULL);

        }
        }

-        return (hp);
+       return (getanswer(&buf, n, 0));

 }
 
 struct hostent *
 }
 
 struct hostent *

-gethostbyaddr(addr, length)
-       char *addr;
-       int length;
+gethostbyaddr(addr, len, type)
+       const char *addr;
+       int len, type;

 {
 {

-        datum key;
+       int n;
+       querybuf buf;

        register struct hostent *hp;
        register struct hostent *hp;

+       char qbuf[MAXDNAME];
+       extern struct hostent *_gethtbyaddr();
+       
+       if (type != AF_INET)
+               return ((struct hostent *) NULL);
+       (void)sprintf(qbuf, "%u.%u.%u.%u.in-addr.arpa",
+               ((unsigned)addr[3] & 0xff),
+               ((unsigned)addr[2] & 0xff),
+               ((unsigned)addr[1] & 0xff),
+               ((unsigned)addr[0] & 0xff));
+       n = res_query(qbuf, C_IN, T_PTR, (char *)&buf, sizeof(buf));
+       if (n < 0) {
+#ifdef DEBUG
+               if (_res.options & RES_DEBUG)
+                       printf("res_query failed\n");
+#endif
+               if (errno == ECONNREFUSED)
+                       return (_gethtbyaddr(addr, len, type));
+               return ((struct hostent *) NULL);
+       }
+       hp = getanswer(&buf, n, 1);
+       if (hp == NULL)
+               return ((struct hostent *) NULL);
+       hp->h_addrtype = type;
+       hp->h_length = len;
+       h_addr_ptrs[0] = (char *)&host_addr;
+       h_addr_ptrs[1] = (char *)0;
+       host_addr = *(struct in_addr *)addr;
+#if BSD < 43 && !defined(h_addr)       /* new-style hostent structure */
+       hp->h_addr = h_addr_ptrs[0];
+#endif
+       return(hp);
+}

 
 

-       if ((_host_db == (DBM *)NULL)
-         && ((_host_db = ndbmopen(HOSTDB, O_RDONLY)) == (DBM *)NULL))
-                return ((struct hostent *)NULL);
-        key.dptr = addr;
-        key.dsize = length;
-       hp = fetchhost(key);
-       if (!_host_stayopen) {
-               ndbmclose(_host_db);
-               _host_db = (DBM *)NULL;
+_sethtent(f)
+       int f;
+{
+       if (hostf == NULL)
+               hostf = fopen(_PATH_HOSTS, "r" );
+       else
+               rewind(hostf);
+       stayopen |= f;
+}
+
+_endhtent()
+{
+       if (hostf && !stayopen) {
+               (void) fclose(hostf);
+               hostf = NULL;
+       }
+}
+
+struct hostent *
+_gethtent()
+{
+       char *p;
+       register char *cp, **q;
+
+       if (hostf == NULL && (hostf = fopen(_PATH_HOSTS, "r" )) == NULL)
+               return (NULL);
+again:
+       if ((p = fgets(hostbuf, BUFSIZ, hostf)) == NULL)
+               return (NULL);
+       if (*p == '#')
+               goto again;
+       cp = strpbrk(p, "#\n");
+       if (cp == NULL)
+               goto again;
+       *cp = '\0';
+       cp = strpbrk(p, " \t");
+       if (cp == NULL)
+               goto again;
+       *cp++ = '\0';
+       /* THIS STUFF IS INTERNET SPECIFIC */
+#if BSD >= 43 || defined(h_addr)       /* new-style hostent structure */
+       host.h_addr_list = host_addrs;
+#endif
+       host.h_addr = hostaddr;
+       *((u_long *)host.h_addr) = inet_addr(p);
+       host.h_length = sizeof (u_long);
+       host.h_addrtype = AF_INET;
+       while (*cp == ' ' || *cp == '\t')
+               cp++;
+       host.h_name = cp;
+       q = host.h_aliases = host_aliases;
+       cp = strpbrk(cp, " \t");
+       if (cp != NULL) 
+               *cp++ = '\0';
+       while (cp && *cp) {
+               if (*cp == ' ' || *cp == '\t') {
+                       cp++;
+                       continue;
+               }
+               if (q < &host_aliases[MAXALIASES - 1])
+                       *q++ = cp;
+               cp = strpbrk(cp, " \t");
+               if (cp != NULL)
+                       *cp++ = '\0';
+       }
+       *q = NULL;
+       return (&host);
+}
+
+struct hostent *
+_gethtbyname(name)
+       char *name;
+{
+       register struct hostent *p;
+       register char **cp;
+       
+       _sethtent(0);
+       while (p = _gethtent()) {
+               if (strcasecmp(p->h_name, name) == 0)
+                       break;
+               for (cp = p->h_aliases; *cp != 0; cp++)
+                       if (strcasecmp(*cp, name) == 0)
+                               goto found;

        }
        }

-        return (hp);
+found:
+       _endhtent();
+       return (p);
+}
+
+struct hostent *
+_gethtbyaddr(addr, len, type)
+       const char *addr;
+       int len, type;
+{
+       register struct hostent *p;
+
+       _sethtent(0);
+       while (p = _gethtent())
+               if (p->h_addrtype == type && !bcmp(p->h_addr, addr, len))
+                       break;
+       _endhtent();
+       return (p);

 }
 }