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