# 2.11BSD#431 - /usr/src/usr.sbin/named/tools/nstest.c

##### Functions

    main              X
    usage             X

##### Variables

    copyright         X
    progname          X

##### Macros

    MAXDATA           X

       1: /*
       2:  * Copyright (c) 1986, 1989 Regents of the University of California.
       3:  * All rights reserved.
       4:  *
       5:  * Redistribution and use in source and binary forms are permitted provided
       6:  * that: (1) source distributions retain this entire copyright notice and
       7:  * comment, and (2) distributions including binaries display the following
       8:  * acknowledgement:  ``This product includes software developed by the
       9:  * University of California, Berkeley and its contributors'' in the
      10:  * documentation or other materials provided with the distribution and in
      11:  * all advertising materials mentioning features or use of this software.
      12:  * Neither the name of the University nor the names of its contributors may
      13:  * be used to endorse or promote products derived from this software without
      14:  * specific prior written permission.
      15:  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
      16:  * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
      17:  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
      18:  */
      19:
      20: #if !defined(lint) && defined(DOSCCS)
      21: char copyright[] =
      22: "@(#) Copyright (c) 1986 Regents of the University of California.\n\
      23:  All rights reserved.\n";
      24:
      25: static char sccsid[] = "@(#)nstest.c	4.12 (Berkeley) 6/1/90";
      26: #endif
      27:
      28: #include <sys/types.h>
      29: #include <sys/socket.h>
      30: #include <netinet/in.h>
      31: #include <stdio.h>
      32: #include <arpa/nameser.h>
      33: #include <resolv.h>
      34:
      35: extern char *inet_ntoa();
      36: char *progname;
      37: FILE *log;
      38: #define MAXDATA     256   /* really should get definition from named/db.h */
      39: main(argc, argv)
      40:     char **argv;
      41: {
      42:     register char *cp;
      43:     u_short port = htons(NAMESERVER_PORT);
      44:     char buf[BUFSIZ];
      45:     char packet[PACKETSZ];
      46:     char answer[PACKETSZ];
      47:     struct rrec NewRR;
      48:     int n, dump_packet;
      49:
      50:     NewRR.r_data = (char *) malloc(MAXDATA);
      51:     NewRR.r_data = (char *) malloc(MAXDATA);
      52:     progname = argv[0];
      53:     dump_packet = 0;
      54:     _res.options |= RES_DEBUG|RES_RECURSE;
      55:     (void) res_init();
      56:     while (argc > 1 && argv[1][0] == '-') {
      57:         argc--;
      58:         cp = *++argv;
      59:         while (*++cp)
      60:             switch (*cp) {
      61:             case 'p':
      62:                 if (--argc <= 0)
      63:                     usage();
      64:                 port = htons(atoi(*++argv));
      65:                 break;
      66:
      67:             case 'i':
      68:                 _res.options |= RES_IGNTC;
      69:                 break;
      70:
      71:             case 'v':
      72:                 _res.options |= RES_USEVC|RES_STAYOPEN;
      73:                 break;
      74:
      75:             case 'r':
      76:                 _res.options &= ~RES_RECURSE;
      77:                 break;
      78:
      79:             case 'd':
      80:                 dump_packet++;
      81:                 break;
      82:
      83:             default:
      84:                 usage();
      85:             }
      86:     }
      87:     _res.nsaddr.sin_family = AF_INET;
      88:     _res.nsaddr.sin_addr.s_addr = INADDR_ANY;
      89:     _res.nsaddr.sin_port = port;
      90:     if (argc > 1) {
      91:         _res.nsaddr.sin_addr.s_addr = inet_addr(argv[1]);
      92:         if (_res.nsaddr.sin_addr.s_addr == (u_long) -1)
      93:             usage();
      94:     }
      95:     if (argc > 2) {
      96:         log = fopen(argv[2],"w");
      97:         if (log == NULL) perror(argv[2]);
      98:     }
      99:     for (;;) {
     100:         printf("> ");
     101:         fflush(stdout);
     102:         if ((cp = (char *)gets(buf)) == NULL)
     103:             break;
     104:         switch (*cp++) {
     105:         case 'a':
     106:             n = res_mkquery(QUERY, cp, C_IN, T_A, (char *)0, 0,
     107:                 NULL, packet, sizeof(packet));
     108:             break;
     109:
     110:         case 'A':
     111:             n = ntohl(inet_addr(cp));
     112:             putlong(n, cp);
     113:             n = res_mkquery(IQUERY, "", C_IN, T_A, cp, sizeof(long),
     114:                 NULL, packet, sizeof(packet));
     115:             break;
     116:
     117:         case 'f':
     118:             n = res_mkquery(QUERY, cp, C_ANY, T_UINFO, (char *)0, 0,
     119:                 NULL, packet, sizeof(packet));
     120:             break;
     121:
     122:         case 'g':
     123:             n = res_mkquery(QUERY, cp, C_ANY, T_GID, (char *)0, 0,
     124:                 NULL, packet, sizeof(packet));
     125:             break;
     126:
     127:         case 'G':
     128:             *(int *)cp = htonl(atoi(cp));
     129:             n = res_mkquery(IQUERY, "", C_ANY, T_GID, cp,
     130:                 sizeof(int), NULL, packet, sizeof(packet));
     131:             break;
     132:
     133:         case 'c':
     134:             n = res_mkquery(QUERY, cp, C_IN, T_CNAME, (char *)0, 0,
     135:                 NULL, packet, sizeof(packet));
     136:             break;
     137:
     138:         case 'h':
     139:             n = res_mkquery(QUERY, cp, C_IN, T_HINFO, (char *)0, 0,
     140:                 NULL, packet, sizeof(packet));
     141:             break;
     142:
     143:         case 'm':
     144:             n = res_mkquery(QUERY, cp, C_IN, T_MX, (char *)0, 0,
     145:                 NULL, packet, sizeof(packet));
     146:             break;
     147:
     148:         case 'M':
     149:             n = res_mkquery(QUERY, cp, C_IN, T_MAILB, (char *)0, 0,
     150:                 NULL, packet, sizeof(packet));
     151:             break;
     152:
     153:         case 'n':
     154:             n = res_mkquery(QUERY, cp, C_IN, T_NS, (char *)0, 0,
     155:                 NULL, packet, sizeof(packet));
     156:             break;
     157:
     158:         case 'p':
     159:             n = res_mkquery(QUERY, cp, C_IN, T_PTR, (char *)0, 0,
     160:                 NULL, packet, sizeof(packet));
     161:             break;
     162:
     163:         case 's':
     164:             n = res_mkquery(QUERY, cp, C_IN, T_SOA, (char *)0, 0,
     165:                 NULL, packet, sizeof(packet));
     166:             break;
     167:
     168:         case 'T':
     169:             n = res_mkquery(QUERY, cp, C_IN, T_TXT, (char *)0, 0,
     170:                 NULL, packet, sizeof(packet));
     171:             break;
     172:
     173:         case 'u':
     174:             n = res_mkquery(QUERY, cp, C_ANY, T_UID, (char *)0, 0,
     175:                 NULL, packet, sizeof(packet));
     176:             break;
     177:
     178:         case 'U':
     179:             *(int *)cp = htonl(atoi(cp));
     180:             n = res_mkquery(IQUERY, "", C_ANY, T_UID, cp,
     181:                 sizeof(int), NULL, packet, sizeof(packet));
     182:             break;
     183:
     184:         case 'x':
     185:             n = res_mkquery(QUERY, cp, C_IN, T_AXFR, (char *)0, 0,
     186:                 NULL, packet, sizeof(packet));
     187:             break;
     188:
     189:         case 'w':
     190:             n = res_mkquery(QUERY, cp, C_IN, T_WKS, (char *)0, 0,
     191:                 NULL, packet, sizeof(packet));
     192:             break;
     193:
     194:         case 'b':
     195:             n = res_mkquery(QUERY, cp, C_IN, T_MB, (char *)0, 0,
     196:                 NULL, packet, sizeof(packet));
     197:             break;
     198:
     199:         case 'B':
     200:             n = res_mkquery(QUERY, cp, C_IN, T_MG, (char *)0, 0,
     201:                 NULL, packet, sizeof(packet));
     202:             break;
     203:
     204:         case 'i':
     205:             n = res_mkquery(QUERY, cp, C_IN, T_MINFO, (char *)0, 0,
     206:                 NULL, packet, sizeof(packet));
     207:             break;
     208:
     209:         case 'r':
     210:             n = res_mkquery(QUERY, cp, C_IN, T_MR, (char *)0, 0,
     211:                 NULL, packet, sizeof(packet));
     212:             break;
     213:
     214:         case '*':
     215:             n = res_mkquery(QUERY, cp, C_IN, T_ANY, (char *)0, 0,
     216:                 NULL, packet, sizeof(packet));
     217:             break;
     218:
     219: #ifdef ALLOW_UPDATES
     220:         case '^':
     221:             {
     222:                 char IType[10], TempStr[50];
     223:                 int Type, oldnbytes, nbytes, i;
     224: #ifdef ALLOW_T_UNSPEC
     225:                 printf("Data type (a = T_A, u = T_UNSPEC): ");
     226:                 gets(IType);
     227:                 if (IType[0] == 'u') {
     228:                     Type = T_UNSPEC;
     229:                     printf("How many data bytes? ");
     230:                     gets(TempStr); /* Throw away CR */
     231:                     sscanf(TempStr, "%d", &nbytes);
     232:                     for (i = 0; i < nbytes; i++) {
     233:                         (NewRR.r_data)[i] = (char) i;
     234:                     }
     235:                 } else {
     236: #endif ALLOW_T_UNSPEC
     237:                     Type = T_A;
     238:                     nbytes = sizeof(u_long);
     239:                     printf("Inet addr for new dname (e.g., 192.4.3.2): ");
     240:                     gets(TempStr);
     241:                     putlong(ntohl(inet_addr(TempStr)), NewRR.r_data);
     242: #ifdef ALLOW_T_UNSPEC
     243:                 }
     244: #endif ALLOW_T_UNSPEC
     245:                 NewRR.r_class = C_IN;
     246:                 NewRR.r_type = Type;
     247:                 NewRR.r_size = nbytes;
     248:                 NewRR.r_ttl = 99999999;
     249:                 printf("Add, modify, or modify all (a/m/M)? ");
     250:                 gets(TempStr);
     251:                 if (TempStr[0] == 'a') {
     252:                     n = res_mkquery(UPDATEA, cp, C_IN, Type,
     253:                             OldRRData, nbytes,
     254:                             &NewRR, packet,
     255:                             sizeof(packet));
     256:                 } else {
     257:                     if (TempStr[0] == 'm') {
     258:                         printf("How many data bytes in old RR? ");
     259:                         gets(TempStr); /* Throw away CR */
     260:                         sscanf(TempStr, "%d", &oldnbytes);
     261:                     for (i = 0; i < oldnbytes; i++) {
     262:                         OldRRData[i] = (char) i;
     263:                     }
     264:                     n = res_mkquery(UPDATEM, cp, C_IN, Type,
     265:                             OldRRData, oldnbytes,
     266:                             &NewRR, packet,
     267:                             sizeof(packet));
     268:                 } else { /* Modify all */
     269:                     n = res_mkquery(UPDATEMA, cp,
     270:                             C_IN, Type, NULL, 0,
     271:                             &NewRR, packet,
     272:                             sizeof(packet));
     273:
     274:                 }
     275:                 }
     276:             }
     277:             break;
     278:
     279: #ifdef ALLOW_T_UNSPEC
     280:         case 'D':
     281:             n = res_mkquery(UPDATEDA, cp, C_IN, T_UNSPEC, (char *)0,
     282:                     0, NULL, packet, sizeof(packet));
     283:             break;
     284:
     285:         case 'd':
     286:             {
     287:                 char TempStr[100];
     288:                 int nbytes, i;
     289:                 printf("How many data bytes in oldrr data? ");
     290:                 gets(TempStr); /* Throw away CR */
     291:                 sscanf(TempStr, "%d", &nbytes);
     292:                 for (i = 0; i < nbytes; i++) {
     293:                     OldRRData[i] = (char) i;
     294:                 }
     295:                 n = res_mkquery(UPDATED, cp, C_IN, T_UNSPEC,
     296:                         OldRRData, nbytes, NULL, packet,
     297:                         sizeof(packet));
     298:             }
     299:             break;
     300: #endif ALLOW_T_UNSPEC
     301: #endif ALLOW_UPDATES
     302:
     303:         default:
     304:             printf("a{host} - query  T_A\n");
     305:             printf("A{addr} - iquery T_A\n");
     306:             printf("b{user} - query  T_MB\n");
     307:             printf("B{user} - query  T_MG\n");
     308:             printf("f{host} - query  T_UINFO\n");
     309:             printf("g{host} - query  T_GID\n");
     310:             printf("G{gid}  - iquery T_GID\n");
     311:             printf("h{host} - query  T_HINFO\n");
     312:             printf("i{host} - query  T_MINFO\n");
     313:             printf("p{host} - query  T_PTR\n");
     314:             printf("m{host} - query  T_MX\n");
     315:             printf("M{host} - query  T_MAILB\n");
     316:             printf("n{host} - query  T_NS\n");
     317:             printf("r{host} - query  T_MR\n");
     318:             printf("s{host} - query  T_SOA\n");
     319:             printf("T{host} - query  T_TXT\n");
     320:             printf("u{host} - query  T_UID\n");
     321:             printf("U{uid}  - iquery T_UID\n");
     322:             printf("x{host} - query  T_AXFR\n");
     323:             printf("w{host} - query  T_WKS\n");
     324:             printf("c{host} - query  T_CNAME\n");
     325:             printf("*{host} - query  T_ANY\n");
     326: #ifdef ALLOW_UPDATES
     327:             printf("^{host} - add/mod/moda    (T_A/T_UNSPEC)\n");
     328: #ifdef ALLOW_T_UNSPEC
     329:             printf("D{host} - deletea T_UNSPEC\n");
     330:             printf("d{host} - delete T_UNSPEC\n");
     331: #endif ALLOW_T_UNSPEC
     332: #endif ALLOW_UPDATES
     333:             continue;
     334:         }
     335:         if (n < 0) {
     336:             printf("res_mkquery: buffer too small\n");
     337:             continue;
     338:         }
     339:         if (log) {
     340:             fprintf(log,"SEND QUERY\n");
     341:             fp_query(packet, log);
     342:         }
     343:         n = res_send(packet, n, answer, sizeof(answer));
     344:         if (n < 0) {
     345:             printf("res_send: send error\n");
     346:             if (log) fprintf(log, "res_send: send error\n");
     347:         }
     348:         else {
     349:             if (dump_packet) {
     350:                 int f;
     351:                 f = creat("ns_packet.dump", 0644);
     352:                 write(f, answer, n);
     353:                 (void) close(f);
     354:             }
     355:             if (log) {
     356:                 fprintf(log, "GOT ANSWER\n");
     357:                 fp_query(answer, log);
     358:             }
     359:         }
     360:     }
     361: }
     362:
     363: usage()
     364: {
     365:     fprintf(stderr, "Usage: %s [-v] [-i] [-r] [-d] [-p port] hostaddr\n",
     366:         progname);
     367:     exit(1);
     368: }

#### Defined functions

main defined in line 39; never used
usage defined in line 363; used 3 times

- in line 63, 84, 93

#### Defined variables

copyright defined in line 21; never used
progname defined in line 36; used 2 times

- in line 52, 366

sccsid defined in line 25; never used

#### Defined macros

MAXDATA defined in line 38; used 2 times

- in line 50-51(2)

Last modified: 1993-04-26 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 1875 |