home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 35 Internet / 35-Internet.zip / bootpd-2.zip / DOVEND.C < prev    next >
C/C++ Source or Header  |  1995-02-15  |  10KB  |  413 lines
  1. /*
  2.  * dovend.c : Inserts all but the first few vendor options.
  3.  */
  4.  
  5. #include <sys/types.h>
  6.  
  7. #include <netinet/in.h>
  8. #include <arpa/inet.h>            /* inet_ntoa */
  9.  
  10. #include <stdlib.h>
  11. #include <stdio.h>
  12. #include <string.h>
  13. #include <errno.h>
  14. #include <syslog.h>
  15.  
  16. #ifndef USE_BFUNCS
  17. # include <memory.h>
  18. /* Yes, memcpy is OK here (no overlapped copies). */
  19. # define bcopy(a,b,c)    memcpy(b,a,c)
  20. # define bzero(p,l)      memset(p,0,l)
  21. # define bcmp(a,b,c)     memcmp(a,b,c)
  22. # define index           strchr
  23. #endif
  24.  
  25. #include "bootp.h"
  26. #include "bootpd.h"
  27. #include "report.h"
  28. #include "dovend.h"
  29.  
  30. #ifdef    __STDC__
  31. #define P(args) args
  32. #else
  33. #define P(args) ()
  34. #endif
  35.  
  36. PRIVATE int insert_generic P((struct shared_bindata *, byte **, int *));
  37.  
  38. /*
  39.  * Insert the 2nd part of the options into an option buffer.
  40.  * Return amount of space used.
  41.  *
  42.  * This inserts everything EXCEPT:
  43.  *   magic cookie, subnet mask, gateway, bootsize, extension file
  44.  * Those are handled separately (in bootpd.c) to allow this function
  45.  * to be shared between bootpd and bootpef.
  46.  *
  47.  * When an "extension file" is in use, the options inserted by
  48.  * this function go into the exten_file, not the bootp response.
  49.  */
  50.  
  51. int
  52. dovend_rfc1497(hp, buf, len)
  53.     struct host *hp;
  54.     byte *buf;
  55.     int len;
  56. {
  57.     int bytesleft = len;
  58.     byte *vp = buf;
  59.  
  60.     static char noroom[] = "%s: No room for \"%s\" option";
  61. #define    NEED(LEN, MSG) do                       \
  62.         if (bytesleft < (LEN)) {                 \
  63.             report(LOG_NOTICE, noroom,          \
  64.                    hp->hostname->string, MSG);  \
  65.             return (vp - buf);                  \
  66.         } while (0)
  67.  
  68.     /*
  69.      * Note that the following have already been inserted:
  70.      *   magic_cookie, subnet_mask, gateway, bootsize
  71.      *
  72.      * The remaining options are inserted in order of importance.
  73.      * (Of course the importance of each is a matter of opinion.)
  74.      * The option insertion order should probably be configurable.
  75.      *
  76.      * This is the order used in the NetBSD version.  Can anyone
  77.      * explain why the time_offset and swap_server are first?
  78.      * Also, why is the hostname so far down the list?  -gwr
  79.      */
  80.  
  81.     if (hp->flags.time_offset) {
  82.         NEED(6, "to");
  83.         *vp++ = TAG_TIME_OFFSET;/* -1 byte  */
  84.         *vp++ = 4;                /* -1 byte  */
  85.         insert_u_long(htonl(hp->time_offset), &vp);    /* -4 bytes */
  86.         bytesleft -= 6;
  87.     }
  88.     /*
  89.      * swap server, root path, dump path
  90.      */
  91.     if (hp->flags.swap_server) {
  92.         NEED(6, "sw");
  93.         /* There is just one SWAP_SERVER, so it is not an iplist. */
  94.         *vp++ = TAG_SWAP_SERVER;/* -1 byte  */
  95.         *vp++ = 4;                /* -1 byte  */
  96.         insert_u_long(hp->swap_server.s_addr, &vp);    /* -4 bytes */
  97.         bytesleft -= 6;            /* Fix real count */
  98.     }
  99.     if (hp->flags.root_path) {
  100.         /*
  101.          * Check for room for root_path.  Add 2 to account for
  102.          * TAG_ROOT_PATH and length.
  103.          */
  104.         len = strlen(hp->root_path->string);
  105.         NEED((len + 2), "rp");
  106.         *vp++ = TAG_ROOT_PATH;
  107.         *vp++ = (byte) (len & 0xFF);
  108.         bcopy(hp->root_path->string, vp, len);
  109.         vp += len;
  110.         bytesleft -= len + 2;
  111.     }
  112.     if (hp->flags.dump_file) {
  113.         /*
  114.          * Check for room for dump_file.  Add 2 to account for
  115.          * TAG_DUMP_FILE and length.
  116.          */
  117.         len = strlen(hp->dump_file->string);
  118.         NEED((len + 2), "df");
  119.         *vp++ = TAG_DUMP_FILE;
  120.         *vp++ = (byte) (len & 0xFF);
  121.         bcopy(hp->dump_file->string, vp, len);
  122.         vp += len;
  123.         bytesleft -= len + 2;
  124.     }
  125.     /*
  126.      * DNS server and domain
  127.      */
  128.     if (hp->flags.domain_server) {
  129.         if (insert_ip(TAG_DOMAIN_SERVER,
  130.                       hp->domain_server,
  131.                       &vp, &bytesleft))
  132.             NEED(8, "ds");
  133.     }
  134.     if (hp->flags.domain_name) {
  135.         /*
  136.          * Check for room for domain_name.  Add 2 to account for
  137.          * TAG_DOMAIN_NAME and length.
  138.          */
  139.         len = strlen(hp->domain_name->string);
  140.         NEED((len + 2), "dn");
  141.         *vp++ = TAG_DOMAIN_NAME;
  142.         *vp++ = (byte) (len & 0xFF);
  143.         bcopy(hp->domain_name->string, vp, len);
  144.         vp += len;
  145.         bytesleft -= len + 2;
  146.     }
  147.     /*
  148.      * NIS (YP) server and domain
  149.      */
  150.     if (hp->flags.nis_server) {
  151.         if (insert_ip(TAG_NIS_SERVER,
  152.                       hp->nis_server,
  153.                       &vp, &bytesleft))
  154.             NEED(8, "ds");
  155.     }
  156.     if (hp->flags.nis_domain) {
  157.         /*
  158.          * Check for room for nis_domain.  Add 2 to account for
  159.          * TAG_NIS_DOMAIN and length.
  160.          */
  161.         len = strlen(hp->nis_domain->string);
  162.         NEED((len + 2), "dn");
  163.         *vp++ = TAG_NIS_DOMAIN;
  164.         *vp++ = (byte) (len & 0xFF);
  165.         bcopy(hp->nis_domain->string, vp, len);
  166.         vp += len;
  167.         bytesleft -= len + 2;
  168.     }
  169.     /* IEN 116 name server */
  170.     if (hp->flags.name_server) {
  171.         if (insert_ip(TAG_NAME_SERVER,
  172.                       hp->name_server,
  173.                       &vp, &bytesleft))
  174.             NEED(8, "ns");
  175.     }
  176.     if (hp->flags.rlp_server) {
  177.         if (insert_ip(TAG_RLP_SERVER,
  178.                       hp->rlp_server,
  179.                       &vp, &bytesleft))
  180.             NEED(8, "rl");
  181.     }
  182.     /* Time server (RFC 868) */
  183.     if (hp->flags.time_server) {
  184.         if (insert_ip(TAG_TIME_SERVER,
  185.                       hp->time_server,
  186.                       &vp, &bytesleft))
  187.             NEED(8, "ts");
  188.     }
  189.     /* NTP (time) Server (RFC 1129) */
  190.     if (hp->flags.ntp_server) {
  191.         if (insert_ip(TAG_NTP_SERVER,
  192.                       hp->ntp_server,
  193.                       &vp, &bytesleft))
  194.             NEED(8, "ts");
  195.     }
  196.     /*
  197.      * I wonder:  If the hostname were "promoted" into the BOOTP
  198.      * response part, might these "extension" files possibly be
  199.      * shared between several clients?
  200.      *
  201.      * Also, why not just use longer BOOTP packets with all the
  202.      * additional length used as option data.  This bootpd version
  203.      * already supports that feature by replying with the same
  204.      * packet length as the client request packet. -gwr
  205.      */
  206.     if (hp->flags.name_switch && hp->flags.send_name) {
  207.         /*
  208.          * Check for room for hostname.  Add 2 to account for
  209.          * TAG_HOST_NAME and length.
  210.          */
  211.         len = strlen(hp->hostname->string);
  212. #if 0
  213.         /*
  214.          * XXX - Too much magic.  The user can always set the hostname
  215.          * to the short version in the bootptab file. -gwr
  216.          */
  217.         if ((len + 2) > bytesleft) {
  218.             /*
  219.              * Not enough room for full (domain-qualified) hostname, try
  220.              * stripping it down to just the first field (host).
  221.              */
  222.             char *tmpstr = hp->hostname->string;
  223.             len = 0;
  224.             while (*tmpstr && (*tmpstr != '.')) {
  225.                 tmpstr++;
  226.                 len++;
  227.             }
  228.         }
  229. #endif
  230.         NEED((len + 2), "hn");
  231.         *vp++ = TAG_HOST_NAME;
  232.         *vp++ = (byte) (len & 0xFF);
  233.         bcopy(hp->hostname->string, vp, len);
  234.         vp += len;
  235.         bytesleft -= len + 2;
  236.     }
  237.     /*
  238.      * The rest of these are less important, so they go last.
  239.      */
  240.     if (hp->flags.lpr_server) {
  241.         if (insert_ip(TAG_LPR_SERVER,
  242.                       hp->lpr_server,
  243.                       &vp, &bytesleft))
  244.             NEED(8, "lp");
  245.     }
  246.     if (hp->flags.cookie_server) {
  247.         if (insert_ip(TAG_COOKIE_SERVER,
  248.                       hp->cookie_server,
  249.                       &vp, &bytesleft))
  250.             NEED(8, "cs");
  251.     }
  252.     if (hp->flags.log_server) {
  253.         if (insert_ip(TAG_LOG_SERVER,
  254.                       hp->log_server,
  255.                       &vp, &bytesleft))
  256.             NEED(8, "lg");
  257.     }
  258.     /*
  259.      * XXX - Add new tags here (to insert options)
  260.      */
  261.     if (hp->flags.generic) {
  262.         if (insert_generic(hp->generic, &vp, &bytesleft))
  263.             NEED(64, "(generic)");
  264.     }
  265.     /*
  266.      * The end marker is inserted by the caller.
  267.      */
  268.     return (vp - buf);
  269. #undef    NEED
  270. }                                /* dovend_rfc1497 */
  271.  
  272.  
  273.  
  274. /*
  275.  * Insert a tag value, a length value, and a list of IP addresses into the
  276.  * memory buffer indirectly pointed to by "dest".  "tag" is the RFC1048 tag
  277.  * number to use, "iplist" is a pointer to a list of IP addresses
  278.  * (struct in_addr_list), and "bytesleft" points to an integer which
  279.  * indicates the size of the "dest" buffer.
  280.  *
  281.  * Return zero if everything fits.
  282.  *
  283.  * This is used to fill the vendor-specific area of a bootp packet in
  284.  * conformance to RFC1048.
  285.  */
  286.  
  287. int
  288. insert_ip(tag, iplist, dest, bytesleft)
  289.     byte tag;
  290.     struct in_addr_list *iplist;
  291.     byte **dest;
  292.     int *bytesleft;
  293. {
  294.     struct in_addr *addrptr;
  295.     unsigned addrcount = 1;
  296.     byte *d;
  297.  
  298.     if (iplist == NULL)
  299.         return (0);
  300.  
  301.     if (*bytesleft >= 6) {
  302.         d = *dest;                /* Save pointer for later */
  303.         **dest = tag;
  304.         (*dest) += 2;
  305.         (*bytesleft) -= 2;        /* Account for tag and length */
  306.         addrptr = iplist->addr;
  307.         addrcount = iplist->addrcount;
  308.         while ((*bytesleft >= 4) && (addrcount > 0)) {
  309.             insert_u_long(addrptr->s_addr, dest);
  310.             addrptr++;
  311.             addrcount--;
  312.             (*bytesleft) -= 4;    /* Four bytes per address */
  313.         }
  314.         d[1] = (byte) ((*dest - d - 2) & 0xFF);
  315.     }
  316.     return (addrcount);
  317. }
  318.  
  319.  
  320.  
  321. /*
  322.  * Insert generic data into a bootp packet.  The data is assumed to already
  323.  * be in RFC1048 format.  It is inserted using a first-fit algorithm which
  324.  * attempts to insert as many tags as possible.  Tags and data which are
  325.  * too large to fit are skipped; any remaining tags are tried until they
  326.  * have all been exhausted.
  327.  * Return zero if everything fits.
  328.  */
  329.  
  330. static int
  331. insert_generic(gendata, buff, bytesleft)
  332.     struct shared_bindata *gendata;
  333.     byte **buff;
  334.     int *bytesleft;
  335. {
  336.     byte *srcptr;
  337.     int length, numbytes;
  338.     int skipped = 0;
  339.  
  340.     if (gendata == NULL)
  341.         return (0);
  342.  
  343.     srcptr = gendata->data;
  344.     length = gendata->length;
  345.     while ((length > 0) && (*bytesleft > 0)) {
  346.         switch (*srcptr) {
  347.         case TAG_END:
  348.             length = 0;            /* Force an exit on next iteration */
  349.             break;
  350.         case TAG_PAD:
  351.             *(*buff)++ = *srcptr++;
  352.             (*bytesleft)--;
  353.             length--;
  354.             break;
  355.         default:
  356.             numbytes = srcptr[1] + 2;
  357.             if (*bytesleft < numbytes)
  358.                 skipped += numbytes;
  359.             else {
  360.                 bcopy(srcptr, *buff, numbytes);
  361.                 (*buff) += numbytes;
  362.                 (*bytesleft) -= numbytes;
  363.             }
  364.             srcptr += numbytes;
  365.             length -= numbytes;
  366.             break;
  367.         }
  368.     } /* while */
  369.     return (skipped);
  370. }
  371.  
  372. /*
  373.  * Insert the unsigned long "value" into memory starting at the byte
  374.  * pointed to by the byte pointer (*dest).  (*dest) is updated to
  375.  * point to the next available byte.
  376.  *
  377.  * Since it is desirable to internally store network addresses in network
  378.  * byte order (in struct in_addr's), this routine expects longs to be
  379.  * passed in network byte order.
  380.  *
  381.  * However, due to the nature of the main algorithm, the long must be in
  382.  * host byte order, thus necessitating the use of ntohl() first.
  383.  */
  384.  
  385. void
  386. insert_u_long(value, dest)
  387.     u_int32 value;
  388.     byte **dest;
  389. {
  390.     byte *temp;
  391.     int n;
  392.  
  393.     value = ntohl(value);        /* Must use host byte order here */
  394.     temp = (*dest += 4);
  395.     for (n = 4; n > 0; n--) {
  396.         *--temp = (byte) (value & 0xFF);
  397.         value >>= 8;
  398.     }
  399.     /* Final result is network byte order */
  400. }
  401.  
  402. /*
  403.  * Local Variables:
  404.  * tab-width: 4
  405.  * c-indent-level: 4
  406.  * c-argdecl-indent: 4
  407.  * c-continued-statement-offset: 4
  408.  * c-continued-brace-offset: -4
  409.  * c-label-offset: -4
  410.  * c-brace-offset: 0
  411.  * End:
  412.  */
  413.