2 * Copyright (C) 2008 Michael Brown <mbrown@fensystems.co.uk>.
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.
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.
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
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.
24 FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
36 #include <ipxe/ipv6.h>
37 #include <ipxe/vsprintf.h>
38 #include <ipxe/dhcp.h>
39 #include <ipxe/uuid.h>
41 #include <ipxe/base16.h>
42 #include <ipxe/base64.h>
44 #include <ipxe/init.h>
45 #include <ipxe/version.h>
46 #include <ipxe/settings.h>
50 * Configuration settings
54 /******************************************************************************
56 * Generic settings blocks
58 ******************************************************************************
65 struct generic_setting {
66 /** List of generic settings */
67 struct list_head list;
69 struct setting setting;
70 /** Size of setting name */
72 /** Size of setting data */
77 * Get generic setting name
79 * @v generic Generic setting
80 * @ret name Generic setting name
82 static inline void * generic_setting_name ( struct generic_setting *generic ) {
83 return ( ( ( void * ) generic ) + sizeof ( *generic ) );
87 * Get generic setting data
89 * @v generic Generic setting
90 * @ret data Generic setting data
92 static inline void * generic_setting_data ( struct generic_setting *generic ) {
93 return ( ( ( void * ) generic ) + sizeof ( *generic ) +
98 * Find generic setting
100 * @v generics Generic settings block
101 * @v setting Setting to find
102 * @ret generic Generic setting, or NULL
104 static struct generic_setting *
105 find_generic_setting ( struct generic_settings *generics,
106 const struct setting *setting ) {
107 struct generic_setting *generic;
109 list_for_each_entry ( generic, &generics->list, list ) {
110 if ( setting_cmp ( &generic->setting, setting ) == 0 )
117 * Store value of generic setting
119 * @v settings Settings block
120 * @v setting Setting to store
121 * @v data Setting data, or NULL to clear setting
122 * @v len Length of setting data
123 * @ret rc Return status code
125 int generic_settings_store ( struct settings *settings,
126 const struct setting *setting,
127 const void *data, size_t len ) {
128 struct generic_settings *generics =
129 container_of ( settings, struct generic_settings, settings );
130 struct generic_setting *old;
131 struct generic_setting *new = NULL;
134 /* Identify existing generic setting, if any */
135 old = find_generic_setting ( generics, setting );
137 /* Create new generic setting, if required */
139 /* Allocate new generic setting */
140 name_len = ( strlen ( setting->name ) + 1 );
141 new = zalloc ( sizeof ( *new ) + name_len + len );
145 /* Populate new generic setting */
146 new->name_len = name_len;
148 memcpy ( &new->setting, setting, sizeof ( new->setting ) );
149 new->setting.name = generic_setting_name ( new );
150 memcpy ( generic_setting_name ( new ),
151 setting->name, name_len );
152 memcpy ( generic_setting_data ( new ), data, len );
155 /* Delete existing generic setting, if any */
157 list_del ( &old->list );
161 /* Add new setting to list, if any */
163 list_add ( &new->list, &generics->list );
169 * Fetch value of generic setting
171 * @v settings Settings block
172 * @v setting Setting to fetch
173 * @v data Buffer to fill with setting data
174 * @v len Length of buffer
175 * @ret len Length of setting data, or negative error
177 int generic_settings_fetch ( struct settings *settings,
178 struct setting *setting,
179 void *data, size_t len ) {
180 struct generic_settings *generics =
181 container_of ( settings, struct generic_settings, settings );
182 struct generic_setting *generic;
184 /* Find generic setting */
185 generic = find_generic_setting ( generics, setting );
189 /* Copy out generic setting data */
190 if ( len > generic->data_len )
191 len = generic->data_len;
192 memcpy ( data, generic_setting_data ( generic ), len );
194 /* Set setting type, if not yet specified */
195 if ( ! setting->type )
196 setting->type = generic->setting.type;
198 return generic->data_len;
202 * Clear generic settings block
204 * @v settings Settings block
206 void generic_settings_clear ( struct settings *settings ) {
207 struct generic_settings *generics =
208 container_of ( settings, struct generic_settings, settings );
209 struct generic_setting *generic;
210 struct generic_setting *tmp;
212 list_for_each_entry_safe ( generic, tmp, &generics->list, list ) {
213 list_del ( &generic->list );
216 assert ( list_empty ( &generics->list ) );
219 /** Generic settings operations */
220 struct settings_operations generic_settings_operations = {
221 .store = generic_settings_store,
222 .fetch = generic_settings_fetch,
223 .clear = generic_settings_clear,
226 /******************************************************************************
228 * Registered settings blocks
230 ******************************************************************************
233 /** Root generic settings block */
234 struct generic_settings generic_settings_root = {
239 LIST_HEAD_INIT ( generic_settings_root.settings.siblings ),
241 LIST_HEAD_INIT ( generic_settings_root.settings.children ),
242 .op = &generic_settings_operations,
244 .list = LIST_HEAD_INIT ( generic_settings_root.list ),
247 /** Root settings block */
248 #define settings_root generic_settings_root.settings
250 /** Autovivified settings block */
251 struct autovivified_settings {
252 /** Reference count */
253 struct refcnt refcnt;
254 /** Generic settings block */
255 struct generic_settings generic;
259 * Free autovivified settings block
261 * @v refcnt Reference count
263 static void autovivified_settings_free ( struct refcnt *refcnt ) {
264 struct autovivified_settings *autovivified =
265 container_of ( refcnt, struct autovivified_settings, refcnt );
267 generic_settings_clear ( &autovivified->generic.settings );
268 free ( autovivified );
272 * Find child settings block
274 * @v parent Parent settings block
275 * @v name Name within this parent
276 * @ret settings Settings block, or NULL
278 struct settings * find_child_settings ( struct settings *parent,
280 struct settings *settings;
282 /* Find target parent settings block */
283 parent = settings_target ( parent );
285 /* Treat empty name as meaning "this block" */
289 /* Look for child with matching name */
290 list_for_each_entry ( settings, &parent->children, siblings ) {
291 if ( strcmp ( settings->name, name ) == 0 )
292 return settings_target ( settings );
299 * Find or create child settings block
301 * @v parent Parent settings block
302 * @v name Name within this parent
303 * @ret settings Settings block, or NULL
305 struct settings * autovivify_child_settings ( struct settings *parent,
308 struct autovivified_settings autovivified;
309 char name[ strlen ( name ) + 1 /* NUL */ ];
311 struct settings *settings;
313 /* Find target parent settings block */
314 parent = settings_target ( parent );
316 /* Return existing settings, if existent */
317 if ( ( settings = find_child_settings ( parent, name ) ) != NULL )
320 /* Create new generic settings block */
321 new_child = zalloc ( sizeof ( *new_child ) );
323 DBGC ( parent, "Settings %p could not create child %s\n",
327 memcpy ( new_child->name, name, sizeof ( new_child->name ) );
328 ref_init ( &new_child->autovivified.refcnt,
329 autovivified_settings_free );
330 generic_settings_init ( &new_child->autovivified.generic,
331 &new_child->autovivified.refcnt );
332 settings = &new_child->autovivified.generic.settings;
333 register_settings ( settings, parent, new_child->name );
338 * Return settings block name
340 * @v settings Settings block
341 * @ret name Settings block name
343 const char * settings_name ( struct settings *settings ) {
345 char tmp[ 1 /* '.' */ + sizeof ( buf ) ];
347 /* Find target settings block */
348 settings = settings_target ( settings );
353 for ( ; settings->parent ; settings = settings->parent ) {
354 memcpy ( ( tmp + 1 ), buf, ( sizeof ( tmp ) - 1 ) );
355 snprintf ( buf, sizeof ( buf ), "%s%s", settings->name, tmp );
362 * Parse settings block name
365 * @v get_child Function to find or create child settings block
366 * @ret settings Settings block, or NULL
368 static struct settings *
369 parse_settings_name ( const char *name, get_child_settings_t get_child ) {
370 struct settings *settings = &settings_root;
371 char name_copy[ strlen ( name ) + 1 ];
375 /* Create modifiable copy of name */
376 memcpy ( name_copy, name, sizeof ( name_copy ) );
377 remainder = name_copy;
379 /* Parse each name component in turn */
380 while ( remainder ) {
382 remainder = strchr ( subname, '.' );
384 *(remainder++) = '\0';
385 settings = get_child ( settings, subname );
394 * Find settings block
397 * @ret settings Settings block, or NULL
399 struct settings * find_settings ( const char *name ) {
401 return parse_settings_name ( name, find_child_settings );
407 * @ret rc Return status code
409 static int apply_settings ( void ) {
410 struct settings_applicator *applicator;
413 /* Call all settings applicators */
414 for_each_table_entry ( applicator, SETTINGS_APPLICATORS ) {
415 if ( ( rc = applicator->apply() ) != 0 ) {
416 DBG ( "Could not apply settings using applicator "
417 "%p: %s\n", applicator, strerror ( rc ) );
426 * Reprioritise settings
428 * @v settings Settings block
430 * Reorders the settings block amongst its siblings according to its
433 static void reprioritise_settings ( struct settings *settings ) {
434 struct settings *parent = settings->parent;
436 struct settings *tmp;
439 /* Stop when we reach the top of the tree */
443 /* Read priority, if present */
444 priority = fetch_intz_setting ( settings, &priority_setting );
446 /* Remove from siblings list */
447 list_del ( &settings->siblings );
449 /* Reinsert after any existing blocks which have a higher priority */
450 list_for_each_entry ( tmp, &parent->children, siblings ) {
451 tmp_priority = fetch_intz_setting ( tmp, &priority_setting );
452 if ( priority > tmp_priority )
455 list_add_tail ( &settings->siblings, &tmp->siblings );
457 /* Recurse up the tree */
458 reprioritise_settings ( parent );
462 * Register settings block
464 * @v settings Settings block
465 * @v parent Parent settings block, or NULL
466 * @v name Settings block name
467 * @ret rc Return status code
469 int register_settings ( struct settings *settings, struct settings *parent,
471 struct settings *old_settings;
474 assert ( settings != NULL );
476 /* Find target parent settings block */
477 parent = settings_target ( parent );
479 /* Apply settings block name */
480 settings->name = name;
482 /* Remove any existing settings with the same name */
483 if ( ( old_settings = find_child_settings ( parent, settings->name ) ))
484 unregister_settings ( old_settings );
486 /* Add to list of settings */
487 ref_get ( settings->refcnt );
488 ref_get ( parent->refcnt );
489 settings->parent = parent;
490 list_add_tail ( &settings->siblings, &parent->children );
491 DBGC ( settings, "Settings %p (\"%s\") registered\n",
492 settings, settings_name ( settings ) );
494 /* Fix up settings priority */
495 reprioritise_settings ( settings );
497 /* Apply potentially-updated settings */
504 * Unregister settings block
506 * @v settings Settings block
508 void unregister_settings ( struct settings *settings ) {
509 struct settings *child;
511 /* Unregister child settings */
512 while ( ( child = list_first_entry ( &settings->children,
513 struct settings, siblings ) ) ) {
514 unregister_settings ( child );
517 DBGC ( settings, "Settings %p (\"%s\") unregistered\n",
518 settings, settings_name ( settings ) );
520 /* Remove from list of settings */
521 ref_put ( settings->parent->refcnt );
522 settings->parent = NULL;
523 list_del ( &settings->siblings );
524 ref_put ( settings->refcnt );
526 /* Apply potentially-updated settings */
530 /******************************************************************************
532 * Core settings routines
534 ******************************************************************************
538 * Redirect to target settings block
540 * @v settings Settings block, or NULL
541 * @ret settings Underlying settings block
543 struct settings * settings_target ( struct settings *settings ) {
545 /* NULL settings implies the global settings root */
547 settings = &settings_root;
549 /* Redirect to underlying settings block, if applicable */
550 if ( settings->op->redirect )
551 return settings->op->redirect ( settings );
553 /* Otherwise, return this settings block */
558 * Check applicability of setting
560 * @v settings Settings block
562 * @ret applies Setting applies within this settings block
564 int setting_applies ( struct settings *settings,
565 const struct setting *setting ) {
567 /* Find target settings block */
568 settings = settings_target ( settings );
570 /* Check applicability of setting */
571 return ( settings->op->applies ?
572 settings->op->applies ( settings, setting ) : 1 );
576 * Find setting applicable to settings block, if any
578 * @v settings Settings block
580 * @ret setting Applicable setting, if any
582 static const struct setting *
583 applicable_setting ( struct settings *settings, const struct setting *setting ){
584 const struct setting *applicable;
586 /* If setting is already applicable, use it */
587 if ( setting_applies ( settings, setting ) )
590 /* Otherwise, look for a matching predefined setting which does apply */
591 for_each_table_entry ( applicable, SETTINGS ) {
592 if ( ( setting_cmp ( setting, applicable ) == 0 ) &&
593 ( setting_applies ( settings, applicable ) ) )
601 * Store value of setting
603 * @v settings Settings block, or NULL
604 * @v setting Setting to store
605 * @v data Setting data, or NULL to clear setting
606 * @v len Length of setting data
607 * @ret rc Return status code
609 int store_setting ( struct settings *settings, const struct setting *setting,
610 const void *data, size_t len ) {
613 /* Find target settings block */
614 settings = settings_target ( settings );
616 /* Fail if setting does not apply to this settings block */
617 if ( ! setting_applies ( settings, setting ) )
621 if ( ! settings->op->store )
625 if ( ( rc = settings->op->store ( settings, setting,
629 /* Reprioritise settings if necessary */
630 if ( setting_cmp ( setting, &priority_setting ) == 0 )
631 reprioritise_settings ( settings );
633 /* If these settings are registered, apply potentially-updated
636 for ( ; settings ; settings = settings->parent ) {
637 if ( settings == &settings_root ) {
638 if ( ( rc = apply_settings() ) != 0 )
650 * @v settings Settings block, or NULL to search all blocks
651 * @v setting Setting to fetch
652 * @v origin Origin of setting to fill in, or NULL
653 * @v fetched Fetched setting to fill in, or NULL
654 * @v data Buffer to fill with setting data
655 * @v len Length of buffer
656 * @ret len Length of setting data, or negative error
658 * The actual length of the setting will be returned even if
659 * the buffer was too small.
661 int fetch_setting ( struct settings *settings, const struct setting *setting,
662 struct settings **origin, struct setting *fetched,
663 void *data, size_t len ) {
664 const struct setting *applicable;
665 struct settings *child;
669 /* Avoid returning uninitialised data on error */
670 memset ( data, 0, len );
674 memcpy ( fetched, setting, sizeof ( *fetched ) );
676 /* Find target settings block */
677 settings = settings_target ( settings );
680 if ( ! settings->op->fetch )
683 /* Try this block first, if an applicable setting exists */
684 if ( ( applicable = applicable_setting ( settings, setting ) ) ) {
686 /* Create modifiable copy of setting */
687 memcpy ( &tmp, applicable, sizeof ( tmp ) );
688 if ( ( ret = settings->op->fetch ( settings, &tmp,
689 data, len ) ) >= 0 ) {
691 /* Default to string type, if not yet specified */
693 tmp.type = &setting_type_string;
695 /* Record origin, if applicable */
699 /* Record fetched setting, if applicable */
701 memcpy ( fetched, &tmp, sizeof ( *fetched ) );
707 /* Recurse into each child block in turn */
708 list_for_each_entry ( child, &settings->children, siblings ) {
709 if ( ( ret = fetch_setting ( child, setting, origin, fetched,
718 * Fetch allocated copy of setting
720 * @v settings Settings block, or NULL to search all blocks
721 * @v setting Setting to fetch
722 * @v origin Origin of setting to fill in, or NULL
723 * @v fetched Fetched setting to fill in, or NULL
724 * @v data Buffer to allocate and fill with setting data
725 * @v alloc Allocation function
726 * @ret len Length of setting, or negative error
728 * The caller is responsible for eventually freeing the allocated
731 static int fetch_setting_alloc ( struct settings *settings,
732 const struct setting *setting,
733 struct settings **origin,
734 struct setting *fetched,
736 void * ( * alloc ) ( size_t len ) ) {
737 struct settings *tmp_origin;
738 struct setting tmp_fetched;
742 /* Use local buffers if necessary */
744 origin = &tmp_origin;
746 fetched = &tmp_fetched;
748 /* Avoid returning uninitialised data on error */
751 /* Check existence, and fetch setting length */
752 len = fetch_setting ( settings, setting, origin, fetched, NULL, 0 );
756 /* Allocate buffer */
757 *data = alloc ( len );
761 /* Fetch setting value */
762 check_len = fetch_setting ( *origin, fetched, NULL, NULL, *data, len );
763 assert ( check_len == len );
768 * Fetch copy of setting
770 * @v settings Settings block, or NULL to search all blocks
771 * @v setting Setting to fetch
772 * @v origin Origin of setting to fill in, or NULL
773 * @v fetched Fetched setting to fill in, or NULL
774 * @v data Buffer to allocate and fill with setting data
775 * @ret len Length of setting, or negative error
777 * The caller is responsible for eventually freeing the allocated
780 int fetch_setting_copy ( struct settings *settings,
781 const struct setting *setting,
782 struct settings **origin, struct setting *fetched,
785 return fetch_setting_alloc ( settings, setting, origin, fetched,
790 * Fetch value of setting
792 * @v settings Settings block, or NULL to search all blocks
793 * @v setting Setting to fetch
794 * @v data Buffer to fill with setting string data
795 * @v len Length of buffer
796 * @ret len Length of setting, or negative error
798 int fetch_raw_setting ( struct settings *settings,
799 const struct setting *setting,
800 void *data, size_t len ) {
802 return fetch_setting ( settings, setting, NULL, NULL, data, len );
806 * Fetch value of setting
808 * @v settings Settings block, or NULL to search all blocks
809 * @v setting Setting to fetch
810 * @v data Buffer to allocate and fill with setting data
811 * @ret len Length of setting, or negative error
813 * The caller is responsible for eventually freeing the allocated
816 int fetch_raw_setting_copy ( struct settings *settings,
817 const struct setting *setting,
820 return fetch_setting_copy ( settings, setting, NULL, NULL, data );
824 * Fetch value of string setting
826 * @v settings Settings block, or NULL to search all blocks
827 * @v setting Setting to fetch
828 * @v data Buffer to fill with setting string data
829 * @v len Length of buffer
830 * @ret len Length of string setting, or negative error
832 * The resulting string is guaranteed to be correctly NUL-terminated.
833 * The returned length will be the length of the underlying setting
836 int fetch_string_setting ( struct settings *settings,
837 const struct setting *setting,
838 char *data, size_t len ) {
840 memset ( data, 0, len );
841 return fetch_raw_setting ( settings, setting, data,
842 ( ( len > 0 ) ? ( len - 1 ) : 0 ) );
846 * Allocate memory for copy of string setting
848 * @v len Length of setting
849 * @ret ptr Allocated memory
851 static void * fetch_string_setting_copy_alloc ( size_t len ) {
852 return zalloc ( len + 1 /* NUL */ );
856 * Fetch value of string setting
858 * @v settings Settings block, or NULL to search all blocks
859 * @v setting Setting to fetch
860 * @v data Buffer to allocate and fill with setting string data
861 * @ret len Length of string setting, or negative error
863 * The resulting string is guaranteed to be correctly NUL-terminated.
864 * The returned length will be the length of the underlying setting
865 * data. The caller is responsible for eventually freeing the
868 int fetch_string_setting_copy ( struct settings *settings,
869 const struct setting *setting, char **data ) {
871 return fetch_setting_alloc ( settings, setting, NULL, NULL,
872 ( ( void ** ) data ),
873 fetch_string_setting_copy_alloc );
877 * Fetch value of IPv4 address setting
879 * @v settings Settings block, or NULL to search all blocks
880 * @v setting Setting to fetch
881 * @v inp IPv4 addresses to fill in
882 * @v count Maximum number of IPv4 addresses
883 * @ret len Length of setting, or negative error
885 int fetch_ipv4_array_setting ( struct settings *settings,
886 const struct setting *setting,
887 struct in_addr *inp, unsigned int count ) {
890 len = fetch_raw_setting ( settings, setting, inp,
891 ( sizeof ( *inp ) * count ) );
894 if ( ( len % sizeof ( *inp ) ) != 0 )
900 * Fetch value of IPv4 address setting
902 * @v settings Settings block, or NULL to search all blocks
903 * @v setting Setting to fetch
904 * @v inp IPv4 address to fill in
905 * @ret len Length of setting, or negative error
907 int fetch_ipv4_setting ( struct settings *settings,
908 const struct setting *setting,
909 struct in_addr *inp ) {
911 return fetch_ipv4_array_setting ( settings, setting, inp, 1 );
915 * Fetch value of IPv6 address setting
917 * @v settings Settings block, or NULL to search all blocks
918 * @v setting Setting to fetch
919 * @v inp IPv6 addresses to fill in
920 * @v count Maximum number of IPv6 addresses
921 * @ret len Length of setting, or negative error
923 int fetch_ipv6_array_setting ( struct settings *settings,
924 const struct setting *setting,
925 struct in6_addr *inp, unsigned int count ) {
928 len = fetch_raw_setting ( settings, setting, inp,
929 ( sizeof ( *inp ) * count ) );
932 if ( ( len % sizeof ( *inp ) ) != 0 )
938 * Fetch value of IPv6 address setting
940 * @v settings Settings block, or NULL to search all blocks
941 * @v setting Setting to fetch
942 * @v inp IPv6 address to fill in
943 * @ret len Length of setting, or negative error
945 int fetch_ipv6_setting ( struct settings *settings,
946 const struct setting *setting,
947 struct in6_addr *inp ) {
949 return fetch_ipv6_array_setting ( settings, setting, inp, 1 );
953 * Extract numeric value of setting
955 * @v is_signed Treat value as a signed integer
956 * @v raw Raw setting data
957 * @v len Length of raw setting data
958 * @ret value Numeric value
959 * @ret len Length of setting, or negative error
961 static int numeric_setting_value ( int is_signed, const void *raw, size_t len,
962 unsigned long *value ) {
963 const uint8_t *unsigned_bytes = raw;
964 const int8_t *signed_bytes = raw;
970 /* Convert to host-ordered longs */
971 is_negative = ( len && ( signed_bytes[0] < 0 ) );
972 *value = ( ( is_signed && is_negative ) ? -1L : 0 );
974 for ( i = 0 ; i < len ; i++ ) {
975 byte = unsigned_bytes[i];
976 *value = ( ( *value << 8 ) | byte );
977 if ( ( ( i + sizeof ( *value ) ) < len ) && ( byte != pad ) )
985 * Fetch value of numeric setting
987 * @v settings Settings block, or NULL to search all blocks
988 * @v setting Setting to fetch
989 * @v value Integer value to fill in
990 * @ret len Length of setting, or negative error
992 int fetch_numeric_setting ( struct settings *settings,
993 const struct setting *setting,
994 unsigned long *value, int is_signed ) {
998 /* Avoid returning uninitialised data on error */
1001 /* Fetch raw (network-ordered, variable-length) setting */
1002 len = fetch_raw_setting ( settings, setting, &tmp, sizeof ( tmp ) );
1006 /* Extract numeric value */
1007 return numeric_setting_value ( is_signed, &tmp, len, value );
1011 * Fetch value of signed integer setting
1013 * @v settings Settings block, or NULL to search all blocks
1014 * @v setting Setting to fetch
1015 * @v value Integer value to fill in
1016 * @ret len Length of setting, or negative error
1018 int fetch_int_setting ( struct settings *settings,
1019 const struct setting *setting,
1022 return fetch_numeric_setting ( settings, setting,
1023 ( ( unsigned long * ) value ), 1 );
1027 * Fetch value of unsigned integer setting
1029 * @v settings Settings block, or NULL to search all blocks
1030 * @v setting Setting to fetch
1031 * @v value Integer value to fill in
1032 * @ret len Length of setting, or negative error
1034 int fetch_uint_setting ( struct settings *settings,
1035 const struct setting *setting,
1036 unsigned long *value ) {
1038 return fetch_numeric_setting ( settings, setting, value, 0 );
1042 * Fetch value of signed integer setting, or zero
1044 * @v settings Settings block, or NULL to search all blocks
1045 * @v setting Setting to fetch
1046 * @ret value Setting value, or zero
1048 long fetch_intz_setting ( struct settings *settings,
1049 const struct setting *setting ) {
1050 unsigned long value;
1052 fetch_numeric_setting ( settings, setting, &value, 1 );
1057 * Fetch value of unsigned integer setting, or zero
1059 * @v settings Settings block, or NULL to search all blocks
1060 * @v setting Setting to fetch
1061 * @ret value Setting value, or zero
1063 unsigned long fetch_uintz_setting ( struct settings *settings,
1064 const struct setting *setting ) {
1065 unsigned long value;
1067 fetch_numeric_setting ( settings, setting, &value, 0 );
1072 * Fetch value of UUID setting
1074 * @v settings Settings block, or NULL to search all blocks
1075 * @v setting Setting to fetch
1076 * @v uuid UUID to fill in
1077 * @ret len Length of setting, or negative error
1079 int fetch_uuid_setting ( struct settings *settings,
1080 const struct setting *setting,
1081 union uuid *uuid ) {
1084 len = fetch_raw_setting ( settings, setting, uuid, sizeof ( *uuid ) );
1087 if ( len != sizeof ( *uuid ) )
1093 * Clear settings block
1095 * @v settings Settings block
1097 void clear_settings ( struct settings *settings ) {
1099 /* Find target settings block */
1100 settings = settings_target ( settings );
1102 /* Clear settings, if applicable */
1103 if ( settings->op->clear )
1104 settings->op->clear ( settings );
1108 * Compare two settings
1110 * @v a Setting to compare
1111 * @v b Setting to compare
1112 * @ret 0 Settings are the same
1113 * @ret non-zero Settings are not the same
1115 int setting_cmp ( const struct setting *a, const struct setting *b ) {
1117 /* If the settings have tags, compare them */
1118 if ( a->tag && ( a->tag == b->tag ) && ( a->scope == b->scope ) )
1121 /* Otherwise, if the settings have names, compare them */
1122 if ( a->name && b->name && a->name[0] )
1123 return strcmp ( a->name, b->name );
1125 /* Otherwise, return a non-match */
1129 /******************************************************************************
1131 * Formatted setting routines
1133 ******************************************************************************
1137 * Format setting value as a string
1139 * @v type Setting type
1140 * @v raw Raw setting value
1141 * @v raw_len Length of raw setting value
1142 * @v buf Buffer to contain formatted value
1143 * @v len Length of buffer
1144 * @ret len Length of formatted value, or negative error
1146 int setting_format ( const struct setting_type *type, const void *raw,
1147 size_t raw_len, char *buf, size_t len ) {
1150 if ( ! type->format )
1153 return type->format ( type, raw, raw_len, buf, len );
1157 * Parse formatted string to setting value
1159 * @v type Setting type
1160 * @v value Formatted setting value
1161 * @v buf Buffer to contain raw value
1162 * @v len Length of buffer
1163 * @ret len Length of raw value, or negative error
1165 int setting_parse ( const struct setting_type *type, const char *value,
1166 void *buf, size_t len ) {
1169 if ( ! type->parse )
1172 return type->parse ( type, value, buf, len );
1176 * Convert setting value to number
1178 * @v type Setting type
1179 * @v raw Raw setting value
1180 * @v raw_len Length of raw setting value
1181 * @ret value Numeric value
1182 * @ret rc Return status code
1184 int setting_numerate ( const struct setting_type *type, const void *raw,
1185 size_t raw_len, unsigned long *value ) {
1188 if ( ! type->numerate )
1191 return type->numerate ( type, raw, raw_len, value );
1195 * Convert number to setting value
1197 * @v type Setting type
1198 * @v value Numeric value
1199 * @v buf Buffer to contain raw value
1200 * @v len Length of buffer
1201 * @ret len Length of raw value, or negative error
1203 int setting_denumerate ( const struct setting_type *type, unsigned long value,
1204 void *buf, size_t len ) {
1207 if ( ! type->denumerate )
1210 return type->denumerate ( type, value, buf, len );
1214 * Fetch formatted value of setting
1216 * @v settings Settings block, or NULL to search all blocks
1217 * @v setting Setting to fetch
1218 * @v origin Origin of setting to fill in, or NULL
1219 * @v fetched Fetched setting to fill in, or NULL
1220 * @v buf Buffer to contain formatted value
1221 * @v len Length of buffer
1222 * @ret len Length of formatted value, or negative error
1224 int fetchf_setting ( struct settings *settings, const struct setting *setting,
1225 struct settings **origin, struct setting *fetched,
1226 char *buf, size_t len ) {
1227 struct setting tmp_fetched;
1232 /* Use local buffers if necessary */
1234 fetched = &tmp_fetched;
1236 /* Fetch raw value */
1237 raw_len = fetch_setting_copy ( settings, setting, origin, fetched,
1239 if ( raw_len < 0 ) {
1241 goto err_fetch_copy;
1245 assert ( fetched->type != NULL );
1247 /* Format setting */
1248 if ( ( ret = setting_format ( fetched->type, raw, raw_len, buf,
1259 * Fetch copy of formatted value of setting
1261 * @v settings Settings block, or NULL to search all blocks
1262 * @v setting Setting to fetch
1263 * @v origin Origin of setting to fill in, or NULL
1264 * @v fetched Fetched setting to fill in, or NULL
1265 * @v value Buffer to allocate and fill with formatted value
1266 * @ret len Length of formatted value, or negative error
1268 * The caller is responsible for eventually freeing the allocated
1271 int fetchf_setting_copy ( struct settings *settings,
1272 const struct setting *setting,
1273 struct settings **origin, struct setting *fetched,
1275 struct settings *tmp_origin;
1276 struct setting tmp_fetched;
1280 /* Use local buffers if necessary */
1282 origin = &tmp_origin;
1284 fetched = &tmp_fetched;
1286 /* Avoid returning uninitialised data on error */
1289 /* Check existence, and fetch formatted value length */
1290 len = fetchf_setting ( settings, setting, origin, fetched, NULL, 0 );
1294 /* Allocate buffer */
1295 *value = zalloc ( len + 1 /* NUL */ );
1299 /* Fetch formatted value */
1300 check_len = fetchf_setting ( *origin, fetched, NULL, NULL, *value,
1301 ( len + 1 /* NUL */ ) );
1302 assert ( check_len == len );
1307 * Store formatted value of setting
1309 * @v settings Settings block
1310 * @v setting Setting to store
1311 * @v value Formatted setting data, or NULL
1312 * @ret rc Return status code
1314 int storef_setting ( struct settings *settings, const struct setting *setting,
1315 const char *value ) {
1321 /* NULL value or empty string implies deletion */
1322 if ( ( ! value ) || ( ! value[0] ) )
1323 return delete_setting ( settings, setting );
1326 assert ( setting->type != NULL );
1328 /* Get raw value length */
1329 raw_len = setting_parse ( setting->type, value, NULL, 0 );
1330 if ( raw_len < 0 ) {
1335 /* Allocate buffer for raw value */
1336 raw = malloc ( raw_len );
1342 /* Parse formatted value */
1343 check_len = setting_parse ( setting->type, value, raw, raw_len );
1344 assert ( check_len == raw_len );
1346 /* Store raw value */
1347 if ( ( rc = store_setting ( settings, setting, raw, raw_len ) ) != 0 )
1358 * Fetch numeric value of setting
1360 * @v settings Settings block, or NULL to search all blocks
1361 * @v setting Setting to fetch
1362 * @v origin Origin of setting to fill in, or NULL
1363 * @v fetched Fetched setting to fill in, or NULL
1364 * @v value Numeric value to fill in
1365 * @ret rc Return status code
1367 int fetchn_setting ( struct settings *settings, const struct setting *setting,
1368 struct settings **origin, struct setting *fetched,
1369 unsigned long *value ) {
1370 struct setting tmp_fetched;
1375 /* Use local buffers if necessary */
1377 fetched = &tmp_fetched;
1379 /* Fetch raw value */
1380 raw_len = fetch_setting_copy ( settings, setting, origin, fetched,
1382 if ( raw_len < 0 ) {
1384 goto err_fetch_copy;
1388 assert ( fetched->type != NULL );
1390 /* Numerate setting */
1391 if ( ( rc = setting_numerate ( fetched->type, raw, raw_len,
1402 * Store numeric value of setting
1404 * @v settings Settings block
1405 * @v setting Setting
1406 * @v value Numeric value
1407 * @ret rc Return status code
1409 int storen_setting ( struct settings *settings, const struct setting *setting,
1410 unsigned long value ) {
1417 assert ( setting->type != NULL );
1419 /* Get raw value length */
1420 raw_len = setting_denumerate ( setting->type, value, NULL, 0 );
1421 if ( raw_len < 0 ) {
1426 /* Allocate buffer for raw value */
1427 raw = malloc ( raw_len );
1433 /* Denumerate value */
1434 check_len = setting_denumerate ( setting->type, value, raw, raw_len );
1435 assert ( check_len == raw_len );
1437 /* Store raw value */
1438 if ( ( rc = store_setting ( settings, setting, raw, raw_len ) ) != 0 )
1448 /******************************************************************************
1452 ******************************************************************************
1456 * Find predefined setting
1459 * @ret setting Setting, or NULL
1461 struct setting * find_setting ( const char *name ) {
1462 struct setting *setting;
1464 for_each_table_entry ( setting, SETTINGS ) {
1465 if ( strcmp ( name, setting->name ) == 0 )
1472 * Parse setting name as tag number
1475 * @ret tag Tag number, or 0 if not a valid number
1477 static unsigned int parse_setting_tag ( const char *name ) {
1478 char *tmp = ( ( char * ) name );
1479 unsigned int tag = 0;
1482 tag = ( ( tag << 8 ) | strtoul ( tmp, &tmp, 0 ) );
1495 * @ret type Setting type, or NULL
1497 static const struct setting_type * find_setting_type ( const char *name ) {
1498 const struct setting_type *type;
1500 for_each_table_entry ( type, SETTING_TYPES ) {
1501 if ( strcmp ( name, type->name ) == 0 )
1508 * Parse setting name
1510 * @v name Name of setting
1511 * @v get_child Function to find or create child settings block
1512 * @v settings Settings block to fill in
1513 * @v setting Setting to fill in
1514 * @ret rc Return status code
1516 * Interprets a name of the form
1517 * "[settings_name/]tag_name[:type_name]" and fills in the appropriate
1520 * Note that on success, this function will have modified the original
1523 int parse_setting_name ( char *name, get_child_settings_t get_child,
1524 struct settings **settings, struct setting *setting ) {
1525 char *settings_name;
1528 struct setting *predefined;
1532 *settings = &settings_root;
1533 memset ( setting, 0, sizeof ( *setting ) );
1536 /* Split name into "[settings_name/]setting_name[:type_name]" */
1537 if ( ( setting_name = strchr ( name, '/' ) ) != NULL ) {
1538 *(setting_name++) = 0;
1539 settings_name = name;
1541 setting_name = name;
1542 settings_name = NULL;
1544 if ( ( type_name = strchr ( setting_name, ':' ) ) != NULL )
1547 /* Identify settings block, if specified */
1548 if ( settings_name ) {
1549 *settings = parse_settings_name ( settings_name, get_child );
1550 if ( *settings == NULL ) {
1551 DBG ( "Unrecognised settings block \"%s\" in \"%s\"\n",
1552 settings_name, name );
1558 /* Identify setting */
1559 setting->tag = parse_setting_tag ( setting_name );
1560 setting->scope = (*settings)->default_scope;
1561 setting->name = setting_name;
1562 for_each_table_entry ( predefined, SETTINGS ) {
1563 /* Matches a predefined setting; use that setting */
1564 if ( setting_cmp ( predefined, setting ) == 0 ) {
1565 memcpy ( setting, predefined, sizeof ( *setting ) );
1570 /* Identify setting type, if specified */
1572 setting->type = find_setting_type ( type_name );
1573 if ( setting->type == NULL ) {
1574 DBG ( "Invalid setting type \"%s\" in \"%s\"\n",
1584 /* Restore original name */
1585 if ( settings_name )
1586 *( setting_name - 1 ) = '/';
1588 *( type_name - 1 ) = ':';
1593 * Return full setting name
1595 * @v settings Settings block, or NULL
1596 * @v setting Setting
1598 * @v len Length of buffer
1599 * @ret len Length of setting name, or negative error
1601 int setting_name ( struct settings *settings, const struct setting *setting,
1602 char *buf, size_t len ) {
1605 settings = settings_target ( settings );
1606 name = settings_name ( settings );
1607 return snprintf ( buf, len, "%s%s%s:%s", name, ( name[0] ? "/" : "" ),
1608 setting->name, setting->type->name );
1611 /******************************************************************************
1615 ******************************************************************************
1619 * Parse string setting value
1621 * @v type Setting type
1622 * @v value Formatted setting value
1623 * @v buf Buffer to contain raw value
1624 * @v len Length of buffer
1625 * @ret len Length of raw value, or negative error
1627 static int parse_string_setting ( const struct setting_type *type __unused,
1628 const char *value, void *buf, size_t len ) {
1629 size_t raw_len = strlen ( value ); /* Exclude terminating NUL */
1631 /* Copy string to buffer */
1632 if ( len > raw_len )
1634 memcpy ( buf, value, len );
1640 * Format string setting value
1642 * @v type Setting type
1643 * @v raw Raw setting value
1644 * @v raw_len Length of raw setting value
1645 * @v buf Buffer to contain formatted value
1646 * @v len Length of buffer
1647 * @ret len Length of formatted value, or negative error
1649 static int format_string_setting ( const struct setting_type *type __unused,
1650 const void *raw, size_t raw_len, char *buf,
1653 /* Copy string to buffer, and terminate */
1654 memset ( buf, 0, len );
1655 if ( len > raw_len )
1657 memcpy ( buf, raw, len );
1662 /** A string setting type */
1663 const struct setting_type setting_type_string __setting_type = {
1665 .parse = parse_string_setting,
1666 .format = format_string_setting,
1669 /** A URI-encoded string setting type
1671 * This setting type is obsolete; the name ":uristring" is retained to
1672 * avoid breaking existing scripts.
1674 const struct setting_type setting_type_uristring __setting_type = {
1675 .name = "uristring",
1676 .parse = parse_string_setting,
1677 .format = format_string_setting,
1681 * Parse IPv4 address setting value (when IPv4 support is not present)
1683 * @v type Setting type
1684 * @v value Formatted setting value
1685 * @v buf Buffer to contain raw value
1686 * @v len Length of buffer
1687 * @ret len Length of raw value, or negative error
1689 __weak int parse_ipv4_setting ( const struct setting_type *type __unused,
1690 const char *value __unused, void *buf __unused,
1691 size_t len __unused ) {
1696 * Format IPv4 address setting value (when IPv4 support is not present)
1698 * @v type Setting type
1699 * @v raw Raw setting value
1700 * @v raw_len Length of raw setting value
1701 * @v buf Buffer to contain formatted value
1702 * @v len Length of buffer
1703 * @ret len Length of formatted value, or negative error
1705 __weak int format_ipv4_setting ( const struct setting_type *type __unused,
1706 const void *raw __unused,
1707 size_t raw_len __unused, char *buf __unused,
1708 size_t len __unused ) {
1712 /** An IPv4 address setting type */
1713 const struct setting_type setting_type_ipv4 __setting_type = {
1715 .parse = parse_ipv4_setting,
1716 .format = format_ipv4_setting,
1720 * Parse IPv6 address setting value (when IPv6 support is not present)
1722 * @v type Setting type
1723 * @v value Formatted setting value
1724 * @v buf Buffer to contain raw value
1725 * @v len Length of buffer
1726 * @ret len Length of raw value, or negative error
1728 __weak int parse_ipv6_setting ( const struct setting_type *type __unused,
1729 const char *value __unused, void *buf __unused,
1730 size_t len __unused ) {
1735 * Format IPv6 address setting value (when IPv6 support is not present)
1737 * @v type Setting type
1738 * @v raw Raw setting value
1739 * @v raw_len Length of raw setting value
1740 * @v buf Buffer to contain formatted value
1741 * @v len Length of buffer
1742 * @ret len Length of formatted value, or negative error
1744 __weak int format_ipv6_setting ( const struct setting_type *type __unused,
1745 const void *raw __unused,
1746 size_t raw_len __unused, char *buf __unused,
1747 size_t len __unused ) {
1751 /** An IPv6 address setting type */
1752 const struct setting_type setting_type_ipv6 __setting_type = {
1754 .parse = parse_ipv6_setting,
1755 .format = format_ipv6_setting,
1758 /** IPv6 settings scope */
1759 const struct settings_scope ipv6_scope;
1762 * Integer setting type indices
1764 * These indexes are defined such that (1<<index) gives the width of
1765 * the integer, in bytes.
1767 enum setting_type_int_index {
1768 SETTING_TYPE_INT8 = 0,
1769 SETTING_TYPE_INT16 = 1,
1770 SETTING_TYPE_INT32 = 2,
1774 * Integer setting type names
1776 * These names exist as a static array in order to allow the type's
1777 * integer size and signedness to be determined from the type's name.
1778 * Note that there are no separate entries for the signed integer
1779 * types: the name pointers simply point to the second character of
1780 * the relevant string.
1782 static const char setting_type_int_name[][8] = {
1783 [SETTING_TYPE_INT8] = "uint8",
1784 [SETTING_TYPE_INT16] = "uint16",
1785 [SETTING_TYPE_INT32] = "uint32",
1789 * Get unsigned integer setting type name
1791 * @v index Integer setting type index
1792 * @ret name Setting type name
1794 #define SETTING_TYPE_UINT_NAME( index ) setting_type_int_name[index]
1797 * Get signed integer setting type name
1799 * @v index Integer setting type index
1800 * @ret name Setting type name
1802 #define SETTING_TYPE_INT_NAME( index ) ( setting_type_int_name[index] + 1 )
1805 * Get integer setting type index
1807 * @v type Setting type
1808 * @ret index Integer setting type index
1810 static unsigned int setting_type_int_index ( const struct setting_type *type ) {
1812 return ( ( type->name - setting_type_int_name[0] ) /
1813 sizeof ( setting_type_int_name[0] ) );
1817 * Get integer setting type width
1819 * @v type Setting type
1820 * @ret index Integer setting type width
1822 static unsigned int setting_type_int_width ( const struct setting_type *type ) {
1824 return ( 1 << setting_type_int_index ( type ) );
1828 * Get integer setting type signedness
1830 * @v type Setting type
1831 * @ret is_signed Integer setting type is signed
1833 static int setting_type_int_is_signed ( const struct setting_type *type ) {
1834 return ( ( type->name - setting_type_int_name[0] ) & 1 );
1838 * Convert number to setting value
1840 * @v type Setting type
1841 * @v value Numeric value
1842 * @v buf Buffer to contain raw value
1843 * @v len Length of buffer
1844 * @ret len Length of raw value, or negative error
1846 static int denumerate_int_setting ( const struct setting_type *type,
1847 unsigned long value, void *buf,
1849 unsigned int size = setting_type_int_width ( type );
1855 u.num = htonl ( value );
1858 memcpy ( buf, &u.bytes[ sizeof ( u ) - size ], len );
1864 * Convert setting value to number
1866 * @v type Setting type
1867 * @v raw Raw setting value
1868 * @v raw_len Length of raw setting value
1869 * @v value Numeric value to fill in
1870 * @ret rc Return status code
1872 static int numerate_int_setting ( const struct setting_type *type,
1873 const void *raw, size_t raw_len,
1874 unsigned long *value ) {
1875 int is_signed = setting_type_int_is_signed ( type );
1878 /* Extract numeric value */
1879 check_len = numeric_setting_value ( is_signed, raw, raw_len, value );
1880 if ( check_len < 0 )
1882 assert ( check_len == ( int ) raw_len );
1888 * Parse integer setting value
1890 * @v type Setting type
1891 * @v value Formatted setting value
1892 * @v buf Buffer to contain raw value
1893 * @v len Length of buffer
1894 * @ret len Length of raw value, or negative error
1896 static int parse_int_setting ( const struct setting_type *type,
1897 const char *value, void *buf, size_t len ) {
1899 unsigned long num_value;
1902 num_value = strtoul ( value, &endp, 0 );
1906 return type->denumerate ( type, num_value, buf, len );
1910 * Format signed integer setting value
1912 * @v type Setting type
1913 * @v raw Raw setting value
1914 * @v raw_len Length of raw setting value
1915 * @v buf Buffer to contain formatted value
1916 * @v len Length of buffer
1917 * @ret len Length of formatted value, or negative error
1919 static int format_int_setting ( const struct setting_type *type,
1920 const void *raw, size_t raw_len,
1921 char *buf, size_t len ) {
1922 unsigned long value;
1925 /* Extract numeric value */
1926 if ( ( ret = type->numerate ( type, raw, raw_len, &value ) ) < 0 )
1930 return snprintf ( buf, len, "%ld", value );
1934 * Format unsigned integer setting value
1936 * @v type Setting type
1937 * @v raw Raw setting value
1938 * @v raw_len Length of raw setting value
1939 * @v buf Buffer to contain formatted value
1940 * @v len Length of buffer
1941 * @ret len Length of formatted value, or negative error
1943 static int format_uint_setting ( const struct setting_type *type,
1944 const void *raw, size_t raw_len,
1945 char *buf, size_t len ) {
1946 unsigned long value;
1949 /* Extract numeric value */
1950 if ( ( ret = type->numerate ( type, raw, raw_len, &value ) ) < 0 )
1954 return snprintf ( buf, len, "%#lx", value );
1958 * Define a signed integer setting type
1960 * @v index Integer setting type index
1961 * @ret type Setting type
1963 #define SETTING_TYPE_INT( index ) { \
1964 .name = SETTING_TYPE_INT_NAME ( index ), \
1965 .parse = parse_int_setting, \
1966 .format = format_int_setting, \
1967 .denumerate = denumerate_int_setting, \
1968 .numerate = numerate_int_setting, \
1972 * Define an unsigned integer setting type
1974 * @v index Integer setting type index
1975 * @ret type Setting type
1977 #define SETTING_TYPE_UINT( index ) { \
1978 .name = SETTING_TYPE_UINT_NAME ( index ), \
1979 .parse = parse_int_setting, \
1980 .format = format_uint_setting, \
1981 .denumerate = denumerate_int_setting, \
1982 .numerate = numerate_int_setting, \
1985 /** A signed 8-bit integer setting type */
1986 const struct setting_type setting_type_int8 __setting_type =
1987 SETTING_TYPE_INT ( SETTING_TYPE_INT8 );
1989 /** A signed 16-bit integer setting type */
1990 const struct setting_type setting_type_int16 __setting_type =
1991 SETTING_TYPE_INT ( SETTING_TYPE_INT16 );
1993 /** A signed 32-bit integer setting type */
1994 const struct setting_type setting_type_int32 __setting_type =
1995 SETTING_TYPE_INT ( SETTING_TYPE_INT32 );
1997 /** An unsigned 8-bit integer setting type */
1998 const struct setting_type setting_type_uint8 __setting_type =
1999 SETTING_TYPE_UINT ( SETTING_TYPE_INT8 );
2001 /** An unsigned 16-bit integer setting type */
2002 const struct setting_type setting_type_uint16 __setting_type =
2003 SETTING_TYPE_UINT ( SETTING_TYPE_INT16 );
2005 /** An unsigned 32-bit integer setting type */
2006 const struct setting_type setting_type_uint32 __setting_type =
2007 SETTING_TYPE_UINT ( SETTING_TYPE_INT32 );
2010 * Parse hex string setting value (using colon delimiter)
2012 * @v type Setting type
2013 * @v value Formatted setting value
2014 * @v buf Buffer to contain raw value
2015 * @v len Length of buffer
2016 * @v size Integer size, in bytes
2017 * @ret len Length of raw value, or negative error
2019 static int parse_hex_setting ( const struct setting_type *type __unused,
2020 const char *value, void *buf, size_t len ) {
2021 return hex_decode ( ':', value, buf, len );
2025 * Format hex string setting value (using colon delimiter)
2027 * @v type Setting type
2028 * @v raw Raw setting value
2029 * @v raw_len Length of raw setting value
2030 * @v buf Buffer to contain formatted value
2031 * @v len Length of buffer
2032 * @ret len Length of formatted value, or negative error
2034 static int format_hex_colon_setting ( const struct setting_type *type __unused,
2035 const void *raw, size_t raw_len,
2036 char *buf, size_t len ) {
2037 return hex_encode ( ':', raw, raw_len, buf, len );
2041 * Parse hex string setting value (using hyphen delimiter)
2043 * @v type Setting type
2044 * @v value Formatted setting value
2045 * @v buf Buffer to contain raw value
2046 * @v len Length of buffer
2047 * @v size Integer size, in bytes
2048 * @ret len Length of raw value, or negative error
2050 static int parse_hex_hyphen_setting ( const struct setting_type *type __unused,
2051 const char *value, void *buf,
2053 return hex_decode ( '-', value, buf, len );
2057 * Format hex string setting value (using hyphen delimiter)
2059 * @v type Setting type
2060 * @v raw Raw setting value
2061 * @v raw_len Length of raw setting value
2062 * @v buf Buffer to contain formatted value
2063 * @v len Length of buffer
2064 * @ret len Length of formatted value, or negative error
2066 static int format_hex_hyphen_setting ( const struct setting_type *type __unused,
2067 const void *raw, size_t raw_len,
2068 char *buf, size_t len ) {
2069 return hex_encode ( '-', raw, raw_len, buf, len );
2073 * Parse hex string setting value (using no delimiter)
2075 * @v type Setting type
2076 * @v value Formatted setting value
2077 * @v buf Buffer to contain raw value
2078 * @v len Length of buffer
2079 * @v size Integer size, in bytes
2080 * @ret len Length of raw value, or negative error
2082 static int parse_hex_raw_setting ( const struct setting_type *type __unused,
2083 const char *value, void *buf, size_t len ) {
2084 return hex_decode ( 0, value, buf, len );
2088 * Format hex string setting value (using no delimiter)
2090 * @v type Setting type
2091 * @v raw Raw setting value
2092 * @v raw_len Length of raw setting value
2093 * @v buf Buffer to contain formatted value
2094 * @v len Length of buffer
2095 * @ret len Length of formatted value, or negative error
2097 static int format_hex_raw_setting ( const struct setting_type *type __unused,
2098 const void *raw, size_t raw_len,
2099 char *buf, size_t len ) {
2100 return hex_encode ( 0, raw, raw_len, buf, len );
2103 /** A hex-string setting (colon-delimited) */
2104 const struct setting_type setting_type_hex __setting_type = {
2106 .parse = parse_hex_setting,
2107 .format = format_hex_colon_setting,
2110 /** A hex-string setting (hyphen-delimited) */
2111 const struct setting_type setting_type_hexhyp __setting_type = {
2113 .parse = parse_hex_hyphen_setting,
2114 .format = format_hex_hyphen_setting,
2117 /** A hex-string setting (non-delimited) */
2118 const struct setting_type setting_type_hexraw __setting_type = {
2120 .parse = parse_hex_raw_setting,
2121 .format = format_hex_raw_setting,
2125 * Parse Base64-encoded setting value
2127 * @v type Setting type
2128 * @v value Formatted setting value
2129 * @v buf Buffer to contain raw value
2130 * @v len Length of buffer
2131 * @v size Integer size, in bytes
2132 * @ret len Length of raw value, or negative error
2134 static int parse_base64_setting ( const struct setting_type *type __unused,
2135 const char *value, void *buf, size_t len ) {
2137 return base64_decode ( value, buf, len );
2141 * Format Base64-encoded setting value
2143 * @v type Setting type
2144 * @v raw Raw setting value
2145 * @v raw_len Length of raw setting value
2146 * @v buf Buffer to contain formatted value
2147 * @v len Length of buffer
2148 * @ret len Length of formatted value, or negative error
2150 static int format_base64_setting ( const struct setting_type *type __unused,
2151 const void *raw, size_t raw_len,
2152 char *buf, size_t len ) {
2154 return base64_encode ( raw, raw_len, buf, len );
2157 /** A Base64-encoded setting */
2158 const struct setting_type setting_type_base64 __setting_type = {
2160 .parse = parse_base64_setting,
2161 .format = format_base64_setting,
2165 * Format UUID setting value
2167 * @v type Setting type
2168 * @v raw Raw setting value
2169 * @v raw_len Length of raw setting value
2170 * @v buf Buffer to contain formatted value
2171 * @v len Length of buffer
2172 * @ret len Length of formatted value, or negative error
2174 static int format_uuid_setting ( const struct setting_type *type __unused,
2175 const void *raw, size_t raw_len, char *buf,
2177 const union uuid *uuid = raw;
2180 if ( raw_len != sizeof ( *uuid ) )
2184 return snprintf ( buf, len, "%s", uuid_ntoa ( uuid ) );
2187 /** UUID setting type */
2188 const struct setting_type setting_type_uuid __setting_type = {
2190 .format = format_uuid_setting,
2194 * Format PCI bus:dev.fn setting value
2196 * @v type Setting type
2197 * @v raw Raw setting value
2198 * @v raw_len Length of raw setting value
2199 * @v buf Buffer to contain formatted value
2200 * @v len Length of buffer
2201 * @ret len Length of formatted value, or negative error
2203 static int format_busdevfn_setting ( const struct setting_type *type __unused,
2204 const void *raw, size_t raw_len, char *buf,
2206 unsigned long busdevfn;
2209 /* Extract numeric value */
2210 check_len = numeric_setting_value ( 0, raw, raw_len, &busdevfn );
2211 if ( check_len < 0 )
2213 assert ( check_len == ( int ) raw_len );
2216 return snprintf ( buf, len, "%02lx:%02lx.%lx", PCI_BUS ( busdevfn ),
2217 PCI_SLOT ( busdevfn ), PCI_FUNC ( busdevfn ) );
2220 /** PCI bus:dev.fn setting type */
2221 const struct setting_type setting_type_busdevfn __setting_type = {
2223 .format = format_busdevfn_setting,
2226 /******************************************************************************
2230 ******************************************************************************
2234 * Expand variables within string
2237 * @ret expstr Expanded string
2239 * The expanded string is allocated with malloc() and the caller must
2240 * eventually free() it.
2242 char * expand_settings ( const char *string ) {
2243 struct settings *settings;
2244 struct setting setting;
2256 /* Obtain temporary modifiable copy of string */
2257 expstr = strdup ( string );
2261 /* Expand while expansions remain */
2266 /* Locate setting to be expanded */
2269 for ( tmp = expstr ; *tmp ; tmp++ ) {
2270 if ( ( tmp[0] == '$' ) && ( tmp[1] == '{' ) )
2272 if ( start && ( tmp[0] == '}' ) ) {
2280 name = ( start + 2 );
2284 /* Expand setting */
2285 if ( ( rc = parse_setting_name ( name, find_child_settings,
2287 &setting ) ) != 0 ) {
2288 /* Treat invalid setting names as empty */
2291 /* Fetch and format setting value. Ignore
2292 * errors; treat non-existent settings as empty.
2294 fetchf_setting_copy ( settings, &setting, NULL, NULL,
2298 /* Construct expanded string and discard old string */
2300 new_len = asprintf ( &expstr, "%s%s%s",
2301 head, ( value ? value : "" ), tail );
2311 /******************************************************************************
2315 ******************************************************************************
2318 /** Hostname setting */
2319 const struct setting hostname_setting __setting ( SETTING_HOST, hostname ) = {
2321 .description = "Host name",
2322 .tag = DHCP_HOST_NAME,
2323 .type = &setting_type_string,
2326 /** Domain name setting */
2327 const struct setting domain_setting __setting ( SETTING_IP_EXTRA, domain ) = {
2329 .description = "DNS domain",
2330 .tag = DHCP_DOMAIN_NAME,
2331 .type = &setting_type_string,
2334 /** TFTP server setting */
2335 const struct setting next_server_setting __setting ( SETTING_BOOT,next-server)={
2336 .name = "next-server",
2337 .description = "TFTP server",
2338 .tag = DHCP_EB_SIADDR,
2339 .type = &setting_type_ipv4,
2342 /** Filename setting */
2343 const struct setting filename_setting __setting ( SETTING_BOOT, filename ) = {
2345 .description = "Boot filename",
2346 .tag = DHCP_BOOTFILE_NAME,
2347 .type = &setting_type_string,
2350 /** Root path setting */
2351 const struct setting root_path_setting __setting ( SETTING_SANBOOT, root-path)={
2352 .name = "root-path",
2353 .description = "SAN root path",
2354 .tag = DHCP_ROOT_PATH,
2355 .type = &setting_type_string,
2358 /** Username setting */
2359 const struct setting username_setting __setting ( SETTING_AUTH, username ) = {
2361 .description = "User name",
2362 .tag = DHCP_EB_USERNAME,
2363 .type = &setting_type_string,
2366 /** Password setting */
2367 const struct setting password_setting __setting ( SETTING_AUTH, password ) = {
2369 .description = "Password",
2370 .tag = DHCP_EB_PASSWORD,
2371 .type = &setting_type_string,
2374 /** Priority setting */
2375 const struct setting priority_setting __setting ( SETTING_MISC, priority ) = {
2377 .description = "Settings priority",
2378 .tag = DHCP_EB_PRIORITY,
2379 .type = &setting_type_int8,
2382 /** DHCP user class setting */
2383 const struct setting user_class_setting __setting ( SETTING_HOST_EXTRA,
2385 .name = "user-class",
2386 .description = "DHCP user class",
2387 .tag = DHCP_USER_CLASS_ID,
2388 .type = &setting_type_string,
2391 /******************************************************************************
2393 * Built-in settings block
2395 ******************************************************************************
2398 /** Built-in setting scope */
2399 const struct settings_scope builtin_scope;
2402 * Fetch error number setting
2404 * @v data Buffer to fill with setting data
2405 * @v len Length of buffer
2406 * @ret len Length of setting data, or negative error
2408 static int errno_fetch ( void *data, size_t len ) {
2411 /* Return current error */
2412 content = htonl ( errno );
2413 if ( len > sizeof ( content ) )
2414 len = sizeof ( content );
2415 memcpy ( data, &content, len );
2416 return sizeof ( content );
2419 /** Error number setting */
2420 const struct setting errno_setting __setting ( SETTING_MISC, errno ) = {
2422 .description = "Last error",
2423 .type = &setting_type_uint32,
2424 .scope = &builtin_scope,
2427 /** Error number built-in setting */
2428 struct builtin_setting errno_builtin_setting __builtin_setting = {
2429 .setting = &errno_setting,
2430 .fetch = errno_fetch,
2434 * Fetch build architecture setting
2436 * @v data Buffer to fill with setting data
2437 * @v len Length of buffer
2438 * @ret len Length of setting data, or negative error
2440 static int buildarch_fetch ( void *data, size_t len ) {
2441 static const char buildarch[] = _S2 ( ARCH );
2443 strncpy ( data, buildarch, len );
2444 return ( sizeof ( buildarch ) - 1 /* NUL */ );
2447 /** Build architecture setting */
2448 const struct setting buildarch_setting __setting ( SETTING_MISC, buildarch ) = {
2449 .name = "buildarch",
2450 .description = "Build architecture",
2451 .type = &setting_type_string,
2452 .scope = &builtin_scope,
2455 /** Build architecture built-in setting */
2456 struct builtin_setting buildarch_builtin_setting __builtin_setting = {
2457 .setting = &buildarch_setting,
2458 .fetch = buildarch_fetch,
2462 * Fetch platform setting
2464 * @v data Buffer to fill with setting data
2465 * @v len Length of buffer
2466 * @ret len Length of setting data, or negative error
2468 static int platform_fetch ( void *data, size_t len ) {
2469 static const char platform[] = _S2 ( PLATFORM );
2471 strncpy ( data, platform, len );
2472 return ( sizeof ( platform ) - 1 /* NUL */ );
2475 /** Platform setting */
2476 const struct setting platform_setting __setting ( SETTING_MISC, platform ) = {
2478 .description = "Platform",
2479 .type = &setting_type_string,
2480 .scope = &builtin_scope,
2483 /** Platform built-in setting */
2484 struct builtin_setting platform_builtin_setting __builtin_setting = {
2485 .setting = &platform_setting,
2486 .fetch = platform_fetch,
2490 * Fetch version setting
2492 * @v data Buffer to fill with setting data
2493 * @v len Length of buffer
2494 * @ret len Length of setting data, or negative error
2496 static int version_fetch ( void *data, size_t len ) {
2497 strncpy ( data, product_version, len );
2498 return ( strlen ( product_version ) );
2501 /** Version setting */
2502 const struct setting version_setting __setting ( SETTING_MISC, version ) = {
2504 .description = "Version",
2505 .type = &setting_type_string,
2506 .scope = &builtin_scope,
2509 /** Version built-in setting */
2510 struct builtin_setting version_builtin_setting __builtin_setting = {
2511 .setting = &version_setting,
2512 .fetch = version_fetch,
2516 * Fetch built-in setting
2518 * @v settings Settings block
2519 * @v setting Setting to fetch
2520 * @v data Buffer to fill with setting data
2521 * @v len Length of buffer
2522 * @ret len Length of setting data, or negative error
2524 static int builtin_fetch ( struct settings *settings __unused,
2525 struct setting *setting,
2526 void *data, size_t len ) {
2527 struct builtin_setting *builtin;
2529 for_each_table_entry ( builtin, BUILTIN_SETTINGS ) {
2530 if ( setting_cmp ( setting, builtin->setting ) == 0 )
2531 return builtin->fetch ( data, len );
2537 * Check applicability of built-in setting
2539 * @v settings Settings block
2540 * @v setting Setting
2541 * @ret applies Setting applies within this settings block
2543 static int builtin_applies ( struct settings *settings __unused,
2544 const struct setting *setting ) {
2546 return ( setting->scope == &builtin_scope );
2549 /** Built-in settings operations */
2550 static struct settings_operations builtin_settings_operations = {
2551 .applies = builtin_applies,
2552 .fetch = builtin_fetch,
2555 /** Built-in settings */
2556 static struct settings builtin_settings = {
2558 .siblings = LIST_HEAD_INIT ( builtin_settings.siblings ),
2559 .children = LIST_HEAD_INIT ( builtin_settings.children ),
2560 .op = &builtin_settings_operations,
2563 /** Initialise built-in settings */
2564 static void builtin_init ( void ) {
2567 if ( ( rc = register_settings ( &builtin_settings, NULL,
2568 "builtin" ) ) != 0 ) {
2569 DBG ( "Could not register built-in settings: %s\n",
2575 /** Built-in settings initialiser */
2576 struct init_fn builtin_init_fn __init_fn ( INIT_NORMAL ) = {
2577 .initialise = builtin_init,