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
32PRIVATE 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
47int
48dovend_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, "ds");
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), "dn");
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, "ts");
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
283int
284insert_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
326static int
327insert_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
381void
382insert_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