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 void *raw;
1002 int raw_len;
1003 int len;
1004
1005 /* Avoid returning uninitialised data on error */
1006 *value = 0;
1007
1008 /* Fetch raw (network-ordered, variable-length) setting */
1009 raw_len = fetch_raw_setting_copy ( settings, setting, &raw );
1010 if ( raw_len < 0 ) {
1011 len = raw_len;
1012 goto err_fetch_copy;
1013 }
1014
1015 /* Extract numeric value */
1016 len = numeric_setting_value ( is_signed, raw, raw_len, value );
1017 if ( len < 0 )
1018 goto err_value;
1019
1020 err_value:
1021 free ( raw );
1022 err_fetch_copy:
1023 return len;
1024}
1025
1026/**
1027 * Fetch value of signed integer setting
1028 *
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
1033 */
1034int fetch_int_setting ( struct settings *settings,
1035 const struct setting *setting,
1036 long *value ) {
1037
1038 return fetch_numeric_setting ( settings, setting,
1039 ( ( unsigned long * ) value ), 1 );
1040}
1041
1042/**
1043 * Fetch value of unsigned integer setting
1044 *
1045 * @v settings Settings block, or NULL to search all blocks
1046 * @v setting Setting to fetch
1047 * @v value Integer value to fill in
1048 * @ret len Length of setting, or negative error
1049 */
1050int fetch_uint_setting ( struct settings *settings,
1051 const struct setting *setting,
1052 unsigned long *value ) {
1053
1054 return fetch_numeric_setting ( settings, setting, value, 0 );
1055}
1056
1057/**
1058 * Fetch value of signed integer setting, or zero
1059 *
1060 * @v settings Settings block, or NULL to search all blocks
1061 * @v setting Setting to fetch
1062 * @ret value Setting value, or zero
1063 */
1064long fetch_intz_setting ( struct settings *settings,
1065 const struct setting *setting ) {
1066 unsigned long value;
1067
1068 fetch_numeric_setting ( settings, setting, &value, 1 );
1069 return value;
1070}
1071
1072/**
1073 * Fetch value of unsigned integer setting, or zero
1074 *
1075 * @v settings Settings block, or NULL to search all blocks
1076 * @v setting Setting to fetch
1077 * @ret value Setting value, or zero
1078 */
1079unsigned long fetch_uintz_setting ( struct settings *settings,
1080 const struct setting *setting ) {
1081 unsigned long value;
1082
1083 fetch_numeric_setting ( settings, setting, &value, 0 );
1084 return value;
1085}
1086
1087/**
1088 * Fetch value of UUID setting
1089 *
1090 * @v settings Settings block, or NULL to search all blocks
1091 * @v setting Setting to fetch
1092 * @v uuid UUID to fill in
1093 * @ret len Length of setting, or negative error
1094 */
1095int fetch_uuid_setting ( struct settings *settings,
1096 const struct setting *setting,
1097 union uuid *uuid ) {
1098 int len;
1099
1100 len = fetch_raw_setting ( settings, setting, uuid, sizeof ( *uuid ) );
1101 if ( len < 0 )
1102 return len;
1103 if ( len != sizeof ( *uuid ) )
1104 return -ERANGE;
1105 return len;
1106}
1107
1108/**
1109 * Clear settings block
1110 *
1111 * @v settings Settings block
1112 */
1113void clear_settings ( struct settings *settings ) {
1114
1115 /* Find target settings block */
1116 settings = settings_target ( settings );
1117
1118 /* Clear settings, if applicable */
1119 if ( settings->op->clear )
1120 settings->op->clear ( settings );
1121}
1122
1123/**
1124 * Compare two settings
1125 *
1126 * @v a Setting to compare
1127 * @v b Setting to compare
1128 * @ret 0 Settings are the same
1129 * @ret non-zero Settings are not the same
1130 */
1131int setting_cmp ( const struct setting *a, const struct setting *b ) {
1132
1133 /* If the settings have tags, compare them */
1134 if ( a->tag && ( a->tag == b->tag ) && ( a->scope == b->scope ) )
1135 return 0;
1136
1137 /* Otherwise, if the settings have names, compare them */
1138 if ( a->name && b->name && a->name[0] )
1139 return strcmp ( a->name, b->name );
1140
1141 /* Otherwise, return a non-match */
1142 return ( ! 0 );
1143}
1144
1145/******************************************************************************
1146 *
1147 * Formatted setting routines
1148 *
1149 ******************************************************************************
1150 */
1151
1152/**
1153 * Format setting value as a string
1154 *
1155 * @v type Setting type
1156 * @v raw Raw setting value
1157 * @v raw_len Length of raw setting value
1158 * @v buf Buffer to contain formatted value
1159 * @v len Length of buffer
1160 * @ret len Length of formatted value, or negative error
1161 */
1162int setting_format ( const struct setting_type *type, const void *raw,
1163 size_t raw_len, char *buf, size_t len ) {
1164
1165 /* Sanity check */
1166 if ( ! type->format )
1167 return -ENOTSUP;
1168
1169 return type->format ( type, raw, raw_len, buf, len );
1170}
1171
1172/**
1173 * Parse formatted string to setting value
1174 *
1175 * @v type Setting type
1176 * @v value Formatted setting value
1177 * @v buf Buffer to contain raw value
1178 * @v len Length of buffer
1179 * @ret len Length of raw value, or negative error
1180 */
1181int setting_parse ( const struct setting_type *type, const char *value,
1182 void *buf, size_t len ) {
1183
1184 /* Sanity check */
1185 if ( ! type->parse )
1186 return -ENOTSUP;
1187
1188 return type->parse ( type, value, buf, len );
1189}
1190
1191/**
1192 * Convert setting value to number
1193 *
1194 * @v type Setting type
1195 * @v raw Raw setting value
1196 * @v raw_len Length of raw setting value
1197 * @ret value Numeric value
1198 * @ret rc Return status code
1199 */
1200int setting_numerate ( const struct setting_type *type, const void *raw,
1201 size_t raw_len, unsigned long *value ) {
1202
1203 /* Sanity check */
1204 if ( ! type->numerate )
1205 return -ENOTSUP;
1206
1207 return type->numerate ( type, raw, raw_len, value );
1208}
1209
1210/**
1211 * Convert number to setting value
1212 *
1213 * @v type Setting type
1214 * @v value Numeric value
1215 * @v buf Buffer to contain raw value
1216 * @v len Length of buffer
1217 * @ret len Length of raw value, or negative error
1218 */
1219int setting_denumerate ( const struct setting_type *type, unsigned long value,
1220 void *buf, size_t len ) {
1221
1222 /* Sanity check */
1223 if ( ! type->denumerate )
1224 return -ENOTSUP;
1225
1226 return type->denumerate ( type, value, buf, len );
1227}
1228
1229/**
1230 * Fetch formatted value of setting
1231 *
1232 * @v settings Settings block, or NULL to search all blocks
1233 * @v setting Setting to fetch
1234 * @v origin Origin of setting to fill in, or NULL
1235 * @v fetched Fetched setting to fill in, or NULL
1236 * @v buf Buffer to contain formatted value
1237 * @v len Length of buffer
1238 * @ret len Length of formatted value, or negative error
1239 */
1240int fetchf_setting ( struct settings *settings, const struct setting *setting,
1241 struct settings **origin, struct setting *fetched,
1242 char *buf, size_t len ) {
1243 struct setting tmp_fetched;
1244 void *raw;
1245 int raw_len;
1246 int ret;
1247
1248 /* Use local buffers if necessary */
1249 if ( ! fetched )
1250 fetched = &tmp_fetched;
1251
1252 /* Fetch raw value */
1253 raw_len = fetch_setting_copy ( settings, setting, origin, fetched,
1254 &raw );
1255 if ( raw_len < 0 ) {
1256 ret = raw_len;
1257 goto err_fetch_copy;
1258 }
1259
1260 /* Sanity check */
1261 assert ( fetched->type != NULL );
1262
1263 /* Format setting */
1264 if ( ( ret = setting_format ( fetched->type, raw, raw_len, buf,
1265 len ) ) < 0 )
1266 goto err_format;
1267
1268 err_format:
1269 free ( raw );
1270 err_fetch_copy:
1271 return ret;
1272}
1273
1274/**
1275 * Fetch copy of formatted value of setting
1276 *
1277 * @v settings Settings block, or NULL to search all blocks
1278 * @v setting Setting to fetch
1279 * @v origin Origin of setting to fill in, or NULL
1280 * @v fetched Fetched setting to fill in, or NULL
1281 * @v value Buffer to allocate and fill with formatted value
1282 * @ret len Length of formatted value, or negative error
1283 *
1284 * The caller is responsible for eventually freeing the allocated
1285 * buffer.
1286 */
1287int fetchf_setting_copy ( struct settings *settings,
1288 const struct setting *setting,
1289 struct settings **origin, struct setting *fetched,
1290 char **value ) {
1291 struct settings *tmp_origin;
1292 struct setting tmp_fetched;
1293 int len;
1294 int check_len;
1295
1296 /* Use local buffers if necessary */
1297 if ( ! origin )
1298 origin = &tmp_origin;
1299 if ( ! fetched )
1300 fetched = &tmp_fetched;
1301
1302 /* Avoid returning uninitialised data on error */
1303 *value = NULL;
1304
1305 /* Check existence, and fetch formatted value length */
1306 len = fetchf_setting ( settings, setting, origin, fetched, NULL, 0 );
1307 if ( len < 0 )
1308 return len;
1309
1310 /* Allocate buffer */
1311 *value = zalloc ( len + 1 /* NUL */ );
1312 if ( ! *value )
1313 return -ENOMEM;
1314
1315 /* Fetch formatted value */
1316 check_len = fetchf_setting ( *origin, fetched, NULL, NULL, *value,
1317 ( len + 1 /* NUL */ ) );
1318 assert ( check_len == len );
1319 return len;
1320}
1321
1322/**
1323 * Store formatted value of setting
1324 *
1325 * @v settings Settings block
1326 * @v setting Setting to store
1327 * @v value Formatted setting data, or NULL
1328 * @ret rc Return status code
1329 */
1330int storef_setting ( struct settings *settings, const struct setting *setting,
1331 const char *value ) {
1332 void *raw;
1333 int raw_len;
1334 int check_len;
1335 int rc;
1336
1337 /* NULL value or empty string implies deletion */
1338 if ( ( ! value ) || ( ! value[0] ) )
1339 return delete_setting ( settings, setting );
1340
1341 /* Sanity check */
1342 assert ( setting->type != NULL );
1343
1344 /* Get raw value length */
1345 raw_len = setting_parse ( setting->type, value, NULL, 0 );
1346 if ( raw_len < 0 ) {
1347 rc = raw_len;
1348 goto err_raw_len;
1349 }
1350
1351 /* Allocate buffer for raw value */
1352 raw = malloc ( raw_len );
1353 if ( ! raw ) {
1354 rc = -ENOMEM;
1355 goto err_alloc_raw;
1356 }
1357
1358 /* Parse formatted value */
1359 check_len = setting_parse ( setting->type, value, raw, raw_len );
1360 assert ( check_len == raw_len );
1361
1362 /* Store raw value */
1363 if ( ( rc = store_setting ( settings, setting, raw, raw_len ) ) != 0 )
1364 goto err_store;
1365
1366 err_store:
1367 free ( raw );
1368 err_alloc_raw:
1369 err_raw_len:
1370 return rc;
1371}
1372
1373/**
1374 * Fetch numeric value of setting
1375 *
1376 * @v settings Settings block, or NULL to search all blocks
1377 * @v setting Setting to fetch
1378 * @v origin Origin of setting to fill in, or NULL
1379 * @v fetched Fetched setting to fill in, or NULL
1380 * @v value Numeric value to fill in
1381 * @ret rc Return status code
1382 */
1383int fetchn_setting ( struct settings *settings, const struct setting *setting,
1384 struct settings **origin, struct setting *fetched,
1385 unsigned long *value ) {
1386 struct setting tmp_fetched;
1387 void *raw;
1388 int raw_len;
1389 int rc;
1390
1391 /* Use local buffers if necessary */
1392 if ( ! fetched )
1393 fetched = &tmp_fetched;
1394
1395 /* Fetch raw value */
1396 raw_len = fetch_setting_copy ( settings, setting, origin, fetched,
1397 &raw );
1398 if ( raw_len < 0 ) {
1399 rc = raw_len;
1400 goto err_fetch_copy;
1401 }
1402
1403 /* Sanity check */
1404 assert ( fetched->type != NULL );
1405
1406 /* Numerate setting */
1407 if ( ( rc = setting_numerate ( fetched->type, raw, raw_len,
1408 value ) ) < 0 )
1409 goto err_numerate;
1410
1411 err_numerate:
1412 free ( raw );
1413 err_fetch_copy:
1414 return rc;
1415}
1416
1417/**
1418 * Store numeric value of setting
1419 *
1420 * @v settings Settings block
1421 * @v setting Setting
1422 * @v value Numeric value
1423 * @ret rc Return status code
1424 */
1425int storen_setting ( struct settings *settings, const struct setting *setting,
1426 unsigned long value ) {
1427 void *raw;
1428 int raw_len;
1429 int check_len;
1430 int rc;
1431
1432 /* Sanity check */
1433 assert ( setting->type != NULL );
1434
1435 /* Get raw value length */
1436 raw_len = setting_denumerate ( setting->type, value, NULL, 0 );
1437 if ( raw_len < 0 ) {
1438 rc = raw_len;
1439 goto err_raw_len;
1440 }
1441
1442 /* Allocate buffer for raw value */
1443 raw = malloc ( raw_len );
1444 if ( ! raw ) {
1445 rc = -ENOMEM;
1446 goto err_alloc_raw;
1447 }
1448
1449 /* Denumerate value */
1450 check_len = setting_denumerate ( setting->type, value, raw, raw_len );
1451 assert ( check_len == raw_len );
1452
1453 /* Store raw value */
1454 if ( ( rc = store_setting ( settings, setting, raw, raw_len ) ) != 0 )
1455 goto err_store;
1456
1457 err_store:
1458 free ( raw );
1459 err_alloc_raw:
1460 err_raw_len:
1461 return rc;
1462}
1463
1464/******************************************************************************
1465 *
1466 * Named settings
1467 *
1468 ******************************************************************************
1469 */
1470
1471/**
1472 * Find predefined setting
1473 *
1474 * @v name Name
1475 * @ret setting Setting, or NULL
1476 */
1477struct setting * find_setting ( const char *name ) {
1478 struct setting *setting;
1479
1480 for_each_table_entry ( setting, SETTINGS ) {
1481 if ( strcmp ( name, setting->name ) == 0 )
1482 return setting;
1483 }
1484 return NULL;
1485}
1486
1487/**
1488 * Parse setting name as tag number
1489 *
1490 * @v name Name
1491 * @ret tag Tag number, or 0 if not a valid number
1492 */
1493static uint64_t parse_setting_tag ( const char *name ) {
1494 char *tmp = ( ( char * ) name );
1495 uint64_t tag = 0;
1496
1497 while ( 1 ) {
1498 tag = ( ( tag << 8 ) | strtoul ( tmp, &tmp, 0 ) );
1499 if ( *tmp == 0 )
1500 return tag;
1501 if ( *tmp != '.' )
1502 return 0;
1503 tmp++;
1504 }
1505}
1506
1507/**
1508 * Find setting type
1509 *
1510 * @v name Name
1511 * @ret type Setting type, or NULL
1512 */
1513static const struct setting_type * find_setting_type ( const char *name ) {
1514 const struct setting_type *type;
1515
1516 for_each_table_entry ( type, SETTING_TYPES ) {
1517 if ( strcmp ( name, type->name ) == 0 )
1518 return type;
1519 }
1520 return NULL;
1521}
1522
1523/**
1524 * Parse setting name
1525 *
1526 * @v name Name of setting
1527 * @v get_child Function to find or create child settings block
1528 * @v settings Settings block to fill in
1529 * @v setting Setting to fill in
1530 * @ret rc Return status code
1531 *
1532 * Interprets a name of the form
1533 * "[settings_name/]tag_name[:type_name]" and fills in the appropriate
1534 * fields.
1535 *
1536 * Note that on success, this function will have modified the original
1537 * setting @c name.
1538 */
1539int parse_setting_name ( char *name, get_child_settings_t get_child,
1540 struct settings **settings, struct setting *setting ) {
1541 char *settings_name;
1542 char *setting_name;
1543 char *type_name;
1544 struct setting *predefined;
1545 int rc;
1546
1547 /* Set defaults */
1548 *settings = &settings_root;
1549 memset ( setting, 0, sizeof ( *setting ) );
1550 setting->name = "";
1551
1552 /* Split name into "[settings_name/]setting_name[:type_name]" */
1553 if ( ( setting_name = strchr ( name, '/' ) ) != NULL ) {
1554 *(setting_name++) = 0;
1555 settings_name = name;
1556 } else {
1557 setting_name = name;
1558 settings_name = NULL;
1559 }
1560 if ( ( type_name = strchr ( setting_name, ':' ) ) != NULL )
1561 *(type_name++) = 0;
1562
1563 /* Identify settings block, if specified */
1564 if ( settings_name ) {
1565 *settings = parse_settings_name ( settings_name, get_child );
1566 if ( *settings == NULL ) {
1567 DBG ( "Unrecognised settings block \"%s\" in \"%s\"\n",
1568 settings_name, name );
1569 rc = -ENODEV;
1570 goto err;
1571 }
1572 }
1573
1574 /* Identify setting */
1575 setting->tag = parse_setting_tag ( setting_name );
1576 setting->scope = (*settings)->default_scope;
1577 setting->name = setting_name;
1578 for_each_table_entry ( predefined, SETTINGS ) {
1579 /* Matches a predefined setting; use that setting */
1580 if ( setting_cmp ( predefined, setting ) == 0 ) {
1581 memcpy ( setting, predefined, sizeof ( *setting ) );
1582 break;
1583 }
1584 }
1585
1586 /* Identify setting type, if specified */
1587 if ( type_name ) {
1588 setting->type = find_setting_type ( type_name );
1589 if ( setting->type == NULL ) {
1590 DBG ( "Invalid setting type \"%s\" in \"%s\"\n",
1591 type_name, name );
1592 rc = -ENOTSUP;
1593 goto err;
1594 }
1595 }
1596
1597 return 0;
1598
1599 err:
1600 /* Restore original name */
1601 if ( settings_name )
1602 *( setting_name - 1 ) = '/';
1603 if ( type_name )
1604 *( type_name - 1 ) = ':';
1605 return rc;
1606}
1607
1608/**
1609 * Return full setting name
1610 *
1611 * @v settings Settings block, or NULL
1612 * @v setting Setting
1613 * @v buf Buffer
1614 * @v len Length of buffer
1615 * @ret len Length of setting name, or negative error
1616 */
1617int setting_name ( struct settings *settings, const struct setting *setting,
1618 char *buf, size_t len ) {
1619 const char *name;
1620
1621 settings = settings_target ( settings );
1622 name = settings_name ( settings );
1623 return snprintf ( buf, len, "%s%s%s:%s", name, ( name[0] ? "/" : "" ),
1624 setting->name, setting->type->name );
1625}
1626
1627/******************************************************************************
1628 *
1629 * Setting types
1630 *
1631 ******************************************************************************
1632 */
1633
1634/**
1635 * Parse string setting value
1636 *
1637 * @v type Setting type
1638 * @v value Formatted setting value
1639 * @v buf Buffer to contain raw value
1640 * @v len Length of buffer
1641 * @ret len Length of raw value, or negative error
1642 */
1643static int parse_string_setting ( const struct setting_type *type __unused,
1644 const char *value, void *buf, size_t len ) {
1645 size_t raw_len = strlen ( value ); /* Exclude terminating NUL */
1646
1647 /* Copy string to buffer */
1648 if ( len > raw_len )
1649 len = raw_len;
1650 memcpy ( buf, value, len );
1651
1652 return raw_len;
1653}
1654
1655/**
1656 * Format string setting value
1657 *
1658 * @v type Setting type
1659 * @v raw Raw setting value
1660 * @v raw_len Length of raw setting value
1661 * @v buf Buffer to contain formatted value
1662 * @v len Length of buffer
1663 * @ret len Length of formatted value, or negative error
1664 */
1665static int format_string_setting ( const struct setting_type *type __unused,
1666 const void *raw, size_t raw_len, char *buf,
1667 size_t len ) {
1668
1669 /* Copy string to buffer, and terminate */
1670 memset ( buf, 0, len );
1671 if ( len > raw_len )
1672 len = raw_len;
1673 memcpy ( buf, raw, len );
1674
1675 return raw_len;
1676}
1677
1678/** A string setting type */
1679const struct setting_type setting_type_string __setting_type = {
1680 .name = "string",
1681 .parse = parse_string_setting,
1682 .format = format_string_setting,
1683};
1684
1685/**
1686 * Parse URI-encoded string setting value
1687 *
1688 * @v type Setting type
1689 * @v value Formatted setting value
1690 * @v buf Buffer to contain raw value
1691 * @v len Length of buffer
1692 * @ret len Length of raw value, or negative error
1693 */
1694static int parse_uristring_setting ( const struct setting_type *type __unused,
1695 const char *value, void *buf, size_t len ){
1696
1697 return uri_decode ( value, buf, len );
1698}
1699
1700/**
1701 * Format URI-encoded string setting value
1702 *
1703 * @v type Setting type
1704 * @v raw Raw setting value
1705 * @v raw_len Length of raw setting value
1706 * @v buf Buffer to contain formatted value
1707 * @v len Length of buffer
1708 * @ret len Length of formatted value, or negative error
1709 */
1710static int format_uristring_setting ( const struct setting_type *type __unused,
1711 const void *raw, size_t raw_len,
1712 char *buf, size_t len ) {
1713
1714 return uri_encode ( 0, raw, raw_len, buf, len );
1715}
1716
1717/** A URI-encoded string setting type */
1718const struct setting_type setting_type_uristring __setting_type = {
1719 .name = "uristring",
1720 .parse = parse_uristring_setting,
1721 .format = format_uristring_setting,
1722};
1723
1724/**
1725 * Parse IPv4 address setting value (when IPv4 support is not present)
1726 *
1727 * @v type Setting type
1728 * @v value Formatted setting value
1729 * @v buf Buffer to contain raw value
1730 * @v len Length of buffer
1731 * @ret len Length of raw value, or negative error
1732 */
1733__weak int parse_ipv4_setting ( const struct setting_type *type __unused,
1734 const char *value __unused, void *buf __unused,
1735 size_t len __unused ) {
1736 return -ENOTSUP;
1737}
1738
1739/**
1740 * Format IPv4 address setting value (when IPv4 support is not present)
1741 *
1742 * @v type Setting type
1743 * @v raw Raw setting value
1744 * @v raw_len Length of raw setting value
1745 * @v buf Buffer to contain formatted value
1746 * @v len Length of buffer
1747 * @ret len Length of formatted value, or negative error
1748 */
1749__weak int format_ipv4_setting ( const struct setting_type *type __unused,
1750 const void *raw __unused,
1751 size_t raw_len __unused, char *buf __unused,
1752 size_t len __unused ) {
1753 return -ENOTSUP;
1754}
1755
1756/** An IPv4 address setting type */
1757const struct setting_type setting_type_ipv4 __setting_type = {
1758 .name = "ipv4",
1759 .parse = parse_ipv4_setting,
1760 .format = format_ipv4_setting,
1761};
1762
1763/**
1764 * Parse IPv6 address setting value (when IPv6 support is not present)
1765 *
1766 * @v type Setting type
1767 * @v value Formatted setting value
1768 * @v buf Buffer to contain raw value
1769 * @v len Length of buffer
1770 * @ret len Length of raw value, or negative error
1771 */
1772__weak int parse_ipv6_setting ( const struct setting_type *type __unused,
1773 const char *value __unused, void *buf __unused,
1774 size_t len __unused ) {
1775 return -ENOTSUP;
1776}
1777
1778/**
1779 * Format IPv6 address setting value (when IPv6 support is not present)
1780 *
1781 * @v type Setting type
1782 * @v raw Raw setting value
1783 * @v raw_len Length of raw setting value
1784 * @v buf Buffer to contain formatted value
1785 * @v len Length of buffer
1786 * @ret len Length of formatted value, or negative error
1787 */
1788__weak int format_ipv6_setting ( const struct setting_type *type __unused,
1789 const void *raw __unused,
1790 size_t raw_len __unused, char *buf __unused,
1791 size_t len __unused ) {
1792 return -ENOTSUP;
1793}
1794
1795/** An IPv6 address setting type */
1796const struct setting_type setting_type_ipv6 __setting_type = {
1797 .name = "ipv6",
1798 .parse = parse_ipv6_setting,
1799 .format = format_ipv6_setting,
1800};
1801
1802/** IPv6 settings scope */
1803const struct settings_scope dhcpv6_scope;
1804
1805/**
1806 * Integer setting type indices
1807 *
1808 * These indexes are defined such that (1<<index) gives the width of
1809 * the integer, in bytes.
1810 */
1816
1817/**
1818 * Integer setting type names
1819 *
1820 * These names exist as a static array in order to allow the type's
1821 * integer size and signedness to be determined from the type's name.
1822 * Note that there are no separate entries for the signed integer
1823 * types: the name pointers simply point to the second character of
1824 * the relevant string.
1825 */
1826static const char setting_type_int_name[][8] = {
1827 [SETTING_TYPE_INT8] = "uint8",
1828 [SETTING_TYPE_INT16] = "uint16",
1829 [SETTING_TYPE_INT32] = "uint32",
1830};
1831
1832/**
1833 * Get unsigned integer setting type name
1834 *
1835 * @v index Integer setting type index
1836 * @ret name Setting type name
1837 */
1838#define SETTING_TYPE_UINT_NAME( index ) setting_type_int_name[index]
1839
1840/**
1841 * Get signed integer setting type name
1842 *
1843 * @v index Integer setting type index
1844 * @ret name Setting type name
1845 */
1846#define SETTING_TYPE_INT_NAME( index ) ( setting_type_int_name[index] + 1 )
1847
1848/**
1849 * Get integer setting type index
1850 *
1851 * @v type Setting type
1852 * @ret index Integer setting type index
1853 */
1854static unsigned int setting_type_int_index ( const struct setting_type *type ) {
1855
1856 return ( ( type->name - setting_type_int_name[0] ) /
1857 sizeof ( setting_type_int_name[0] ) );
1858}
1859
1860/**
1861 * Get integer setting type width
1862 *
1863 * @v type Setting type
1864 * @ret index Integer setting type width
1865 */
1866static unsigned int setting_type_int_width ( const struct setting_type *type ) {
1867
1868 return ( 1 << setting_type_int_index ( type ) );
1869}
1870
1871/**
1872 * Get integer setting type signedness
1873 *
1874 * @v type Setting type
1875 * @ret is_signed Integer setting type is signed
1876 */
1877static int setting_type_int_is_signed ( const struct setting_type *type ) {
1878 return ( ( type->name - setting_type_int_name[0] ) & 1 );
1879}
1880
1881/**
1882 * Convert number to setting value
1883 *
1884 * @v type Setting type
1885 * @v value Numeric value
1886 * @v buf Buffer to contain raw value
1887 * @v len Length of buffer
1888 * @ret len Length of raw value, or negative error
1889 */
1890static int denumerate_int_setting ( const struct setting_type *type,
1891 unsigned long value, void *buf,
1892 size_t len ) {
1893 unsigned int size = setting_type_int_width ( type );
1894 union {
1895 uint32_t num;
1896 uint8_t bytes[4];
1897 } u;
1898
1899 u.num = htonl ( value );
1900 if ( len > size )
1901 len = size;
1902 memcpy ( buf, &u.bytes[ sizeof ( u ) - size ], len );
1903
1904 return size;
1905}
1906
1907/**
1908 * Convert setting value to number
1909 *
1910 * @v type Setting type
1911 * @v raw Raw setting value
1912 * @v raw_len Length of raw setting value
1913 * @v value Numeric value to fill in
1914 * @ret rc Return status code
1915 */
1916static int numerate_int_setting ( const struct setting_type *type,
1917 const void *raw, size_t raw_len,
1918 unsigned long *value ) {
1919 int is_signed = setting_type_int_is_signed ( type );
1920 int check_len;
1921
1922 /* Extract numeric value */
1923 check_len = numeric_setting_value ( is_signed, raw, raw_len, value );
1924 if ( check_len < 0 )
1925 return check_len;
1926 assert ( check_len == ( int ) raw_len );
1927
1928 return 0;
1929}
1930
1931/**
1932 * Parse integer setting value
1933 *
1934 * @v type Setting type
1935 * @v value Formatted setting value
1936 * @v buf Buffer to contain raw value
1937 * @v len Length of buffer
1938 * @ret len Length of raw value, or negative error
1939 */
1940static int parse_int_setting ( const struct setting_type *type,
1941 const char *value, void *buf, size_t len ) {
1942 char *endp;
1943 unsigned long num_value;
1944
1945 /* Parse value */
1946 num_value = strtoul ( value, &endp, 0 );
1947 if ( *endp )
1948 return -EINVAL;
1949
1950 return type->denumerate ( type, num_value, buf, len );
1951}
1952
1953/**
1954 * Format signed integer setting value
1955 *
1956 * @v type Setting type
1957 * @v raw Raw setting value
1958 * @v raw_len Length of raw setting value
1959 * @v buf Buffer to contain formatted value
1960 * @v len Length of buffer
1961 * @ret len Length of formatted value, or negative error
1962 */
1963static int format_int_setting ( const struct setting_type *type,
1964 const void *raw, size_t raw_len,
1965 char *buf, size_t len ) {
1966 unsigned long value;
1967 int ret;
1968
1969 /* Extract numeric value */
1970 if ( ( ret = type->numerate ( type, raw, raw_len, &value ) ) < 0 )
1971 return ret;
1972
1973 /* Format value */
1974 return snprintf ( buf, len, "%ld", value );
1975}
1976
1977/**
1978 * Format unsigned integer setting value
1979 *
1980 * @v type Setting type
1981 * @v raw Raw setting value
1982 * @v raw_len Length of raw setting value
1983 * @v buf Buffer to contain formatted value
1984 * @v len Length of buffer
1985 * @ret len Length of formatted value, or negative error
1986 */
1987static int format_uint_setting ( const struct setting_type *type,
1988 const void *raw, size_t raw_len,
1989 char *buf, size_t len ) {
1990 unsigned long value;
1991 int ret;
1992
1993 /* Extract numeric value */
1994 if ( ( ret = type->numerate ( type, raw, raw_len, &value ) ) < 0 )
1995 return ret;
1996
1997 /* Format value */
1998 return snprintf ( buf, len, "%#lx", value );
1999}
2000
2001/**
2002 * Define a signed integer setting type
2003 *
2004 * @v index Integer setting type index
2005 * @ret type Setting type
2006 */
2007#define SETTING_TYPE_INT( index ) { \
2008 .name = SETTING_TYPE_INT_NAME ( index ), \
2009 .parse = parse_int_setting, \
2010 .format = format_int_setting, \
2011 .denumerate = denumerate_int_setting, \
2012 .numerate = numerate_int_setting, \
2013}
2014
2015/**
2016 * Define an unsigned integer setting type
2017 *
2018 * @v index Integer setting type index
2019 * @ret type Setting type
2020 */
2021#define SETTING_TYPE_UINT( index ) { \
2022 .name = SETTING_TYPE_UINT_NAME ( index ), \
2023 .parse = parse_int_setting, \
2024 .format = format_uint_setting, \
2025 .denumerate = denumerate_int_setting, \
2026 .numerate = numerate_int_setting, \
2027}
2028
2029/** A signed 8-bit integer setting type */
2030const struct setting_type setting_type_int8 __setting_type =
2031 SETTING_TYPE_INT ( SETTING_TYPE_INT8 );
2032
2033/** A signed 16-bit integer setting type */
2034const struct setting_type setting_type_int16 __setting_type =
2035 SETTING_TYPE_INT ( SETTING_TYPE_INT16 );
2036
2037/** A signed 32-bit integer setting type */
2038const struct setting_type setting_type_int32 __setting_type =
2039 SETTING_TYPE_INT ( SETTING_TYPE_INT32 );
2040
2041/** An unsigned 8-bit integer setting type */
2042const struct setting_type setting_type_uint8 __setting_type =
2043 SETTING_TYPE_UINT ( SETTING_TYPE_INT8 );
2044
2045/** An unsigned 16-bit integer setting type */
2046const struct setting_type setting_type_uint16 __setting_type =
2047 SETTING_TYPE_UINT ( SETTING_TYPE_INT16 );
2048
2049/** An unsigned 32-bit integer setting type */
2050const struct setting_type setting_type_uint32 __setting_type =
2051 SETTING_TYPE_UINT ( SETTING_TYPE_INT32 );
2052
2053/**
2054 * Parse hex string setting value (using colon delimiter)
2055 *
2056 * @v type Setting type
2057 * @v value Formatted setting value
2058 * @v buf Buffer to contain raw value
2059 * @v len Length of buffer
2060 * @v size Integer size, in bytes
2061 * @ret len Length of raw value, or negative error
2062 */
2063static int parse_hex_setting ( const struct setting_type *type __unused,
2064 const char *value, void *buf, size_t len ) {
2065 return hex_decode ( ':', value, buf, len );
2066}
2067
2068/**
2069 * Format hex string setting value (using colon delimiter)
2070 *
2071 * @v type Setting type
2072 * @v raw Raw setting value
2073 * @v raw_len Length of raw setting value
2074 * @v buf Buffer to contain formatted value
2075 * @v len Length of buffer
2076 * @ret len Length of formatted value, or negative error
2077 */
2078static int format_hex_colon_setting ( const struct setting_type *type __unused,
2079 const void *raw, size_t raw_len,
2080 char *buf, size_t len ) {
2081 return hex_encode ( ':', raw, raw_len, buf, len );
2082}
2083
2084/**
2085 * Parse hex string setting value (using hyphen delimiter)
2086 *
2087 * @v type Setting type
2088 * @v value Formatted setting value
2089 * @v buf Buffer to contain raw value
2090 * @v len Length of buffer
2091 * @v size Integer size, in bytes
2092 * @ret len Length of raw value, or negative error
2093 */
2094static int parse_hex_hyphen_setting ( const struct setting_type *type __unused,
2095 const char *value, void *buf,
2096 size_t len ) {
2097 return hex_decode ( '-', value, buf, len );
2098}
2099
2100/**
2101 * Format hex string setting value (using hyphen delimiter)
2102 *
2103 * @v type Setting type
2104 * @v raw Raw setting value
2105 * @v raw_len Length of raw setting value
2106 * @v buf Buffer to contain formatted value
2107 * @v len Length of buffer
2108 * @ret len Length of formatted value, or negative error
2109 */
2110static int format_hex_hyphen_setting ( const struct setting_type *type __unused,
2111 const void *raw, size_t raw_len,
2112 char *buf, size_t len ) {
2113 return hex_encode ( '-', raw, raw_len, buf, len );
2114}
2115
2116/**
2117 * Parse hex string setting value (using no delimiter)
2118 *
2119 * @v type Setting type
2120 * @v value Formatted setting value
2121 * @v buf Buffer to contain raw value
2122 * @v len Length of buffer
2123 * @v size Integer size, in bytes
2124 * @ret len Length of raw value, or negative error
2125 */
2126static int parse_hex_raw_setting ( const struct setting_type *type __unused,
2127 const char *value, void *buf, size_t len ) {
2128 return hex_decode ( 0, value, buf, len );
2129}
2130
2131/**
2132 * Format hex string setting value (using no delimiter)
2133 *
2134 * @v type Setting type
2135 * @v raw Raw setting value
2136 * @v raw_len Length of raw setting value
2137 * @v buf Buffer to contain formatted value
2138 * @v len Length of buffer
2139 * @ret len Length of formatted value, or negative error
2140 */
2141static int format_hex_raw_setting ( const struct setting_type *type __unused,
2142 const void *raw, size_t raw_len,
2143 char *buf, size_t len ) {
2144 return hex_encode ( 0, raw, raw_len, buf, len );
2145}
2146
2147/** A hex-string setting (colon-delimited) */
2148const struct setting_type setting_type_hex __setting_type = {
2149 .name = "hex",
2150 .parse = parse_hex_setting,
2151 .format = format_hex_colon_setting,
2152};
2153
2154/** A hex-string setting (hyphen-delimited) */
2155const struct setting_type setting_type_hexhyp __setting_type = {
2156 .name = "hexhyp",
2157 .parse = parse_hex_hyphen_setting,
2158 .format = format_hex_hyphen_setting,
2159};
2160
2161/** A hex-string setting (non-delimited) */
2162const struct setting_type setting_type_hexraw __setting_type = {
2163 .name = "hexraw",
2164 .parse = parse_hex_raw_setting,
2165 .format = format_hex_raw_setting,
2166};
2167
2168/**
2169 * Parse Base64-encoded setting value
2170 *
2171 * @v type Setting type
2172 * @v value Formatted setting value
2173 * @v buf Buffer to contain raw value
2174 * @v len Length of buffer
2175 * @v size Integer size, in bytes
2176 * @ret len Length of raw value, or negative error
2177 */
2178static int parse_base64_setting ( const struct setting_type *type __unused,
2179 const char *value, void *buf, size_t len ) {
2180
2181 return base64_decode ( value, buf, len );
2182}
2183
2184/**
2185 * Format Base64-encoded setting value
2186 *
2187 * @v type Setting type
2188 * @v raw Raw setting value
2189 * @v raw_len Length of raw setting value
2190 * @v buf Buffer to contain formatted value
2191 * @v len Length of buffer
2192 * @ret len Length of formatted value, or negative error
2193 */
2194static int format_base64_setting ( const struct setting_type *type __unused,
2195 const void *raw, size_t raw_len,
2196 char *buf, size_t len ) {
2197
2198 return base64_encode ( raw, raw_len, buf, len );
2199}
2200
2201/** A Base64-encoded setting */
2202const struct setting_type setting_type_base64 __setting_type = {
2203 .name = "base64",
2204 .parse = parse_base64_setting,
2205 .format = format_base64_setting,
2206};
2207
2208/**
2209 * Parse UUID/GUID setting value
2210 *
2211 * @v type Setting type
2212 * @v value Formatted setting value
2213 * @v buf Buffer to contain raw value
2214 * @v len Length of buffer
2215 * @v size Integer size, in bytes
2216 * @ret len Length of raw value, or negative error
2217 */
2218static int parse_uuid_setting ( const struct setting_type *type,
2219 const char *value, void *buf, size_t len ) {
2220 union uuid uuid;
2221 int rc;
2222
2223 /* Parse UUID */
2224 if ( ( rc = uuid_aton ( value, &uuid ) ) != 0 )
2225 return rc;
2226
2227 /* Mangle GUID byte ordering */
2228 if ( type == &setting_type_guid )
2229 uuid_mangle ( &uuid );
2230
2231 /* Copy value */
2232 if ( len > sizeof ( uuid ) )
2233 len = sizeof ( uuid );
2234 memcpy ( buf, uuid.raw, len );
2235
2236 return ( sizeof ( uuid ) );
2237}
2238
2239/**
2240 * Format UUID/GUID setting value
2241 *
2242 * @v type Setting type
2243 * @v raw Raw setting value
2244 * @v raw_len Length of raw setting value
2245 * @v buf Buffer to contain formatted value
2246 * @v len Length of buffer
2247 * @ret len Length of formatted value, or negative error
2248 */
2249static int format_uuid_setting ( const struct setting_type *type,
2250 const void *raw, size_t raw_len, char *buf,
2251 size_t len ) {
2252 union uuid uuid;
2253
2254 /* Range check */
2255 if ( raw_len != sizeof ( uuid ) )
2256 return -ERANGE;
2257
2258 /* Copy value */
2259 memcpy ( &uuid, raw, sizeof ( uuid ) );
2260
2261 /* Mangle GUID byte ordering */
2262 if ( type == &setting_type_guid )
2263 uuid_mangle ( &uuid );
2264
2265 /* Format value */
2266 return snprintf ( buf, len, "%s", uuid_ntoa ( &uuid ) );
2267}
2268
2269/** UUID setting type */
2270const struct setting_type setting_type_uuid __setting_type = {
2271 .name = "uuid",
2272 .parse = parse_uuid_setting,
2273 .format = format_uuid_setting,
2274};
2275
2276/** GUID setting type */
2277const struct setting_type setting_type_guid __setting_type = {
2278 .name = "guid",
2279 .parse = parse_uuid_setting,
2280 .format = format_uuid_setting,
2281};
2282
2283/**
2284 * Format PCI bus:dev.fn setting value
2285 *
2286 * @v type Setting type
2287 * @v raw Raw setting value
2288 * @v raw_len Length of raw setting value
2289 * @v buf Buffer to contain formatted value
2290 * @v len Length of buffer
2291 * @ret len Length of formatted value, or negative error
2292 */
2293static int format_busdevfn_setting ( const struct setting_type *type __unused,
2294 const void *raw, size_t raw_len, char *buf,
2295 size_t len ) {
2296 unsigned long busdevfn;
2297 unsigned int seg;
2298 unsigned int bus;
2299 unsigned int slot;
2300 unsigned int func;
2301 int check_len;
2302
2303 /* Extract numeric value */
2304 check_len = numeric_setting_value ( 0, raw, raw_len, &busdevfn );
2305 if ( check_len < 0 )
2306 return check_len;
2307 assert ( check_len == ( int ) raw_len );
2308
2309 /* Extract PCI address components */
2310 seg = PCI_SEG ( busdevfn );
2311 bus = PCI_BUS ( busdevfn );
2312 slot = PCI_SLOT ( busdevfn );
2313 func = PCI_FUNC ( busdevfn );
2314
2315 /* Format value */
2316 return snprintf ( buf, len, "%04x:%02x:%02x.%x", seg, bus, slot, func );
2317}
2318
2319/** PCI bus:dev.fn setting type */
2320const struct setting_type setting_type_busdevfn __setting_type = {
2321 .name = "busdevfn",
2322 .format = format_busdevfn_setting,
2323};
2324
2325/******************************************************************************
2326 *
2327 * Setting expansion
2328 *
2329 ******************************************************************************
2330 */
2331
2332/**
2333 * Expand variables within string
2334 *
2335 * @v string String
2336 * @ret expstr Expanded string
2337 *
2338 * The expanded string is allocated with malloc() and the caller must
2339 * eventually free() it.
2340 */
2341char * expand_settings ( const char *string ) {
2342 struct settings *settings;
2343 struct setting setting;
2344 char *expstr;
2345 char *start;
2346 char *end;
2347 char *head;
2348 char *name;
2349 char *tail;
2350 char *value;
2351 char *tmp;
2352 int new_len;
2353 int rc;
2354
2355 /* Obtain temporary modifiable copy of string */
2356 expstr = strdup ( string );
2357 if ( ! expstr )
2358 return NULL;
2359
2360 /* Expand while expansions remain */
2361 while ( 1 ) {
2362
2363 head = expstr;
2364
2365 /* Locate setting to be expanded */
2366 start = NULL;
2367 end = NULL;
2368 for ( tmp = expstr ; *tmp ; tmp++ ) {
2369 if ( ( tmp[0] == '$' ) && ( tmp[1] == '{' ) )
2370 start = tmp;
2371 if ( start && ( tmp[0] == '}' ) ) {
2372 end = tmp;
2373 break;
2374 }
2375 }
2376 if ( ! end )
2377 break;
2378 *start = '\0';
2379 name = ( start + 2 );
2380 *end = '\0';
2381 tail = ( end + 1 );
2382
2383 /* Expand setting */
2384 if ( ( rc = parse_setting_name ( name, find_child_settings,
2385 &settings,
2386 &setting ) ) != 0 ) {
2387 /* Treat invalid setting names as empty */
2388 value = NULL;
2389 } else {
2390 /* Fetch and format setting value. Ignore
2391 * errors; treat non-existent settings as empty.
2392 */
2393 fetchf_setting_copy ( settings, &setting, NULL, NULL,
2394 &value );
2395 }
2396
2397 /* Construct expanded string and discard old string */
2398 tmp = expstr;
2399 new_len = asprintf ( &expstr, "%s%s%s",
2400 head, ( value ? value : "" ), tail );
2401 free ( value );
2402 free ( tmp );
2403 if ( new_len < 0 )
2404 return NULL;
2405 }
2406
2407 return expstr;
2408}
2409
2410/******************************************************************************
2411 *
2412 * Settings
2413 *
2414 ******************************************************************************
2415 */
2416
2417/** Hostname setting */
2418const struct setting hostname_setting __setting ( SETTING_HOST, hostname ) = {
2419 .name = "hostname",
2420 .description = "Host name",
2421 .tag = DHCP_HOST_NAME,
2422 .type = &setting_type_string,
2423};
2424
2425/** Domain name setting */
2426const struct setting domain_setting __setting ( SETTING_IP_EXTRA, domain ) = {
2427 .name = "domain",
2428 .description = "DNS domain",
2429 .tag = DHCP_DOMAIN_NAME,
2430 .type = &setting_type_string,
2431};
2432
2433/** TFTP server setting */
2434const struct setting next_server_setting __setting ( SETTING_BOOT,next-server)={
2435 .name = "next-server",
2436 .description = "TFTP server",
2437 .tag = DHCP_EB_SIADDR,
2438 .type = &setting_type_ipv4,
2439};
2440
2441/** Filename setting */
2442const struct setting filename_setting __setting ( SETTING_BOOT, filename ) = {
2443 .name = "filename",
2444 .description = "Boot filename",
2445 .tag = DHCP_BOOTFILE_NAME,
2446 .type = &setting_type_string,
2447};
2448
2449/** Root path setting */
2450const struct setting root_path_setting __setting ( SETTING_SANBOOT, root-path)={
2451 .name = "root-path",
2452 .description = "SAN root path",
2453 .tag = DHCP_ROOT_PATH,
2454 .type = &setting_type_string,
2455};
2456
2457/** SAN filename setting */
2458const struct setting san_filename_setting __setting ( SETTING_SANBOOT,
2459 san-filename ) = {
2460 .name = "san-filename",
2461 .description = "SAN filename",
2462 .tag = DHCP_EB_SAN_FILENAME,
2463 .type = &setting_type_string,
2464};
2465
2466/** Username setting */
2467const struct setting username_setting __setting ( SETTING_AUTH, username ) = {
2468 .name = "username",
2469 .description = "User name",
2470 .tag = DHCP_EB_USERNAME,
2471 .type = &setting_type_string,
2472};
2473
2474/** Password setting */
2475const struct setting password_setting __setting ( SETTING_AUTH, password ) = {
2476 .name = "password",
2477 .description = "Password",
2478 .tag = DHCP_EB_PASSWORD,
2479 .type = &setting_type_string,
2480};
2481
2482/** Priority setting */
2483const struct setting priority_setting __setting ( SETTING_MISC, priority ) = {
2484 .name = "priority",
2485 .description = "Settings priority",
2486 .tag = DHCP_EB_PRIORITY,
2487 .type = &setting_type_int8,
2488};
2489
2490/** DHCP user class setting */
2491const struct setting user_class_setting __setting ( SETTING_HOST_EXTRA,
2492 user-class ) = {
2493 .name = "user-class",
2494 .description = "DHCP user class",
2495 .tag = DHCP_USER_CLASS_ID,
2496 .type = &setting_type_string,
2497};
2498
2499/** DHCP vendor class setting */
2500const struct setting vendor_class_setting __setting ( SETTING_HOST_EXTRA,
2501 vendor-class ) = {
2502 .name = "vendor-class",
2503 .description = "DHCP vendor class",
2504 .tag = DHCP_VENDOR_CLASS_ID,
2505 .type = &setting_type_string,
2506};
2507
2508/******************************************************************************
2509 *
2510 * Built-in settings block
2511 *
2512 ******************************************************************************
2513 */
2514
2515/** Built-in setting scope */
2516const struct settings_scope builtin_scope;
2517
2518/**
2519 * Fetch error number setting
2520 *
2521 * @v data Buffer to fill with setting data
2522 * @v len Length of buffer
2523 * @ret len Length of setting data, or negative error
2524 */
2525static int errno_fetch ( void *data, size_t len ) {
2526 uint32_t content;
2527
2528 /* Return current error */
2529 content = htonl ( errno );
2530 if ( len > sizeof ( content ) )
2531 len = sizeof ( content );
2532 memcpy ( data, &content, len );
2533 return sizeof ( content );
2534}
2535
2536/** Error number setting */
2537const struct setting errno_setting __setting ( SETTING_MISC, errno ) = {
2538 .name = "errno",
2539 .description = "Last error",
2540 .type = &setting_type_uint32,
2541 .scope = &builtin_scope,
2542};
2543
2544/** Error number built-in setting */
2545struct builtin_setting errno_builtin_setting __builtin_setting = {
2546 .setting = &errno_setting,
2547 .fetch = errno_fetch,
2548};
2549
2550/**
2551 * Fetch build architecture setting
2552 *
2553 * @v data Buffer to fill with setting data
2554 * @v len Length of buffer
2555 * @ret len Length of setting data, or negative error
2556 */
2557static int buildarch_fetch ( void *data, size_t len ) {
2558 static const char buildarch[] = _S2 ( ARCH );
2559
2560 strncpy ( data, buildarch, len );
2561 return ( sizeof ( buildarch ) - 1 /* NUL */ );
2562}
2563
2564/** Build architecture setting */
2565const struct setting buildarch_setting __setting ( SETTING_MISC, buildarch ) = {
2566 .name = "buildarch",
2567 .description = "Build architecture",
2568 .type = &setting_type_string,
2569 .scope = &builtin_scope,
2570};
2571
2572/** Build architecture built-in setting */
2573struct builtin_setting buildarch_builtin_setting __builtin_setting = {
2574 .setting = &buildarch_setting,
2575 .fetch = buildarch_fetch,
2576};
2577
2578/**
2579 * Fetch platform setting
2580 *
2581 * @v data Buffer to fill with setting data
2582 * @v len Length of buffer
2583 * @ret len Length of setting data, or negative error
2584 */
2585static int platform_fetch ( void *data, size_t len ) {
2586 static const char platform[] = _S2 ( PLATFORM );
2587
2588 strncpy ( data, platform, len );
2589 return ( sizeof ( platform ) - 1 /* NUL */ );
2590}
2591
2592/** Platform setting */
2593const struct setting platform_setting __setting ( SETTING_MISC, platform ) = {
2594 .name = "platform",
2595 .description = "Platform",
2596 .type = &setting_type_string,
2597 .scope = &builtin_scope,
2598};
2599
2600/** Platform built-in setting */
2601struct builtin_setting platform_builtin_setting __builtin_setting = {
2602 .setting = &platform_setting,
2603 .fetch = platform_fetch,
2604};
2605
2606/**
2607 * Fetch version setting
2608 *
2609 * @v data Buffer to fill with setting data
2610 * @v len Length of buffer
2611 * @ret len Length of setting data, or negative error
2612 */
2613static int version_fetch ( void *data, size_t len ) {
2614 strncpy ( data, product_version, len );
2615 return ( strlen ( product_version ) );
2616}
2617
2618/** Version setting */
2619const struct setting version_setting __setting ( SETTING_MISC, version ) = {
2620 .name = "version",
2621 .description = "Version",
2622 .type = &setting_type_string,
2623 .scope = &builtin_scope,
2624};
2625
2626/** Version built-in setting */
2627struct builtin_setting version_builtin_setting __builtin_setting = {
2628 .setting = &version_setting,
2629 .fetch = version_fetch,
2630};
2631
2632/**
2633 * Fetch current time setting
2634 *
2635 * @v data Buffer to fill with setting data
2636 * @v len Length of buffer
2637 * @ret len Length of setting data, or negative error
2638 */
2639static int unixtime_fetch ( void *data, size_t len ) {
2640 uint32_t content;
2641
2642 /* Return current time */
2643 content = htonl ( time ( NULL ) );
2644 if ( len > sizeof ( content ) )
2645 len = sizeof ( content );
2646 memcpy ( data, &content, len );
2647 return sizeof ( content );
2648}
2649
2650/**
2651 * Store current time setting
2652 *
2653 * @v data Setting data, or NULL to clear setting
2654 * @v len Length of setting data
2655 * @ret rc Return status code
2656 */
2657static int unixtime_store ( const void *data, size_t len ) {
2658 unsigned long value;
2659 int check_len;
2660 int rc;
2661
2662 /* Get intended current time */
2663 check_len = numeric_setting_value ( 0, data, len, &value );
2664 if ( check_len < 0 ) {
2665 rc = check_len;
2666 return rc;
2667 }
2668
2669 /* Adjust or restore system clock, as applicable */
2670 if ( len ) {
2671 time_adjust ( value - time ( NULL ) );
2672 } else {
2673 time_restore();
2674 }
2675
2676 return 0;
2677}
2678
2679/** Current time setting */
2680const struct setting unixtime_setting __setting ( SETTING_MISC, unixtime ) = {
2681 .name = "unixtime",
2682 .description = "Seconds since the Epoch",
2683 .type = &setting_type_uint32,
2684 .scope = &builtin_scope,
2685};
2686
2687/** Current time built-in setting */
2688struct builtin_setting unixtime_builtin_setting __builtin_setting = {
2689 .setting = &unixtime_setting,
2690 .store = unixtime_store,
2691 .fetch = unixtime_fetch,
2692};
2693
2694/**
2695 * Fetch current working URI-related setting
2696 *
2697 * @v data Buffer to fill with setting data
2698 * @v len Length of buffer
2699 * @v rel Relative URI string
2700 * @ret len Length of setting data, or negative error
2701 */
2702static int cwuri_fetch_uri ( void *data, size_t len, const char *rel ) {
2703 struct uri *reluri;
2704 struct uri *uri;
2705 char *uristring;
2706 int ret;
2707
2708 /* Check that current working URI is set */
2709 if ( ! cwuri ) {
2710 ret = -ENOENT;
2711 goto err_unset;
2712 }
2713
2714 /* Construct relative URI */
2715 reluri = parse_uri ( rel );
2716 if ( ! reluri ) {
2717 ret = -ENOMEM;
2718 goto err_parse;
2719 }
2720
2721 /* Construct resolved URI */
2722 uri = resolve_uri ( cwuri, reluri );
2723 if ( ! uri ) {
2724 ret = -ENOMEM;
2725 goto err_resolve;
2726 }
2727
2728 /* Format URI string into allocated buffer (with NUL) */
2729 uristring = format_uri_alloc ( uri );
2730 if ( ! uristring ) {
2731 ret = -ENOMEM;
2732 goto err_format;
2733 }
2734
2735 /* Copy URI string to buffer */
2736 strncpy ( data, uristring, len );
2737 ret = strlen ( uristring );
2738
2739 free ( uristring );
2740 err_format:
2741 uri_put ( uri );
2742 err_resolve:
2743 uri_put ( reluri );
2744 err_parse:
2745 err_unset:
2746 return ret;
2747}
2748
2749/**
2750 * Fetch current working URI setting
2751 *
2752 * @v data Buffer to fill with setting data
2753 * @v len Length of buffer
2754 * @ret len Length of setting data, or negative error
2755 */
2756static int cwuri_fetch ( void *data, size_t len ) {
2757
2758 return cwuri_fetch_uri ( data, len, "" );
2759}
2760
2761/**
2762 * Fetch current working directory URI setting
2763 *
2764 * @v data Buffer to fill with setting data
2765 * @v len Length of buffer
2766 * @ret len Length of setting data, or negative error
2767 */
2768static int cwduri_fetch ( void *data, size_t len ) {
2769
2770 return cwuri_fetch_uri ( data, len, "." );
2771}
2772
2773/** Current working URI setting */
2774const struct setting cwuri_setting __setting ( SETTING_MISC, cwuri ) = {
2775 .name = "cwuri",
2776 .description = "Current working URI",
2777 .type = &setting_type_string,
2778 .scope = &builtin_scope,
2779};
2780
2781/** Current working directory URI setting */
2782const struct setting cwduri_setting __setting ( SETTING_MISC, cwduri ) = {
2783 .name = "cwduri",
2784 .description = "Current working directory URI",
2785 .type = &setting_type_string,
2786 .scope = &builtin_scope,
2787};
2788
2789/** Current working URI built-in setting */
2790struct builtin_setting cwuri_builtin_setting __builtin_setting = {
2791 .setting = &cwuri_setting,
2792 .fetch = cwuri_fetch,
2793};
2794
2795/** Current working directory URI built-in setting */
2796struct builtin_setting cwduri_builtin_setting __builtin_setting = {
2797 .setting = &cwduri_setting,
2798 .fetch = cwduri_fetch,
2799};
2800
2801/**
2802 * Store built-in setting
2803 *
2804 * @v settings Settings block
2805 * @v setting Setting to store
2806 * @v data Setting data, or NULL to clear setting
2807 * @v len Length of setting data
2808 * @ret rc Return status code
2809 */
2810static int builtin_store ( struct settings *settings __unused,
2811 const struct setting *setting,
2812 const void *data, size_t len ) {
2813 struct builtin_setting *builtin;
2814
2815 for_each_table_entry ( builtin, BUILTIN_SETTINGS ) {
2816 if ( setting_cmp ( setting, builtin->setting ) == 0 ) {
2817 if ( ! builtin->store )
2818 return -ENOTSUP;
2819 return builtin->store ( data, len );
2820 }
2821 }
2822 return -ENOENT;
2823}
2824
2825/**
2826 * Fetch built-in setting
2827 *
2828 * @v settings Settings block
2829 * @v setting Setting to fetch
2830 * @v data Buffer to fill with setting data
2831 * @v len Length of buffer
2832 * @ret len Length of setting data, or negative error
2833 */
2834static int builtin_fetch ( struct settings *settings __unused,
2835 struct setting *setting,
2836 void *data, size_t len ) {
2837 struct builtin_setting *builtin;
2838
2839 for_each_table_entry ( builtin, BUILTIN_SETTINGS ) {
2840 if ( setting_cmp ( setting, builtin->setting ) == 0 )
2841 return builtin->fetch ( data, len );
2842 }
2843 return -ENOENT;
2844}
2845
2846/**
2847 * Check applicability of built-in setting
2848 *
2849 * @v settings Settings block
2850 * @v setting Setting
2851 * @ret applies Setting applies within this settings block
2852 */
2853static int builtin_applies ( struct settings *settings __unused,
2854 const struct setting *setting ) {
2855
2856 return ( setting->scope == &builtin_scope );
2857}
2858
2859/** Built-in settings operations */
2860static struct settings_operations builtin_settings_operations = {
2861 .applies = builtin_applies,
2862 .store = builtin_store,
2863 .fetch = builtin_fetch,
2864};
2865
2866/** Built-in settings */
2867static struct settings builtin_settings = {
2868 .refcnt = NULL,
2869 .siblings = LIST_HEAD_INIT ( builtin_settings.siblings ),
2870 .children = LIST_HEAD_INIT ( builtin_settings.children ),
2871 .op = &builtin_settings_operations,
2872};
2873
2874/** Initialise built-in settings */
2875static void builtin_init ( void ) {
2876 int rc;
2877
2878 if ( ( rc = register_settings ( &builtin_settings, NULL,
2879 "builtin" ) ) != 0 ) {
2880 DBG ( "Could not register built-in settings: %s\n",
2881 strerror ( rc ) );
2882 return;
2883 }
2884}
2885
2886/** Built-in settings initialiser */
2887struct init_fn builtin_init_fn __init_fn ( INIT_NORMAL ) = {
2888 .name = "builtin",
2889 .initialise = builtin_init,
2890};
NULL
#define NULL
NULL pointer (VOID *).
Definition Base.h:321
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:61
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:598
DBGC
#define DBGC(...)
Definition compiler.h:530
DBG
#define DBG(...)
Print a debugging message.
Definition compiler.h:523
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:921
ENOENT
#define ENOENT
No such file or directory.
Definition errno.h:558
EINVAL
#define EINVAL
Invalid argument.
Definition errno.h:472
ENOMEM
#define ENOMEM
Not enough space.
Definition errno.h:578
ENOTSUP
#define ENOTSUP
Operation not supported.
Definition errno.h:633
ERANGE
#define ERANGE
Result too large.
Definition errno.h:683
ENODEV
#define ENODEV
No such device.
Definition errno.h:553
ENOTTY
#define ENOTTY
Inappropriate I/O control operation.
Definition errno.h:638
FILE_SECBOOT
#define FILE_SECBOOT(_status)
Declare a file's UEFI Secure Boot permission status.
Definition compiler.h:951
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:244
_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:542
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:315
__builtin_setting
#define __builtin_setting
Declare a built-in setting.
Definition settings.h:292
generic_settings_init
static void generic_settings_init(struct generic_settings *generics, struct refcnt *refcnt)
Initialise a settings block.
Definition settings.h:528
SETTINGS
#define SETTINGS
Configuration setting table.
Definition settings.h:54
BUILTIN_SETTINGS
#define BUILTIN_SETTINGS
Built-in settings table.
Definition settings.h:289
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:718
malloc
void * malloc(size_t size)
Allocate memory.
Definition malloc.c:677
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:286
PCI_FUNC
#define PCI_FUNC(busdevfn)
Definition pci.h:289
PCI_BUS
#define PCI_BUS(busdevfn)
Definition pci.h:287
PCI_SLOT
#define PCI_SLOT(busdevfn)
Definition pci.h:288
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:1200
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:1162
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:2141
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:1694
builtin_settings_operations
static struct settings_operations builtin_settings_operations
Built-in settings operations.
Definition settings.c:2860
version_fetch
static int version_fetch(void *data, size_t len)
Fetch version setting.
Definition settings.c:2613
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:2341
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:1916
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:1617
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:1788
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:1643
platform_fetch
static int platform_fetch(void *data, size_t len)
Fetch platform setting.
Definition settings.c:2585
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:2078
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:1987
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:1665
find_setting_type
static const struct setting_type * find_setting_type(const char *name)
Find setting type.
Definition settings.c:1513
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:1803
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:2178
unixtime_store
static int unixtime_store(const void *data, size_t len)
Store current time setting.
Definition settings.c:2657
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:1772
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:1826
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:2021
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:1383
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:1079
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:1181
cwduri_fetch
static int cwduri_fetch(void *data, size_t len)
Fetch current working directory URI setting.
Definition settings.c:2768
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:2194
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:2249
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:1034
builtin_settings
static struct settings builtin_settings
Built-in settings.
Definition settings.c:2867
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:2126
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:2875
builtin_applies
static int builtin_applies(struct settings *settings __unused, const struct setting *setting)
Check applicability of built-in setting.
Definition settings.c:2853
setting_type_int_width
static unsigned int setting_type_int_width(const struct setting_type *type)
Get integer setting type width.
Definition settings.c:1866
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:2702
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:2525
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:1539
find_setting
struct setting * find_setting(const char *name)
Find predefined setting.
Definition settings.c:1477
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:2063
clear_settings
void clear_settings(struct settings *settings)
Clear settings block.
Definition settings.c:1113
builtin_scope
const struct settings_scope builtin_scope
Built-in setting scope.
Definition settings.c:2516
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:1940
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:1131
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:1963
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:2834
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:1050
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:1240
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:2007
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:1890
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:1749
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:1287
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:2557
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:1330
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:1064
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:2293
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:1095
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:2218
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:1710
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:1733
storen_setting
int storen_setting(struct settings *settings, const struct setting *setting, unsigned long value)
Store numeric value of setting.
Definition settings.c:1425
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:2094
builtin_store
static int builtin_store(struct settings *settings __unused, const struct setting *setting, const void *data, size_t len)
Store built-in setting.
Definition settings.c:2810
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:2110
setting_type_int_index
setting_type_int_index
Integer setting type indices.
Definition settings.c:1811
SETTING_TYPE_INT8
@ SETTING_TYPE_INT8
Definition settings.c:1812
SETTING_TYPE_INT16
@ SETTING_TYPE_INT16
Definition settings.c:1813
SETTING_TYPE_INT32
@ SETTING_TYPE_INT32
Definition settings.c:1814
parse_setting_tag
static uint64_t parse_setting_tag(const char *name)
Parse setting name as tag number.
Definition settings.c:1493
cwuri_fetch
static int cwuri_fetch(void *data, size_t len)
Fetch current working URI setting.
Definition settings.c:2756
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:1877
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:1219
unixtime_fetch
static int unixtime_fetch(void *data, size_t len)
Fetch current time setting.
Definition settings.c:2639
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:516
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:288
strdup
char * strdup(const char *src)
Duplicate string.
Definition string.c:425
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:392
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:285
builtin_setting::store
int(* store)(const void *data, size_t len)
Store setting value.
Definition settings.h:278
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:307
generic_settings::list
struct list_head list
List of generic settings.
Definition settings.h:311
generic_settings::settings
struct settings settings
Settings block.
Definition settings.h:309
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:72
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.16.1