![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dhcpopts.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / roms / ipxe / src / net|
Return to dhcpopts.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / ipxe / src / net |
1.1 root 1: /*
2: * Copyright (C) 2008 Michael Brown <[email protected]>.
3: *
4: * This program is free software; you can redistribute it and/or
5: * modify it under the terms of the GNU General Public License as
6: * published by the Free Software Foundation; either version 2 of the
7: * License, or any later version.
8: *
9: * This program is distributed in the hope that it will be useful, but
10: * WITHOUT ANY WARRANTY; without even the implied warranty of
11: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12: * General Public License for more details.
13: *
14: * You should have received a copy of the GNU General Public License
15: * along with this program; if not, write to the Free Software
16: * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17: */
18:
19: FILE_LICENCE ( GPL2_OR_LATER );
20:
21: #include <stdint.h>
22: #include <stdlib.h>
23: #include <stdio.h>
24: #include <errno.h>
25: #include <string.h>
26: #include <ipxe/dhcp.h>
27: #include <ipxe/dhcpopts.h>
28:
29: /** @file
30: *
31: * DHCP options
32: *
33: */
34:
35: /**
36: * Obtain printable version of a DHCP option tag
37: *
38: * @v tag DHCP option tag
39: * @ret name String representation of the tag
40: *
41: */
42: static inline char * dhcp_tag_name ( unsigned int tag ) {
43: static char name[8];
44:
45: if ( DHCP_IS_ENCAP_OPT ( tag ) ) {
46: snprintf ( name, sizeof ( name ), "%d.%d",
47: DHCP_ENCAPSULATOR ( tag ),
48: DHCP_ENCAPSULATED ( tag ) );
49: } else {
50: snprintf ( name, sizeof ( name ), "%d", tag );
51: }
52: return name;
53: }
54:
55: /**
56: * Get pointer to DHCP option
57: *
58: * @v options DHCP options block
59: * @v offset Offset within options block
60: * @ret option DHCP option
61: */
62: static inline __attribute__ (( always_inline )) struct dhcp_option *
63: dhcp_option ( struct dhcp_options *options, unsigned int offset ) {
64: return ( ( struct dhcp_option * ) ( options->data + offset ) );
65: }
66:
67: /**
68: * Get offset of a DHCP option
69: *
70: * @v options DHCP options block
71: * @v option DHCP option
72: * @ret offset Offset within options block
73: */
74: static inline __attribute__ (( always_inline )) int
75: dhcp_option_offset ( struct dhcp_options *options,
76: struct dhcp_option *option ) {
77: return ( ( ( void * ) option ) - options->data );
78: }
79:
80: /**
81: * Calculate length of any DHCP option
82: *
83: * @v option DHCP option
84: * @ret len Length (including tag and length field)
85: */
86: static unsigned int dhcp_option_len ( struct dhcp_option *option ) {
87: if ( ( option->tag == DHCP_END ) || ( option->tag == DHCP_PAD ) ) {
88: return 1;
89: } else {
90: return ( option->len + DHCP_OPTION_HEADER_LEN );
91: }
92: }
93:
94: /**
95: * Find DHCP option within DHCP options block, and its encapsulator (if any)
96: *
97: * @v options DHCP options block
98: * @v tag DHCP option tag to search for
99: * @ret encap_offset Offset of encapsulating DHCP option
100: * @ret offset Offset of DHCP option, or negative error
101: *
102: * Searches for the DHCP option matching the specified tag within the
103: * DHCP option block. Encapsulated options may be searched for by
104: * using DHCP_ENCAP_OPT() to construct the tag value.
105: *
106: * If the option is encapsulated, and @c encap_offset is non-NULL, it
107: * will be filled in with the offset of the encapsulating option.
108: *
109: * This routine is designed to be paranoid. It does not assume that
110: * the option data is well-formatted, and so must guard against flaws
111: * such as options missing a @c DHCP_END terminator, or options whose
112: * length would take them beyond the end of the data block.
113: */
114: static int find_dhcp_option_with_encap ( struct dhcp_options *options,
115: unsigned int tag,
116: int *encap_offset ) {
117: unsigned int original_tag __attribute__ (( unused )) = tag;
118: struct dhcp_option *option;
119: int offset = 0;
120: ssize_t remaining = options->used_len;
121: unsigned int option_len;
122:
123: /* Sanity check */
124: if ( tag == DHCP_PAD )
125: return -ENOENT;
126:
127: /* Search for option */
128: while ( remaining ) {
129: /* Calculate length of this option. Abort processing
130: * if the length is malformed (i.e. takes us beyond
131: * the end of the data block).
132: */
133: option = dhcp_option ( options, offset );
134: option_len = dhcp_option_len ( option );
135: remaining -= option_len;
136: if ( remaining < 0 )
137: break;
138: /* Check for explicit end marker */
139: if ( option->tag == DHCP_END ) {
140: if ( tag == DHCP_END )
141: /* Special case where the caller is interested
142: * in whether we have this marker or not.
143: */
144: return offset;
145: else
146: break;
147: }
148: /* Check for matching tag */
149: if ( option->tag == tag ) {
150: DBGC ( options, "DHCPOPT %p found %s (length %d)\n",
151: options, dhcp_tag_name ( original_tag ),
152: option_len );
153: return offset;
154: }
155: /* Check for start of matching encapsulation block */
156: if ( DHCP_IS_ENCAP_OPT ( tag ) &&
157: ( option->tag == DHCP_ENCAPSULATOR ( tag ) ) ) {
158: if ( encap_offset )
159: *encap_offset = offset;
160: /* Continue search within encapsulated option block */
161: tag = DHCP_ENCAPSULATED ( tag );
162: remaining = option_len;
163: offset += DHCP_OPTION_HEADER_LEN;
164: continue;
165: }
166: offset += option_len;
167: }
168:
169: return -ENOENT;
170: }
171:
172: /**
173: * Refuse to reallocate DHCP option block
174: *
175: * @v options DHCP option block
176: * @v len New length
177: * @ret rc Return status code
178: */
179: int dhcpopt_no_realloc ( struct dhcp_options *options, size_t len ) {
180: return ( ( len <= options->alloc_len ) ? 0 : -ENOSPC );
181: }
182:
183: /**
184: * Resize a DHCP option
185: *
186: * @v options DHCP option block
187: * @v offset Offset of option to resize
188: * @v encap_offset Offset of encapsulating offset (or -ve for none)
189: * @v old_len Old length (including header)
190: * @v new_len New length (including header)
191: * @ret rc Return status code
192: */
193: static int resize_dhcp_option ( struct dhcp_options *options,
194: int offset, int encap_offset,
195: size_t old_len, size_t new_len ) {
196: struct dhcp_option *encapsulator;
197: struct dhcp_option *option;
198: ssize_t delta = ( new_len - old_len );
199: size_t old_alloc_len;
200: size_t new_used_len;
201: size_t new_encapsulator_len;
202: void *source;
203: void *dest;
204: void *end;
205: int rc;
206:
207: /* Check for sufficient space */
208: if ( new_len > DHCP_MAX_LEN ) {
209: DBGC ( options, "DHCPOPT %p overlength option\n", options );
210: return -ENOSPC;
211: }
212: new_used_len = ( options->used_len + delta );
213:
214: /* Expand options block, if necessary */
215: if ( new_used_len > options->alloc_len ) {
216: /* Reallocate options block */
217: old_alloc_len = options->alloc_len;
218: if ( ( rc = options->realloc ( options, new_used_len ) ) != 0 ){
219: DBGC ( options, "DHCPOPT %p could not reallocate to "
220: "%zd bytes\n", options, new_used_len );
221: return rc;
222: }
223: /* Clear newly allocated space */
224: memset ( ( options->data + old_alloc_len ), 0,
225: ( options->alloc_len - old_alloc_len ) );
226: }
227:
228: /* Update encapsulator, if applicable */
229: if ( encap_offset >= 0 ) {
230: encapsulator = dhcp_option ( options, encap_offset );
231: new_encapsulator_len = ( encapsulator->len + delta );
232: if ( new_encapsulator_len > DHCP_MAX_LEN ) {
233: DBGC ( options, "DHCPOPT %p overlength encapsulator\n",
234: options );
235: return -ENOSPC;
236: }
237: encapsulator->len = new_encapsulator_len;
238: }
239:
240: /* Update used length */
241: options->used_len = new_used_len;
242:
243: /* Move remainder of option data */
244: option = dhcp_option ( options, offset );
245: source = ( ( ( void * ) option ) + old_len );
246: dest = ( ( ( void * ) option ) + new_len );
247: end = ( options->data + options->alloc_len );
248: memmove ( dest, source, ( end - dest ) );
249:
250: /* Shrink options block, if applicable */
251: if ( new_used_len < options->alloc_len ) {
252: if ( ( rc = options->realloc ( options, new_used_len ) ) != 0 ){
253: DBGC ( options, "DHCPOPT %p could not reallocate to "
254: "%zd bytes\n", options, new_used_len );
255: return rc;
256: }
257: }
258:
259: return 0;
260: }
261:
262: /**
263: * Set value of DHCP option
264: *
265: * @v options DHCP option block
266: * @v tag DHCP option tag
267: * @v data New value for DHCP option
268: * @v len Length of value, in bytes
269: * @ret offset Offset of DHCP option, or negative error
270: *
271: * Sets the value of a DHCP option within the options block. The
272: * option may or may not already exist. Encapsulators will be created
273: * (and deleted) as necessary.
274: *
275: * This call may fail due to insufficient space in the options block.
276: * If it does fail, and the option existed previously, the option will
277: * be left with its original value.
278: */
279: static int set_dhcp_option ( struct dhcp_options *options, unsigned int tag,
280: const void *data, size_t len ) {
281: static const uint8_t empty_encap[] = { DHCP_END };
282: int offset;
283: int encap_offset = -1;
284: int creation_offset;
285: struct dhcp_option *option;
286: unsigned int encap_tag = DHCP_ENCAPSULATOR ( tag );
287: size_t old_len = 0;
288: size_t new_len = ( len ? ( len + DHCP_OPTION_HEADER_LEN ) : 0 );
289: int rc;
290:
291: /* Sanity check */
292: if ( tag == DHCP_PAD )
293: return -ENOTTY;
294:
295: creation_offset = find_dhcp_option_with_encap ( options, DHCP_END,
296: NULL );
297: if ( creation_offset < 0 )
298: creation_offset = options->used_len;
299: /* Find old instance of this option, if any */
300: offset = find_dhcp_option_with_encap ( options, tag, &encap_offset );
301: if ( offset >= 0 ) {
302: old_len = dhcp_option_len ( dhcp_option ( options, offset ) );
303: DBGC ( options, "DHCPOPT %p resizing %s from %zd to %zd\n",
304: options, dhcp_tag_name ( tag ), old_len, new_len );
305: } else {
306: DBGC ( options, "DHCPOPT %p creating %s (length %zd)\n",
307: options, dhcp_tag_name ( tag ), new_len );
308: }
309:
310: /* Ensure that encapsulator exists, if required */
311: if ( encap_tag ) {
312: if ( encap_offset < 0 ) {
313: encap_offset =
314: set_dhcp_option ( options, encap_tag,
315: empty_encap,
316: sizeof ( empty_encap ) );
317: }
318: if ( encap_offset < 0 )
319: return encap_offset;
320: creation_offset = ( encap_offset + DHCP_OPTION_HEADER_LEN );
321: }
322:
323: /* Create new option if necessary */
324: if ( offset < 0 )
325: offset = creation_offset;
326:
327: /* Resize option to fit new data */
328: if ( ( rc = resize_dhcp_option ( options, offset, encap_offset,
329: old_len, new_len ) ) != 0 )
330: return rc;
331:
332: /* Copy new data into option, if applicable */
333: if ( len ) {
334: option = dhcp_option ( options, offset );
335: option->tag = tag;
336: option->len = len;
337: memcpy ( &option->data, data, len );
338: }
339:
340: /* Delete encapsulator if there's nothing else left in it */
341: if ( encap_offset >= 0 ) {
342: option = dhcp_option ( options, encap_offset );
343: if ( option->len <= 1 )
344: set_dhcp_option ( options, encap_tag, NULL, 0 );
345: }
346:
347: return offset;
348: }
349:
350: /**
351: * Check applicability of DHCP option setting
352: *
353: * @v tag Setting tag number
354: * @ret applies Setting applies to this option block
355: */
356: int dhcpopt_applies ( unsigned int tag ) {
357:
358: return ( tag && ( tag <= DHCP_ENCAP_OPT ( DHCP_MAX_OPTION,
359: DHCP_MAX_OPTION ) ) );
360: }
361:
362: /**
363: * Store value of DHCP option setting
364: *
365: * @v options DHCP option block
366: * @v tag Setting tag number
367: * @v data Setting data, or NULL to clear setting
368: * @v len Length of setting data
369: * @ret rc Return status code
370: */
371: int dhcpopt_store ( struct dhcp_options *options, unsigned int tag,
372: const void *data, size_t len ) {
373: int offset;
374:
375: offset = set_dhcp_option ( options, tag, data, len );
376: if ( offset < 0 )
377: return offset;
378: return 0;
379: }
380:
381: /**
382: * Fetch value of DHCP option setting
383: *
384: * @v options DHCP option block
385: * @v tag Setting tag number
386: * @v data Buffer to fill with setting data
387: * @v len Length of buffer
388: * @ret len Length of setting data, or negative error
389: */
390: int dhcpopt_fetch ( struct dhcp_options *options, unsigned int tag,
391: void *data, size_t len ) {
392: int offset;
393: struct dhcp_option *option;
394: size_t option_len;
395:
396: offset = find_dhcp_option_with_encap ( options, tag, NULL );
397: if ( offset < 0 )
398: return offset;
399:
400: option = dhcp_option ( options, offset );
401: option_len = option->len;
402: if ( len > option_len )
403: len = option_len;
404: memcpy ( data, option->data, len );
405:
406: return option_len;
407: }
408:
409: /**
410: * Recalculate length of DHCP options block
411: *
412: * @v options Uninitialised DHCP option block
413: *
414: * The "used length" field will be updated based on scanning through
415: * the block to find the end of the options.
416: */
417: void dhcpopt_update_used_len ( struct dhcp_options *options ) {
418: struct dhcp_option *option;
419: int offset = 0;
420: ssize_t remaining = options->alloc_len;
421: unsigned int option_len;
422:
423: /* Find last non-pad option */
424: options->used_len = 0;
425: while ( remaining ) {
426: option = dhcp_option ( options, offset );
427: option_len = dhcp_option_len ( option );
428: remaining -= option_len;
429: if ( remaining < 0 )
430: break;
431: offset += option_len;
432: if ( option->tag != DHCP_PAD )
433: options->used_len = offset;
434: }
435: }
436:
437: /**
438: * Initialise prepopulated block of DHCP options
439: *
440: * @v options Uninitialised DHCP option block
441: * @v data Memory for DHCP option data
442: * @v alloc_len Length of memory for DHCP option data
443: * @v realloc DHCP option block reallocator
444: *
445: * The memory content must already be filled with valid DHCP options.
446: * A zeroed block counts as a block of valid DHCP options.
447: */
448: void dhcpopt_init ( struct dhcp_options *options, void *data, size_t alloc_len,
449: int ( * realloc ) ( struct dhcp_options *options,
450: size_t len ) ) {
451:
452: /* Fill in fields */
453: options->data = data;
454: options->alloc_len = alloc_len;
455: options->realloc = realloc;
456:
457: /* Update length */
458: dhcpopt_update_used_len ( options );
459:
460: DBGC ( options, "DHCPOPT %p created (data %p lengths %#zx,%#zx)\n",
461: options, options->data, options->used_len, options->alloc_len );
462: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.