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