[Settings] Introduce settings applicators.
[people/dverkamp/gpxe.git] / src / core / settings.c
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., 675 Mass Ave, Cambridge, MA 02139, USA.
17  */
18
19 #include <stdint.h>
20 #include <stdlib.h>
21 #include <stdio.h>
22 #include <string.h>
23 #include <strings.h>
24 #include <byteswap.h>
25 #include <errno.h>
26 #include <assert.h>
27 #include <gpxe/in.h>
28 #include <gpxe/vsprintf.h>
29 #include <gpxe/dhcp.h>
30 #include <gpxe/settings.h>
31
32 /** @file
33  *
34  * Configuration settings
35  *
36  */
37
38 /** Registered setting types */
39 static struct setting_type setting_types[0]
40         __table_start ( struct setting_type, setting_types );
41 static struct setting_type setting_types_end[0]
42         __table_end ( struct setting_type, setting_types );
43
44 /** Registered named settings */
45 static struct named_setting named_settings[0]
46         __table_start ( struct named_setting, named_settings );
47 static struct named_setting named_settings_end[0]
48         __table_end ( struct named_setting, named_settings );
49
50 /** Registered settings applicators */
51 static struct settings_applicator settings_applicators[0]
52         __table_start ( struct settings_applicator, settings_applicators );
53 static struct settings_applicator settings_applicators_end[0]
54         __table_end ( struct settings_applicator, settings_applicators );
55
56 /**
57  * Obtain printable version of a settings tag number
58  *
59  * @v tag               Settings tag number
60  * @ret name            String representation of the tag
61  */
62 static inline char * setting_tag_name ( unsigned int tag ) {
63         static char name[8];
64
65         if ( DHCP_IS_ENCAP_OPT ( tag ) ) {
66                 snprintf ( name, sizeof ( name ), "%d.%d",
67                            DHCP_ENCAPSULATOR ( tag ),
68                            DHCP_ENCAPSULATED ( tag ) );
69         } else {
70                 snprintf ( name, sizeof ( name ), "%d", tag );
71         }
72         return name;
73 }
74
75 /******************************************************************************
76  *
77  * Registered settings blocks
78  *
79  ******************************************************************************
80  */
81
82 // Dummy routine just for testing
83 int simple_settings_store ( struct settings *settings, unsigned int tag,
84                             const void *data, size_t len ) {
85         DBGC ( settings, "Settings %p: store %s to:\n",
86                settings, setting_tag_name ( tag ) );
87         DBGC_HD ( settings, data, len );
88         return 0;
89 }
90
91 // Dummy routine just for testing
92 int simple_settings_fetch ( struct settings *settings, unsigned int tag,
93                             void *data, size_t len ) {
94         unsigned int i;
95
96         DBGC ( settings, "Settings %p: fetch %s\n",
97                settings, setting_tag_name ( tag ) );
98         for ( i = 0 ; i < len ; i++ )
99                 *( ( ( uint8_t * ) data ) + i ) = i;
100         return ( len ? len : 8 );
101 }
102
103 /** Simple settings operations */
104 struct settings_operations simple_settings_operations = {
105         .store = simple_settings_store,
106         .fetch = simple_settings_fetch,
107 };
108
109 /** Root settings block */
110 struct settings settings_root = {
111         .refcnt = NULL,
112         .name = "",
113         .siblings = LIST_HEAD_INIT ( settings_root.siblings ),
114         .children = LIST_HEAD_INIT ( settings_root.children ),
115         .op = &simple_settings_operations,
116 };
117
118 /**
119  * Apply all settings
120  *
121  * @ret rc              Return status code
122  */
123 static int apply_settings ( void ) {
124         struct settings_applicator *applicator;
125         int rc;
126
127         /* Call all settings applicators */
128         for ( applicator = settings_applicators ;
129               applicator < settings_applicators_end ; applicator++ ) {
130                 if ( ( rc = applicator->apply() ) != 0 ) {
131                         DBG ( "Could not apply settings using applicator "
132                               "%p: %s\n", applicator, strerror ( rc ) );
133                         return rc;
134                 }
135         }
136
137         return 0;
138 }
139
140 /**
141  * Reprioritise settings
142  *
143  * @v settings          Settings block
144  *
145  * Reorders the settings block amongst its siblings according to its
146  * priority.
147  */
148 static void reprioritise_settings ( struct settings *settings ) {
149         struct settings *parent = settings->parent;
150         long priority;
151         struct settings *tmp;
152         long tmp_priority;
153
154         /* Stop when we reach the top of the tree */
155         if ( ! parent )
156                 return;
157
158         /* Read priority, if present */
159         priority = 0;
160         fetch_int_setting ( settings, DHCP_EB_PRIORITY, &priority );
161
162         /* Remove from siblings list */
163         list_del ( &settings->siblings );
164
165         /* Reinsert after any existing blocks which have a higher priority */
166         list_for_each_entry ( tmp, &parent->children, siblings ) {
167                 tmp_priority = 0;
168                 fetch_int_setting ( tmp, DHCP_EB_PRIORITY, &tmp_priority );
169                 if ( priority > tmp_priority )
170                         break;
171         }
172         list_add_tail ( &settings->siblings, &tmp->siblings );
173
174         /* Recurse up the tree */
175         reprioritise_settings ( parent );
176 }
177
178 /**
179  * Register settings block
180  *
181  * @v settings          Settings block
182  * @v parent            Parent settings block, or NULL
183  * @ret rc              Return status code
184  */
185 int register_settings ( struct settings *settings, struct settings *parent ) {
186
187         /* NULL parent => add to settings root */
188         assert ( settings != NULL );
189         if ( parent == NULL )
190                 parent = &settings_root;
191
192         /* Add to list of settings */
193         ref_get ( settings->refcnt );
194         ref_get ( parent->refcnt );
195         settings->parent = parent;
196         list_add_tail ( &settings->siblings, &parent->children );
197         DBGC ( settings, "Settings %p registered\n", settings );
198
199         /* Fix up settings priority */
200         reprioritise_settings ( settings );
201
202         /* Apply potentially-updated settings */
203         apply_settings();
204
205         return 0;
206 }
207
208 /**
209  * Unregister settings block
210  *
211  * @v settings          Settings block
212  */
213 void unregister_settings ( struct settings *settings ) {
214
215         /* Remove from list of settings */
216         ref_put ( settings->refcnt );
217         ref_put ( settings->parent->refcnt );
218         list_del ( &settings->siblings );
219         DBGC ( settings, "Settings %p unregistered\n", settings );
220
221         /* Apply potentially-updated settings */
222         apply_settings();
223 }
224
225 /**
226  * Find child named settings block
227  *
228  * @v parent            Parent settings block
229  * @v name              Name within this parent
230  * @ret settings        Settings block, or NULL
231  */
232 struct settings * find_child_settings ( struct settings *parent,
233                                         const char *name ) {
234         struct settings *settings;
235         size_t len;
236
237         /* Look for a child whose name matches the initial component */
238         list_for_each_entry ( settings, &parent->children, siblings ) {
239                 len = strlen ( settings->name );
240                 if ( strncmp ( name, settings->name, len ) != 0 )
241                         continue;
242                 if ( name[len] == 0 )
243                         return settings;
244                 if ( name[len] == '.' )
245                         return find_child_settings ( settings,
246                                                      ( name + len + 1 ) );
247         }
248
249         return NULL;
250 }
251
252 /**
253  * Find named settings block
254  *
255  * @v name              Name
256  * @ret settings        Settings block, or NULL
257  */
258 struct settings * find_settings ( const char *name ) {
259
260         /* If name is empty, use the root */
261         if ( ! *name )
262                 return &settings_root;
263
264         return find_child_settings ( &settings_root, name );
265 }
266
267 /******************************************************************************
268  *
269  * Core settings routines
270  *
271  ******************************************************************************
272  */
273
274 /**
275  * Store value of setting
276  *
277  * @v settings          Settings block
278  * @v tag               Setting tag number
279  * @v data              Setting data, or NULL to clear setting
280  * @v len               Length of setting data
281  * @ret rc              Return status code
282  */
283 int store_setting ( struct settings *settings, unsigned int tag,
284                     const void *data, size_t len ) {
285         int rc;
286
287         /* Store setting */
288         if ( ( rc = settings->op->store ( settings, tag, data, len ) ) != 0 )
289                 return rc;
290
291         /* Reprioritise settings if necessary */
292         if ( tag == DHCP_EB_PRIORITY )
293                 reprioritise_settings ( settings );
294
295         /* Apply potentially-updated setting */
296         if ( ( rc = apply_settings() ) != 0 )
297                 return rc;
298
299         return 0;
300 }
301
302 /**
303  * Fetch value of setting
304  *
305  * @v settings          Settings block, or NULL to search all blocks
306  * @v tag               Setting tag number
307  * @v data              Buffer to fill with setting data
308  * @v len               Length of buffer
309  * @ret len             Length of setting data, or negative error
310  *
311  * The actual length of the setting will be returned even if
312  * the buffer was too small.
313  */
314 int fetch_setting ( struct settings *settings, unsigned int tag,
315                     void *data, size_t len ) {
316         struct settings *child;
317         int ret;
318
319         /* NULL settings implies starting at the global settings root */
320         if ( ! settings )
321                 settings = &settings_root;
322
323         /* Try this block first */
324         if ( ( ret = settings->op->fetch ( settings, tag, data, len ) ) >= 0)
325                 return ret;
326
327         /* Recurse into each child block in turn */
328         list_for_each_entry ( child, &settings->children, siblings ) {
329                 if ( ( ret = fetch_setting ( settings, tag, data, len ) ) >= 0)
330                         return ret;
331         }
332
333         return -ENOENT;
334 }
335
336 /**
337  * Fetch length of setting
338  *
339  * @v settings          Settings block, or NULL to search all blocks
340  * @v tag               Setting tag number
341  * @ret len             Length of setting data, or negative error
342  *
343  * This function can also be used as an existence check for the
344  * setting.
345  */
346 int fetch_setting_len ( struct settings *settings, unsigned int tag ) {
347         return fetch_setting ( settings, tag, NULL, 0 );
348 }
349
350 /**
351  * Fetch value of string setting
352  *
353  * @v settings          Settings block, or NULL to search all blocks
354  * @v tag               Setting tag number
355  * @v data              Buffer to fill with setting string data
356  * @v len               Length of buffer
357  * @ret len             Length of string setting, or negative error
358  *
359  * The resulting string is guaranteed to be correctly NUL-terminated.
360  * The returned length will be the length of the underlying setting
361  * data.
362  */
363 int fetch_string_setting ( struct settings *settings, unsigned int tag,
364                            char *data, size_t len ) {
365         memset ( data, 0, len );
366         return fetch_setting ( settings, tag, data, ( len - 1 ) );
367 }
368
369 /**
370  * Fetch value of IPv4 address setting
371  *
372  * @v settings          Settings block, or NULL to search all blocks
373  * @v tag               Setting tag number
374  * @v inp               IPv4 address to fill in
375  * @ret len             Length of setting, or negative error
376  */
377 int fetch_ipv4_setting ( struct settings *settings, unsigned int tag,
378                          struct in_addr *inp ) {
379         int len;
380
381         len = fetch_setting ( settings, tag, inp, sizeof ( *inp ) );
382         if ( len < 0 )
383                 return len;
384         if ( len < ( int ) sizeof ( *inp ) )
385                 return -ERANGE;
386         return len;
387 }
388
389 /**
390  * Fetch value of signed integer setting
391  *
392  * @v settings          Settings block, or NULL to search all blocks
393  * @v tag               Setting tag number
394  * @v value             Integer value to fill in
395  * @ret len             Length of setting, or negative error
396  */
397 int fetch_int_setting ( struct settings *settings, unsigned int tag,
398                         long *value ) {
399         union {
400                 long value;
401                 uint8_t u8[ sizeof ( long ) ];
402                 int8_t s8[ sizeof ( long ) ];
403         } buf;
404         int len;
405         int i;
406
407         buf.value = 0;
408         len = fetch_setting ( settings, tag, &buf, sizeof ( buf ) );
409         if ( len < 0 )
410                 return len;
411         if ( len > ( int ) sizeof ( buf ) )
412                 return -ERANGE;
413
414         *value = ( ( buf.s8[0] >= 0 ) ? 0 : -1L );
415         for ( i = 0 ; i < len ; i++ ) {
416                 *value = ( ( *value << 8 ) | buf.u8[i] );
417         }
418
419         return len;
420 }
421
422 /**
423  * Fetch value of unsigned integer setting
424  *
425  * @v settings          Settings block, or NULL to search all blocks
426  * @v tag               Setting tag number
427  * @v value             Integer value to fill in
428  * @ret len             Length of setting, or negative error
429  */
430 int fetch_uint_setting ( struct settings *settings, unsigned int tag,
431                          unsigned long *value ) {
432         long svalue;
433         int len;
434
435         len = fetch_int_setting ( settings, tag, &svalue );
436         if ( len < 0 )
437                 return len;
438
439         *value = ( svalue & ( -1UL >> ( sizeof ( long ) - len ) ) );
440
441         return len;
442 }
443
444 /******************************************************************************
445  *
446  * Named and typed setting routines
447  *
448  ******************************************************************************
449  */
450
451 /**
452  * Store value of typed setting
453  *
454  * @v settings          Settings block
455  * @v tag               Setting tag number
456  * @v type              Settings type
457  * @v value             Formatted setting data, or NULL
458  * @ret rc              Return status code
459  */
460 int store_typed_setting ( struct settings *settings,
461                           unsigned int tag, struct setting_type *type,
462                           const char *value ) {
463
464         /* NULL value implies deletion.  Avoid imposing the burden of
465          * checking for NULL values on each typed setting's storef()
466          * method.
467          */
468         if ( ! value )
469                 return delete_setting ( settings, tag );
470                 
471         return type->storef ( settings, tag, value );
472 }
473
474 /**
475  * Find named setting
476  *
477  * @v name              Name
478  * @ret setting         Named setting, or NULL
479  */
480 static struct named_setting * find_named_setting ( const char *name ) {
481         struct named_setting *setting;
482
483         for ( setting = named_settings ; setting < named_settings_end ;
484               setting++ ) {
485                 if ( strcmp ( name, setting->name ) == 0 )
486                         return setting;
487         }
488         return NULL;
489 }
490
491 /**
492  * Find setting type
493  *
494  * @v name              Name
495  * @ret type            Setting type, or NULL
496  */
497 static struct setting_type * find_setting_type ( const char *name ) {
498         struct setting_type *type;
499
500         for ( type = setting_types ; type < setting_types_end ; type++ ) {
501                 if ( strcmp ( name, type->name ) == 0 )
502                         return type;
503         }
504         return NULL;
505 }
506
507 /**
508  * Parse setting name
509  *
510  * @v name              Name of setting
511  * @ret settings        Settings block, or NULL
512  * @ret tag             Setting tag number
513  * @ret type            Setting type
514  * @ret rc              Return status code
515  *
516  * Interprets a name of the form
517  * "[settings_name/]tag_name[:type_name]" and fills in the appropriate
518  * fields.
519  */
520 static int parse_setting_name ( const char *name, struct settings **settings,
521                                 unsigned int *tag,
522                                 struct setting_type **type ) {
523         char tmp_name[ strlen ( name ) + 1 ];
524         char *settings_name;
525         char *tag_name;
526         char *type_name;
527         struct named_setting *named_setting;
528         char *tmp;
529
530         /* Set defaults */
531         *settings = &settings_root;
532         *tag = 0;
533         *type = &setting_type_hex;
534
535         /* Split name into "[settings_name/]tag_name[:type_name]" */
536         memcpy ( tmp_name, name, sizeof ( tmp_name ) );
537         if ( ( tag_name = strchr ( tmp_name, '/' ) ) != NULL ) {
538                 *(tag_name++) = 0;
539                 settings_name = tmp_name;
540         } else {
541                 tag_name = tmp_name;
542                 settings_name = NULL;
543         }
544         if ( ( type_name = strchr ( tag_name, ':' ) ) != NULL )
545                 *(type_name++) = 0;
546
547         /* Identify settings block, if specified */
548         if ( settings_name ) {
549                 *settings = find_settings ( settings_name );
550                 if ( *settings == NULL ) {
551                         DBG ( "Unrecognised settings block \"%s\" in \"%s\"\n",
552                               settings_name, name );
553                         return -ENODEV;
554                 }
555         }
556
557         /* Identify tag number */
558         if ( ( named_setting = find_named_setting ( tag_name ) ) != NULL ) {
559                 *tag = named_setting->tag;
560                 *type = named_setting->type;
561         } else {
562                 /* Unrecognised name: try to interpret as a tag number */
563                 tmp = tag_name;
564                 while ( 1 ) {
565                         *tag = ( ( *tag << 8 ) | strtoul ( tmp, &tmp, 0 ) );
566                         if ( *tmp == 0 )
567                                 break;
568                         if ( *tmp != '.' ) {
569                                 DBG ( "Invalid tag number \"%s\" in \"%s\"\n",
570                                       tag_name, name );
571                                 return -ENOENT;
572                         }
573                         tmp++;
574                 }
575         }
576
577         /* Identify setting type, if specified */
578         if ( type_name ) {
579                 *type = find_setting_type ( type_name );
580                 if ( *type == NULL ) {
581                         DBG ( "Invalid setting type \"%s\" in \"%s\"\n",
582                               type_name, name );
583                         return -ENOTSUP;
584                 }
585         }
586
587         return 0;
588 }
589
590 /**
591  * Parse and store value of named setting
592  *
593  * @v name              Name of setting
594  * @v value             Formatted setting data, or NULL
595  * @ret rc              Return status code
596  */
597 int store_named_setting ( const char *name, const char *value ) {
598         struct settings *settings;
599         unsigned int tag;
600         struct setting_type *type;
601         int rc;
602
603         if ( ( rc = parse_setting_name ( name, &settings, &tag,
604                                          &type ) ) != 0 )
605                 return rc;
606         return store_typed_setting ( settings, tag, type, value );
607 }
608
609 /**
610  * Fetch and format value of named setting
611  *
612  * @v name              Name of setting
613  * @v buf               Buffer to contain formatted value
614  * @v len               Length of buffer
615  * @ret len             Length of formatted value, or negative error
616  */
617 int fetch_named_setting ( const char *name, char *buf, size_t len ) {
618         struct settings *settings;
619         unsigned int tag;
620         struct setting_type *type;
621         int rc;
622
623         if ( ( rc = parse_setting_name ( name, &settings, &tag,
624                                          &type ) ) != 0 )
625                 return rc;
626         return fetch_typed_setting ( settings, tag, type, buf, len );
627 }
628
629 /******************************************************************************
630  *
631  * Setting types
632  *
633  ******************************************************************************
634  */
635
636 /**
637  * Parse and store value of string setting
638  *
639  * @v settings          Settings block
640  * @v tag               Setting tag number
641  * @v value             Formatted setting data
642  * @ret rc              Return status code
643  */
644 static int storef_string ( struct settings *settings, unsigned int tag,
645                            const char *value ) {
646         return store_setting ( settings, tag, value, strlen ( value ) );
647 }
648
649 /**
650  * Fetch and format value of string setting
651  *
652  * @v settings          Settings block, or NULL to search all blocks
653  * @v tag               Setting tag number
654  * @v buf               Buffer to contain formatted value
655  * @v len               Length of buffer
656  * @ret len             Length of formatted value, or negative error
657  */
658 static int fetchf_string ( struct settings *settings, unsigned int tag,
659                            char *buf, size_t len ) {
660         return fetch_string_setting ( settings, tag, buf, len );
661 }
662
663 /** A string setting type */
664 struct setting_type setting_type_string __setting_type = {
665         .name = "string",
666         .storef = storef_string,
667         .fetchf = fetchf_string,
668 };
669
670 /**
671  * Parse and store value of IPv4 address setting
672  *
673  * @v settings          Settings block
674  * @v tag               Setting tag number
675  * @v value             Formatted setting data
676  * @ret rc              Return status code
677  */
678 static int storef_ipv4 ( struct settings *settings, unsigned int tag,
679                          const char *value ) {
680         struct in_addr ipv4;
681
682         if ( inet_aton ( value, &ipv4 ) == 0 )
683                 return -EINVAL;
684         return store_setting ( settings, tag, &ipv4, sizeof ( ipv4 ) );
685 }
686
687 /**
688  * Fetch and format value of IPv4 address setting
689  *
690  * @v settings          Settings block, or NULL to search all blocks
691  * @v tag               Setting tag number
692  * @v buf               Buffer to contain formatted value
693  * @v len               Length of buffer
694  * @ret len             Length of formatted value, or negative error
695  */
696 static int fetchf_ipv4 ( struct settings *settings, unsigned int tag,
697                          char *buf, size_t len ) {
698         struct in_addr ipv4;
699         int rc;
700
701         if ( ( rc = fetch_ipv4_setting ( settings, tag, &ipv4 ) ) < 0 )
702                 return rc;
703         return snprintf ( buf, len, inet_ntoa ( ipv4 ) );
704 }
705
706 /** An IPv4 address setting type */
707 struct setting_type setting_type_ipv4 __setting_type = {
708         .name = "ipv4",
709         .storef = storef_ipv4,
710         .fetchf = fetchf_ipv4,
711 };
712
713 /**
714  * Parse and store value of integer setting
715  *
716  * @v settings          Settings block
717  * @v tag               Setting tag number
718  * @v value             Formatted setting data
719  * @v size              Integer size, in bytes
720  * @ret rc              Return status code
721  */
722 static int storef_int ( struct settings *settings, unsigned int tag,
723                         const char *value, unsigned int size ) {
724         union {
725                 uint32_t num;
726                 uint8_t bytes[4];
727         } u;
728         char *endp;
729
730         u.num = htonl ( strtoul ( value, &endp, 0 ) );
731         if ( *endp )
732                 return -EINVAL;
733         return store_setting ( settings, tag, 
734                                &u.bytes[ sizeof ( u ) - size ], size );
735 }
736
737 /**
738  * Parse and store value of 8-bit integer setting
739  *
740  * @v settings          Settings block
741  * @v tag               Setting tag number
742  * @v value             Formatted setting data
743  * @v size              Integer size, in bytes
744  * @ret rc              Return status code
745  */
746 static int storef_int8 ( struct settings *settings, unsigned int tag,
747                          const char *value ) {
748         return storef_int ( settings, tag, value, 1 );
749 }
750
751 /**
752  * Parse and store value of 16-bit integer setting
753  *
754  * @v settings          Settings block
755  * @v tag               Setting tag number
756  * @v value             Formatted setting data
757  * @v size              Integer size, in bytes
758  * @ret rc              Return status code
759  */
760 static int storef_int16 ( struct settings *settings, unsigned int tag,
761                           const char *value ) {
762         return storef_int ( settings, tag, value, 2 );
763 }
764
765 /**
766  * Parse and store value of 32-bit integer setting
767  *
768  * @v settings          Settings block
769  * @v tag               Setting tag number
770  * @v value             Formatted setting data
771  * @v size              Integer size, in bytes
772  * @ret rc              Return status code
773  */
774 static int storef_int32 ( struct settings *settings, unsigned int tag,
775                           const char *value ) {
776         return storef_int ( settings, tag, value, 4 );
777 }
778
779 /**
780  * Fetch and format value of signed integer setting
781  *
782  * @v settings          Settings block, or NULL to search all blocks
783  * @v tag               Setting tag number
784  * @v buf               Buffer to contain formatted value
785  * @v len               Length of buffer
786  * @ret len             Length of formatted value, or negative error
787  */
788 static int fetchf_int ( struct settings *settings, unsigned int tag,
789                         char *buf, size_t len ) {
790         long value;
791         int rc;
792
793         if ( ( rc = fetch_int_setting ( settings, tag, &value ) ) < 0 )
794                 return rc;
795         return snprintf ( buf, len, "%ld", value );
796 }
797
798 /**
799  * Fetch and format value of unsigned integer setting
800  *
801  * @v settings          Settings block, or NULL to search all blocks
802  * @v tag               Setting tag number
803  * @v buf               Buffer to contain formatted value
804  * @v len               Length of buffer
805  * @ret len             Length of formatted value, or negative error
806  */
807 static int fetchf_uint ( struct settings *settings, unsigned int tag,
808                          char *buf, size_t len ) {
809         unsigned long value;
810         int rc;
811
812         if ( ( rc = fetch_uint_setting ( settings, tag, &value ) ) < 0 )
813                 return rc;
814         return snprintf ( buf, len, "%#lx", value );
815 }
816
817 /** A signed 8-bit integer setting type */
818 struct setting_type setting_type_int8 __setting_type = {
819         .name = "int8",
820         .storef = storef_int8,
821         .fetchf = fetchf_int,
822 };
823
824 /** A signed 16-bit integer setting type */
825 struct setting_type setting_type_int16 __setting_type = {
826         .name = "int16",
827         .storef = storef_int16,
828         .fetchf = fetchf_int,
829 };
830
831 /** A signed 32-bit integer setting type */
832 struct setting_type setting_type_int32 __setting_type = {
833         .name = "int32",
834         .storef = storef_int32,
835         .fetchf = fetchf_int,
836 };
837
838 /** An unsigned 8-bit integer setting type */
839 struct setting_type setting_type_uint8 __setting_type = {
840         .name = "uint8",
841         .storef = storef_int8,
842         .fetchf = fetchf_uint,
843 };
844
845 /** An unsigned 16-bit integer setting type */
846 struct setting_type setting_type_uint16 __setting_type = {
847         .name = "uint16",
848         .storef = storef_int16,
849         .fetchf = fetchf_uint,
850 };
851
852 /** An unsigned 32-bit integer setting type */
853 struct setting_type setting_type_uint32 __setting_type = {
854         .name = "uint32",
855         .storef = storef_int32,
856         .fetchf = fetchf_uint,
857 };
858
859 /**
860  * Parse and store value of hex string setting
861  *
862  * @v settings          Settings block
863  * @v tag               Setting tag number
864  * @v value             Formatted setting data
865  * @ret rc              Return status code
866  */
867 static int storef_hex ( struct settings *settings, unsigned int tag,
868                         const char *value ) {
869         char *ptr = ( char * ) value;
870         uint8_t bytes[ strlen ( value ) ]; /* cannot exceed strlen(value) */
871         unsigned int len = 0;
872
873         while ( 1 ) {
874                 bytes[len++] = strtoul ( ptr, &ptr, 16 );
875                 switch ( *ptr ) {
876                 case '\0' :
877                         return store_setting ( settings, tag, bytes, len );
878                 case ':' :
879                         ptr++;
880                         break;
881                 default :
882                         return -EINVAL;
883                 }
884         }
885 }
886
887 /**
888  * Fetch and format value of hex string setting
889  *
890  * @v settings          Settings block, or NULL to search all blocks
891  * @v tag               Setting tag number
892  * @v buf               Buffer to contain formatted value
893  * @v len               Length of buffer
894  * @ret len             Length of formatted value, or negative error
895  */
896 static int fetchf_hex ( struct settings *settings, unsigned int tag,
897                         char *buf, size_t len ) {
898         int raw_len;
899         int check_len;
900         int used = 0;
901         int i;
902
903         raw_len = fetch_setting_len ( settings, tag );
904         if ( raw_len < 0 )
905                 return raw_len;
906
907         {
908                 uint8_t raw[raw_len];
909
910                 check_len = fetch_setting ( settings, tag, raw, sizeof (raw) );
911                 assert ( check_len == raw_len );
912                 
913                 if ( len )
914                         buf[0] = 0; /* Ensure that a terminating NUL exists */
915                 for ( i = 0 ; i < raw_len ; i++ ) {
916                         used += ssnprintf ( ( buf + used ), ( len - used ),
917                                             "%s%02x", ( used ? ":" : "" ),
918                                             raw[i] );
919                 }
920                 return used;
921         }
922 }
923
924 /** A hex-string setting */
925 struct setting_type setting_type_hex __setting_type = {
926         .name = "hex",
927         .storef = storef_hex,
928         .fetchf = fetchf_hex,
929 };
930
931 /******************************************************************************
932  *
933  * Named settings
934  *
935  ******************************************************************************
936  */
937
938 /** Some basic setting definitions */
939 struct named_setting basic_named_settings[] __named_setting = {
940         {
941                 .name = "ip",
942                 .description = "IPv4 address",
943                 .tag = DHCP_EB_YIADDR,
944                 .type = &setting_type_ipv4,
945         },
946         {
947                 .name = "netmask",
948                 .description = "IPv4 subnet mask",
949                 .tag = DHCP_SUBNET_MASK,
950                 .type = &setting_type_ipv4,
951         },
952         {
953                 .name = "gateway",
954                 .description = "Default gateway",
955                 .tag = DHCP_ROUTERS,
956                 .type = &setting_type_ipv4,
957         },
958         {
959                 .name = "dns",
960                 .description = "DNS server",
961                 .tag = DHCP_DNS_SERVERS,
962                 .type = &setting_type_ipv4,
963         },
964         {
965                 .name = "hostname",
966                 .description = "Host name",
967                 .tag = DHCP_HOST_NAME,
968                 .type = &setting_type_string,
969         },
970         {
971                 .name = "filename",
972                 .description = "Boot filename",
973                 .tag = DHCP_BOOTFILE_NAME,
974                 .type = &setting_type_string,
975         },
976         {
977                 .name = "root-path",
978                 .description = "NFS/iSCSI root path",
979                 .tag = DHCP_ROOT_PATH,
980                 .type = &setting_type_string,
981         },
982         {
983                 .name = "username",
984                 .description = "User name",
985                 .tag = DHCP_EB_USERNAME,
986                 .type = &setting_type_string,
987         },
988         {
989                 .name = "password",
990                 .description = "Password",
991                 .tag = DHCP_EB_PASSWORD,
992                 .type = &setting_type_string,
993         },
994         {
995                 .name = "initiator-iqn",
996                 .description = "iSCSI initiator name",
997                 .tag = DHCP_ISCSI_INITIATOR_IQN,
998                 .type = &setting_type_string,
999         },
1000         {
1001                 .name = "priority",
1002                 .description = "Priority of these settings",
1003                 .tag = DHCP_EB_PRIORITY,
1004                 .type = &setting_type_int8,
1005         },
1006 };