BSD 4_3_Net_1 release

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

/*
* Copyright (c) 1983 Regents of the University of California.
* All rights reserved.
*
* Redistribution and use in source and binary forms are permitted
* provided that the above copyright notice and this paragraph are
* duplicated in all such forms and that any documentation,
* advertising materials, and other materials related to such
* distribution and use acknowledge that the software was developed
* by the University of California, Berkeley.  The name of the
* University may not be used to endorse or promote products derived
* from this software without specific prior written permission.
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*/

#if defined(LIBC_SCCS) && !defined(lint)
static char sccsid[] = "@(#)gethostnamadr.c     5.7 (Berkeley) 6/27/88";
#endif /* LIBC_SCCS and not lint */

#include <stdio.h>
#include <netdb.h>
#include <sys/file.h>
#include <ndbm.h>
#include <ctype.h>

#define MAXALIASES      35

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

int h_errno;

/*
* The following is shared with gethostent.c
*/
extern  char *_host_file;
DBM     *_host_db = (DBM *)NULL;
int     _host_stayopen; /* set by sethostent(), cleared by endhostent() */

static struct hostent *
fetchhost(key)
       datum key;
{
       register char *cp, *tp, **ap;
       int naliases;

       if (key.dptr == 0)
               return ((struct hostent *)NULL);
       key = dbm_fetch(_host_db, key);
       if (key.dptr == 0)
               return ((struct hostent *)NULL);
       cp = key.dptr;
       tp = hostbuf;
       host.h_name = tp;
       while (*tp++ = *cp++)
               ;
       bcopy(cp, (char *)&naliases, sizeof(int)); cp += sizeof (int);
       for (ap = host_aliases; naliases > 0; naliases--) {
               *ap++ = tp;
               while (*tp++ = *cp++)
                       ;
       }
       *ap = (char *)NULL;
       host.h_aliases = host_aliases;
       bcopy(cp, (char *)&host.h_addrtype, sizeof (int));
       cp += sizeof (int);
       bcopy(cp, (char *)&host.h_length, sizeof (int));
       cp += sizeof (int);
       host.h_addr_list = host_addrs;
       host.h_addr = tp;
       bcopy(cp, tp, host.h_length);
       return (&host);
}

struct hostent *
gethostbyname(nam)
       register char *nam;
{
       register struct hostent *hp;
       register char **cp;
       datum key;
       char lowname[128];
       register char *lp = lowname;
       
       while (*nam)
               if (isupper(*nam))
                       *lp++ = tolower(*nam++);
               else
                       *lp++ = *nam++;
       *lp = '\0';

       if ((_host_db == (DBM *)NULL)
         && ((_host_db = dbm_open(_host_file, O_RDONLY)) == (DBM *)NULL)) {
               sethostent(_host_stayopen);
               while (hp = gethostent()) {
                       if (strcmp(hp->h_name, lowname) == 0)
                               break;
                       for (cp = hp->h_aliases; cp != 0 && *cp != 0; cp++)
                               if (strcmp(*cp, lowname) == 0)
                                       goto found;
               }
       found:
               if (!_host_stayopen)
                       endhostent();
               return (hp);
       }
       key.dptr = lowname;
       key.dsize = strlen(lowname);
       hp = fetchhost(key);
       if (!_host_stayopen) {
               dbm_close(_host_db);
               _host_db = (DBM *)NULL;
       }
       if ( hp == NULL)
               h_errno = HOST_NOT_FOUND;
       return (hp);
}

struct hostent *
gethostbyaddr(addr, length, type)
       char *addr;
       register int length;
       register int type;
{
       register struct hostent *hp;
       datum key;

       if ((_host_db == (DBM *)NULL)
         && ((_host_db = dbm_open(_host_file, O_RDONLY)) == (DBM *)NULL)) {
               sethostent(_host_stayopen);
               while (hp = gethostent()) {
                       if (hp->h_addrtype == type && hp->h_length == length
                           && bcmp(hp->h_addr, addr, length) == 0)
                               break;
               }
               if (!_host_stayopen)
                       endhostent();
               if ( hp == NULL)
                       h_errno = HOST_NOT_FOUND;
               return (hp);
       }
       key.dptr = addr;
       key.dsize = length;
       hp = fetchhost(key);
       if (!_host_stayopen) {
               dbm_close(_host_db);
               _host_db = (DBM *)NULL;
       }
       if ( hp == NULL)
               h_errno = HOST_NOT_FOUND;
       return (hp);
}