1 /* 2 * dovend.c : Inserts all but the first few vendor options. 3 * 4 * $Id$ 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 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 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 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 */ 415