src/core/settings.c

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