/**
* Extract numeric value of setting
*
+ * @v is_signed Treat value as a signed integer
* @v raw Raw setting data
* @v len Length of raw setting data
- * @ret signed_value Value, when interpreted as a signed integer
- * @ret unsigned_value Value, when interpreted as an unsigned integer
+ * @ret value Numeric value
* @ret len Length of setting, or negative error
*/
-static int numeric_setting_value ( const void *raw, size_t len,
- signed long *signed_value,
- unsigned long *unsigned_value ) {
+static int numeric_setting_value ( int is_signed, const void *raw, size_t len,
+ unsigned long *value ) {
const uint8_t *unsigned_bytes = raw;
const int8_t *signed_bytes = raw;
int is_negative;
/* Convert to host-ordered longs */
is_negative = ( len && ( signed_bytes[0] < 0 ) );
- *signed_value = ( is_negative ? -1L : 0 );
- *unsigned_value = 0;
+ *value = ( ( is_signed && is_negative ) ? -1L : 0 );
for ( i = 0 ; i < len ; i++ ) {
byte = unsigned_bytes[i];
- *signed_value = ( ( *signed_value << 8 ) | byte );
- *unsigned_value = ( ( *unsigned_value << 8 ) | byte );
+ *value = ( ( *value << 8 ) | byte );
}
return len;
}
/**
- * Fetch value of signed integer setting
+ * Fetch value of numeric setting
*
* @v settings Settings block, or NULL to search all blocks
* @v setting Setting to fetch
* @v value Integer value to fill in
* @ret len Length of setting, or negative error
*/
-int fetch_int_setting ( struct settings *settings, struct setting *setting,
- long *value ) {
- unsigned long dummy;
- long tmp;
+int fetch_numeric_setting ( struct settings *settings, struct setting *setting,
+ unsigned long *value, int is_signed ) {
+ unsigned long tmp;
int len;
/* Avoid returning uninitialised data on error */
return len;
/* Extract numeric value */
- return numeric_setting_value ( &tmp, len, value, &dummy );
+ return numeric_setting_value ( is_signed, &tmp, len, value );
+}
+
+/**
+ * Fetch value of signed integer setting
+ *
+ * @v settings Settings block, or NULL to search all blocks
+ * @v setting Setting to fetch
+ * @v value Integer value to fill in
+ * @ret len Length of setting, or negative error
+ */
+int fetch_int_setting ( struct settings *settings, struct setting *setting,
+ long *value ) {
+
+ return fetch_numeric_setting ( settings, setting,
+ ( ( unsigned long * ) value ), 1 );
}
/**
*/
int fetch_uint_setting ( struct settings *settings, struct setting *setting,
unsigned long *value ) {
- signed long dummy;
- long tmp;
- int len;
- /* Avoid returning uninitialised data on error */
- *value = 0;
-
- /* Fetch raw (network-ordered, variable-length) setting */
- len = fetch_setting ( settings, setting, &tmp, sizeof ( tmp ) );
- if ( len < 0 )
- return len;
-
- /* Extract numeric value */
- return numeric_setting_value ( &tmp, len, &dummy, value );
+ return fetch_numeric_setting ( settings, setting, value, 0 );
}
/**
* @ret value Setting value, or zero
*/
long fetch_intz_setting ( struct settings *settings, struct setting *setting ){
- long value;
+ unsigned long value;
- fetch_int_setting ( settings, setting, &value );
+ fetch_numeric_setting ( settings, setting, &value, 1 );
return value;
}
struct setting *setting ) {
unsigned long value;
- fetch_uint_setting ( settings, setting, &value );
+ fetch_numeric_setting ( settings, setting, &value, 0 );
return value;
}
******************************************************************************
*/
+/**
+ * Format setting value as a string
+ *
+ * @v type Setting type
+ * @v raw Raw setting value
+ * @v raw_len Length of raw setting value
+ * @v buf Buffer to contain formatted value
+ * @v len Length of buffer
+ * @ret len Length of formatted value, or negative error
+ */
+int setting_format ( struct setting_type *type, const void *raw,
+ size_t raw_len, char *buf, size_t len ) {
+
+ /* Sanity check */
+ if ( ! type->format )
+ return -ENOTSUP;
+
+ return type->format ( type, raw, raw_len, buf, len );
+}
+
+/**
+ * Parse formatted string to setting value
+ *
+ * @v type Setting type
+ * @v value Formatted setting value
+ * @v buf Buffer to contain raw value
+ * @v len Length of buffer
+ * @ret len Length of raw value, or negative error
+ */
+int setting_parse ( struct setting_type *type, const char *value,
+ void *buf, size_t len ) {
+
+ /* Sanity check */
+ if ( ! type->parse )
+ return -ENOTSUP;
+
+ return type->parse ( type, value, buf, len );
+}
+
+/**
+ * Convert setting value to number
+ *
+ * @v type Setting type
+ * @v raw Raw setting value
+ * @v raw_len Length of raw setting value
+ * @ret value Numeric value
+ * @ret rc Return status code
+ */
+int setting_numerate ( struct setting_type *type, const void *raw,
+ size_t raw_len, unsigned long *value ) {
+
+ /* Sanity check */
+ if ( ! type->numerate )
+ return -ENOTSUP;
+
+ return type->numerate ( type, raw, raw_len, value );
+}
+
+/**
+ * Convert number to setting value
+ *
+ * @v type Setting type
+ * @v value Numeric value
+ * @v buf Buffer to contain raw value
+ * @v len Length of buffer
+ * @ret len Length of raw value, or negative error
+ */
+int setting_denumerate ( struct setting_type *type, unsigned long value,
+ void *buf, size_t len ) {
+
+ /* Sanity check */
+ if ( ! type->denumerate )
+ return -ENOTSUP;
+
+ return type->denumerate ( type, value, buf, len );
+}
+
/**
* Fetch formatted value of setting
*
* @v settings Settings block, or NULL to search all blocks
* @v setting Setting to fetch
- * @v type Settings type
* @v buf Buffer to contain formatted value
* @v len Length of buffer
* @ret len Length of formatted value, or negative error
/* Sanity check */
assert ( setting->type != NULL );
- assert ( setting->type->format != NULL );
/* Format setting */
- if ( ( ret = setting->type->format ( raw, raw_len, buf, len ) ) < 0 )
+ if ( ( ret = setting_format ( setting->type, raw, raw_len, buf,
+ len ) ) < 0 )
goto err_format;
err_format:
*
* @v settings Settings block, or NULL to search all blocks
* @v setting Setting to fetch
- * @v type Settings type
* @v value Buffer to allocate and fill with formatted value
* @ret len Length of formatted value, or negative error
*
/* Sanity check */
assert ( setting->type != NULL );
- assert ( setting->type->parse != NULL );
/* Get raw value length */
- raw_len = setting->type->parse ( value, NULL, 0 );
+ raw_len = setting_parse ( setting->type, value, NULL, 0 );
if ( raw_len < 0 ) {
rc = raw_len;
- goto err_parse_len;
+ goto err_raw_len;
}
/* Allocate buffer for raw value */
}
/* Parse formatted value */
- check_len = setting->type->parse ( value, raw, raw_len );
+ check_len = setting_parse ( setting->type, value, raw, raw_len );
+ assert ( check_len == raw_len );
+
+ /* Store raw value */
+ if ( ( rc = store_setting ( settings, setting, raw, raw_len ) ) != 0 )
+ goto err_store;
+
+ err_store:
+ free ( raw );
+ err_alloc_raw:
+ err_raw_len:
+ return rc;
+}
+
+/**
+ * Fetch numeric value of setting
+ *
+ * @v settings Settings block, or NULL to search all blocks
+ * @v setting Setting to fetch
+ * @v value Numeric value to fill in
+ * @ret rc Return status code
+ */
+int fetchn_setting ( struct settings *settings, struct setting *setting,
+ unsigned long *value ) {
+ void *raw;
+ int raw_len;
+ int rc;
+
+ /* Fetch raw value */
+ raw_len = fetch_setting_copy ( settings, setting, &raw );
+ if ( raw_len < 0 ) {
+ rc = raw_len;
+ goto err_fetch_copy;
+ }
+
+ /* Sanity check */
+ assert ( setting->type != NULL );
+
+ /* Numerate setting */
+ if ( ( rc = setting_numerate ( setting->type, raw, raw_len,
+ value ) ) < 0 )
+ goto err_numerate;
+
+ err_numerate:
+ free ( raw );
+ err_fetch_copy:
+ return rc;
+}
+
+/**
+ * Store numeric value of setting
+ *
+ * @v settings Settings block
+ * @v setting Setting
+ * @v value Numeric value
+ * @ret rc Return status code
+ */
+int storen_setting ( struct settings *settings, struct setting *setting,
+ unsigned long value ) {
+ void *raw;
+ int raw_len;
+ int check_len;
+ int rc;
+
+ /* Sanity check */
+ assert ( setting->type != NULL );
+
+ /* Get raw value length */
+ raw_len = setting_denumerate ( setting->type, value, NULL, 0 );
+ if ( raw_len < 0 ) {
+ rc = raw_len;
+ goto err_raw_len;
+ }
+
+ /* Allocate buffer for raw value */
+ raw = malloc ( raw_len );
+ if ( ! raw ) {
+ rc = -ENOMEM;
+ goto err_alloc_raw;
+ }
+
+ /* Denumerate value */
+ check_len = setting_denumerate ( setting->type, value, raw, raw_len );
assert ( check_len == raw_len );
/* Store raw value */
err_store:
free ( raw );
err_alloc_raw:
- err_parse_len:
+ err_raw_len:
return rc;
}
/**
* Parse string setting value
*
+ * @v type Setting type
* @v value Formatted setting value
* @v buf Buffer to contain raw value
* @v len Length of buffer
* @ret len Length of raw value, or negative error
*/
-static int parse_string_setting ( const char *value, void *buf, size_t len ) {
+static int parse_string_setting ( struct setting_type *type __unused,
+ const char *value, void *buf, size_t len ) {
size_t raw_len = strlen ( value ); /* Exclude terminating NUL */
/* Copy string to buffer */
/**
* Format string setting value
*
+ * @v type Setting type
* @v raw Raw setting value
* @v raw_len Length of raw setting value
* @v buf Buffer to contain formatted value
* @v len Length of buffer
* @ret len Length of formatted value, or negative error
*/
-static int format_string_setting ( const void *raw, size_t raw_len, char *buf,
+static int format_string_setting ( struct setting_type *type __unused,
+ const void *raw, size_t raw_len, char *buf,
size_t len ) {
/* Copy string to buffer, and terminate */
/**
* Parse URI-encoded string setting value
*
+ * @v type Setting type
* @v value Formatted setting value
* @v buf Buffer to contain raw value
* @v len Length of buffer
* @ret len Length of raw value, or negative error
*/
-static int parse_uristring_setting ( const char *value, void *buf,
- size_t len ) {
+static int parse_uristring_setting ( struct setting_type *type __unused,
+ const char *value, void *buf, size_t len ){
char tmp[ len + 1 /* NUL */ ];
size_t raw_len;
/**
* Format URI-encoded string setting value
*
+ * @v type Setting type
* @v raw Raw setting value
* @v raw_len Length of raw setting value
* @v buf Buffer to contain formatted value
* @v len Length of buffer
* @ret len Length of formatted value, or negative error
*/
-static int format_uristring_setting ( const void *raw, size_t raw_len,
+static int format_uristring_setting ( struct setting_type *type __unused,
+ const void *raw, size_t raw_len,
char *buf, size_t len ) {
char tmp[ raw_len + 1 /* NUL */ ];
/**
* Parse IPv4 address setting value
*
+ * @v type Setting type
* @v value Formatted setting value
* @v buf Buffer to contain raw value
* @v len Length of buffer
* @ret len Length of raw value, or negative error
*/
-static int parse_ipv4_setting ( const char *value, void *buf, size_t len ) {
+static int parse_ipv4_setting ( struct setting_type *type __unused,
+ const char *value, void *buf, size_t len ) {
struct in_addr ipv4;
/* Parse IPv4 address */
/**
* Format IPv4 address setting value
*
+ * @v type Setting type
* @v raw Raw setting value
* @v raw_len Length of raw setting value
* @v buf Buffer to contain formatted value
* @v len Length of buffer
* @ret len Length of formatted value, or negative error
*/
-static int format_ipv4_setting ( const void *raw, size_t raw_len, char *buf,
+static int format_ipv4_setting ( struct setting_type *type __unused,
+ const void *raw, size_t raw_len, char *buf,
size_t len ) {
const struct in_addr *ipv4 = raw;
};
/**
- * Parse integer setting value
+ * Integer setting type indices
*
- * @v value Formatted setting value
+ * These indexes are defined such that (1<<index) gives the width of
+ * the integer, in bytes.
+ */
+enum setting_type_int_index {
+ SETTING_TYPE_INT8 = 0,
+ SETTING_TYPE_INT16 = 1,
+ SETTING_TYPE_INT32 = 2,
+};
+
+/**
+ * Integer setting type names
+ *
+ * These names exist as a static array in order to allow the type's
+ * integer size and signedness to be determined from the type's name.
+ * Note that there are no separate entries for the signed integer
+ * types: the name pointers simply point to the second character of
+ * the relevant string.
+ */
+static const char setting_type_int_name[][8] = {
+ [SETTING_TYPE_INT8] = "uint8",
+ [SETTING_TYPE_INT16] = "uint16",
+ [SETTING_TYPE_INT32] = "uint32",
+};
+
+/**
+ * Get unsigned integer setting type name
+ *
+ * @v index Integer setting type index
+ * @ret name Setting type name
+ */
+#define SETTING_TYPE_UINT_NAME( index ) setting_type_int_name[index]
+
+/**
+ * Get signed integer setting type name
+ *
+ * @v index Integer setting type index
+ * @ret name Setting type name
+ */
+#define SETTING_TYPE_INT_NAME( index ) ( setting_type_int_name[index] + 1 )
+
+/**
+ * Get integer setting type index
+ *
+ * @v type Setting type
+ * @ret index Integer setting type index
+ */
+static unsigned int setting_type_int_index ( struct setting_type *type ) {
+
+ return ( ( type->name - setting_type_int_name[0] ) /
+ sizeof ( setting_type_int_name[0] ) );
+}
+
+/**
+ * Get integer setting type width
+ *
+ * @v type Setting type
+ * @ret index Integer setting type width
+ */
+static unsigned int setting_type_int_width ( struct setting_type *type ) {
+
+ return ( 1 << setting_type_int_index ( type ) );
+}
+
+/**
+ * Get integer setting type signedness
+ *
+ * @v type Setting type
+ * @ret is_signed Integer setting type is signed
+ */
+static int setting_type_int_is_signed ( struct setting_type *type ) {
+ return ( ( type->name - setting_type_int_name[0] ) & 1 );
+}
+
+/**
+ * Convert number to setting value
+ *
+ * @v type Setting type
+ * @v value Numeric value
* @v buf Buffer to contain raw value
* @v len Length of buffer
- * @v size Integer size, in bytes
* @ret len Length of raw value, or negative error
*/
-static int parse_int_setting ( const char *value, void *buf, size_t len,
- unsigned int size ) {
+static int denumerate_int_setting ( struct setting_type *type,
+ unsigned long value, void *buf,
+ size_t len ) {
+ unsigned int size = setting_type_int_width ( type );
union {
uint32_t num;
uint8_t bytes[4];
} u;
- char *endp;
-
- /* Parse value */
- u.num = htonl ( strtoul ( value, &endp, 0 ) );
- if ( *endp )
- return -EINVAL;
- /* Copy to buffer */
+ u.num = htonl ( value );
if ( len > size )
len = size;
memcpy ( buf, &u.bytes[ sizeof ( u ) - size ], len );
}
/**
- * Parse 8-bit integer setting value
+ * Convert setting value to number
*
- * @v value Formatted setting value
- * @v buf Buffer to contain raw value
- * @v len Length of buffer
- * @v size Integer size, in bytes
- * @ret len Length of raw value, or negative error
+ * @v type Setting type
+ * @v raw Raw setting value
+ * @v raw_len Length of raw setting value
+ * @v value Numeric value to fill in
+ * @ret rc Return status code
*/
-static int parse_int8_setting ( const char *value, void *buf, size_t len ) {
- return parse_int_setting ( value, buf, len, sizeof ( uint8_t ) );
-}
+static int numerate_int_setting ( struct setting_type *type,
+ const void *raw, size_t raw_len,
+ unsigned long *value ) {
+ int is_signed = setting_type_int_is_signed ( type );
+ int check_len;
-/**
- * Parse 16-bit integer setting value
- *
- * @v value Formatted setting value
- * @v buf Buffer to contain raw value
- * @v len Length of buffer
- * @v size Integer size, in bytes
- * @ret len Length of raw value, or negative error
- */
-static int parse_int16_setting ( const char *value, void *buf, size_t len ) {
- return parse_int_setting ( value, buf, len, sizeof ( uint16_t ) );
+ /* Extract numeric value */
+ check_len = numeric_setting_value ( is_signed, raw, raw_len, value );
+ if ( check_len < 0 )
+ return check_len;
+ assert ( check_len == ( int ) raw_len );
+
+ return 0;
}
/**
- * Parse 32-bit integer setting value
+ * Parse integer setting value
*
+ * @v type Setting type
* @v value Formatted setting value
* @v buf Buffer to contain raw value
* @v len Length of buffer
- * @v size Integer size, in bytes
* @ret len Length of raw value, or negative error
*/
-static int parse_int32_setting ( const char *value, void *buf, size_t len ) {
- return parse_int_setting ( value, buf, len, sizeof ( uint32_t ) );
+static int parse_int_setting ( struct setting_type *type, const char *value,
+ void *buf, size_t len ) {
+ char *endp;
+ unsigned long num_value;
+
+ /* Parse value */
+ num_value = strtoul ( value, &endp, 0 );
+ if ( *endp )
+ return -EINVAL;
+
+ return type->denumerate ( type, num_value, buf, len );
}
/**
* Format signed integer setting value
*
+ * @v type Setting type
* @v raw Raw setting value
* @v raw_len Length of raw setting value
* @v buf Buffer to contain formatted value
* @v len Length of buffer
* @ret len Length of formatted value, or negative error
*/
-static int format_int_setting ( const void *raw, size_t raw_len, char *buf,
- size_t len ) {
- signed long value;
- unsigned long dummy;
- int check_len;
+static int format_int_setting ( struct setting_type *type, const void *raw,
+ size_t raw_len, char *buf, size_t len ) {
+ unsigned long value;
+ int ret;
/* Extract numeric value */
- check_len = numeric_setting_value ( raw, raw_len, &value, &dummy );
- if ( check_len < 0 )
- return check_len;
- assert ( check_len == ( int ) raw_len );
+ if ( ( ret = type->numerate ( type, raw, raw_len, &value ) ) < 0 )
+ return ret;
/* Format value */
return snprintf ( buf, len, "%ld", value );
/**
* Format unsigned integer setting value
*
+ * @v type Setting type
* @v raw Raw setting value
* @v raw_len Length of raw setting value
* @v buf Buffer to contain formatted value
* @v len Length of buffer
* @ret len Length of formatted value, or negative error
*/
-static int format_uint_setting ( const void *raw, size_t raw_len, char *buf,
- size_t len ) {
- signed long dummy;
+static int format_uint_setting ( struct setting_type *type, const void *raw,
+ size_t raw_len, char *buf, size_t len ) {
unsigned long value;
- int check_len;
+ int ret;
/* Extract numeric value */
- check_len = numeric_setting_value ( raw, raw_len, &dummy, &value );
- if ( check_len < 0 )
- return check_len;
- assert ( check_len == ( int ) raw_len );
+ if ( ( ret = type->numerate ( type, raw, raw_len, &value ) ) < 0 )
+ return ret;
/* Format value */
return snprintf ( buf, len, "%#lx", value );
}
+/**
+ * Define a signed integer setting type
+ *
+ * @v index Integer setting type index
+ * @ret type Setting type
+ */
+#define SETTING_TYPE_INT( index ) { \
+ .name = SETTING_TYPE_INT_NAME ( index ), \
+ .parse = parse_int_setting, \
+ .format = format_int_setting, \
+ .denumerate = denumerate_int_setting, \
+ .numerate = numerate_int_setting, \
+}
+
+/**
+ * Define an unsigned integer setting type
+ *
+ * @v index Integer setting type index
+ * @ret type Setting type
+ */
+#define SETTING_TYPE_UINT( index ) { \
+ .name = SETTING_TYPE_UINT_NAME ( index ), \
+ .parse = parse_int_setting, \
+ .format = format_uint_setting, \
+ .denumerate = denumerate_int_setting, \
+ .numerate = numerate_int_setting, \
+}
+
/** A signed 8-bit integer setting type */
-struct setting_type setting_type_int8 __setting_type = {
- .name = "int8",
- .parse = parse_int8_setting,
- .format = format_int_setting,
-};
+struct setting_type setting_type_int8 __setting_type =
+ SETTING_TYPE_INT ( SETTING_TYPE_INT8 );
/** A signed 16-bit integer setting type */
-struct setting_type setting_type_int16 __setting_type = {
- .name = "int16",
- .parse = parse_int16_setting,
- .format = format_int_setting,
-};
+struct setting_type setting_type_int16 __setting_type =
+ SETTING_TYPE_INT ( SETTING_TYPE_INT16 );
/** A signed 32-bit integer setting type */
-struct setting_type setting_type_int32 __setting_type = {
- .name = "int32",
- .parse = parse_int32_setting,
- .format = format_int_setting,
-};
+struct setting_type setting_type_int32 __setting_type =
+ SETTING_TYPE_INT ( SETTING_TYPE_INT32 );
/** An unsigned 8-bit integer setting type */
-struct setting_type setting_type_uint8 __setting_type = {
- .name = "uint8",
- .parse = parse_int8_setting,
- .format = format_uint_setting,
-};
+struct setting_type setting_type_uint8 __setting_type =
+ SETTING_TYPE_UINT ( SETTING_TYPE_INT8 );
/** An unsigned 16-bit integer setting type */
-struct setting_type setting_type_uint16 __setting_type = {
- .name = "uint16",
- .parse = parse_int16_setting,
- .format = format_uint_setting,
-};
+struct setting_type setting_type_uint16 __setting_type =
+ SETTING_TYPE_UINT ( SETTING_TYPE_INT16 );
/** An unsigned 32-bit integer setting type */
-struct setting_type setting_type_uint32 __setting_type = {
- .name = "uint32",
- .parse = parse_int32_setting,
- .format = format_uint_setting,
-};
+struct setting_type setting_type_uint32 __setting_type =
+ SETTING_TYPE_UINT ( SETTING_TYPE_INT32 );
/**
* Format hex string setting value
*
+ * @v delimiter Byte delimiter
* @v raw Raw setting value
* @v raw_len Length of raw setting value
* @v buf Buffer to contain formatted value
* @v len Length of buffer
- * @v delimiter Byte delimiter
* @ret len Length of formatted value, or negative error
*/
-static int format_hex_setting ( const void *raw, size_t raw_len, char *buf,
- size_t len, const char *delimiter ) {
+static int format_hex_setting ( const char *delimiter, const void *raw,
+ size_t raw_len, char *buf, size_t len ) {
const uint8_t *bytes = raw;
int used = 0;
unsigned int i;
/**
* Parse hex string setting value (using colon delimiter)
*
+ * @v type Setting type
* @v value Formatted setting value
* @v buf Buffer to contain raw value
* @v len Length of buffer
* @v size Integer size, in bytes
* @ret len Length of raw value, or negative error
*/
-static int parse_hex_setting ( const char *value, void *buf, size_t len ) {
+static int parse_hex_setting ( struct setting_type *type __unused,
+ const char *value, void *buf, size_t len ) {
return hex_decode ( value, ':', buf, len );
}
/**
* Format hex string setting value (using colon delimiter)
*
+ * @v type Setting type
* @v raw Raw setting value
* @v raw_len Length of raw setting value
* @v buf Buffer to contain formatted value
* @v len Length of buffer
* @ret len Length of formatted value, or negative error
*/
-static int format_hex_colon_setting ( const void *raw, size_t raw_len,
+static int format_hex_colon_setting ( struct setting_type *type __unused,
+ const void *raw, size_t raw_len,
char *buf, size_t len ) {
- return format_hex_setting ( raw, raw_len, buf, len, ":" );
+ return format_hex_setting ( ":", raw, raw_len, buf, len );
}
/**
* Parse hex string setting value (using hyphen delimiter)
*
+ * @v type Setting type
* @v value Formatted setting value
* @v buf Buffer to contain raw value
* @v len Length of buffer
* @v size Integer size, in bytes
* @ret len Length of raw value, or negative error
*/
-static int parse_hex_hyphen_setting ( const char *value, void *buf,
+static int parse_hex_hyphen_setting ( struct setting_type *type __unused,
+ const char *value, void *buf,
size_t len ) {
return hex_decode ( value, '-', buf, len );
}
/**
* Format hex string setting value (using hyphen delimiter)
*
+ * @v type Setting type
* @v raw Raw setting value
* @v raw_len Length of raw setting value
* @v buf Buffer to contain formatted value
* @v len Length of buffer
* @ret len Length of formatted value, or negative error
*/
-static int format_hex_hyphen_setting ( const void *raw, size_t raw_len,
+static int format_hex_hyphen_setting ( struct setting_type *type __unused,
+ const void *raw, size_t raw_len,
char *buf, size_t len ) {
- return format_hex_setting ( raw, raw_len, buf, len, "-" );
+ return format_hex_setting ( "-", raw, raw_len, buf, len );
}
/**
* Parse hex string setting value (using no delimiter)
*
+ * @v type Setting type
* @v value Formatted setting value
* @v buf Buffer to contain raw value
* @v len Length of buffer
* @v size Integer size, in bytes
* @ret len Length of raw value, or negative error
*/
-static int parse_hex_raw_setting ( const char *value, void *buf,
- size_t len ) {
+static int parse_hex_raw_setting ( struct setting_type *type __unused,
+ const char *value, void *buf, size_t len ) {
return hex_decode ( value, 0, buf, len );
}
/**
* Format hex string setting value (using no delimiter)
*
+ * @v type Setting type
* @v raw Raw setting value
* @v raw_len Length of raw setting value
* @v buf Buffer to contain formatted value
* @v len Length of buffer
* @ret len Length of formatted value, or negative error
*/
-static int format_hex_raw_setting ( const void *raw, size_t raw_len,
+static int format_hex_raw_setting ( struct setting_type *type __unused,
+ const void *raw, size_t raw_len,
char *buf, size_t len ) {
- return format_hex_setting ( raw, raw_len, buf, len, "" );
+ return format_hex_setting ( "", raw, raw_len, buf, len );
}
/** A hex-string setting (colon-delimited) */
.format = format_hex_raw_setting,
};
-/**
- * Parse UUID setting value
- *
- * @v value Formatted setting value
- * @v buf Buffer to contain raw value
- * @v len Length of buffer
- * @ret len Length of raw value, or negative error
- */
-static int parse_uuid_setting ( const char *value __unused,
- void *buf __unused, size_t len __unused ) {
- return -ENOTSUP;
-}
-
/**
* Format UUID setting value
*
+ * @v type Setting type
* @v raw Raw setting value
* @v raw_len Length of raw setting value
* @v buf Buffer to contain formatted value
* @v len Length of buffer
* @ret len Length of formatted value, or negative error
*/
-static int format_uuid_setting ( const void *raw, size_t raw_len, char *buf,
+static int format_uuid_setting ( struct setting_type *type __unused,
+ const void *raw, size_t raw_len, char *buf,
size_t len ) {
const union uuid *uuid = raw;
/** UUID setting type */
struct setting_type setting_type_uuid __setting_type = {
.name = "uuid",
- .parse = parse_uuid_setting,
.format = format_uuid_setting,
};
-/**
- * Parse PCI bus:dev.fn setting value
- *
- * @v value Formatted setting value
- * @v buf Buffer to contain raw value
- * @v len Length of buffer
- * @ret len Length of raw value, or negative error
- */
-static int parse_busdevfn_setting ( const char *value __unused,
- void *buf __unused, size_t len __unused ) {
- return -ENOTSUP;
-}
-
/**
* Format PCI bus:dev.fn setting value
*
+ * @v type Setting type
* @v raw Raw setting value
* @v raw_len Length of raw setting value
* @v buf Buffer to contain formatted value
* @v len Length of buffer
* @ret len Length of formatted value, or negative error
*/
-static int format_busdevfn_setting ( const void *raw, size_t raw_len, char *buf,
+static int format_busdevfn_setting ( struct setting_type *type __unused,
+ const void *raw, size_t raw_len, char *buf,
size_t len ) {
- signed long dummy;
unsigned long busdevfn;
int check_len;
/* Extract numeric value */
- check_len = numeric_setting_value ( raw, raw_len, &dummy, &busdevfn );
+ check_len = numeric_setting_value ( 0, raw, raw_len, &busdevfn );
if ( check_len < 0 )
return check_len;
assert ( check_len == ( int ) raw_len );
/** PCI bus:dev.fn setting type */
struct setting_type setting_type_busdevfn __setting_type = {
.name = "busdevfn",
- .parse = parse_busdevfn_setting,
.format = format_busdevfn_setting,
};
len = fetchf_setting ( settings, setting, actual, \
sizeof ( actual ) ); \
DBGC ( settings, "Fetched %s \"%s\" from:\n", \
- (setting)->type->name, formatted ); \
+ (setting)->type->name, actual ); \
DBGC_HDA ( settings, 0, raw, sizeof ( raw ) ); \
ok ( len == ( int ) ( sizeof ( actual ) - 1 ) ); \
ok ( strcmp ( actual, formatted ) == 0 ); \
} while ( 0 )
+/**
+ * Report a numeric-store test result
+ *
+ * @v settings Settings block
+ * @v setting Setting
+ * @v numeric Numeric value
+ * @v raw_array Expected raw value
+ */
+#define storen_ok( settings, setting, numeric, raw_array ) do { \
+ const uint8_t expected[] = raw_array; \
+ uint8_t actual[ sizeof ( expected ) ]; \
+ int len; \
+ \
+ ok ( storen_setting ( settings, setting, numeric ) == 0 ); \
+ len = fetch_setting ( settings, setting, actual, \
+ sizeof ( actual ) ); \
+ if ( len >= 0 ) { \
+ DBGC ( settings, "Stored %s %#lx, got:\n", \
+ (setting)->type->name, \
+ ( unsigned long ) numeric ); \
+ DBGC_HDA ( settings, 0, actual, len ); \
+ } else { \
+ DBGC ( settings, "Stored %s %#lx, got error %s\n", \
+ (setting)->type->name, \
+ ( unsigned long ) numeric, strerror ( len ) ); \
+ } \
+ ok ( len == ( int ) sizeof ( actual ) ); \
+ ok ( memcmp ( actual, expected, sizeof ( actual ) ) == 0 ); \
+ } while ( 0 )
+
+/**
+ * Report a numeric-fetch test result
+ *
+ * @v settings Settings block
+ * @v setting Setting
+ * @v raw_array Raw array
+ * @v numeric Expected numeric value
+ */
+#define fetchn_ok( settings, setting, raw_array, numeric ) do { \
+ const uint8_t raw[] = raw_array; \
+ unsigned long actual; \
+ \
+ ok ( store_setting ( settings, setting, raw, \
+ sizeof ( raw ) ) == 0 ); \
+ ok ( fetchn_setting ( settings, setting, &actual ) == 0 ); \
+ DBGC ( settings, "Fetched %s %#lx from:\n", \
+ (setting)->type->name, actual ); \
+ DBGC_HDA ( settings, 0, raw, sizeof ( raw ) ); \
+ ok ( actual == ( unsigned long ) numeric ); \
+ } while ( 0 )
+
/** Test generic settings block */
struct generic_settings test_generic_settings = {
.settings = {
fetchf_ok ( &test_settings, &test_ipv4_setting,
RAW ( 212, 13, 204, 60 ), "212.13.204.60" );
- /* Integer setting types */
+ /* Integer setting types (as formatted strings) */
storef_ok ( &test_settings, &test_int8_setting,
"54", RAW ( 54 ) );
storef_ok ( &test_settings, &test_int8_setting,
fetchf_ok ( &test_settings, &test_uint32_setting,
RAW ( 0xf2, 0x37, 0xb2, 0x18 ), "0xf237b218" );
+ /* Integer setting types (as numeric values) */
+ storen_ok ( &test_settings, &test_int8_setting,
+ 72, RAW ( 72 ) );
+ storen_ok ( &test_settings, &test_int8_setting,
+ 0xabcd, RAW ( 0xcd ) );
+ fetchn_ok ( &test_settings, &test_int8_setting,
+ RAW ( 0xfe ), -2 );
+ storen_ok ( &test_settings, &test_uint8_setting,
+ 84, RAW ( 84 ) );
+ fetchn_ok ( &test_settings, &test_uint8_setting,
+ RAW ( 0xfe ), 0xfe );
+ storen_ok ( &test_settings, &test_int16_setting,
+ 0x87bd, RAW ( 0x87, 0xbd ) );
+ fetchn_ok ( &test_settings, &test_int16_setting,
+ RAW ( 0x3d, 0x14 ), 0x3d14 );
+ fetchn_ok ( &test_settings, &test_int16_setting,
+ RAW ( 0x80 ), -128 );
+ storen_ok ( &test_settings, &test_uint16_setting,
+ 1, RAW ( 0x00, 0x01 ) );
+ fetchn_ok ( &test_settings, &test_uint16_setting,
+ RAW ( 0xbd, 0x87 ), 0xbd87 );
+ fetchn_ok ( &test_settings, &test_uint16_setting,
+ RAW ( 0x80 ), 0x0080 );
+ storen_ok ( &test_settings, &test_int32_setting,
+ 0x0812bfd2, RAW ( 0x08, 0x12, 0xbf, 0xd2 ) );
+ fetchn_ok ( &test_settings, &test_int32_setting,
+ RAW ( 0x43, 0x87, 0x91, 0xb4 ), 0x438791b4 );
+ fetchn_ok ( &test_settings, &test_int32_setting,
+ RAW ( 0xff, 0xff, 0xfe ), -2 );
+ storen_ok ( &test_settings, &test_uint32_setting,
+ 0xb5927ab8, RAW ( 0xb5, 0x92, 0x7a, 0xb8 ) );
+ fetchn_ok ( &test_settings, &test_uint32_setting,
+ RAW ( 0x98, 0xab, 0x41, 0x81 ), 0x98ab4181 );
+ fetchn_ok ( &test_settings, &test_uint32_setting,
+ RAW ( 0xff, 0xff, 0xfe ), 0x00fffffe );
+
/* "hex" setting type */
storef_ok ( &test_settings, &test_hex_setting,
"08:12:f5:22:90:1b:4b:47:a8:30:cb:4d:67:4c:d6:76",
projects / thirdparty / ipxe.git / commitdiff
