home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / unix / volume15 / ien116 / nameserver.c < prev    next >
Encoding:
C/C++ Source or Header  |  1988-06-07  |  13.5 KB  |  506 lines
  1. #ifndef lint
  2.   static char *RCSid = "$Header: nameserver.c,v 2.3.1 88/02/26 jerry Rel $";
  3. #endif
  4.  
  5. /* nameserver --
  6.    Use the IEN 116 protocol to respond to nameserver requests.
  7.  
  8.    Modified by Jerry Aguirre.  21Mar1988
  9.    Count in header does not include header bytes.  Added a "glob"
  10.    capability so "*" returns all host names.  Removed fatal abort if no
  11.    tty so daemon can be started from rc.local.
  12.  
  13.    Written by Michael I. Bushnell.
  14.    Copyright (c) 1987 Michael I. Bushnell
  15.    You are hereby granted permission to use this program however you wish,
  16.    including copying and distribution.  However, you are obligated not to sell
  17.    it or any part of it.  Anyone who obtains this program receives the right
  18.    to do the same.  This statement may not be removed from this program.
  19. */
  20.  
  21. /*
  22.  * $Source: /u1/staff/mike/src/nameserver/RCS/nameserver.c,v $
  23.  * $Revision: 2.3 $
  24.  * $Date: 87/06/24 15:02:59 $
  25.  * $State: Rel $
  26.  * $Author: mike $
  27.  * $Locker:  $
  28.  * $Log:    nameserver.c,v $
  29.  * Revision 2.3.1 88/02/26 Jerry Aguirre
  30.  * Modified to work with Bridge terminal server version 1300.  The field
  31.  * size doesn't include the 2 byte header.  Also added a glob capability
  32.  * so '*' or 'xyz*' works.  The '*' may not return all hosts because the
  33.  * sendto limits the size I can send.
  34.  *
  35.  * Revision 2.3  87/06/24  15:02:59  mike
  36.  * Final preparations for release.  Addeed Copyright.
  37.  * 
  38.  * Revision 2.2  87/06/24  14:54:29  mike
  39.  * de-lintified.  Lint, stupidly, doesn't pick up the definition of h_errno f
  40.  * from libc.a.  Sigh.  Prepared for release.
  41.  * 
  42.  * Revision 2.1  87/06/24  14:48:14  mike
  43.  * Better comments.
  44.  * 
  45.  * Revision 2.0  87/06/23  16:55:03  mike
  46.  * Split it up into different functions.
  47.  * 
  48.  * Revision 1.9  87/06/23  16:14:09  mike
  49.  * Added stuff to divorce process from shell and control terminal.
  50.  * 
  51.  * Revision 1.8  87/06/19  16:59:36  mike
  52.  * Uses syslog instead of perror.
  53.  * Lots of symbolic constants.
  54.  * 
  55.  * Revision 1.7  87/06/19  14:43:49  mike
  56.  * Fixed bug... need to initialize addrlen to sizeof(hisname).
  57.  * 
  58.  * Revision 1.6  87/06/16  16:08:04  mike
  59.  * Changed all "sizeof (hisaddr)" to "addrlen."
  60.  * Still a bug...the last sendto is returning EINVAL???
  61.  * 
  62.  * Revision 1.5  87/06/16  15:57:07  mike
  63.  * Actually...you need to return the raw bytes.  So I changed it back.
  64.  * Also added bookoo error checking.
  65.  * 
  66.  * Revision 1.4  87/06/15  13:50:22  mike
  67.  * Fixed bug...need to cast the argument of inet_ntoa into a struct in_addr.
  68.  * 
  69.  * Revision 1.3  87/06/08  14:16:56  mike
  70.  * Uses a PORT number instead of system chosen default...now its 5001.
  71.  * 
  72.  * Revision 1.2  87/06/08  14:10:33  mike
  73.  * Now it compiles.
  74.  * 
  75.  * Revision 1.1  87/06/08  13:42:20  mike
  76.  * Initial revision
  77.  * 
  78.  */
  79.  
  80. #include <sys/file.h>
  81. #include <sgtty.h>
  82.  
  83. #include <signal.h>
  84. #include <syslog.h>
  85.  
  86. #include <sys/types.h>
  87. #include <sys/socket.h>
  88. #include <netinet/in.h>
  89. #include <netdb.h>
  90.  
  91. #include <stdio.h>
  92. #include <ctype.h>
  93.  
  94. #include "ien116.h"
  95.  
  96. /* Generic constants */
  97. #define BUFLEN 512        /* Length of I/O buffers */
  98. #define RBUFLEN 1400        /* Length of glob reply buffer */
  99.             /* note that there is a limit on size of sendto */
  100. #define DEF_PROTO 0        /* Use default protocol */
  101. #define NO_FLAGS 0        /* No flags on recvfrom/sendto */
  102.  
  103. /* Message lengths */
  104. #define RET_MSG_LEN 6        /* Length of what we add to buf */
  105. #define ERR_MSG_LEN 3        /* Length of error messages */
  106.  
  107. char buf[BUFLEN];        /* Input/Output buffer */
  108. extern int errno, h_errno;
  109. extern char *sys_errlist[];
  110.  
  111. int debug;
  112.  
  113. main(argc, argv) int argc; char *argv[];
  114. {
  115.   int sock;            /* Datagram socket */
  116.   struct sockaddr_in hisname;    /* Address of requestor */
  117.   int addrlen;            /* Length of his address */
  118.   struct hostent *hp, *gethostbyname();    /* Host inquired of */
  119.   char *name;            /* Name of the machine requested */
  120.   int msglen;            /* Length of the message received */
  121.   char *nameloc();
  122.   int arg, i;
  123.  
  124.   for (arg = 1; arg < argc; arg++) {
  125.     if (argv[arg][0] == '-') {
  126.       for (i = 1; argv[arg][i]; i++) {
  127.     switch (argv[arg][i]) {
  128.     case 'd':
  129.       if (isdigit(argv[arg][i+1])) {
  130.         debug = atoi(&argv[arg][i+1]);
  131.         break;
  132.       } else debug = 1;
  133.       continue;
  134.  
  135.     default:
  136.       fprintf(stderr, "nameserver: unknown option \'-%c\'.\n",
  137.                         argv[arg][i]);
  138.     }
  139.     break;
  140.       }
  141.     } else {
  142.       fprintf(stderr, "nameserver: unexpected argument \"%s\".\n",
  143.                         argv[arg]);
  144.     }
  145.   }
  146.  
  147.   if (!debug) setupsig();    /* Set up signal handling */
  148.   setuplog();            /* Set up the syslog connection */
  149.   if (!debug) divorce();    /* Divorce ourselves from terminal and shell */
  150.   sock = makesocket();        /* make and bind the socket */
  151.  
  152.   addrlen = sizeof(hisname);    
  153.  
  154.   /* Main loop */
  155.  restart:
  156.   while (1)
  157.     {
  158.       /* Read a message */
  159.       msglen = recvfrom(sock, buf, BUFLEN - RET_MSG_LEN,
  160.             NO_FLAGS, (struct sockaddr *)&hisname, &addrlen);
  161.       if (debug) fprintf(stderr, "nameserver: got a request\n");
  162.       if (msglen == -1)
  163.     {
  164.       syslog(LOG_ERR, "Error on incoming message: %s\n", 
  165.          sys_errlist[errno]);
  166.       if (debug) fprintf(stderr, "Error on incoming message: %s\n", 
  167.          sys_errlist[errno]);
  168.       goto restart;
  169.     }
  170.  
  171.       /* Find the name */
  172.       name = nameloc(buf, BUFLEN, msglen, &hisname, addrlen, sock);
  173.       if ((int) name == -1) {
  174.     if (debug) fprintf(stderr, "nameserver: namelog() returned -1\n");
  175.     goto restart;
  176.       }
  177.  
  178.       if (isglob(name)) {
  179.       if (debug) fprintf(stderr, "nameserver: looking up pattern \"%s\".\n",
  180.                             name);
  181.       doglob(name, &hisname, addrlen, sock);
  182.       goto restart;
  183.       }
  184.  
  185.       if (debug) fprintf(stderr, "nameserver: looking up host \"%s\".\n",
  186.                             name);
  187.       /* Get the host entry */
  188.       if ((hp = gethostbyname(name))== NULL)
  189.     {
  190.       /* Send error message */
  191.       buf[msglen] = ERR;    
  192.       buf[msglen+1] = ERR_MSG_LEN - 2;
  193.       if (h_errno == HOST_NOT_FOUND ||
  194.           h_errno == TRY_AGAIN ||
  195.           h_errno == NO_ADDRESS) 
  196.         buf[msglen+2] = HOST_UNK; 
  197.       else
  198.         buf[msglen+2] = UNK_ERR; 
  199.       if (sendto(sock, buf, msglen+ERR_MSG_LEN, NO_FLAGS, 
  200.              (struct sockaddr *)&hisname, addrlen)==-1)
  201.         {
  202.           syslog(LOG_ERR, "Error sending error 3: %s\n", sys_errlist[errno]);
  203.           goto restart;
  204.         }  
  205.     }
  206.       else
  207.     {
  208.       /* Send the reply */
  209.       buf[msglen] = ADDR_ANS;
  210.       buf[msglen+1] = RET_MSG_LEN - 2;
  211.       buf[msglen+2] = hp->h_addr_list[0][0];
  212.       buf[msglen+3] = hp->h_addr_list[0][1];
  213.       buf[msglen+4] = hp->h_addr_list[0][2];
  214.       buf[msglen+5] = hp->h_addr_list[0][3];
  215.  
  216.       if (debug) fprintf(stderr, "nameserver: return IP %d.%d.%d.%d\n",
  217.                 hp->h_addr_list[0][0] & 0xff,
  218.                 hp->h_addr_list[0][1] & 0xff,
  219.                 hp->h_addr_list[0][2] & 0xff,
  220.                 hp->h_addr_list[0][3] & 0xff);
  221.  
  222.       if (sendto(sock, buf, msglen+RET_MSG_LEN, NO_FLAGS, 
  223.              (struct sockaddr *)&hisname, addrlen)==-1)
  224.         {
  225.           syslog(LOG_ERR, "Error sending reply: %s\n", sys_errlist[errno]);
  226.           goto restart;
  227.         }
  228.     }
  229.     }
  230. }
  231.  
  232.  
  233. /* setupsig -- Set all signals to be ignored.  Those which cannot be ignored
  234.    will be left at the default. */
  235. setupsig()
  236. {
  237.   int i;            /* Index of signals */
  238.   
  239.   for (i=0; i < NSIG; ++i)
  240.     (void) signal(i, SIG_IGN);
  241. }
  242.   
  243.  
  244. /* setuplog -- set up the syslog connection */
  245. setuplog()
  246. {
  247.   openlog("nameserver", LOG_PID | LOG_CONS, LOG_DAEMON);
  248. }
  249.  
  250.  
  251. /* divorce -- Divorce ourselves from the terminal and the shell */
  252. divorce()
  253. {
  254.   int term;            /* Terminal filed */
  255.  
  256.   /* First the shell */
  257.   switch(fork()) 
  258.     {
  259.     case -1:
  260.       syslog(LOG_CRIT, "Cannot fork: %s\n", sys_errlist[errno]);
  261.       exit(1);
  262.       break;
  263.     case 0:
  264.       break;
  265.     default:
  266.       exit(0);
  267.       break;
  268.     }
  269.  
  270.   /* Now the files */
  271.   /* POTENTIAL BUG-- ASSUMES THAT THE TERMINAL IS ONLY OPEN ON FILEDS 0,1,2 */
  272.   (void) close (0);
  273.   (void) close (1);
  274.   (void) close (2);
  275.   /* Now the terminal */
  276.   /* if started from rc.local, crontab, etc. there is no tty */
  277.   if ((term = open("/dev/tty", O_RDWR, 0)) >= 0)
  278.     {
  279.       if (ioctl(term, TIOCNOTTY, (char *) 0) == -1)
  280.     {
  281.       syslog(LOG_CRIT, "Cannot divorce from control terminal: %s\n", 
  282.          sys_errlist[errno]);
  283.       exit(1);
  284.     }
  285.       (void) close(term);
  286.     }
  287. }
  288.  
  289.  
  290. /* makesocket -- return the filed of a new bound socket */
  291. makesocket()
  292. {
  293.   int sock;            /* Socket */
  294.   struct sockaddr_in ourname;    /* Our name */
  295.  
  296.   /* create the socket */
  297.   sock = socket(AF_INET, SOCK_DGRAM, DEF_PROTO);
  298.   if (sock < 0)
  299.     {
  300.       syslog(LOG_CRIT, "Error opening socket: %s\n", sys_errlist[errno]);
  301.       exit(1);
  302.     }
  303.   ourname.sin_family = AF_INET;
  304.   ourname.sin_port = htons((u_short)PORT);
  305.   ourname.sin_addr.s_addr = INADDR_ANY;
  306.   if (bind(sock, &ourname, sizeof(ourname)))
  307.  
  308.     {
  309.       syslog(LOG_CRIT, "Error binding socket: %s\n", sys_errlist[errno]);
  310.       exit(1);
  311.     }
  312.   return sock;
  313. }  
  314.  
  315.  
  316. /* nameloc -- return the address of a null-terminated string which is the
  317.    name to be looked up.  Report syntax errors to reportto through sock.
  318.    If an error occurs, return (char *) -1.  If an error occurs, buf will be 
  319.    changed. */
  320. char *
  321. nameloc(buf, buflen, msglen, reportto, addrlen, sock)
  322.      char *buf;            /* Buffer holding the request */
  323.      int buflen,        /* Length of the buffer */
  324.        msglen,            /* Length of the message in the buffer */
  325.        sock,            /* Socket for error replies */
  326.        addrlen;            /* Length of reportto */
  327.      struct sockaddr_in *reportto; /* Who we report errors to */
  328. {
  329.   char *name;            /* Address of the name */
  330.   int code;            /* Type of request */
  331.  
  332.   buf[msglen] = '\0';
  333.   /* Check type */      
  334.   code = buf[0];
  335.   if (code != ADDR_REQ)
  336.     if (code !=ADDR_ANS && code !=ERR)
  337.       {
  338.     /* Send error message */
  339.     buf[0] = ERR;    
  340.     buf[1] = ERR_MSG_LEN - 2;
  341.     buf[2] = SYNT_ERR;
  342.     if (sendto(sock, buf, ERR_MSG_LEN, NO_FLAGS, 
  343.            (struct sockaddr *)&reportto, addrlen)==-1)
  344.       {
  345.         syslog(LOG_ERR, "Error sending error 0: %s\n", sys_errlist[errno]);
  346.         return (char *) -1;
  347.       }        
  348.       }
  349.     else
  350.       return (char *) -1;
  351.   
  352.   /* Put name at the start of a null-terminated string */
  353.   if (buf[2]!='!')
  354.     name=buf+2;
  355.   else
  356.     {
  357.       for(name=buf+2; *name!='!'; ++name)
  358.     if (name-buf >= buflen)
  359.       {            
  360.         /* Send error packet */
  361.         buf[0] = ERR;
  362.         buf[1] = ERR_MSG_LEN - 2;
  363.         buf[2] = SYNT_ERR;
  364.         if (sendto(sock, buf, ERR_MSG_LEN, NO_FLAGS, 
  365.                (struct sockaddr *)&reportto, addrlen)==-1)
  366.           {
  367.         syslog(LOG_ERR, "Error sending error 1: %s\n", 
  368.                sys_errlist[errno]);
  369.         return (char *) -1;
  370.           }
  371.       }
  372.       for(++name; *name!='!'; ++name)
  373.     if (name-buf >= buflen)
  374.       {            
  375.         /* Send error packet */
  376.         buf[0] = ERR;
  377.         buf[1] = ERR_MSG_LEN - 2;
  378.         buf[2] = SYNT_ERR;
  379.         if (sendto(sock, buf, ERR_MSG_LEN, NO_FLAGS, 
  380.                (struct sockaddr *)&reportto, addrlen)==-1)
  381.           {
  382.         syslog(LOG_ERR, "Error sending error 2: %s\n", 
  383.                sys_errlist[errno]);
  384.         return (char *) -1;
  385.           }
  386.       }
  387.       ++name;
  388.     }
  389.   return name;
  390. }
  391.  
  392. int
  393. isglob(s) char *s; /* true if string s has pattern characters */
  394. {
  395.     while (*s) {
  396.     switch (*s++) {
  397.     case '*': return 1;
  398.     }
  399.     }
  400.     return 0;
  401. }
  402.  
  403. /* check all hosts against pattern 's'.  To reduce clutter only the
  404.  * primary host name is checked, aliases are ignored.
  405.  */
  406. doglob(s, reportto, addrlen, sock)
  407.     char *s;            /* string containing pattern */
  408.     struct sockaddr_in *reportto; /* Who we report errors to */
  409.     int addrlen;        /* Length of reportto */
  410.     int sock;            /* Socket for error replies */
  411. {
  412.     struct hostent *hp, *gethostent();
  413.     int i, l, n;
  414.     char buf[RBUFLEN];        /* Output buffer */
  415.  
  416.     if (s[0] == '\0') { /* null pattern is illegal */
  417.     reterror(ADDR_REQ, s, SYNT_ERR, reportto, addrlen, sock);
  418.     return 0;
  419.     }
  420.     sethostent(1);
  421.     i = 0; n = 0;
  422.     while ((i < RBUFLEN) && (hp = gethostent())) {
  423.     if (requ(s, hp->h_name)) { /* we found a match */
  424.         n++;
  425.         l = strlen(hp->h_name);
  426.         if (l > 255) l = 255;
  427.         if ((i + 2 + l + 2 + 4) >= RBUFLEN) break;
  428.         buf[i++] = ADDR_REQ;
  429.         buf[i++] = l;
  430.         strncpy(buf+i, hp->h_name, l);
  431.         i += l;
  432.         buf[i++] = ADDR_ANS;
  433.         buf[i++] = 4;
  434.         buf[i++] = hp->h_addr_list[0][0];
  435.         buf[i++] = hp->h_addr_list[0][1];
  436.         buf[i++] = hp->h_addr_list[0][2];
  437.         buf[i++] = hp->h_addr_list[0][3];
  438.     }
  439.     }
  440.     endhostent();
  441.     if (n == 0) {
  442.     reterror(ADDR_REQ, s, HOST_UNK, reportto, addrlen, sock);
  443.     return 1;
  444.     }
  445.     if (i > 0) {
  446.     if (sendto(sock, buf, i, NO_FLAGS, 
  447.          (struct sockaddr *)reportto, addrlen)==-1) {
  448.         syslog(LOG_ERR, "Error sending reply: %s\n", sys_errlist[errno]);
  449.         return 0;
  450.     }
  451.     }
  452.     return 1;
  453. }
  454.  
  455. reterror(rcode, rs, ecode, reportto, addrlen, sock)
  456.      int rcode;            /* type of request containing error */
  457.      char *rs;            /* string for above request */
  458.      int ecode;            /* error code to return */
  459.      struct sockaddr_in *reportto; /* Who we report errors to */
  460.      int addrlen;        /* Length of reportto */
  461.      int sock;            /* Socket for error replies */
  462. {
  463.     int i;
  464.     char buf[BUFLEN];        /* Output buffer */
  465.  
  466.     buf[0] = rcode;
  467.     i = strlen(rs);
  468.     if (i > 255) i = 255;
  469.     buf[1] = i;
  470.     strncpy(buf+2, rs, i);
  471.     i += 2;
  472.     buf[i++] = ERR;
  473.     buf[i++] = 1;
  474.     buf[i++] = ecode;
  475.     if (sendto(sock, buf, i, NO_FLAGS, 
  476.            (struct sockaddr *)&reportto, addrlen)==-1) {
  477.     syslog(LOG_ERR, "Error sending error %d: %s\n",
  478.                     ecode, sys_errlist[errno]);
  479.     return 0;
  480.     }        
  481.     return 1;
  482. }
  483.  
  484. /* Compare pattern 'p' to string 's'.  Pattern can contain '*'
  485.  * characters that will match 0 or more characters in string.  Otherwise
  486.  * the strings are compared on a character by character basis.  Returns
  487.  * non-zero for a match.
  488.  */
  489. int
  490. requ(p, s) register char *p, *s;
  491. {
  492.     while (*p) {
  493.     if (*p == '*') {
  494.         do {
  495.         if (requ(p+1, s)) return 1;    /* match */
  496.         } while (*s++);
  497.         return 0;    /* no match */
  498.     }
  499.     else if (*s == '\0') return 0; /* no match */
  500.     else if (*p != *s) return 0; /* no match */
  501.     p++; s++;    /* they match so far */
  502.     }
  503.     if (*s) return 0; /* no match */
  504.     return 1;    /* reached end of both strings, match */
  505. }
  506.