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