libexec/bootpd/dovend.c

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