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