# 2.11BSD#431 - /usr/src/usr.sbin/mkhosts/mkhosts.c

##### Functions

    keylower          X
    main              X
    merge             X

##### Variables

    buf               X
    copyright         X

##### Macros

    MAXADDRS          X
    MAXALIASES        X

       1: /*
       2:  * Copyright (c) 1983 Regents of the University of California.
       3:  * All rights reserved.  The Berkeley software License Agreement
       4:  * specifies the terms and conditions for redistribution.
       5:  */
       6:
       7: #if !defined(lint) && defined(DOSCCS)
       8: char copyright[] =
       9: "@(#) Copyright (c) 1980 Regents of the University of California.\n\
      10:  All rights reserved.\n";
      11:
      12: /* static char sccsid[] = "@(#)mkhosts.c	5.1 (Berkeley) 5/28/85"; */
      13: static char sccsid[] = "@(#)mkhosts.c	1.2 (2.11BSD) 1995/08/17";
      14: #endif
      15:
      16: #include <ctype.h>
      17: #include <sys/param.h>
      18: #include <sys/file.h>
      19: #include <stdio.h>
      20: #include <netdb.h>
      21: #include <ndbm.h>
      22:
      23: void    keylower();
      24: char    buf[BUFSIZ];
      25:
      26: main(argc, argv)
      27:     char *argv[];
      28: {
      29:     DBM *dp;
      30:     register struct hostent *hp;
      31:     struct hostent *hp2;
      32:     datum key, content;
      33:     register char *cp, *tp, **sp;
      34:     register int *nap;
      35:     int naliases, naddrs;
      36:     int verbose = 0, entries = 0, maxlen = 0, error = 0;
      37:     char tempname[BUFSIZ], newname[BUFSIZ];
      38:     char lowname[MAXHOSTNAMELEN + 1];
      39:
      40:     if (argc > 1 && strcmp(argv[1], "-v") == 0) {
      41:         verbose++;
      42:         argv++, argc--;
      43:     }
      44:     if (argc != 2) {
      45:         fprintf(stderr, "usage: mkhosts [ -v ] file\n");
      46:         exit(1);
      47:     }
      48:     if (access(argv[1], R_OK) < 0) {
      49:         perror(argv[1]);
      50:         exit(1);
      51:     }
      52:     umask(0);
      53:
      54:     sprintf(tempname, "%s.new", argv[1]);
      55:     dp = dbm_open(tempname, O_WRONLY|O_CREAT|O_EXCL, 0644);
      56:     if (dp == NULL) {
      57:         fprintf(stderr, "dbm_open failed: ");
      58:         perror(argv[1]);
      59:         exit(1);
      60:     }
      61:     sethostfile(argv[1]);
      62:     sethostent(1);
      63:     while (hp = gethostent()) {
      64:         cp = buf;
      65:         tp = hp->h_name;
      66:         while (*cp++ = *tp++)
      67:             ;
      68:         nap = (int *)cp;
      69:         cp += sizeof (int);
      70:
      71:         keylower(lowname, hp->h_name);
      72:         key.dptr = lowname;
      73:         key.dsize = strlen(lowname);
      74: /*
      75: 			key.dptr = hp->h_name;
      76: 			key.dsize = strlen(hp->h_name);
      77: */
      78:         hp2 = (struct hostent *)fetchhost(dp, key);
      79:         if (hp2) {
      80:             merge(hp, hp2);
      81:             hp = hp2;
      82:         }
      83:         naliases = 0;
      84:         for (sp = hp->h_aliases; *sp; sp++) {
      85:             tp = *sp;
      86:             while (*cp++ = *tp++)
      87:                 ;
      88:             naliases++;
      89:         }
      90:         bcopy((char *)&naliases, (char *)nap, sizeof(int));
      91:         bcopy((char *)&hp->h_addrtype, cp, sizeof (int));
      92:         cp += sizeof (int);
      93:         bcopy((char *)&hp->h_length, cp, sizeof (int));
      94:         cp += sizeof (int);
      95:         for (naddrs = 0, sp = hp->h_addr_list; *sp; sp++) {
      96:             bcopy(*sp, cp, hp->h_length);
      97:             cp += hp->h_length;
      98:             naddrs++;
      99:         }
     100:         content.dptr = buf;
     101:         content.dsize = cp - buf;
     102:         if (verbose)
     103:             printf("store %s, %d aliases %d addresses\n", hp->h_name, naliases, naddrs);
     104:         if (dbm_store(dp, key, content, DBM_REPLACE) < 0) {
     105:             perror(hp->h_name);
     106:             goto err;
     107:         }
     108:         for (sp = hp->h_aliases; *sp; sp++) {
     109:             keylower(lowname, *sp);
     110:             key.dptr = lowname;
     111:             key.dsize = strlen(lowname);
     112: /*
     113: 				key.dptr = *sp;
     114: 				key.dsize = strlen(*sp);
     115: */
     116:             if (dbm_store(dp, key, content, DBM_REPLACE) < 0) {
     117:                 perror(*sp);
     118:                 goto err;
     119:             }
     120:         }
     121:         for (sp = hp->h_addr_list; *sp; sp++) {
     122:             key.dptr = *sp;
     123:             key.dsize = hp->h_length;
     124:             if (dbm_store(dp, key, content, DBM_REPLACE) < 0) {
     125:                 perror("dbm_store host address");
     126:                 goto err;
     127:             }
     128:         }
     129:         entries++;
     130:         if (cp - buf > maxlen)
     131:             maxlen = cp - buf;
     132:     }
     133:     endhostent();
     134:     dbm_close(dp);
     135:
     136:     sprintf(tempname, "%s.new.pag", argv[1]);
     137:     sprintf(newname, "%s.pag", argv[1]);
     138:     if (rename(tempname, newname) < 0) {
     139:         perror("rename .pag");
     140:         exit(1);
     141:     }
     142:     sprintf(tempname, "%s.new.dir", argv[1]);
     143:     sprintf(newname, "%s.dir", argv[1]);
     144:     if (rename(tempname, newname) < 0) {
     145:         perror("rename .dir");
     146:         exit(1);
     147:     }
     148:     printf("%d host entries, maximum length %d\n", entries, maxlen);
     149:     exit(0);
     150: err:
     151:     sprintf(tempname, "%s.new.pag", argv[1]);
     152:     unlink(tempname);
     153:     sprintf(tempname, "%s.new.dir", argv[1]);
     154:     unlink(tempname);
     155:     exit(1);
     156: }
     157:
     158: /* following code lifted from libc/net/hosttable/gethnamadr.c */
     159:
     160: #define MAXALIASES  35
     161: #define MAXADDRS    10
     162:
     163: static  struct  hostent host2;
     164: static  char    *hstaliases[MAXALIASES];
     165: static  char    *hstaddrs[MAXADDRS];
     166: static  char    buf2[BUFSIZ];
     167:
     168: static struct hostent *
     169: fetchhost(dp, key)
     170:     DBM *dp;
     171:     datum key;
     172: {
     173:         register char *cp, **ap;
     174:     register int naddrs;
     175:     int naliases;
     176:
     177:     key = dbm_fetch(dp, key);
     178:     if (key.dptr == 0)
     179:                 return ((struct hostent *)NULL);
     180:     bcopy(key.dptr, buf2, key.dsize);
     181:         cp = buf2;
     182:     host2.h_name = cp;
     183:     while (*cp++)
     184:         ;
     185:     bcopy(cp, (char *)&naliases, sizeof(int));
     186:     cp += sizeof (int);
     187:     for (ap = hstaliases; naliases > 0; naliases--) {
     188:         *ap++ = cp;
     189:         while (*cp++)
     190:             ;
     191:     }
     192:     *ap = (char *)NULL;
     193:     host2.h_aliases = hstaliases;
     194:     bcopy(cp, (char *)&host2.h_addrtype, sizeof (int));
     195:     cp += sizeof (int);
     196:     bcopy(cp, (char *)&host2.h_length, sizeof (int));
     197:     cp += sizeof (int);
     198:     host2.h_addr_list = hstaddrs;
     199:     naddrs = (key.dsize - (cp - buf2)) / host2.h_length;
     200:     if (naddrs > MAXADDRS)
     201:         naddrs = MAXADDRS;
     202:     for (ap = hstaddrs; naddrs; naddrs--) {
     203:         *ap++ = cp;
     204:         cp += host2.h_length;
     205:     }
     206:     *ap = (char *)NULL;
     207:         return (&host2);
     208: }
     209:
     210: merge(hp2, hp)
     211:     struct  hostent *hp2, *hp;
     212: {
     213: register char   **sp, **sp2;
     214:     char    **endalias, **endadr, **hp2ali, **hp2adr;
     215:     long    l;
     216:
     217:     hp2ali = &hp2->h_aliases[0];
     218:     hp2adr = &hp2->h_addr_list[0];
     219:
     220:     for (sp = hp->h_addr_list; *sp; sp++)
     221:         ;
     222:     endadr = sp;
     223:     for (sp = hp->h_aliases; *sp; sp++)
     224:         ;
     225:     endalias = sp;
     226:     for (sp = hp->h_aliases; *sp && *hp2ali; sp++) {
     227:         for (sp2 = hp2ali; *sp2; sp2++) {
     228:             if (!strcmp(*sp2, *sp))
     229:                 break;
     230:         }
     231:         if (*sp2 == (char *)NULL) {
     232:             *endalias++ = *hp2ali++;
     233:             *endalias = (char *)NULL;
     234:         }
     235:     }
     236:     for (sp = hp->h_addr_list; *sp && *hp2adr; sp++) {
     237:         for (sp2 = hp2adr; *sp2; sp2++) {
     238:             if (!bcmp(*sp2, *sp, hp->h_length))
     239:                 break;
     240:         }
     241:         if (*sp2 == (char *)NULL) {
     242:             *endadr++ = *hp2adr++;
     243:             *endadr = (char *)NULL;
     244:         }
     245:     }
     246: }
     247:
     248: void
     249: keylower(out, in)
     250:     register char *out, *in;
     251:     {
     252:
     253:     while   (*in)
     254:         {
     255:         if  (isupper(*in))
     256:             *out++ = tolower(*in++);
     257:         else
     258:             *out++ = *in++;
     259:         }
     260:     *out++ = '\0';
     261:     }

#### Defined functions

fetchhost defined in line 168; used 1 times

- in line 78

keylower defined in line 248; used 3 times

- in line 23, 71, 109

main defined in line 26; never used
merge defined in line 210; used 1 times

- in line 80

#### Defined variables

buf defined in line 24; used 5 times

- in line 64, 100-101(2), 130-131(2)

buf2 defined in line 166; used 3 times

- in line 180-181(2), 199

copyright defined in line 8; never used
host2 defined in line 163; used 8 times

- in line 182, 193-207(7)

hstaddrs defined in line 165; used 2 times

- in line 198-202(2)

hstaliases defined in line 164; used 2 times

- in line 187, 193

sccsid defined in line 13; never used

#### Defined macros

MAXADDRS defined in line 161; used 3 times

- in line 165, 200-201(2)

MAXALIASES defined in line 160; used 1 times

- in line 164

Last modified: 1995-08-19 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 1764 |