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