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