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