iPXE
settings.c
Go to the documentation of this file.
1/*
2 * Copyright (C) 2008 Michael Brown <mbrown@fensystems.co.uk>.
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., 51 Franklin Street, Fifth Floor, Boston, MA
17 * 02110-1301, USA.
18 *
19 * You can also choose to distribute this program under the terms of
20 * the Unmodified Binary Distribution Licence (as given in the file
21 * COPYING.UBDL), provided that you have satisfied its requirements.
22 */
23
24FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
25FILE_SECBOOT ( PERMITTED );
26
27#include <stdint.h>
28#include <stdlib.h>
29#include <stdio.h>
30#include <string.h>
31#include <strings.h>
32#include <byteswap.h>
33#include <errno.h>
34#include <assert.h>
35#include <time.h>
36#include <ipxe/in.h>
37#include <ipxe/ip.h>
38#include <ipxe/ipv6.h>
39#include <ipxe/vsprintf.h>
40#include <ipxe/dhcp.h>
41#include <ipxe/uuid.h>
42#include <ipxe/uri.h>
43#include <ipxe/base16.h>
44#include <ipxe/base64.h>
45#include <ipxe/pci.h>
46#include <ipxe/init.h>
47#include <ipxe/version.h>
48#include <ipxe/settings.h>
49
50/** @file
51 *
52 * Configuration settings
53 *
54 */
55
56/******************************************************************************
57 *
58 * Generic settings blocks
59 *
60 ******************************************************************************
61 */
62
63/**
64 * A generic setting
65 *
66 */
67struct generic_setting {
68 /** List of generic settings */
69 struct list_head list;
70 /** Setting */
71 struct setting setting;
72 /** Size of setting name */
73 size_t name_len;
74 /** Size of setting data */
75 size_t data_len;
76};
77
78/**
79 * Get generic setting name
80 *
81 * @v generic Generic setting
82 * @ret name Generic setting name
83 */
84static inline void * generic_setting_name ( struct generic_setting *generic ) {
85 return ( ( ( void * ) generic ) + sizeof ( *generic ) );
86}
87
88/**
89 * Get generic setting data
90 *
91 * @v generic Generic setting
92 * @ret data Generic setting data
93 */
94static inline void * generic_setting_data ( struct generic_setting *generic ) {
95 return ( ( ( void * ) generic ) + sizeof ( *generic ) +
96 generic->name_len );
97}
98
99/**
100 * Find generic setting
101 *
102 * @v generics Generic settings block
103 * @v setting Setting to find
104 * @ret generic Generic setting, or NULL
105 */
106static struct generic_setting *
107find_generic_setting ( struct generic_settings *generics,
108 const struct setting *setting ) {
109 struct generic_setting *generic;
110
111 list_for_each_entry ( generic, &generics->list, list ) {
112 if ( setting_cmp ( &generic->setting, setting ) == 0 )
113 return generic;
114 }
115 return NULL;
116}
117
118/**
119 * Store value of generic setting
120 *
121 * @v settings Settings block
122 * @v setting Setting to store
123 * @v data Setting data, or NULL to clear setting
124 * @v len Length of setting data
125 * @ret rc Return status code
126 */
127int generic_settings_store ( struct settings *settings,
128 const struct setting *setting,
129 const void *data, size_t len ) {
130 struct generic_settings *generics =
131 container_of ( settings, struct generic_settings, settings );
132 struct generic_setting *old;
133 struct generic_setting *new = NULL;
134 size_t name_len;
135
136 /* Identify existing generic setting, if any */
137 old = find_generic_setting ( generics, setting );
138
139 /* Create new generic setting, if required */
140 if ( len ) {
141 /* Allocate new generic setting */
142 name_len = ( strlen ( setting->name ) + 1 );
143 new = zalloc ( sizeof ( *new ) + name_len + len );
144 if ( ! new )
145 return -ENOMEM;
146
147 /* Populate new generic setting */
148 new->name_len = name_len;
149 new->data_len = len;
150 memcpy ( &new->setting, setting, sizeof ( new->setting ) );
151 new->setting.name = generic_setting_name ( new );
152 memcpy ( generic_setting_name ( new ),
153 setting->name, name_len );
154 memcpy ( generic_setting_data ( new ), data, len );
155 }
156
157 /* Delete existing generic setting, if any */
158 if ( old ) {
159 list_del ( &old->list );
160 free ( old );
161 }
162
163 /* Add new setting to list, if any */
164 if ( new )
165 list_add ( &new->list, &generics->list );
166
167 return 0;
168}
169
170/**
171 * Fetch value of generic setting
172 *
173 * @v settings Settings block
174 * @v setting Setting to fetch
175 * @v data Buffer to fill with setting data
176 * @v len Length of buffer
177 * @ret len Length of setting data, or negative error
178 */
179int generic_settings_fetch ( struct settings *settings,
180 struct setting *setting,
181 void *data, size_t len ) {
182 struct generic_settings *generics =
183 container_of ( settings, struct generic_settings, settings );
184 struct generic_setting *generic;
185
186 /* Find generic setting */
187 generic = find_generic_setting ( generics, setting );
188 if ( ! generic )
189 return -ENOENT;
190
191 /* Copy out generic setting data */
192 if ( len > generic->data_len )
193 len = generic->data_len;
194 memcpy ( data, generic_setting_data ( generic ), len );
195
196 /* Set setting type, if not yet specified */
197 if ( ! setting->type )
198 setting->type = generic->setting.type;
199
200 return generic->data_len;
201}
202
203/**
204 * Clear generic settings block
205 *
206 * @v settings Settings block
207 */
208void generic_settings_clear ( struct settings *settings ) {
209 struct generic_settings *generics =
210 container_of ( settings, struct generic_settings, settings );
211 struct generic_setting *generic;
212 struct generic_setting *tmp;
213
214 list_for_each_entry_safe ( generic, tmp, &generics->list, list ) {
215 list_del ( &generic->list );
216 free ( generic );
217 }
218 assert ( list_empty ( &generics->list ) );
219}
220
221/** Generic settings operations */
227
228/******************************************************************************
229 *
230 * Registered settings blocks
231 *
232 ******************************************************************************
233 */
234
235/** Root generic settings block */
236struct generic_settings generic_settings_root = {
237 .settings = {
238 .refcnt = NULL,
239 .name = "",
240 .siblings =
241 LIST_HEAD_INIT ( generic_settings_root.settings.siblings ),
242 .children =
243 LIST_HEAD_INIT ( generic_settings_root.settings.children ),
244 .op = &generic_settings_operations,
245 },
246 .list = LIST_HEAD_INIT ( generic_settings_root.list ),
247};
248
249/** Root settings block */
250#define settings_root generic_settings_root.settings
251
252/** Autovivified settings block */
253struct autovivified_settings {
254 /** Reference count */
255 struct refcnt refcnt;
256 /** Generic settings block */
257 struct generic_settings generic;
258};
259
260/**
261 * Free autovivified settings block
262 *
263 * @v refcnt Reference count
264 */
265static void autovivified_settings_free ( struct refcnt *refcnt ) {
266 struct autovivified_settings *autovivified =
267 container_of ( refcnt, struct autovivified_settings, refcnt );
268
269 generic_settings_clear ( &autovivified->generic.settings );
270 free ( autovivified );
271}
272
273/**
274 * Find child settings block
275 *
276 * @v parent Parent settings block
277 * @v name Name within this parent
278 * @ret settings Settings block, or NULL
279 */
280struct settings * find_child_settings ( struct settings *parent,
281 const char *name ) {
282 struct settings *settings;
283
284 /* Find target parent settings block */
285 parent = settings_target ( parent );
286
287 /* Treat empty name as meaning "this block" */
288 if ( ! *name )
289 return parent;
290
291 /* Look for child with matching name */
292 list_for_each_entry ( settings, &parent->children, siblings ) {
293 if ( strcmp ( settings->name, name ) == 0 )
294 return settings_target ( settings );
295 }
296
297 return NULL;
298}
299
300/**
301 * Find or create child settings block
302 *
303 * @v parent Parent settings block
304 * @v name Name within this parent
305 * @ret settings Settings block, or NULL
306 */
307struct settings * autovivify_child_settings ( struct settings *parent,
308 const char *name ) {
309 struct {
310 struct autovivified_settings autovivified;
311 char name[ strlen ( name ) + 1 /* NUL */ ];
312 } *new_child;
313 struct settings *settings;
314
315 /* Find target parent settings block */
316 parent = settings_target ( parent );
317
318 /* Return existing settings, if existent */
319 if ( ( settings = find_child_settings ( parent, name ) ) != NULL )
320 return settings;
321
322 /* Create new generic settings block */
323 new_child = zalloc ( sizeof ( *new_child ) );
324 if ( ! new_child ) {
325 DBGC ( parent, "Settings %p could not create child %s\n",
326 parent, name );
327 return NULL;
328 }
329 memcpy ( new_child->name, name, sizeof ( new_child->name ) );
330 ref_init ( &new_child->autovivified.refcnt,
331 autovivified_settings_free );
332 generic_settings_init ( &new_child->autovivified.generic,
333 &new_child->autovivified.refcnt );
334 settings = &new_child->autovivified.generic.settings;
335 register_settings ( settings, parent, new_child->name );
336 ref_put ( settings->refcnt );
337 return settings;
338}
339
340/**
341 * Return settings block name
342 *
343 * @v settings Settings block
344 * @ret name Settings block name
345 */
346const char * settings_name ( struct settings *settings ) {
347 static char buf[16];
348 char tmp[ 1 /* '.' */ + sizeof ( buf ) ];
349
350 /* Find target settings block */
351 settings = settings_target ( settings );
352
353 /* Construct name */
354 buf[0] = '\0';
355 tmp[0] = '\0';
356 for ( ; settings->parent ; settings = settings->parent ) {
357 memcpy ( ( tmp + 1 ), buf, ( sizeof ( tmp ) - 1 ) );
358 snprintf ( buf, sizeof ( buf ), "%s%s", settings->name, tmp );
359 tmp[0] = '.';
360 }
361 return buf;
362}
363
364/**
365 * Parse settings block name
366 *
367 * @v name Name
368 * @v get_child Function to find or create child settings block
369 * @ret settings Settings block, or NULL
370 */
371static struct settings *
372parse_settings_name ( const char *name, get_child_settings_t get_child ) {
373 struct settings *settings = &settings_root;
374 char *name_copy;
375 char *subname;
376 char *remainder;
377
378 /* Create modifiable copy of name */
379 name_copy = strdup ( name );
380 if ( ! name_copy )
381 return NULL;
382 remainder = name_copy;
383
384 /* Parse each name component in turn */
385 while ( remainder ) {
386 subname = remainder;
387 remainder = strchr ( subname, '.' );
388 if ( remainder )
389 *(remainder++) = '\0';
390 settings = get_child ( settings, subname );
391 if ( ! settings )
392 break;
393 }
394
395 /* Free modifiable copy of name */
396 free ( name_copy );
397
398 return settings;
399}
400
401/**
402 * Find settings block
403 *
404 * @v name Name
405 * @ret settings Settings block, or NULL
406 */
407struct settings * find_settings ( const char *name ) {
408
409 return parse_settings_name ( name, find_child_settings );
410}
411
412/**
413 * Apply all settings
414 *
415 */
416static void apply_settings ( void ) {
417 struct settings_applicator *applicator;
418 int rc;
419
420 /* Call all settings applicators */
421 for_each_table_entry ( applicator, SETTINGS_APPLICATORS ) {
422 if ( ( rc = applicator->apply() ) != 0 ) {
423 DBG ( "Could not apply settings using applicator "
424 "%p: %s\n", applicator, strerror ( rc ) );
425 /* Continue to apply remaining settings */
426 }
427 }
428}
429
430/**
431 * Reprioritise settings
432 *
433 * @v settings Settings block
434 *
435 * Reorders the settings block amongst its siblings according to its
436 * priority.
437 */
438static void reprioritise_settings ( struct settings *settings ) {
439 struct settings *parent = settings->parent;
440 long priority;
441 struct settings *tmp;
442 long tmp_priority;
443
444 /* Stop when we reach the top of the tree */
445 if ( ! parent )
446 return;
447
448 /* Read priority, if present */
449 priority = fetch_intz_setting ( settings, &priority_setting );
450
451 /* Remove from siblings list */
452 list_del ( &settings->siblings );
453
454 /* Reinsert after any existing blocks which have a higher priority */
455 list_for_each_entry ( tmp, &parent->children, siblings ) {
456 tmp_priority = fetch_intz_setting ( tmp, &priority_setting );
457 if ( priority > tmp_priority )
458 break;
459 if ( settings->order > tmp->order )
460 break;
461 }
462 list_add_tail ( &settings->siblings, &tmp->siblings );
463
464 /* Recurse up the tree */
465 reprioritise_settings ( parent );
466}
467
468/**
469 * Register settings block
470 *
471 * @v settings Settings block
472 * @v parent Parent settings block, or NULL
473 * @v name Settings block name
474 * @ret rc Return status code
475 */
476int register_settings ( struct settings *settings, struct settings *parent,
477 const char *name ) {
478 struct settings *old_settings;
479
480 /* Sanity check */
481 assert ( settings != NULL );
482
483 /* Find target parent settings block */
484 parent = settings_target ( parent );
485
486 /* Apply settings block name */
487 settings->name = name;
488
489 /* Remove any existing settings with the same name */
490 if ( ( old_settings = find_child_settings ( parent, settings->name ) ))
491 unregister_settings ( old_settings );
492
493 /* Add to list of settings */
494 ref_get ( settings->refcnt );
495 ref_get ( parent->refcnt );
496 settings->parent = parent;
497 list_add_tail ( &settings->siblings, &parent->children );
498 DBGC ( settings, "Settings %p (\"%s\") registered\n",
499 settings, settings_name ( settings ) );
500
501 /* Fix up settings priority */
502 reprioritise_settings ( settings );
503
504 /* Apply potentially-updated settings */
505 apply_settings();
506
507 return 0;
508}
509
510/**
511 * Unregister settings block
512 *
513 * @v settings Settings block
514 */
515void unregister_settings ( struct settings *settings ) {
516 struct settings *child;
517
518 /* Unregister child settings */
519 while ( ( child = list_first_entry ( &settings->children,
520 struct settings, siblings ) ) ) {
521 unregister_settings ( child );
522 }
523
524 DBGC ( settings, "Settings %p (\"%s\") unregistered\n",
525 settings, settings_name ( settings ) );
526
527 /* Remove from list of settings */
528 ref_put ( settings->parent->refcnt );
529 settings->parent = NULL;
530 list_del ( &settings->siblings );
531 ref_put ( settings->refcnt );
532
533 /* Apply potentially-updated settings */
534 apply_settings();
535}
536
537/******************************************************************************
538 *
539 * Core settings routines
540 *
541 ******************************************************************************
542 */
543
544/**
545 * Redirect to target settings block
546 *
547 * @v settings Settings block, or NULL
548 * @ret settings Underlying settings block
549 */
550struct settings * settings_target ( struct settings *settings ) {
551
552 /* NULL settings implies the global settings root */
553 if ( ! settings )
554 settings = &settings_root;
555
556 /* Redirect to underlying settings block, if applicable */
557 if ( settings->op->redirect )
558 return settings->op->redirect ( settings );
559
560 /* Otherwise, return this settings block */
561 return settings;
562}
563
564/**
565 * Check applicability of setting
566 *
567 * @v settings Settings block
568 * @v setting Setting
569 * @ret applies Setting applies within this settings block
570 */
571int setting_applies ( struct settings *settings,
572 const struct setting *setting ) {
573
574 /* Find target settings block */
575 settings = settings_target ( settings );
576
577 /* Check applicability of setting */
578 return ( settings->op->applies ?
579 settings->op->applies ( settings, setting ) : 1 );
580}
581
582/**
583 * Find setting applicable to settings block, if any
584 *
585 * @v settings Settings block
586 * @v setting Setting
587 * @ret setting Applicable setting, if any
588 */
589static const struct setting *
590applicable_setting ( struct settings *settings, const struct setting *setting ){
591 const struct setting *applicable;
592
593 /* If setting is already applicable, use it */
594 if ( setting_applies ( settings, setting ) )
595 return setting;
596
597 /* Otherwise, look for a matching predefined setting which does apply */
598 for_each_table_entry ( applicable, SETTINGS ) {
599 if ( ( setting_cmp ( setting, applicable ) == 0 ) &&
600 ( setting_applies ( settings, applicable ) ) )
601 return applicable;
602 }
603
604 return NULL;
605}
606
607/**
608 * Store value of setting
609 *
610 * @v settings Settings block, or NULL
611 * @v setting Setting to store
612 * @v data Setting data, or NULL to clear setting
613 * @v len Length of setting data
614 * @ret rc Return status code
615 */
616int store_setting ( struct settings *settings, const struct setting *setting,
617 const void *data, size_t len ) {
618 int rc;
619
620 /* Find target settings block */
621 settings = settings_target ( settings );
622
623 /* Fail if setting does not apply to this settings block */
624 if ( ! setting_applies ( settings, setting ) )
625 return -ENOTTY;
626
627 /* Sanity check */
628 if ( ! settings->op->store )
629 return -ENOTSUP;
630
631 /* Store setting */
632 if ( ( rc = settings->op->store ( settings, setting,
633 data, len ) ) != 0 )
634 return rc;
635
636 /* Reprioritise settings if necessary */
637 if ( setting_cmp ( setting, &priority_setting ) == 0 )
638 reprioritise_settings ( settings );
639
640 /* If these settings are registered, apply potentially-updated
641 * settings
642 */
643 for ( ; settings ; settings = settings->parent ) {
644 if ( settings == &settings_root ) {
645 apply_settings();
646 break;
647 }
648 }
649
650 return 0;
651}
652
653/**
654 * Fetch setting
655 *
656 * @v settings Settings block, or NULL to search all blocks
657 * @v setting Setting to fetch
658 * @v origin Origin of setting to fill in, or NULL
659 * @v fetched Fetched setting to fill in, or NULL
660 * @v data Buffer to fill with setting data
661 * @v len Length of buffer
662 * @ret len Length of setting data, or negative error
663 *
664 * The actual length of the setting will be returned even if
665 * the buffer was too small.
666 */
667int fetch_setting ( struct settings *settings, const struct setting *setting,
668 struct settings **origin, struct setting *fetched,
669 void *data, size_t len ) {
670 const struct setting *applicable;
671 struct settings *child;
672 struct setting tmp;
673 int ret;
674
675 /* Avoid returning uninitialised data on error */
676 memset ( data, 0, len );
677 if ( origin )
678 *origin = NULL;
679 if ( fetched )
680 memcpy ( fetched, setting, sizeof ( *fetched ) );
681
682 /* Find target settings block */
683 settings = settings_target ( settings );
684
685 /* Sanity check */
686 if ( ! settings->op->fetch )
687 return -ENOTSUP;
688
689 /* Try this block first, if an applicable setting exists */
690 if ( ( applicable = applicable_setting ( settings, setting ) ) ) {
691
692 /* Create modifiable copy of setting */
693 memcpy ( &tmp, applicable, sizeof ( tmp ) );
694 if ( ( ret = settings->op->fetch ( settings, &tmp,
695 data, len ) ) >= 0 ) {
696
697 /* Default to string type, if not yet specified */
698 if ( ! tmp.type )
699 tmp.type = &setting_type_string;
700
701 /* Record origin, if applicable */
702 if ( origin )
703 *origin = settings;
704
705 /* Record fetched setting, if applicable */
706 if ( fetched )
707 memcpy ( fetched, &tmp, sizeof ( *fetched ) );
708
709 return ret;
710 }
711 }
712
713 /* Recurse into each child block in turn */
714 list_for_each_entry ( child, &settings->children, siblings ) {
715 if ( ( ret = fetch_setting ( child, setting, origin, fetched,
716 data, len ) ) >= 0 )
717 return ret;
718 }
719
720 return -ENOENT;
721}
722
723/**
724 * Fetch allocated copy of setting
725 *
726 * @v settings Settings block, or NULL to search all blocks
727 * @v setting Setting to fetch
728 * @v origin Origin of setting to fill in, or NULL
729 * @v fetched Fetched setting to fill in, or NULL
730 * @v data Buffer to allocate and fill with setting data
731 * @v alloc Allocation function
732 * @ret len Length of setting, or negative error
733 *
734 * The caller is responsible for eventually freeing the allocated
735 * buffer.
736 */
737static int fetch_setting_alloc ( struct settings *settings,
738 const struct setting *setting,
739 struct settings **origin,
740 struct setting *fetched,
741 void **data,
742 void * ( * alloc ) ( size_t len ) ) {
743 struct settings *tmp_origin;
744 struct setting tmp_fetched;
745 int len;
746 int check_len;
747
748 /* Use local buffers if necessary */
749 if ( ! origin )
750 origin = &tmp_origin;
751 if ( ! fetched )
752 fetched = &tmp_fetched;
753
754 /* Avoid returning uninitialised data on error */
755 *data = NULL;
756
757 /* Check existence, and fetch setting length */
758 len = fetch_setting ( settings, setting, origin, fetched, NULL, 0 );
759 if ( len < 0 )
760 return len;
761
762 /* Allocate buffer */
763 *data = alloc ( len );
764 if ( ! *data )
765 return -ENOMEM;
766
767 /* Fetch setting value */
768 check_len = fetch_setting ( *origin, fetched, NULL, NULL, *data, len );
769 assert ( check_len == len );
770 return len;
771}
772
773/**
774 * Fetch copy of setting
775 *
776 * @v settings Settings block, or NULL to search all blocks
777 * @v setting Setting to fetch
778 * @v origin Origin of setting to fill in, or NULL
779 * @v fetched Fetched setting to fill in, or NULL
780 * @v data Buffer to allocate and fill with setting data
781 * @ret len Length of setting, or negative error
782 *
783 * The caller is responsible for eventually freeing the allocated
784 * buffer.
785 */
786int fetch_setting_copy ( struct settings *settings,
787 const struct setting *setting,
788 struct settings **origin, struct setting *fetched,
789 void **data ) {
790
791 return fetch_setting_alloc ( settings, setting, origin, fetched,
792 data, malloc );
793}
794
795/**
796 * Fetch value of setting
797 *
798 * @v settings Settings block, or NULL to search all blocks
799 * @v setting Setting to fetch
800 * @v data Buffer to fill with setting string data
801 * @v len Length of buffer
802 * @ret len Length of setting, or negative error
803 */
804int fetch_raw_setting ( struct settings *settings,
805 const struct setting *setting,
806 void *data, size_t len ) {
807
808 return fetch_setting ( settings, setting, NULL, NULL, data, len );
809}
810
811/**
812 * Fetch value of setting
813 *
814 * @v settings Settings block, or NULL to search all blocks
815 * @v setting Setting to fetch
816 * @v data Buffer to allocate and fill with setting data
817 * @ret len Length of setting, or negative error
818 *
819 * The caller is responsible for eventually freeing the allocated
820 * buffer.
821 */
822int fetch_raw_setting_copy ( struct settings *settings,
823 const struct setting *setting,
824 void **data ) {
825
826 return fetch_setting_copy ( settings, setting, NULL, NULL, data );
827}
828
829/**
830 * Fetch value of string setting
831 *
832 * @v settings Settings block, or NULL to search all blocks
833 * @v setting Setting to fetch
834 * @v data Buffer to fill with setting string data
835 * @v len Length of buffer
836 * @ret len Length of string setting, or negative error
837 *
838 * The resulting string is guaranteed to be correctly NUL-terminated.
839 * The returned length will be the length of the underlying setting
840 * data.
841 */
842int fetch_string_setting ( struct settings *settings,
843 const struct setting *setting,
844 char *data, size_t len ) {
845
846 memset ( data, 0, len );
847 return fetch_raw_setting ( settings, setting, data,
848 ( ( len > 0 ) ? ( len - 1 ) : 0 ) );
849}
850
851/**
852 * Allocate memory for copy of string setting
853 *
854 * @v len Length of setting
855 * @ret ptr Allocated memory
856 */
857static void * fetch_string_setting_copy_alloc ( size_t len ) {
858 return zalloc ( len + 1 /* NUL */ );
859}
860
861/**
862 * Fetch value of string setting
863 *
864 * @v settings Settings block, or NULL to search all blocks
865 * @v setting Setting to fetch
866 * @v data Buffer to allocate and fill with setting string data
867 * @ret len Length of string setting, or negative error
868 *
869 * The resulting string is guaranteed to be correctly NUL-terminated.
870 * The returned length will be the length of the underlying setting
871 * data. The caller is responsible for eventually freeing the
872 * allocated buffer.
873 */
874int fetch_string_setting_copy ( struct settings *settings,
875 const struct setting *setting, char **data ) {
876
877 return fetch_setting_alloc ( settings, setting, NULL, NULL,
878 ( ( void ** ) data ),
879 fetch_string_setting_copy_alloc );
880}
881
882/**
883 * Fetch value of IPv4 address setting
884 *
885 * @v settings Settings block, or NULL to search all blocks
886 * @v setting Setting to fetch
887 * @v inp IPv4 addresses to fill in
888 * @v count Maximum number of IPv4 addresses
889 * @ret len Length of setting, or negative error
890 */
891int fetch_ipv4_array_setting ( struct settings *settings,
892 const struct setting *setting,
893 struct in_addr *inp, unsigned int count ) {
894 int len;
895
896 len = fetch_raw_setting ( settings, setting, inp,
897 ( sizeof ( *inp ) * count ) );
898 if ( len < 0 )
899 return len;
900 if ( ( len % sizeof ( *inp ) ) != 0 )
901 return -ERANGE;
902 return len;
903}
904
905/**
906 * Fetch value of IPv4 address setting
907 *
908 * @v settings Settings block, or NULL to search all blocks
909 * @v setting Setting to fetch
910 * @v inp IPv4 address to fill in
911 * @ret len Length of setting, or negative error
912 */
913int fetch_ipv4_setting ( struct settings *settings,
914 const struct setting *setting,
915 struct in_addr *inp ) {
916
917 return fetch_ipv4_array_setting ( settings, setting, inp, 1 );
918}
919
920/**
921 * Fetch value of IPv6 address setting
922 *
923 * @v settings Settings block, or NULL to search all blocks
924 * @v setting Setting to fetch
925 * @v inp IPv6 addresses to fill in
926 * @v count Maximum number of IPv6 addresses
927 * @ret len Length of setting, or negative error
928 */
929int fetch_ipv6_array_setting ( struct settings *settings,
930 const struct setting *setting,
931 struct in6_addr *inp, unsigned int count ) {
932 int len;
933
934 len = fetch_raw_setting ( settings, setting, inp,
935 ( sizeof ( *inp ) * count ) );
936 if ( len < 0 )
937 return len;
938 if ( ( len % sizeof ( *inp ) ) != 0 )
939 return -ERANGE;
940 return len;
941}
942
943/**
944 * Fetch value of IPv6 address setting
945 *
946 * @v settings Settings block, or NULL to search all blocks
947 * @v setting Setting to fetch
948 * @v inp IPv6 address to fill in
949 * @ret len Length of setting, or negative error
950 */
951int fetch_ipv6_setting ( struct settings *settings,
952 const struct setting *setting,
953 struct in6_addr *inp ) {
954
955 return fetch_ipv6_array_setting ( settings, setting, inp, 1 );
956}
957
958/**
959 * Extract numeric value of setting
960 *
961 * @v is_signed Treat value as a signed integer
962 * @v raw Raw setting data
963 * @v len Length of raw setting data
964 * @ret value Numeric value
965 * @ret len Length of setting, or negative error
966 */
967static int numeric_setting_value ( int is_signed, const void *raw, size_t len,
968 unsigned long *value ) {
969 const uint8_t *unsigned_bytes = raw;
970 const int8_t *signed_bytes = raw;
971 int is_negative;
972 unsigned int i;
973 uint8_t pad;
974 uint8_t byte;
975
976 /* Convert to host-ordered longs */
977 is_negative = ( len && ( signed_bytes[0] < 0 ) );
978 *value = ( ( is_signed && is_negative ) ? -1L : 0 );
979 pad = *value;
980 for ( i = 0 ; i < len ; i++ ) {
981 byte = unsigned_bytes[i];
982 *value = ( ( *value << 8 ) | byte );
983 if ( ( ( i + sizeof ( *value ) ) < len ) && ( byte != pad ) )
984 return -ERANGE;
985 }
986
987 return len;
988}
989
990/**
991 * Fetch value of numeric setting
992 *
993 * @v settings Settings block, or NULL to search all blocks
994 * @v setting Setting to fetch
995 * @v value Integer value to fill in
996 * @ret len Length of setting, or negative error
997 */
998int fetch_numeric_setting ( struct settings *settings,
999 const struct setting *setting,
1000 unsigned long *value, int is_signed ) {
1001 unsigned long tmp;
1002 int len;
1003
1004 /* Avoid returning uninitialised data on error */
1005 *value = 0;
1006
1007 /* Fetch raw (network-ordered, variable-length) setting */
1008 len = fetch_raw_setting ( settings, setting, &tmp, sizeof ( tmp ) );
1009 if ( len < 0 )
1010 return len;
1011
1012 /* Extract numeric value */
1013 return numeric_setting_value ( is_signed, &tmp, len, value );
1014}
1015
1016/**
1017 * Fetch value of signed integer setting
1018 *
1019 * @v settings Settings block, or NULL to search all blocks
1020 * @v setting Setting to fetch
1021 * @v value Integer value to fill in
1022 * @ret len Length of setting, or negative error
1023 */
1024int fetch_int_setting ( struct settings *settings,
1025 const struct setting *setting,
1026 long *value ) {
1027
1028 return fetch_numeric_setting ( settings, setting,
1029 ( ( unsigned long * ) value ), 1 );
1030}
1031
1032/**
1033 * Fetch value of unsigned integer setting
1034 *
1035 * @v settings Settings block, or NULL to search all blocks
1036 * @v setting Setting to fetch
1037 * @v value Integer value to fill in
1038 * @ret len Length of setting, or negative error
1039 */
1040int fetch_uint_setting ( struct settings *settings,
1041 const struct setting *setting,
1042 unsigned long *value ) {
1043
1044 return fetch_numeric_setting ( settings, setting, value, 0 );
1045}
1046
1047/**
1048 * Fetch value of signed integer setting, or zero
1049 *
1050 * @v settings Settings block, or NULL to search all blocks
1051 * @v setting Setting to fetch
1052 * @ret value Setting value, or zero
1053 */
1054long fetch_intz_setting ( struct settings *settings,
1055 const struct setting *setting ) {
1056 unsigned long value;
1057
1058 fetch_numeric_setting ( settings, setting, &value, 1 );
1059 return value;
1060}
1061
1062/**
1063 * Fetch value of unsigned integer setting, or zero
1064 *
1065 * @v settings Settings block, or NULL to search all blocks
1066 * @v setting Setting to fetch
1067 * @ret value Setting value, or zero
1068 */
1069unsigned long fetch_uintz_setting ( struct settings *settings,
1070 const struct setting *setting ) {
1071 unsigned long value;
1072
1073 fetch_numeric_setting ( settings, setting, &value, 0 );
1074 return value;
1075}
1076
1077/**
1078 * Fetch value of UUID setting
1079 *
1080 * @v settings Settings block, or NULL to search all blocks
1081 * @v setting Setting to fetch
1082 * @v uuid UUID to fill in
1083 * @ret len Length of setting, or negative error
1084 */
1085int fetch_uuid_setting ( struct settings *settings,
1086 const struct setting *setting,
1087 union uuid *uuid ) {
1088 int len;
1089
1090 len = fetch_raw_setting ( settings, setting, uuid, sizeof ( *uuid ) );
1091 if ( len < 0 )
1092 return len;
1093 if ( len != sizeof ( *uuid ) )
1094 return -ERANGE;
1095 return len;
1096}
1097
1098/**
1099 * Clear settings block
1100 *
1101 * @v settings Settings block
1102 */
1103void clear_settings ( struct settings *settings ) {
1104
1105 /* Find target settings block */
1106 settings = settings_target ( settings );
1107
1108 /* Clear settings, if applicable */
1109 if ( settings->op->clear )
1110 settings->op->clear ( settings );
1111}
1112
1113/**
1114 * Compare two settings
1115 *
1116 * @v a Setting to compare
1117 * @v b Setting to compare
1118 * @ret 0 Settings are the same
1119 * @ret non-zero Settings are not the same
1120 */
1121int setting_cmp ( const struct setting *a, const struct setting *b ) {
1122
1123 /* If the settings have tags, compare them */
1124 if ( a->tag && ( a->tag == b->tag ) && ( a->scope == b->scope ) )
1125 return 0;
1126
1127 /* Otherwise, if the settings have names, compare them */
1128 if ( a->name && b->name && a->name[0] )
1129 return strcmp ( a->name, b->name );
1130
1131 /* Otherwise, return a non-match */
1132 return ( ! 0 );
1133}
1134
1135/******************************************************************************
1136 *
1137 * Formatted setting routines
1138 *
1139 ******************************************************************************
1140 */
1141
1142/**
1143 * Format setting value as a string
1144 *
1145 * @v type Setting type
1146 * @v raw Raw setting value
1147 * @v raw_len Length of raw setting value
1148 * @v buf Buffer to contain formatted value
1149 * @v len Length of buffer
1150 * @ret len Length of formatted value, or negative error
1151 */
1152int setting_format ( const struct setting_type *type, const void *raw,
1153 size_t raw_len, char *buf, size_t len ) {
1154
1155 /* Sanity check */
1156 if ( ! type->format )
1157 return -ENOTSUP;
1158
1159 return type->format ( type, raw, raw_len, buf, len );
1160}
1161
1162/**
1163 * Parse formatted string to setting value
1164 *
1165 * @v type Setting type
1166 * @v value Formatted setting value
1167 * @v buf Buffer to contain raw value
1168 * @v len Length of buffer
1169 * @ret len Length of raw value, or negative error
1170 */
1171int setting_parse ( const struct setting_type *type, const char *value,
1172 void *buf, size_t len ) {
1173
1174 /* Sanity check */
1175 if ( ! type->parse )
1176 return -ENOTSUP;
1177
1178 return type->parse ( type, value, buf, len );
1179}
1180
1181/**
1182 * Convert setting value to number
1183 *
1184 * @v type Setting type
1185 * @v raw Raw setting value
1186 * @v raw_len Length of raw setting value
1187 * @ret value Numeric value
1188 * @ret rc Return status code
1189 */
1190int setting_numerate ( const struct setting_type *type, const void *raw,
1191 size_t raw_len, unsigned long *value ) {
1192
1193 /* Sanity check */
1194 if ( ! type->numerate )
1195 return -ENOTSUP;
1196
1197 return type->numerate ( type, raw, raw_len, value );
1198}
1199
1200/**
1201 * Convert number to setting value
1202 *
1203 * @v type Setting type
1204 * @v value Numeric value
1205 * @v buf Buffer to contain raw value
1206 * @v len Length of buffer
1207 * @ret len Length of raw value, or negative error
1208 */
1209int setting_denumerate ( const struct setting_type *type, unsigned long value,
1210 void *buf, size_t len ) {
1211
1212 /* Sanity check */
1213 if ( ! type->denumerate )
1214 return -ENOTSUP;
1215
1216 return type->denumerate ( type, value, buf, len );
1217}
1218
1219/**
1220 * Fetch formatted value of setting
1221 *
1222 * @v settings Settings block, or NULL to search all blocks
1223 * @v setting Setting to fetch
1224 * @v origin Origin of setting to fill in, or NULL
1225 * @v fetched Fetched setting to fill in, or NULL
1226 * @v buf Buffer to contain formatted value
1227 * @v len Length of buffer
1228 * @ret len Length of formatted value, or negative error
1229 */
1230int fetchf_setting ( struct settings *settings, const struct setting *setting,
1231 struct settings **origin, struct setting *fetched,
1232 char *buf, size_t len ) {
1233 struct setting tmp_fetched;
1234 void *raw;
1235 int raw_len;
1236 int ret;
1237
1238 /* Use local buffers if necessary */
1239 if ( ! fetched )
1240 fetched = &tmp_fetched;
1241
1242 /* Fetch raw value */
1243 raw_len = fetch_setting_copy ( settings, setting, origin, fetched,
1244 &raw );
1245 if ( raw_len < 0 ) {
1246 ret = raw_len;
1247 goto err_fetch_copy;
1248 }
1249
1250 /* Sanity check */
1251 assert ( fetched->type != NULL );
1252
1253 /* Format setting */
1254 if ( ( ret = setting_format ( fetched->type, raw, raw_len, buf,
1255 len ) ) < 0 )
1256 goto err_format;
1257
1258 err_format:
1259 free ( raw );
1260 err_fetch_copy:
1261 return ret;
1262}
1263
1264/**
1265 * Fetch copy of formatted value of setting
1266 *
1267 * @v settings Settings block, or NULL to search all blocks
1268 * @v setting Setting to fetch
1269 * @v origin Origin of setting to fill in, or NULL
1270 * @v fetched Fetched setting to fill in, or NULL
1271 * @v value Buffer to allocate and fill with formatted value
1272 * @ret len Length of formatted value, or negative error
1273 *
1274 * The caller is responsible for eventually freeing the allocated
1275 * buffer.
1276 */
1277int fetchf_setting_copy ( struct settings *settings,
1278 const struct setting *setting,
1279 struct settings **origin, struct setting *fetched,
1280 char **value ) {
1281 struct settings *tmp_origin;
1282 struct setting tmp_fetched;
1283 int len;
1284 int check_len;
1285
1286 /* Use local buffers if necessary */
1287 if ( ! origin )
1288 origin = &tmp_origin;
1289 if ( ! fetched )
1290 fetched = &tmp_fetched;
1291
1292 /* Avoid returning uninitialised data on error */
1293 *value = NULL;
1294
1295 /* Check existence, and fetch formatted value length */
1296 len = fetchf_setting ( settings, setting, origin, fetched, NULL, 0 );
1297 if ( len < 0 )
1298 return len;
1299
1300 /* Allocate buffer */
1301 *value = zalloc ( len + 1 /* NUL */ );
1302 if ( ! *value )
1303 return -ENOMEM;
1304
1305 /* Fetch formatted value */
1306 check_len = fetchf_setting ( *origin, fetched, NULL, NULL, *value,
1307 ( len + 1 /* NUL */ ) );
1308 assert ( check_len == len );
1309 return len;
1310}
1311
1312/**
1313 * Store formatted value of setting
1314 *
1315 * @v settings Settings block
1316 * @v setting Setting to store
1317 * @v value Formatted setting data, or NULL
1318 * @ret rc Return status code
1319 */
1320int storef_setting ( struct settings *settings, const struct setting *setting,
1321 const char *value ) {
1322 void *raw;
1323 int raw_len;
1324 int check_len;
1325 int rc;
1326
1327 /* NULL value or empty string implies deletion */
1328 if ( ( ! value ) || ( ! value[0] ) )
1329 return delete_setting ( settings, setting );
1330
1331 /* Sanity check */
1332 assert ( setting->type != NULL );
1333
1334 /* Get raw value length */
1335 raw_len = setting_parse ( setting->type, value, NULL, 0 );
1336 if ( raw_len < 0 ) {
1337 rc = raw_len;
1338 goto err_raw_len;
1339 }
1340
1341 /* Allocate buffer for raw value */
1342 raw = malloc ( raw_len );
1343 if ( ! raw ) {
1344 rc = -ENOMEM;
1345 goto err_alloc_raw;
1346 }
1347
1348 /* Parse formatted value */
1349 check_len = setting_parse ( setting->type, value, raw, raw_len );
1350 assert ( check_len == raw_len );
1351
1352 /* Store raw value */
1353 if ( ( rc = store_setting ( settings, setting, raw, raw_len ) ) != 0 )
1354 goto err_store;
1355
1356 err_store:
1357 free ( raw );
1358 err_alloc_raw:
1359 err_raw_len:
1360 return rc;
1361}
1362
1363/**
1364 * Fetch numeric value of setting
1365 *
1366 * @v settings Settings block, or NULL to search all blocks
1367 * @v setting Setting to fetch
1368 * @v origin Origin of setting to fill in, or NULL
1369 * @v fetched Fetched setting to fill in, or NULL
1370 * @v value Numeric value to fill in
1371 * @ret rc Return status code
1372 */
1373int fetchn_setting ( struct settings *settings, const struct setting *setting,
1374 struct settings **origin, struct setting *fetched,
1375 unsigned long *value ) {
1376 struct setting tmp_fetched;
1377 void *raw;
1378 int raw_len;
1379 int rc;
1380
1381 /* Use local buffers if necessary */
1382 if ( ! fetched )
1383 fetched = &tmp_fetched;
1384
1385 /* Fetch raw value */
1386 raw_len = fetch_setting_copy ( settings, setting, origin, fetched,
1387 &raw );
1388 if ( raw_len < 0 ) {
1389 rc = raw_len;
1390 goto err_fetch_copy;
1391 }
1392
1393 /* Sanity check */
1394 assert ( fetched->type != NULL );
1395
1396 /* Numerate setting */
1397 if ( ( rc = setting_numerate ( fetched->type, raw, raw_len,
1398 value ) ) < 0 )
1399 goto err_numerate;
1400
1401 err_numerate:
1402 free ( raw );
1403 err_fetch_copy:
1404 return rc;
1405}
1406
1407/**
1408 * Store numeric value of setting
1409 *
1410 * @v settings Settings block
1411 * @v setting Setting
1412 * @v value Numeric value
1413 * @ret rc Return status code
1414 */
1415int storen_setting ( struct settings *settings, const struct setting *setting,
1416 unsigned long value ) {
1417 void *raw;
1418 int raw_len;
1419 int check_len;
1420 int rc;
1421
1422 /* Sanity check */
1423 assert ( setting->type != NULL );
1424
1425 /* Get raw value length */
1426 raw_len = setting_denumerate ( setting->type, value, NULL, 0 );
1427 if ( raw_len < 0 ) {
1428 rc = raw_len;
1429 goto err_raw_len;
1430 }
1431
1432 /* Allocate buffer for raw value */
1433 raw = malloc ( raw_len );
1434 if ( ! raw ) {
1435 rc = -ENOMEM;
1436 goto err_alloc_raw;
1437 }
1438
1439 /* Denumerate value */
1440 check_len = setting_denumerate ( setting->type, value, raw, raw_len );
1441 assert ( check_len == raw_len );
1442
1443 /* Store raw value */
1444 if ( ( rc = store_setting ( settings, setting, raw, raw_len ) ) != 0 )
1445 goto err_store;
1446
1447 err_store:
1448 free ( raw );
1449 err_alloc_raw:
1450 err_raw_len:
1451 return rc;
1452}
1453
1454/******************************************************************************
1455 *
1456 * Named settings
1457 *
1458 ******************************************************************************
1459 */
1460
1461/**
1462 * Find predefined setting
1463 *
1464 * @v name Name
1465 * @ret setting Setting, or NULL
1466 */
1467struct setting * find_setting ( const char *name ) {
1468 struct setting *setting;
1469
1470 for_each_table_entry ( setting, SETTINGS ) {
1471 if ( strcmp ( name, setting->name ) == 0 )
1472 return setting;
1473 }
1474 return NULL;
1475}
1476
1477/**
1478 * Parse setting name as tag number
1479 *
1480 * @v name Name
1481 * @ret tag Tag number, or 0 if not a valid number
1482 */
1483static uint64_t parse_setting_tag ( const char *name ) {
1484 char *tmp = ( ( char * ) name );
1485 uint64_t tag = 0;
1486
1487 while ( 1 ) {
1488 tag = ( ( tag << 8 ) | strtoul ( tmp, &tmp, 0 ) );
1489 if ( *tmp == 0 )
1490 return tag;
1491 if ( *tmp != '.' )
1492 return 0;
1493 tmp++;
1494 }
1495}
1496
1497/**
1498 * Find setting type
1499 *
1500 * @v name Name
1501 * @ret type Setting type, or NULL
1502 */
1503static const struct setting_type * find_setting_type ( const char *name ) {
1504 const struct setting_type *type;
1505
1506 for_each_table_entry ( type, SETTING_TYPES ) {
1507 if ( strcmp ( name, type->name ) == 0 )
1508 return type;
1509 }
1510 return NULL;
1511}
1512
1513/**
1514 * Parse setting name
1515 *
1516 * @v name Name of setting
1517 * @v get_child Function to find or create child settings block
1518 * @v settings Settings block to fill in
1519 * @v setting Setting to fill in
1520 * @ret rc Return status code
1521 *
1522 * Interprets a name of the form
1523 * "[settings_name/]tag_name[:type_name]" and fills in the appropriate
1524 * fields.
1525 *
1526 * Note that on success, this function will have modified the original
1527 * setting @c name.
1528 */
1529int parse_setting_name ( char *name, get_child_settings_t get_child,
1530 struct settings **settings, struct setting *setting ) {
1531 char *settings_name;
1532 char *setting_name;
1533 char *type_name;
1534 struct setting *predefined;
1535 int rc;
1536
1537 /* Set defaults */
1538 *settings = &settings_root;
1539 memset ( setting, 0, sizeof ( *setting ) );
1540 setting->name = "";
1541
1542 /* Split name into "[settings_name/]setting_name[:type_name]" */
1543 if ( ( setting_name = strchr ( name, '/' ) ) != NULL ) {
1544 *(setting_name++) = 0;
1545 settings_name = name;
1546 } else {
1547 setting_name = name;
1548 settings_name = NULL;
1549 }
1550 if ( ( type_name = strchr ( setting_name, ':' ) ) != NULL )
1551 *(type_name++) = 0;
1552
1553 /* Identify settings block, if specified */
1554 if ( settings_name ) {
1555 *settings = parse_settings_name ( settings_name, get_child );
1556 if ( *settings == NULL ) {
1557 DBG ( "Unrecognised settings block \"%s\" in \"%s\"\n",
1558 settings_name, name );
1559 rc = -ENODEV;
1560 goto err;
1561 }
1562 }
1563
1564 /* Identify setting */
1565 setting->tag = parse_setting_tag ( setting_name );
1566 setting->scope = (*settings)->default_scope;
1567 setting->name = setting_name;
1568 for_each_table_entry ( predefined, SETTINGS ) {
1569 /* Matches a predefined setting; use that setting */
1570 if ( setting_cmp ( predefined, setting ) == 0 ) {
1571 memcpy ( setting, predefined, sizeof ( *setting ) );
1572 break;
1573 }
1574 }
1575
1576 /* Identify setting type, if specified */
1577 if ( type_name ) {
1578 setting->type = find_setting_type ( type_name );
1579 if ( setting->type == NULL ) {
1580 DBG ( "Invalid setting type \"%s\" in \"%s\"\n",
1581 type_name, name );
1582 rc = -ENOTSUP;
1583 goto err;
1584 }
1585 }
1586
1587 return 0;
1588
1589 err:
1590 /* Restore original name */
1591 if ( settings_name )
1592 *( setting_name - 1 ) = '/';
1593 if ( type_name )
1594 *( type_name - 1 ) = ':';
1595 return rc;
1596}
1597
1598/**
1599 * Return full setting name
1600 *
1601 * @v settings Settings block, or NULL
1602 * @v setting Setting
1603 * @v buf Buffer
1604 * @v len Length of buffer
1605 * @ret len Length of setting name, or negative error
1606 */
1607int setting_name ( struct settings *settings, const struct setting *setting,
1608 char *buf, size_t len ) {
1609 const char *name;
1610
1611 settings = settings_target ( settings );
1612 name = settings_name ( settings );
1613 return snprintf ( buf, len, "%s%s%s:%s", name, ( name[0] ? "/" : "" ),
1614 setting->name, setting->type->name );
1615}
1616
1617/******************************************************************************
1618 *
1619 * Setting types
1620 *
1621 ******************************************************************************
1622 */
1623
1624/**
1625 * Parse string setting value
1626 *
1627 * @v type Setting type
1628 * @v value Formatted setting value
1629 * @v buf Buffer to contain raw value
1630 * @v len Length of buffer
1631 * @ret len Length of raw value, or negative error
1632 */
1633static int parse_string_setting ( const struct setting_type *type __unused,
1634 const char *value, void *buf, size_t len ) {
1635 size_t raw_len = strlen ( value ); /* Exclude terminating NUL */
1636
1637 /* Copy string to buffer */
1638 if ( len > raw_len )
1639 len = raw_len;
1640 memcpy ( buf, value, len );
1641
1642 return raw_len;
1643}
1644
1645/**
1646 * Format string setting value
1647 *
1648 * @v type Setting type
1649 * @v raw Raw setting value
1650 * @v raw_len Length of raw setting value
1651 * @v buf Buffer to contain formatted value
1652 * @v len Length of buffer
1653 * @ret len Length of formatted value, or negative error
1654 */
1655static int format_string_setting ( const struct setting_type *type __unused,
1656 const void *raw, size_t raw_len, char *buf,
1657 size_t len ) {
1658
1659 /* Copy string to buffer, and terminate */
1660 memset ( buf, 0, len );
1661 if ( len > raw_len )
1662 len = raw_len;
1663 memcpy ( buf, raw, len );
1664
1665 return raw_len;
1666}
1667
1668/** A string setting type */
1669const struct setting_type setting_type_string __setting_type = {
1670 .name = "string",
1671 .parse = parse_string_setting,
1672 .format = format_string_setting,
1673};
1674
1675/**
1676 * Parse URI-encoded string setting value
1677 *
1678 * @v type Setting type
1679 * @v value Formatted setting value
1680 * @v buf Buffer to contain raw value
1681 * @v len Length of buffer
1682 * @ret len Length of raw value, or negative error
1683 */
1684static int parse_uristring_setting ( const struct setting_type *type __unused,
1685 const char *value, void *buf, size_t len ){
1686
1687 return uri_decode ( value, buf, len );
1688}
1689
1690/**
1691 * Format URI-encoded string setting value
1692 *
1693 * @v type Setting type
1694 * @v raw Raw setting value
1695 * @v raw_len Length of raw setting value
1696 * @v buf Buffer to contain formatted value
1697 * @v len Length of buffer
1698 * @ret len Length of formatted value, or negative error
1699 */
1700static int format_uristring_setting ( const struct setting_type *type __unused,
1701 const void *raw, size_t raw_len,
1702 char *buf, size_t len ) {
1703
1704 return uri_encode ( 0, raw, raw_len, buf, len );
1705}
1706
1707/** A URI-encoded string setting type */
1708const struct setting_type setting_type_uristring __setting_type = {
1709 .name = "uristring",
1710 .parse = parse_uristring_setting,
1711 .format = format_uristring_setting,
1712};
1713
1714/**
1715 * Parse IPv4 address setting value (when IPv4 support is not present)
1716 *
1717 * @v type Setting type
1718 * @v value Formatted setting value
1719 * @v buf Buffer to contain raw value
1720 * @v len Length of buffer
1721 * @ret len Length of raw value, or negative error
1722 */
1723__weak int parse_ipv4_setting ( const struct setting_type *type __unused,
1724 const char *value __unused, void *buf __unused,
1725 size_t len __unused ) {
1726 return -ENOTSUP;
1727}
1728
1729/**
1730 * Format IPv4 address setting value (when IPv4 support is not present)
1731 *
1732 * @v type Setting type
1733 * @v raw Raw setting value
1734 * @v raw_len Length of raw setting value
1735 * @v buf Buffer to contain formatted value
1736 * @v len Length of buffer
1737 * @ret len Length of formatted value, or negative error
1738 */
1739__weak int format_ipv4_setting ( const struct setting_type *type __unused,
1740 const void *raw __unused,
1741 size_t raw_len __unused, char *buf __unused,
1742 size_t len __unused ) {
1743 return -ENOTSUP;
1744}
1745
1746/** An IPv4 address setting type */
1747const struct setting_type setting_type_ipv4 __setting_type = {
1748 .name = "ipv4",
1749 .parse = parse_ipv4_setting,
1750 .format = format_ipv4_setting,
1751};
1752
1753/**
1754 * Parse IPv6 address setting value (when IPv6 support is not present)
1755 *
1756 * @v type Setting type
1757 * @v value Formatted setting value
1758 * @v buf Buffer to contain raw value
1759 * @v len Length of buffer
1760 * @ret len Length of raw value, or negative error
1761 */
1762__weak int parse_ipv6_setting ( const struct setting_type *type __unused,
1763 const char *value __unused, void *buf __unused,
1764 size_t len __unused ) {
1765 return -ENOTSUP;
1766}
1767
1768/**
1769 * Format IPv6 address setting value (when IPv6 support is not present)
1770 *
1771 * @v type Setting type
1772 * @v raw Raw setting value
1773 * @v raw_len Length of raw setting value
1774 * @v buf Buffer to contain formatted value
1775 * @v len Length of buffer
1776 * @ret len Length of formatted value, or negative error
1777 */
1778__weak int format_ipv6_setting ( const struct setting_type *type __unused,
1779 const void *raw __unused,
1780 size_t raw_len __unused, char *buf __unused,
1781 size_t len __unused ) {
1782 return -ENOTSUP;
1783}
1784
1785/** An IPv6 address setting type */
1786const struct setting_type setting_type_ipv6 __setting_type = {
1787 .name = "ipv6",
1788 .parse = parse_ipv6_setting,
1789 .format = format_ipv6_setting,
1790};
1791
1792/** IPv6 settings scope */
1793const struct settings_scope dhcpv6_scope;
1794
1795/**
1796 * Integer setting type indices
1797 *
1798 * These indexes are defined such that (1<<index) gives the width of
1799 * the integer, in bytes.
1800 */
1806
1807/**
1808 * Integer setting type names
1809 *
1810 * These names exist as a static array in order to allow the type's
1811 * integer size and signedness to be determined from the type's name.
1812 * Note that there are no separate entries for the signed integer
1813 * types: the name pointers simply point to the second character of
1814 * the relevant string.
1815 */
1816static const char setting_type_int_name[][8] = {
1817 [SETTING_TYPE_INT8] = "uint8",
1818 [SETTING_TYPE_INT16] = "uint16",
1819 [SETTING_TYPE_INT32] = "uint32",
1820};
1821
1822/**
1823 * Get unsigned integer setting type name
1824 *
1825 * @v index Integer setting type index
1826 * @ret name Setting type name
1827 */
1828#define SETTING_TYPE_UINT_NAME( index ) setting_type_int_name[index]
1829
1830/**
1831 * Get signed integer setting type name
1832 *
1833 * @v index Integer setting type index
1834 * @ret name Setting type name
1835 */
1836#define SETTING_TYPE_INT_NAME( index ) ( setting_type_int_name[index] + 1 )
1837
1838/**
1839 * Get integer setting type index
1840 *
1841 * @v type Setting type
1842 * @ret index Integer setting type index
1843 */
1844static unsigned int setting_type_int_index ( const struct setting_type *type ) {
1845
1846 return ( ( type->name - setting_type_int_name[0] ) /
1847 sizeof ( setting_type_int_name[0] ) );
1848}
1849
1850/**
1851 * Get integer setting type width
1852 *
1853 * @v type Setting type
1854 * @ret index Integer setting type width
1855 */
1856static unsigned int setting_type_int_width ( const struct setting_type *type ) {
1857
1858 return ( 1 << setting_type_int_index ( type ) );
1859}
1860
1861/**
1862 * Get integer setting type signedness
1863 *
1864 * @v type Setting type
1865 * @ret is_signed Integer setting type is signed
1866 */
1867static int setting_type_int_is_signed ( const struct setting_type *type ) {
1868 return ( ( type->name - setting_type_int_name[0] ) & 1 );
1869}
1870
1871/**
1872 * Convert number to setting value
1873 *
1874 * @v type Setting type
1875 * @v value Numeric value
1876 * @v buf Buffer to contain raw value
1877 * @v len Length of buffer
1878 * @ret len Length of raw value, or negative error
1879 */
1880static int denumerate_int_setting ( const struct setting_type *type,
1881 unsigned long value, void *buf,
1882 size_t len ) {
1883 unsigned int size = setting_type_int_width ( type );
1884 union {
1885 uint32_t num;
1886 uint8_t bytes[4];
1887 } u;
1888
1889 u.num = htonl ( value );
1890 if ( len > size )
1891 len = size;
1892 memcpy ( buf, &u.bytes[ sizeof ( u ) - size ], len );
1893
1894 return size;
1895}
1896
1897/**
1898 * Convert setting value to number
1899 *
1900 * @v type Setting type
1901 * @v raw Raw setting value
1902 * @v raw_len Length of raw setting value
1903 * @v value Numeric value to fill in
1904 * @ret rc Return status code
1905 */
1906static int numerate_int_setting ( const struct setting_type *type,
1907 const void *raw, size_t raw_len,
1908 unsigned long *value ) {
1909 int is_signed = setting_type_int_is_signed ( type );
1910 int check_len;
1911
1912 /* Extract numeric value */
1913 check_len = numeric_setting_value ( is_signed, raw, raw_len, value );
1914 if ( check_len < 0 )
1915 return check_len;
1916 assert ( check_len == ( int ) raw_len );
1917
1918 return 0;
1919}
1920
1921/**
1922 * Parse integer setting value
1923 *
1924 * @v type Setting type
1925 * @v value Formatted setting value
1926 * @v buf Buffer to contain raw value
1927 * @v len Length of buffer
1928 * @ret len Length of raw value, or negative error
1929 */
1930static int parse_int_setting ( const struct setting_type *type,
1931 const char *value, void *buf, size_t len ) {
1932 char *endp;
1933 unsigned long num_value;
1934
1935 /* Parse value */
1936 num_value = strtoul ( value, &endp, 0 );
1937 if ( *endp )
1938 return -EINVAL;
1939
1940 return type->denumerate ( type, num_value, buf, len );
1941}
1942
1943/**
1944 * Format signed integer setting value
1945 *
1946 * @v type Setting type
1947 * @v raw Raw setting value
1948 * @v raw_len Length of raw setting value
1949 * @v buf Buffer to contain formatted value
1950 * @v len Length of buffer
1951 * @ret len Length of formatted value, or negative error
1952 */
1953static int format_int_setting ( const struct setting_type *type,
1954 const void *raw, size_t raw_len,
1955 char *buf, size_t len ) {
1956 unsigned long value;
1957 int ret;
1958
1959 /* Extract numeric value */
1960 if ( ( ret = type->numerate ( type, raw, raw_len, &value ) ) < 0 )
1961 return ret;
1962
1963 /* Format value */
1964 return snprintf ( buf, len, "%ld", value );
1965}
1966
1967/**
1968 * Format unsigned integer setting value
1969 *
1970 * @v type Setting type
1971 * @v raw Raw setting value
1972 * @v raw_len Length of raw setting value
1973 * @v buf Buffer to contain formatted value
1974 * @v len Length of buffer
1975 * @ret len Length of formatted value, or negative error
1976 */
1977static int format_uint_setting ( const struct setting_type *type,
1978 const void *raw, size_t raw_len,
1979 char *buf, size_t len ) {
1980 unsigned long value;
1981 int ret;
1982
1983 /* Extract numeric value */
1984 if ( ( ret = type->numerate ( type, raw, raw_len, &value ) ) < 0 )
1985 return ret;
1986
1987 /* Format value */
1988 return snprintf ( buf, len, "%#lx", value );
1989}
1990
1991/**
1992 * Define a signed integer setting type
1993 *
1994 * @v index Integer setting type index
1995 * @ret type Setting type
1996 */
1997#define SETTING_TYPE_INT( index ) { \
1998 .name = SETTING_TYPE_INT_NAME ( index ), \
1999 .parse = parse_int_setting, \
2000 .format = format_int_setting, \
2001 .denumerate = denumerate_int_setting, \
2002 .numerate = numerate_int_setting, \
2003}
2004
2005/**
2006 * Define an unsigned integer setting type
2007 *
2008 * @v index Integer setting type index
2009 * @ret type Setting type
2010 */
2011#define SETTING_TYPE_UINT( index ) { \
2012 .name = SETTING_TYPE_UINT_NAME ( index ), \
2013 .parse = parse_int_setting, \
2014 .format = format_uint_setting, \
2015 .denumerate = denumerate_int_setting, \
2016 .numerate = numerate_int_setting, \
2017}
2018
2019/** A signed 8-bit integer setting type */
2020const struct setting_type setting_type_int8 __setting_type =
2021 SETTING_TYPE_INT ( SETTING_TYPE_INT8 );
2022
2023/** A signed 16-bit integer setting type */
2024const struct setting_type setting_type_int16 __setting_type =
2025 SETTING_TYPE_INT ( SETTING_TYPE_INT16 );
2026
2027/** A signed 32-bit integer setting type */
2028const struct setting_type setting_type_int32 __setting_type =
2029 SETTING_TYPE_INT ( SETTING_TYPE_INT32 );
2030
2031/** An unsigned 8-bit integer setting type */
2032const struct setting_type setting_type_uint8 __setting_type =
2033 SETTING_TYPE_UINT ( SETTING_TYPE_INT8 );
2034
2035/** An unsigned 16-bit integer setting type */
2036const struct setting_type setting_type_uint16 __setting_type =
2037 SETTING_TYPE_UINT ( SETTING_TYPE_INT16 );
2038
2039/** An unsigned 32-bit integer setting type */
2040const struct setting_type setting_type_uint32 __setting_type =
2041 SETTING_TYPE_UINT ( SETTING_TYPE_INT32 );
2042
2043/**
2044 * Parse hex string setting value (using colon delimiter)
2045 *
2046 * @v type Setting type
2047 * @v value Formatted setting value
2048 * @v buf Buffer to contain raw value
2049 * @v len Length of buffer
2050 * @v size Integer size, in bytes
2051 * @ret len Length of raw value, or negative error
2052 */
2053static int parse_hex_setting ( const struct setting_type *type __unused,
2054 const char *value, void *buf, size_t len ) {
2055 return hex_decode ( ':', value, buf, len );
2056}
2057
2058/**
2059 * Format hex string setting value (using colon delimiter)
2060 *
2061 * @v type Setting type
2062 * @v raw Raw setting value
2063 * @v raw_len Length of raw setting value
2064 * @v buf Buffer to contain formatted value
2065 * @v len Length of buffer
2066 * @ret len Length of formatted value, or negative error
2067 */
2068static int format_hex_colon_setting ( const struct setting_type *type __unused,
2069 const void *raw, size_t raw_len,
2070 char *buf, size_t len ) {
2071 return hex_encode ( ':', raw, raw_len, buf, len );
2072}
2073
2074/**
2075 * Parse hex string setting value (using hyphen delimiter)
2076 *
2077 * @v type Setting type
2078 * @v value Formatted setting value
2079 * @v buf Buffer to contain raw value
2080 * @v len Length of buffer
2081 * @v size Integer size, in bytes
2082 * @ret len Length of raw value, or negative error
2083 */
2084static int parse_hex_hyphen_setting ( const struct setting_type *type __unused,
2085 const char *value, void *buf,
2086 size_t len ) {
2087 return hex_decode ( '-', value, buf, len );
2088}
2089
2090/**
2091 * Format hex string setting value (using hyphen delimiter)
2092 *
2093 * @v type Setting type
2094 * @v raw Raw setting value
2095 * @v raw_len Length of raw setting value
2096 * @v buf Buffer to contain formatted value
2097 * @v len Length of buffer
2098 * @ret len Length of formatted value, or negative error
2099 */
2100static int format_hex_hyphen_setting ( const struct setting_type *type __unused,
2101 const void *raw, size_t raw_len,
2102 char *buf, size_t len ) {
2103 return hex_encode ( '-', raw, raw_len, buf, len );
2104}
2105
2106/**
2107 * Parse hex string setting value (using no delimiter)
2108 *
2109 * @v type Setting type
2110 * @v value Formatted setting value
2111 * @v buf Buffer to contain raw value
2112 * @v len Length of buffer
2113 * @v size Integer size, in bytes
2114 * @ret len Length of raw value, or negative error
2115 */
2116static int parse_hex_raw_setting ( const struct setting_type *type __unused,
2117 const char *value, void *buf, size_t len ) {
2118 return hex_decode ( 0, value, buf, len );
2119}
2120
2121/**
2122 * Format hex string setting value (using no delimiter)
2123 *
2124 * @v type Setting type
2125 * @v raw Raw setting value
2126 * @v raw_len Length of raw setting value
2127 * @v buf Buffer to contain formatted value
2128 * @v len Length of buffer
2129 * @ret len Length of formatted value, or negative error
2130 */
2131static int format_hex_raw_setting ( const struct setting_type *type __unused,
2132 const void *raw, size_t raw_len,
2133 char *buf, size_t len ) {
2134 return hex_encode ( 0, raw, raw_len, buf, len );
2135}
2136
2137/** A hex-string setting (colon-delimited) */
2138const struct setting_type setting_type_hex __setting_type = {
2139 .name = "hex",
2140 .parse = parse_hex_setting,
2141 .format = format_hex_colon_setting,
2142};
2143
2144/** A hex-string setting (hyphen-delimited) */
2145const struct setting_type setting_type_hexhyp __setting_type = {
2146 .name = "hexhyp",
2147 .parse = parse_hex_hyphen_setting,
2148 .format = format_hex_hyphen_setting,
2149};
2150
2151/** A hex-string setting (non-delimited) */
2152const struct setting_type setting_type_hexraw __setting_type = {
2153 .name = "hexraw",
2154 .parse = parse_hex_raw_setting,
2155 .format = format_hex_raw_setting,
2156};
2157
2158/**
2159 * Parse Base64-encoded setting value
2160 *
2161 * @v type Setting type
2162 * @v value Formatted setting value
2163 * @v buf Buffer to contain raw value
2164 * @v len Length of buffer
2165 * @v size Integer size, in bytes
2166 * @ret len Length of raw value, or negative error
2167 */
2168static int parse_base64_setting ( const struct setting_type *type __unused,
2169 const char *value, void *buf, size_t len ) {
2170
2171 return base64_decode ( value, buf, len );
2172}
2173
2174/**
2175 * Format Base64-encoded setting value
2176 *
2177 * @v type Setting type
2178 * @v raw Raw setting value
2179 * @v raw_len Length of raw setting value
2180 * @v buf Buffer to contain formatted value
2181 * @v len Length of buffer
2182 * @ret len Length of formatted value, or negative error
2183 */
2184static int format_base64_setting ( const struct setting_type *type __unused,
2185 const void *raw, size_t raw_len,
2186 char *buf, size_t len ) {
2187
2188 return base64_encode ( raw, raw_len, buf, len );
2189}
2190
2191/** A Base64-encoded setting */
2192const struct setting_type setting_type_base64 __setting_type = {
2193 .name = "base64",
2194 .parse = parse_base64_setting,
2195 .format = format_base64_setting,
2196};
2197
2198/**
2199 * Parse UUID/GUID setting value
2200 *
2201 * @v type Setting type
2202 * @v value Formatted setting value
2203 * @v buf Buffer to contain raw value
2204 * @v len Length of buffer
2205 * @v size Integer size, in bytes
2206 * @ret len Length of raw value, or negative error
2207 */
2208static int parse_uuid_setting ( const struct setting_type *type,
2209 const char *value, void *buf, size_t len ) {
2210 union uuid uuid;
2211 int rc;
2212
2213 /* Parse UUID */
2214 if ( ( rc = uuid_aton ( value, &uuid ) ) != 0 )
2215 return rc;
2216
2217 /* Mangle GUID byte ordering */
2218 if ( type == &setting_type_guid )
2219 uuid_mangle ( &uuid );
2220
2221 /* Copy value */
2222 if ( len > sizeof ( uuid ) )
2223 len = sizeof ( uuid );
2224 memcpy ( buf, uuid.raw, len );
2225
2226 return ( sizeof ( uuid ) );
2227}
2228
2229/**
2230 * Format UUID/GUID setting value
2231 *
2232 * @v type Setting type
2233 * @v raw Raw setting value
2234 * @v raw_len Length of raw setting value
2235 * @v buf Buffer to contain formatted value
2236 * @v len Length of buffer
2237 * @ret len Length of formatted value, or negative error
2238 */
2239static int format_uuid_setting ( const struct setting_type *type,
2240 const void *raw, size_t raw_len, char *buf,
2241 size_t len ) {
2242 union uuid uuid;
2243
2244 /* Range check */
2245 if ( raw_len != sizeof ( uuid ) )
2246 return -ERANGE;
2247
2248 /* Copy value */
2249 memcpy ( &uuid, raw, sizeof ( uuid ) );
2250
2251 /* Mangle GUID byte ordering */
2252 if ( type == &setting_type_guid )
2253 uuid_mangle ( &uuid );
2254
2255 /* Format value */
2256 return snprintf ( buf, len, "%s", uuid_ntoa ( &uuid ) );
2257}
2258
2259/** UUID setting type */
2260const struct setting_type setting_type_uuid __setting_type = {
2261 .name = "uuid",
2262 .parse = parse_uuid_setting,
2263 .format = format_uuid_setting,
2264};
2265
2266/** GUID setting type */
2267const struct setting_type setting_type_guid __setting_type = {
2268 .name = "guid",
2269 .parse = parse_uuid_setting,
2270 .format = format_uuid_setting,
2271};
2272
2273/**
2274 * Format PCI bus:dev.fn setting value
2275 *
2276 * @v type Setting type
2277 * @v raw Raw setting value
2278 * @v raw_len Length of raw setting value
2279 * @v buf Buffer to contain formatted value
2280 * @v len Length of buffer
2281 * @ret len Length of formatted value, or negative error
2282 */
2283static int format_busdevfn_setting ( const struct setting_type *type __unused,
2284 const void *raw, size_t raw_len, char *buf,
2285 size_t len ) {
2286 unsigned long busdevfn;
2287 unsigned int seg;
2288 unsigned int bus;
2289 unsigned int slot;
2290 unsigned int func;
2291 int check_len;
2292
2293 /* Extract numeric value */
2294 check_len = numeric_setting_value ( 0, raw, raw_len, &busdevfn );
2295 if ( check_len < 0 )
2296 return check_len;
2297 assert ( check_len == ( int ) raw_len );
2298
2299 /* Extract PCI address components */
2300 seg = PCI_SEG ( busdevfn );
2301 bus = PCI_BUS ( busdevfn );
2302 slot = PCI_SLOT ( busdevfn );
2303 func = PCI_FUNC ( busdevfn );
2304
2305 /* Format value */
2306 return snprintf ( buf, len, "%04x:%02x:%02x.%x", seg, bus, slot, func );
2307}
2308
2309/** PCI bus:dev.fn setting type */
2310const struct setting_type setting_type_busdevfn __setting_type = {
2311 .name = "busdevfn",
2312 .format = format_busdevfn_setting,
2313};
2314
2315/******************************************************************************
2316 *
2317 * Setting expansion
2318 *
2319 ******************************************************************************
2320 */
2321
2322/**
2323 * Expand variables within string
2324 *
2325 * @v string String
2326 * @ret expstr Expanded string
2327 *
2328 * The expanded string is allocated with malloc() and the caller must
2329 * eventually free() it.
2330 */
2331char * expand_settings ( const char *string ) {
2332 struct settings *settings;
2333 struct setting setting;
2334 char *expstr;
2335 char *start;
2336 char *end;
2337 char *head;
2338 char *name;
2339 char *tail;
2340 char *value;
2341 char *tmp;
2342 int new_len;
2343 int rc;
2344
2345 /* Obtain temporary modifiable copy of string */
2346 expstr = strdup ( string );
2347 if ( ! expstr )
2348 return NULL;
2349
2350 /* Expand while expansions remain */
2351 while ( 1 ) {
2352
2353 head = expstr;
2354
2355 /* Locate setting to be expanded */
2356 start = NULL;
2357 end = NULL;
2358 for ( tmp = expstr ; *tmp ; tmp++ ) {
2359 if ( ( tmp[0] == '$' ) && ( tmp[1] == '{' ) )
2360 start = tmp;
2361 if ( start && ( tmp[0] == '}' ) ) {
2362 end = tmp;
2363 break;
2364 }
2365 }
2366 if ( ! end )
2367 break;
2368 *start = '\0';
2369 name = ( start + 2 );
2370 *end = '\0';
2371 tail = ( end + 1 );
2372
2373 /* Expand setting */
2374 if ( ( rc = parse_setting_name ( name, find_child_settings,
2375 &settings,
2376 &setting ) ) != 0 ) {
2377 /* Treat invalid setting names as empty */
2378 value = NULL;
2379 } else {
2380 /* Fetch and format setting value. Ignore
2381 * errors; treat non-existent settings as empty.
2382 */
2383 fetchf_setting_copy ( settings, &setting, NULL, NULL,
2384 &value );
2385 }
2386
2387 /* Construct expanded string and discard old string */
2388 tmp = expstr;
2389 new_len = asprintf ( &expstr, "%s%s%s",
2390 head, ( value ? value : "" ), tail );
2391 free ( value );
2392 free ( tmp );
2393 if ( new_len < 0 )
2394 return NULL;
2395 }
2396
2397 return expstr;
2398}
2399
2400/******************************************************************************
2401 *
2402 * Settings
2403 *
2404 ******************************************************************************
2405 */
2406
2407/** Hostname setting */
2408const struct setting hostname_setting __setting ( SETTING_HOST, hostname ) = {
2409 .name = "hostname",
2410 .description = "Host name",
2411 .tag = DHCP_HOST_NAME,
2412 .type = &setting_type_string,
2413};
2414
2415/** Domain name setting */
2416const struct setting domain_setting __setting ( SETTING_IP_EXTRA, domain ) = {
2417 .name = "domain",
2418 .description = "DNS domain",
2419 .tag = DHCP_DOMAIN_NAME,
2420 .type = &setting_type_string,
2421};
2422
2423/** TFTP server setting */
2424const struct setting next_server_setting __setting ( SETTING_BOOT,next-server)={
2425 .name = "next-server",
2426 .description = "TFTP server",
2427 .tag = DHCP_EB_SIADDR,
2428 .type = &setting_type_ipv4,
2429};
2430
2431/** Filename setting */
2432const struct setting filename_setting __setting ( SETTING_BOOT, filename ) = {
2433 .name = "filename",
2434 .description = "Boot filename",
2435 .tag = DHCP_BOOTFILE_NAME,
2436 .type = &setting_type_string,
2437};
2438
2439/** Root path setting */
2440const struct setting root_path_setting __setting ( SETTING_SANBOOT, root-path)={
2441 .name = "root-path",
2442 .description = "SAN root path",
2443 .tag = DHCP_ROOT_PATH,
2444 .type = &setting_type_string,
2445};
2446
2447/** SAN filename setting */
2448const struct setting san_filename_setting __setting ( SETTING_SANBOOT,
2449 san-filename ) = {
2450 .name = "san-filename",
2451 .description = "SAN filename",
2452 .tag = DHCP_EB_SAN_FILENAME,
2453 .type = &setting_type_string,
2454};
2455
2456/** Username setting */
2457const struct setting username_setting __setting ( SETTING_AUTH, username ) = {
2458 .name = "username",
2459 .description = "User name",
2460 .tag = DHCP_EB_USERNAME,
2461 .type = &setting_type_string,
2462};
2463
2464/** Password setting */
2465const struct setting password_setting __setting ( SETTING_AUTH, password ) = {
2466 .name = "password",
2467 .description = "Password",
2468 .tag = DHCP_EB_PASSWORD,
2469 .type = &setting_type_string,
2470};
2471
2472/** Priority setting */
2473const struct setting priority_setting __setting ( SETTING_MISC, priority ) = {
2474 .name = "priority",
2475 .description = "Settings priority",
2476 .tag = DHCP_EB_PRIORITY,
2477 .type = &setting_type_int8,
2478};
2479
2480/** DHCP user class setting */
2481const struct setting user_class_setting __setting ( SETTING_HOST_EXTRA,
2482 user-class ) = {
2483 .name = "user-class",
2484 .description = "DHCP user class",
2485 .tag = DHCP_USER_CLASS_ID,
2486 .type = &setting_type_string,
2487};
2488
2489/** DHCP vendor class setting */
2490const struct setting vendor_class_setting __setting ( SETTING_HOST_EXTRA,
2491 vendor-class ) = {
2492 .name = "vendor-class",
2493 .description = "DHCP vendor class",
2494 .tag = DHCP_VENDOR_CLASS_ID,
2495 .type = &setting_type_string,
2496};
2497
2498/******************************************************************************
2499 *
2500 * Built-in settings block
2501 *
2502 ******************************************************************************
2503 */
2504
2505/** Built-in setting scope */
2506const struct settings_scope builtin_scope;
2507
2508/**
2509 * Fetch error number setting
2510 *
2511 * @v data Buffer to fill with setting data
2512 * @v len Length of buffer
2513 * @ret len Length of setting data, or negative error
2514 */
2515static int errno_fetch ( void *data, size_t len ) {
2516 uint32_t content;
2517
2518 /* Return current error */
2519 content = htonl ( errno );
2520 if ( len > sizeof ( content ) )
2521 len = sizeof ( content );
2522 memcpy ( data, &content, len );
2523 return sizeof ( content );
2524}
2525
2526/** Error number setting */
2527const struct setting errno_setting __setting ( SETTING_MISC, errno ) = {
2528 .name = "errno",
2529 .description = "Last error",
2530 .type = &setting_type_uint32,
2531 .scope = &builtin_scope,
2532};
2533
2534/** Error number built-in setting */
2535struct builtin_setting errno_builtin_setting __builtin_setting = {
2536 .setting = &errno_setting,
2537 .fetch = errno_fetch,
2538};
2539
2540/**
2541 * Fetch build architecture setting
2542 *
2543 * @v data Buffer to fill with setting data
2544 * @v len Length of buffer
2545 * @ret len Length of setting data, or negative error
2546 */
2547static int buildarch_fetch ( void *data, size_t len ) {
2548 static const char buildarch[] = _S2 ( ARCH );
2549
2550 strncpy ( data, buildarch, len );
2551 return ( sizeof ( buildarch ) - 1 /* NUL */ );
2552}
2553
2554/** Build architecture setting */
2555const struct setting buildarch_setting __setting ( SETTING_MISC, buildarch ) = {
2556 .name = "buildarch",
2557 .description = "Build architecture",
2558 .type = &setting_type_string,
2559 .scope = &builtin_scope,
2560};
2561
2562/** Build architecture built-in setting */
2563struct builtin_setting buildarch_builtin_setting __builtin_setting = {
2564 .setting = &buildarch_setting,
2565 .fetch = buildarch_fetch,
2566};
2567
2568/**
2569 * Fetch platform setting
2570 *
2571 * @v data Buffer to fill with setting data
2572 * @v len Length of buffer
2573 * @ret len Length of setting data, or negative error
2574 */
2575static int platform_fetch ( void *data, size_t len ) {
2576 static const char platform[] = _S2 ( PLATFORM );
2577
2578 strncpy ( data, platform, len );
2579 return ( sizeof ( platform ) - 1 /* NUL */ );
2580}
2581
2582/** Platform setting */
2583const struct setting platform_setting __setting ( SETTING_MISC, platform ) = {
2584 .name = "platform",
2585 .description = "Platform",
2586 .type = &setting_type_string,
2587 .scope = &builtin_scope,
2588};
2589
2590/** Platform built-in setting */
2591struct builtin_setting platform_builtin_setting __builtin_setting = {
2592 .setting = &platform_setting,
2593 .fetch = platform_fetch,
2594};
2595
2596/**
2597 * Fetch version setting
2598 *
2599 * @v data Buffer to fill with setting data
2600 * @v len Length of buffer
2601 * @ret len Length of setting data, or negative error
2602 */
2603static int version_fetch ( void *data, size_t len ) {
2604 strncpy ( data, product_version, len );
2605 return ( strlen ( product_version ) );
2606}
2607
2608/** Version setting */
2609const struct setting version_setting __setting ( SETTING_MISC, version ) = {
2610 .name = "version",
2611 .description = "Version",
2612 .type = &setting_type_string,
2613 .scope = &builtin_scope,
2614};
2615
2616/** Version built-in setting */
2617struct builtin_setting version_builtin_setting __builtin_setting = {
2618 .setting = &version_setting,
2619 .fetch = version_fetch,
2620};
2621
2622/**
2623 * Fetch current time setting
2624 *
2625 * @v data Buffer to fill with setting data
2626 * @v len Length of buffer
2627 * @ret len Length of setting data, or negative error
2628 */
2629static int unixtime_fetch ( void *data, size_t len ) {
2630 uint32_t content;
2631
2632 /* Return current time */
2633 content = htonl ( time(NULL) );
2634 if ( len > sizeof ( content ) )
2635 len = sizeof ( content );
2636 memcpy ( data, &content, len );
2637 return sizeof ( content );
2638}
2639
2640/** Current time setting */
2641const struct setting unixtime_setting __setting ( SETTING_MISC, unixtime ) = {
2642 .name = "unixtime",
2643 .description = "Seconds since the Epoch",
2644 .type = &setting_type_uint32,
2645 .scope = &builtin_scope,
2646};
2647
2648/** Current time built-in setting */
2649struct builtin_setting unixtime_builtin_setting __builtin_setting = {
2650 .setting = &unixtime_setting,
2651 .fetch = unixtime_fetch,
2652};
2653
2654/**
2655 * Fetch current working URI-related setting
2656 *
2657 * @v data Buffer to fill with setting data
2658 * @v len Length of buffer
2659 * @v rel Relative URI string
2660 * @ret len Length of setting data, or negative error
2661 */
2662static int cwuri_fetch_uri ( void *data, size_t len, const char *rel ) {
2663 struct uri *reluri;
2664 struct uri *uri;
2665 char *uristring;
2666 int ret;
2667
2668 /* Check that current working URI is set */
2669 if ( ! cwuri ) {
2670 ret = -ENOENT;
2671 goto err_unset;
2672 }
2673
2674 /* Construct relative URI */
2675 reluri = parse_uri ( rel );
2676 if ( ! reluri ) {
2677 ret = -ENOMEM;
2678 goto err_parse;
2679 }
2680
2681 /* Construct resolved URI */
2682 uri = resolve_uri ( cwuri, reluri );
2683 if ( ! uri ) {
2684 ret = -ENOMEM;
2685 goto err_resolve;
2686 }
2687
2688 /* Format URI string into allocated buffer (with NUL) */
2689 uristring = format_uri_alloc ( uri );
2690 if ( ! uristring ) {
2691 ret = -ENOMEM;
2692 goto err_format;
2693 }
2694
2695 /* Copy URI string to buffer */
2696 strncpy ( data, uristring, len );
2697 ret = strlen ( uristring );
2698
2699 free ( uristring );
2700 err_format:
2701 uri_put ( uri );
2702 err_resolve:
2703 uri_put ( reluri );
2704 err_parse:
2705 err_unset:
2706 return ret;
2707}
2708
2709/**
2710 * Fetch current working URI setting
2711 *
2712 * @v data Buffer to fill with setting data
2713 * @v len Length of buffer
2714 * @ret len Length of setting data, or negative error
2715 */
2716static int cwuri_fetch ( void *data, size_t len ) {
2717
2718 return cwuri_fetch_uri ( data, len, "" );
2719}
2720
2721/**
2722 * Fetch current working directory URI setting
2723 *
2724 * @v data Buffer to fill with setting data
2725 * @v len Length of buffer
2726 * @ret len Length of setting data, or negative error
2727 */
2728static int cwduri_fetch ( void *data, size_t len ) {
2729
2730 return cwuri_fetch_uri ( data, len, "." );
2731}
2732
2733/** Current working URI setting */
2734const struct setting cwuri_setting __setting ( SETTING_MISC, cwuri ) = {
2735 .name = "cwuri",
2736 .description = "Current working URI",
2737 .type = &setting_type_string,
2738 .scope = &builtin_scope,
2739};
2740
2741/** Current working directory URI setting */
2742const struct setting cwduri_setting __setting ( SETTING_MISC, cwduri ) = {
2743 .name = "cwduri",
2744 .description = "Current working directory URI",
2745 .type = &setting_type_string,
2746 .scope = &builtin_scope,
2747};
2748
2749/** Current working URI built-in setting */
2750struct builtin_setting cwuri_builtin_setting __builtin_setting = {
2751 .setting = &cwuri_setting,
2752 .fetch = cwuri_fetch,
2753};
2754
2755/** Current working directory URI built-in setting */
2756struct builtin_setting cwduri_builtin_setting __builtin_setting = {
2757 .setting = &cwduri_setting,
2758 .fetch = cwduri_fetch,
2759};
2760
2761/**
2762 * Fetch built-in setting
2763 *
2764 * @v settings Settings block
2765 * @v setting Setting to fetch
2766 * @v data Buffer to fill with setting data
2767 * @v len Length of buffer
2768 * @ret len Length of setting data, or negative error
2769 */
2770static int builtin_fetch ( struct settings *settings __unused,
2771 struct setting *setting,
2772 void *data, size_t len ) {
2773 struct builtin_setting *builtin;
2774
2775 for_each_table_entry ( builtin, BUILTIN_SETTINGS ) {
2776 if ( setting_cmp ( setting, builtin->setting ) == 0 )
2777 return builtin->fetch ( data, len );
2778 }
2779 return -ENOENT;
2780}
2781
2782/**
2783 * Check applicability of built-in setting
2784 *
2785 * @v settings Settings block
2786 * @v setting Setting
2787 * @ret applies Setting applies within this settings block
2788 */
2789static int builtin_applies ( struct settings *settings __unused,
2790 const struct setting *setting ) {
2791
2792 return ( setting->scope == &builtin_scope );
2793}
2794
2795/** Built-in settings operations */
2796static struct settings_operations builtin_settings_operations = {
2797 .applies = builtin_applies,
2798 .fetch = builtin_fetch,
2799};
2800
2801/** Built-in settings */
2802static struct settings builtin_settings = {
2803 .refcnt = NULL,
2804 .siblings = LIST_HEAD_INIT ( builtin_settings.siblings ),
2805 .children = LIST_HEAD_INIT ( builtin_settings.children ),
2806 .op = &builtin_settings_operations,
2807};
2808
2809/** Initialise built-in settings */
2810static void builtin_init ( void ) {
2811 int rc;
2812
2813 if ( ( rc = register_settings ( &builtin_settings, NULL,
2814 "builtin" ) ) != 0 ) {
2815 DBG ( "Could not register built-in settings: %s\n",
2816 strerror ( rc ) );
2817 return;
2818 }
2819}
2820
2821/** Built-in settings initialiser */
2822struct init_fn builtin_init_fn __init_fn ( INIT_NORMAL ) = {
2823 .name = "builtin",
2824 .initialise = builtin_init,
2825};
NULL
#define NULL
NULL pointer (VOID *)
Definition Base.h:322
raw
__be32 raw[7]
Definition CIB_PRM.h:0
seg
struct golan_mkey_seg seg
Definition CIB_PRM.h:0
pad
u32 pad[9]
Padding.
Definition ar9003_mac.h:23
generic
struct arbelprm_event_queue_entry generic
Definition arbel.h:0
rc
struct arbelprm_rc_send_wqe rc
Definition arbel.h:3
value
pseudo_bit_t value[0x00020]
Definition arbel.h:2
uint32_t
unsigned int uint32_t
Definition stdint.h:12
uint64_t
unsigned long long uint64_t
Definition stdint.h:13
uint8_t
unsigned char uint8_t
Definition stdint.h:10
int8_t
signed char int8_t
Definition stdint.h:15
old
int old
Definition bitops.h:65
asprintf
int asprintf(char **strp, const char *fmt,...)
Write a formatted string to newly allocated memory.
Definition asprintf.c:42
assert.h
Assertions.
assert
#define assert(condition)
Assert a condition at run-time.
Definition assert.h:50
version
u32 version
Driver version.
Definition ath9k_hw.c:1985
name
const char * name
Definition ath9k_hw.c:1986
hex_decode
int hex_decode(char separator, const char *encoded, void *data, size_t len)
Decode hexadecimal string (with optional byte separator character)
Definition base16.c:77
hex_encode
size_t hex_encode(char separator, const void *raw, size_t raw_len, char *data, size_t len)
Encode hexadecimal string (with optional byte separator character)
Definition base16.c:51
base16.h
Base16 encoding.
raw_len
static size_t raw_len
Definition base16.h:54
base64_encode
size_t base64_encode(const void *raw, size_t raw_len, char *data, size_t len)
Base64-encode data.
Definition base64.c:52
base64_decode
int base64_decode(const char *encoded, void *data, size_t len)
Base64-decode string.
Definition base64.c:92
base64.h
Base64 encoding.
cwuri
struct uri * cwuri
Current working URI.
Definition cwuri.c:39
vendor
static unsigned short vendor
Definition davicom.c:128
u
union @104331263140136355135267063077374276003064103115 u
next
uint32_t next
Next descriptor address.
Definition dwmac.h:11
len
ring len
Length.
Definition dwmac.h:226
tag
uint64_t tag
Identity tag.
Definition edd.h:1
bus
uint8_t bus
Bus.
Definition edd.h:1
slot
uint8_t slot
Slot.
Definition edd.h:3
type
uint32_t type
Operating system type.
Definition ena.h:1
data
uint8_t data[48]
Additional event data.
Definition ena.h:11
busdevfn
uint16_t busdevfn
PCI bus:dev.fn address.
Definition ena.h:17
errno
int errno
Global "last error" number.
Definition errno.c:21
errno.h
Error codes.
__unused
#define __unused
Declare a variable or data structure as unused.
Definition compiler.h:573
DBGC
#define DBGC(...)
Definition compiler.h:505
DBG
#define DBG(...)
Print a debugging message.
Definition compiler.h:498
DHCP_ROOT_PATH
#define DHCP_ROOT_PATH
Root path.
Definition dhcp.h:84
DHCP_DOMAIN_NAME
#define DHCP_DOMAIN_NAME
Domain name.
Definition dhcp.h:81
DHCP_EB_PASSWORD
#define DHCP_EB_PASSWORD
Password.
Definition dhcp.h:497
DHCP_EB_PRIORITY
#define DHCP_EB_PRIORITY
Priority of this options block.
Definition dhcp.h:366
DHCP_EB_SIADDR
#define DHCP_EB_SIADDR
"Server" IP address
Definition dhcp.h:382
DHCP_VENDOR_CLASS_ID
#define DHCP_VENDOR_CLASS_ID
Vendor class identifier.
Definition dhcp.h:217
DHCP_EB_SAN_FILENAME
#define DHCP_EB_SAN_FILENAME
SAN filename.
Definition dhcp.h:472
DHCP_EB_USERNAME
#define DHCP_EB_USERNAME
Username.
Definition dhcp.h:488
DHCP_USER_CLASS_ID
#define DHCP_USER_CLASS_ID
User class identifier.
Definition dhcp.h:268
DHCP_BOOTFILE_NAME
#define DHCP_BOOTFILE_NAME
Bootfile name.
Definition dhcp.h:265
DHCP_HOST_NAME
#define DHCP_HOST_NAME
Host name.
Definition dhcp.h:78
INIT_NORMAL
#define INIT_NORMAL
Normal initialisation.
Definition init.h:32
start
uint32_t start
Starting offset.
Definition netvsc.h:1
size
uint16_t size
Buffer size.
Definition dwmac.h:3
count
static unsigned int count
Number of entries.
Definition dwmac.h:220
head
uint8_t head
Head number.
Definition int13.h:23
FILE_LICENCE
#define FILE_LICENCE(_licence)
Declare a particular licence as applying to a file.
Definition compiler.h:896
ENOENT
#define ENOENT
No such file or directory.
Definition errno.h:515
EINVAL
#define EINVAL
Invalid argument.
Definition errno.h:429
ENOMEM
#define ENOMEM
Not enough space.
Definition errno.h:535
ENOTSUP
#define ENOTSUP
Operation not supported.
Definition errno.h:590
ERANGE
#define ERANGE
Result too large.
Definition errno.h:640
ENODEV
#define ENODEV
No such device.
Definition errno.h:510
ENOTTY
#define ENOTTY
Inappropriate I/O control operation.
Definition errno.h:595
FILE_SECBOOT
#define FILE_SECBOOT(_status)
Declare a file's UEFI Secure Boot permission status.
Definition compiler.h:926
SETTING_HOST_EXTRA
#define SETTING_HOST_EXTRA
Host identity additional settings.
Definition settings.h:77
SETTING_SANBOOT
#define SETTING_SANBOOT
SAN boot settings.
Definition settings.h:74
SETTING_BOOT
#define SETTING_BOOT
Generic boot settings.
Definition settings.h:72
SETTING_IP_EXTRA
#define SETTING_IP_EXTRA
IPv4 additional settings.
Definition settings.h:71
SETTING_HOST
#define SETTING_HOST
Host identity settings.
Definition settings.h:76
SETTING_AUTH
#define SETTING_AUTH
Authentication settings.
Definition settings.h:78
SETTING_MISC
#define SETTING_MISC
Miscellaneous settings.
Definition settings.h:81
bytes
uint8_t bytes[64]
Definition ib_mad.h:5
htonl
#define htonl(value)
Definition byteswap.h:134
__weak
#define __weak
Declare a function as weak (use before the definition)
Definition compiler.h:219
_S2
#define _S2(x)
Stringify expanded argument.
Definition compiler.h:53
dhcp.h
Dynamic Host Configuration Protocol.
origin
uint64_t origin
Origin.
Definition hyperv.h:9
settings.h
Configuration settings.
__setting
#define __setting(setting_order, name)
Declare a configuration setting.
Definition settings.h:57
SETTINGS_APPLICATORS
#define SETTINGS_APPLICATORS
Settings applicator table.
Definition settings.h:261
delete_setting
static int delete_setting(struct settings *settings, const struct setting *setting)
Delete setting.
Definition settings.h:534
get_child_settings_t
struct settings *(* get_child_settings_t)(struct settings *settings, const char *name)
A child settings block locator function.
Definition settings.h:307
__builtin_setting
#define __builtin_setting
Declare a built-in setting.
Definition settings.h:284
generic_settings_init
static void generic_settings_init(struct generic_settings *generics, struct refcnt *refcnt)
Initialise a settings block.
Definition settings.h:520
SETTINGS
#define SETTINGS
Configuration setting table.
Definition settings.h:54
BUILTIN_SETTINGS
#define BUILTIN_SETTINGS
Built-in settings table.
Definition settings.h:281
SETTING_TYPES
#define SETTING_TYPES
Configuration setting type table.
Definition settings.h:243
__setting_type
#define __setting_type
Declare a configuration setting type.
Definition settings.h:246
string.h
String functions.
memcpy
void * memcpy(void *dest, const void *src, size_t len) __nonnull
memset
void * memset(void *dest, int character, size_t len) __nonnull
strings.h
String functions.
time.h
Date and time.
__init_fn
#define __init_fn(init_order)
Declare an initialisation functon.
Definition init.h:24
ip.h
IP protocol.
ipv6.h
IPv6 protocol.
version.h
Version number.
tmp
unsigned long tmp
Definition linux_pci.h:65
list_first_entry
#define list_first_entry(list, type, member)
Get the container of the first entry in a list.
Definition list.h:334
LIST_HEAD_INIT
#define LIST_HEAD_INIT(list)
Initialise a static list head.
Definition list.h:31
list_for_each_entry_safe
#define list_for_each_entry_safe(pos, tmp, head, member)
Iterate over entries in a list, safe against deletion of the current entry.
Definition list.h:459
list_add_tail
#define list_add_tail(new, head)
Add a new entry to the tail of a list.
Definition list.h:94
list_for_each_entry
#define list_for_each_entry(pos, head, member)
Iterate over entries in a list.
Definition list.h:432
list_del
#define list_del(list)
Delete an entry from a list.
Definition list.h:120
list_empty
#define list_empty(list)
Test whether a list is empty.
Definition list.h:137
list_add
#define list_add(new, head)
Add a new entry to the head of a list.
Definition list.h:70
username
static struct dynamic_item username
Definition login_ui.c:36
password
static struct dynamic_item password
Definition login_ui.c:37
zalloc
void * zalloc(size_t size)
Allocate cleared memory.
Definition malloc.c:662
malloc
void * malloc(size_t size)
Allocate memory.
Definition malloc.c:621
num
uint32_t num
Definition multiboot.h:0
end
uint32_t end
Ending offset.
Definition netvsc.h:7
pci.h
PCI bus.
PCI_SEG
#define PCI_SEG(busdevfn)
Definition pci.h:283
PCI_FUNC
#define PCI_FUNC(busdevfn)
Definition pci.h:286
PCI_BUS
#define PCI_BUS(busdevfn)
Definition pci.h:284
PCI_SLOT
#define PCI_SLOT(busdevfn)
Definition pci.h:285
free
static void(* free)(struct refcnt *refcnt))
Definition refcnt.h:55
ref_get
#define ref_get(refcnt)
Get additional reference to object.
Definition refcnt.h:93
ref_put
#define ref_put(refcnt)
Drop reference to object.
Definition refcnt.h:107
ref_init
#define ref_init(refcnt, free)
Initialise a reference counter.
Definition refcnt.h:65
setting_numerate
int setting_numerate(const struct setting_type *type, const void *raw, size_t raw_len, unsigned long *value)
Convert setting value to number.
Definition settings.c:1190
setting_format
int setting_format(const struct setting_type *type, const void *raw, size_t raw_len, char *buf, size_t len)
Format setting value as a string.
Definition settings.c:1152
format_hex_raw_setting
static int format_hex_raw_setting(const struct setting_type *type __unused, const void *raw, size_t raw_len, char *buf, size_t len)
Format hex string setting value (using no delimiter)
Definition settings.c:2131
parse_uristring_setting
static int parse_uristring_setting(const struct setting_type *type __unused, const char *value, void *buf, size_t len)
Parse URI-encoded string setting value.
Definition settings.c:1684
builtin_settings_operations
static struct settings_operations builtin_settings_operations
Built-in settings operations.
Definition settings.c:2796
version_fetch
static int version_fetch(void *data, size_t len)
Fetch version setting.
Definition settings.c:2603
register_settings
int register_settings(struct settings *settings, struct settings *parent, const char *name)
Register settings block.
Definition settings.c:476
expand_settings
char * expand_settings(const char *string)
Expand variables within string.
Definition settings.c:2331
reprioritise_settings
static void reprioritise_settings(struct settings *settings)
Reprioritise settings.
Definition settings.c:438
autovivify_child_settings
struct settings * autovivify_child_settings(struct settings *parent, const char *name)
Find or create child settings block.
Definition settings.c:307
numerate_int_setting
static int numerate_int_setting(const struct setting_type *type, const void *raw, size_t raw_len, unsigned long *value)
Convert setting value to number.
Definition settings.c:1906
parse_settings_name
static struct settings * parse_settings_name(const char *name, get_child_settings_t get_child)
Parse settings block name.
Definition settings.c:372
setting_name
int setting_name(struct settings *settings, const struct setting *setting, char *buf, size_t len)
Return full setting name.
Definition settings.c:1607
format_ipv6_setting
__weak int format_ipv6_setting(const struct setting_type *type __unused, const void *raw __unused, size_t raw_len __unused, char *buf __unused, size_t len __unused)
Format IPv6 address setting value (when IPv6 support is not present)
Definition settings.c:1778
fetch_raw_setting_copy
int fetch_raw_setting_copy(struct settings *settings, const struct setting *setting, void **data)
Fetch value of setting.
Definition settings.c:822
parse_string_setting
static int parse_string_setting(const struct setting_type *type __unused, const char *value, void *buf, size_t len)
Parse string setting value.
Definition settings.c:1633
platform_fetch
static int platform_fetch(void *data, size_t len)
Fetch platform setting.
Definition settings.c:2575
format_hex_colon_setting
static int format_hex_colon_setting(const struct setting_type *type __unused, const void *raw, size_t raw_len, char *buf, size_t len)
Format hex string setting value (using colon delimiter)
Definition settings.c:2068
format_uint_setting
static int format_uint_setting(const struct setting_type *type, const void *raw, size_t raw_len, char *buf, size_t len)
Format unsigned integer setting value.
Definition settings.c:1977
fetch_numeric_setting
int fetch_numeric_setting(struct settings *settings, const struct setting *setting, unsigned long *value, int is_signed)
Fetch value of numeric setting.
Definition settings.c:998
format_string_setting
static int format_string_setting(const struct setting_type *type __unused, const void *raw, size_t raw_len, char *buf, size_t len)
Format string setting value.
Definition settings.c:1655
find_setting_type
static const struct setting_type * find_setting_type(const char *name)
Find setting type.
Definition settings.c:1503
generic_settings_root
struct generic_settings generic_settings_root
Root generic settings block.
Definition settings.c:236
fetch_ipv6_array_setting
int fetch_ipv6_array_setting(struct settings *settings, const struct setting *setting, struct in6_addr *inp, unsigned int count)
Fetch value of IPv6 address setting.
Definition settings.c:929
dhcpv6_scope
const struct settings_scope dhcpv6_scope
IPv6 settings scope.
Definition settings.c:1793
parse_base64_setting
static int parse_base64_setting(const struct setting_type *type __unused, const char *value, void *buf, size_t len)
Parse Base64-encoded setting value.
Definition settings.c:2168
parse_ipv6_setting
__weak int parse_ipv6_setting(const struct setting_type *type __unused, const char *value __unused, void *buf __unused, size_t len __unused)
Parse IPv6 address setting value (when IPv6 support is not present)
Definition settings.c:1762
fetch_raw_setting
int fetch_raw_setting(struct settings *settings, const struct setting *setting, void *data, size_t len)
Fetch value of setting.
Definition settings.c:804
setting_type_int_name
static const char setting_type_int_name[][8]
Integer setting type names.
Definition settings.c:1816
find_generic_setting
static struct generic_setting * find_generic_setting(struct generic_settings *generics, const struct setting *setting)
Find generic setting.
Definition settings.c:107
fetch_setting
int fetch_setting(struct settings *settings, const struct setting *setting, struct settings **origin, struct setting *fetched, void *data, size_t len)
Fetch setting.
Definition settings.c:667
SETTING_TYPE_UINT
#define SETTING_TYPE_UINT(index)
Define an unsigned integer setting type.
Definition settings.c:2011
settings_target
struct settings * settings_target(struct settings *settings)
Redirect to target settings block.
Definition settings.c:550
fetchn_setting
int fetchn_setting(struct settings *settings, const struct setting *setting, struct settings **origin, struct setting *fetched, unsigned long *value)
Fetch numeric value of setting.
Definition settings.c:1373
fetch_uintz_setting
unsigned long fetch_uintz_setting(struct settings *settings, const struct setting *setting)
Fetch value of unsigned integer setting, or zero.
Definition settings.c:1069
autovivified_settings_free
static void autovivified_settings_free(struct refcnt *refcnt)
Free autovivified settings block.
Definition settings.c:265
fetch_string_setting_copy_alloc
static void * fetch_string_setting_copy_alloc(size_t len)
Allocate memory for copy of string setting.
Definition settings.c:857
setting_parse
int setting_parse(const struct setting_type *type, const char *value, void *buf, size_t len)
Parse formatted string to setting value.
Definition settings.c:1171
cwduri_fetch
static int cwduri_fetch(void *data, size_t len)
Fetch current working directory URI setting.
Definition settings.c:2728
format_base64_setting
static int format_base64_setting(const struct setting_type *type __unused, const void *raw, size_t raw_len, char *buf, size_t len)
Format Base64-encoded setting value.
Definition settings.c:2184
format_uuid_setting
static int format_uuid_setting(const struct setting_type *type, const void *raw, size_t raw_len, char *buf, size_t len)
Format UUID/GUID setting value.
Definition settings.c:2239
fetch_int_setting
int fetch_int_setting(struct settings *settings, const struct setting *setting, long *value)
Fetch value of signed integer setting.
Definition settings.c:1024
builtin_settings
static struct settings builtin_settings
Built-in settings.
Definition settings.c:2802
fetch_setting_alloc
static int fetch_setting_alloc(struct settings *settings, const struct setting *setting, struct settings **origin, struct setting *fetched, void **data, void *(*alloc)(size_t len))
Fetch allocated copy of setting.
Definition settings.c:737
parse_hex_raw_setting
static int parse_hex_raw_setting(const struct setting_type *type __unused, const char *value, void *buf, size_t len)
Parse hex string setting value (using no delimiter)
Definition settings.c:2116
fetch_setting_copy
int fetch_setting_copy(struct settings *settings, const struct setting *setting, struct settings **origin, struct setting *fetched, void **data)
Fetch copy of setting.
Definition settings.c:786
fetch_ipv4_array_setting
int fetch_ipv4_array_setting(struct settings *settings, const struct setting *setting, struct in_addr *inp, unsigned int count)
Fetch value of IPv4 address setting.
Definition settings.c:891
builtin_init
static void builtin_init(void)
Initialise built-in settings.
Definition settings.c:2810
builtin_applies
static int builtin_applies(struct settings *settings __unused, const struct setting *setting)
Check applicability of built-in setting.
Definition settings.c:2789
setting_type_int_width
static unsigned int setting_type_int_width(const struct setting_type *type)
Get integer setting type width.
Definition settings.c:1856
cwuri_fetch_uri
static int cwuri_fetch_uri(void *data, size_t len, const char *rel)
Fetch current working URI-related setting.
Definition settings.c:2662
fetch_string_setting
int fetch_string_setting(struct settings *settings, const struct setting *setting, char *data, size_t len)
Fetch value of string setting.
Definition settings.c:842
errno_fetch
static int errno_fetch(void *data, size_t len)
Fetch error number setting.
Definition settings.c:2515
parse_setting_name
int parse_setting_name(char *name, get_child_settings_t get_child, struct settings **settings, struct setting *setting)
Parse setting name.
Definition settings.c:1529
find_setting
struct setting * find_setting(const char *name)
Find predefined setting.
Definition settings.c:1467
setting_applies
int setting_applies(struct settings *settings, const struct setting *setting)
Check applicability of setting.
Definition settings.c:571
applicable_setting
static const struct setting * applicable_setting(struct settings *settings, const struct setting *setting)
Find setting applicable to settings block, if any.
Definition settings.c:590
parse_hex_setting
static int parse_hex_setting(const struct setting_type *type __unused, const char *value, void *buf, size_t len)
Parse hex string setting value (using colon delimiter)
Definition settings.c:2053
clear_settings
void clear_settings(struct settings *settings)
Clear settings block.
Definition settings.c:1103
builtin_scope
const struct settings_scope builtin_scope
Built-in setting scope.
Definition settings.c:2506
fetch_ipv6_setting
int fetch_ipv6_setting(struct settings *settings, const struct setting *setting, struct in6_addr *inp)
Fetch value of IPv6 address setting.
Definition settings.c:951
parse_int_setting
static int parse_int_setting(const struct setting_type *type, const char *value, void *buf, size_t len)
Parse integer setting value.
Definition settings.c:1930
fetch_string_setting_copy
int fetch_string_setting_copy(struct settings *settings, const struct setting *setting, char **data)
Fetch value of string setting.
Definition settings.c:874
unregister_settings
void unregister_settings(struct settings *settings)
Unregister settings block.
Definition settings.c:515
setting_cmp
int setting_cmp(const struct setting *a, const struct setting *b)
Compare two settings.
Definition settings.c:1121
format_int_setting
static int format_int_setting(const struct setting_type *type, const void *raw, size_t raw_len, char *buf, size_t len)
Format signed integer setting value.
Definition settings.c:1953
builtin_fetch
static int builtin_fetch(struct settings *settings __unused, struct setting *setting, void *data, size_t len)
Fetch built-in setting.
Definition settings.c:2770
generic_settings_fetch
int generic_settings_fetch(struct settings *settings, struct setting *setting, void *data, size_t len)
Fetch value of generic setting.
Definition settings.c:179
fetch_ipv4_setting
int fetch_ipv4_setting(struct settings *settings, const struct setting *setting, struct in_addr *inp)
Fetch value of IPv4 address setting.
Definition settings.c:913
find_settings
struct settings * find_settings(const char *name)
Find settings block.
Definition settings.c:407
fetch_uint_setting
int fetch_uint_setting(struct settings *settings, const struct setting *setting, unsigned long *value)
Fetch value of unsigned integer setting.
Definition settings.c:1040
fetchf_setting
int fetchf_setting(struct settings *settings, const struct setting *setting, struct settings **origin, struct setting *fetched, char *buf, size_t len)
Fetch formatted value of setting.
Definition settings.c:1230
generic_settings_clear
void generic_settings_clear(struct settings *settings)
Clear generic settings block.
Definition settings.c:208
SETTING_TYPE_INT
#define SETTING_TYPE_INT(index)
Define a signed integer setting type.
Definition settings.c:1997
settings_root
#define settings_root
Root settings block.
Definition settings.c:250
find_child_settings
struct settings * find_child_settings(struct settings *parent, const char *name)
Find child settings block.
Definition settings.c:280
denumerate_int_setting
static int denumerate_int_setting(const struct setting_type *type, unsigned long value, void *buf, size_t len)
Convert number to setting value.
Definition settings.c:1880
format_ipv4_setting
__weak int format_ipv4_setting(const struct setting_type *type __unused, const void *raw __unused, size_t raw_len __unused, char *buf __unused, size_t len __unused)
Format IPv4 address setting value (when IPv4 support is not present)
Definition settings.c:1739
fetchf_setting_copy
int fetchf_setting_copy(struct settings *settings, const struct setting *setting, struct settings **origin, struct setting *fetched, char **value)
Fetch copy of formatted value of setting.
Definition settings.c:1277
generic_settings_store
int generic_settings_store(struct settings *settings, const struct setting *setting, const void *data, size_t len)
Store value of generic setting.
Definition settings.c:127
buildarch_fetch
static int buildarch_fetch(void *data, size_t len)
Fetch build architecture setting.
Definition settings.c:2547
generic_setting_data
static void * generic_setting_data(struct generic_setting *generic)
Get generic setting data.
Definition settings.c:94
storef_setting
int storef_setting(struct settings *settings, const struct setting *setting, const char *value)
Store formatted value of setting.
Definition settings.c:1320
fetch_intz_setting
long fetch_intz_setting(struct settings *settings, const struct setting *setting)
Fetch value of signed integer setting, or zero.
Definition settings.c:1054
format_busdevfn_setting
static int format_busdevfn_setting(const struct setting_type *type __unused, const void *raw, size_t raw_len, char *buf, size_t len)
Format PCI bus:dev.fn setting value.
Definition settings.c:2283
generic_setting_name
static void * generic_setting_name(struct generic_setting *generic)
Get generic setting name.
Definition settings.c:84
fetch_uuid_setting
int fetch_uuid_setting(struct settings *settings, const struct setting *setting, union uuid *uuid)
Fetch value of UUID setting.
Definition settings.c:1085
parse_uuid_setting
static int parse_uuid_setting(const struct setting_type *type, const char *value, void *buf, size_t len)
Parse UUID/GUID setting value.
Definition settings.c:2208
numeric_setting_value
static int numeric_setting_value(int is_signed, const void *raw, size_t len, unsigned long *value)
Extract numeric value of setting.
Definition settings.c:967
apply_settings
static void apply_settings(void)
Apply all settings.
Definition settings.c:416
format_uristring_setting
static int format_uristring_setting(const struct setting_type *type __unused, const void *raw, size_t raw_len, char *buf, size_t len)
Format URI-encoded string setting value.
Definition settings.c:1700
store_setting
int store_setting(struct settings *settings, const struct setting *setting, const void *data, size_t len)
Store value of setting.
Definition settings.c:616
parse_ipv4_setting
__weak int parse_ipv4_setting(const struct setting_type *type __unused, const char *value __unused, void *buf __unused, size_t len __unused)
Parse IPv4 address setting value (when IPv4 support is not present)
Definition settings.c:1723
storen_setting
int storen_setting(struct settings *settings, const struct setting *setting, unsigned long value)
Store numeric value of setting.
Definition settings.c:1415
parse_hex_hyphen_setting
static int parse_hex_hyphen_setting(const struct setting_type *type __unused, const char *value, void *buf, size_t len)
Parse hex string setting value (using hyphen delimiter)
Definition settings.c:2084
generic_settings_operations
struct settings_operations generic_settings_operations
Generic settings operations.
Definition settings.c:222
settings_name
const char * settings_name(struct settings *settings)
Return settings block name.
Definition settings.c:346
format_hex_hyphen_setting
static int format_hex_hyphen_setting(const struct setting_type *type __unused, const void *raw, size_t raw_len, char *buf, size_t len)
Format hex string setting value (using hyphen delimiter)
Definition settings.c:2100
setting_type_int_index
setting_type_int_index
Integer setting type indices.
Definition settings.c:1801
SETTING_TYPE_INT8
@ SETTING_TYPE_INT8
Definition settings.c:1802
SETTING_TYPE_INT16
@ SETTING_TYPE_INT16
Definition settings.c:1803
SETTING_TYPE_INT32
@ SETTING_TYPE_INT32
Definition settings.c:1804
parse_setting_tag
static uint64_t parse_setting_tag(const char *name)
Parse setting name as tag number.
Definition settings.c:1483
cwuri_fetch
static int cwuri_fetch(void *data, size_t len)
Fetch current working URI setting.
Definition settings.c:2716
setting_type_int_is_signed
static int setting_type_int_is_signed(const struct setting_type *type)
Get integer setting type signedness.
Definition settings.c:1867
setting_denumerate
int setting_denumerate(const struct setting_type *type, unsigned long value, void *buf, size_t len)
Convert number to setting value.
Definition settings.c:1209
unixtime_fetch
static int unixtime_fetch(void *data, size_t len)
Fetch current time setting.
Definition settings.c:2629
byte
unsigned char byte
Definition smc9000.h:38
container_of
#define container_of(ptr, type, field)
Get containing structure.
Definition stddef.h:36
priority
uint16_t priority
Priotity.
Definition stp.h:1
root
struct stp_switch root
Root switch.
Definition stp.h:15
strerror
char * strerror(int errno)
Retrieve string representation of error number.
Definition strerror.c:79
strtoul
unsigned long strtoul(const char *string, char **endp, int base)
Convert string to numeric value.
Definition string.c:485
strcmp
int strcmp(const char *first, const char *second)
Compare strings.
Definition string.c:174
strchr
char * strchr(const char *src, int character)
Find character within a string.
Definition string.c:272
strdup
char * strdup(const char *src)
Duplicate string.
Definition string.c:394
strlen
size_t strlen(const char *src)
Get length of string.
Definition string.c:244
strncpy
char * strncpy(char *dest, const char *src, size_t max)
Copy string.
Definition string.c:361
autovivified_settings
Autovivified settings block.
Definition settings.c:253
autovivified_settings::refcnt
struct refcnt refcnt
Reference count.
Definition settings.c:255
autovivified_settings::generic
struct generic_settings generic
Generic settings block.
Definition settings.c:257
builtin_setting
A built-in setting.
Definition settings.h:268
builtin_setting::setting
const struct setting * setting
Setting.
Definition settings.h:270
builtin_setting::fetch
int(* fetch)(void *data, size_t len)
Fetch setting value.
Definition settings.h:277
generic_setting
A generic setting.
Definition settings.c:67
generic_setting::name_len
size_t name_len
Size of setting name.
Definition settings.c:73
generic_setting::list
struct list_head list
List of generic settings.
Definition settings.c:69
generic_setting::data_len
size_t data_len
Size of setting data.
Definition settings.c:75
generic_setting::setting
struct setting setting
Setting.
Definition settings.c:71
generic_settings
A generic settings block.
Definition settings.h:299
generic_settings::list
struct list_head list
List of generic settings.
Definition settings.h:303
generic_settings::settings
struct settings settings
Settings block.
Definition settings.h:301
in6_addr
IP6 address structure.
Definition in.h:51
in_addr
IP address structure.
Definition in.h:42
init_fn
An initialisation function.
Definition init.h:15
list_head
A doubly-linked list entry (or list head)
Definition list.h:19
refcnt
A reference counter.
Definition refcnt.h:27
setting_type
A setting type.
Definition settings.h:192
setting_type::name
const char * name
Name.
Definition settings.h:197
setting
A setting.
Definition settings.h:24
setting::name
const char * name
Name.
Definition settings.h:29
setting::scope
const struct settings_scope * scope
Setting scope (or NULL)
Definition settings.h:50
setting::type
const struct setting_type * type
Setting type.
Definition settings.h:37
setting::tag
uint64_t tag
Setting tag, if applicable.
Definition settings.h:44
settings_applicator
A settings applicator.
Definition settings.h:252
settings_applicator::apply
int(* apply)(void)
Apply updated settings.
Definition settings.h:257
settings_operations
Settings block operations.
Definition settings.h:86
settings_operations::applies
int(* applies)(struct settings *settings, const struct setting *setting)
Check applicability of setting.
Definition settings.h:99
settings_operations::fetch
int(* fetch)(struct settings *settings, struct setting *setting, void *data, size_t len)
Fetch value of setting.
Definition settings.h:123
settings_operations::store
int(* store)(struct settings *settings, const struct setting *setting, const void *data, size_t len)
Store value of setting.
Definition settings.h:109
settings_operations::clear
void(* clear)(struct settings *settings)
Clear settings block.
Definition settings.h:129
settings_operations::redirect
struct settings *(* redirect)(struct settings *settings)
Redirect to underlying settings block (if applicable)
Definition settings.h:92
settings_scope
A setting scope.
Definition settings.h:177
settings
A settings block.
Definition settings.h:133
settings::op
struct settings_operations * op
Settings block operations.
Definition settings.h:145
settings::children
struct list_head children
Child settings blocks.
Definition settings.h:143
settings::order
int order
Sibling ordering.
Definition settings.h:149
settings::name
const char * name
Name.
Definition settings.h:137
settings::parent
struct settings * parent
Parent settings block.
Definition settings.h:139
settings::siblings
struct list_head siblings
Sibling settings blocks.
Definition settings.h:141
settings::refcnt
struct refcnt * refcnt
Reference counter.
Definition settings.h:135
uri
A Uniform Resource Identifier.
Definition uri.h:65
for_each_table_entry
#define for_each_table_entry(pointer, table)
Iterate through all entries within a linker table.
Definition tables.h:386
uuid
A universally unique ID.
Definition uuid.h:16
uuid::raw
uint8_t raw[16]
Definition uuid.h:30
uri_decode
size_t uri_decode(const char *encoded, void *buf, size_t len)
Decode URI field.
Definition uri.c:54
parse_uri
struct uri * parse_uri(const char *uri_string)
Parse URI.
Definition uri.c:297
resolve_uri
struct uri * resolve_uri(const struct uri *base_uri, struct uri *relative_uri)
Resolve base+relative URI.
Definition uri.c:696
uri_encode
size_t uri_encode(unsigned int field, const void *raw, size_t raw_len, char *buf, ssize_t len)
Encode URI field.
Definition uri.c:201
format_uri_alloc
char * format_uri_alloc(const struct uri *uri)
Format URI.
Definition uri.c:542
uri.h
Uniform Resource Identifiers.
uri_put
static void uri_put(struct uri *uri)
Decrement URI reference count.
Definition uri.h:206
uuid_ntoa
const char * uuid_ntoa(const union uuid *uuid)
Convert UUID to printable string.
Definition uuid.c:46
uuid_aton
int uuid_aton(const char *string, union uuid *uuid)
Parse UUID.
Definition uuid.c:67
uuid.h
Universally unique IDs.
uuid_mangle
static void uuid_mangle(union uuid *uuid)
Change UUID endianness.
Definition uuid.h:44
product_version
const char product_version[]
Product version string.
Definition version.c:71
snprintf
int snprintf(char *buf, size_t size, const char *fmt,...)
Write a formatted string to a buffer.
Definition vsprintf.c:383
vsprintf.h
printf() and friends
Generated by doxygen 1.14.0