+## [2.3.0] - 2025-02-15

+### Added

+ - fsck.ubifs: Add fsck utility for ubifs

+ - ubifs-utils: Support Address-Sanitizier debug

+ - nand-utils: nanddump: Add support for testing continuous reads

+ - mtd-tests: nandbiterrs: Add support for testing continuous reads

+ - mtd-tests: flash_speed: Benchmark continuous reads

+

+### Fixed

+ - Various integer handling errors (potential overflows, divide by zero)

+ - mkfs.jffs2: fix segfault when parsing dev table

+ - nand-utils: nanddump: Explicitely use the page size when relevant

+ - misc-utils: add missing error handling for 'bam' allocation in ftl_check.c

+ - mtdinfo: type mis-match in printf format string

+ - nanddump: const cast warning

+ - flashcp: uninitialized variable

+ - jffs2reader: potential null pointer dereference

+ - tests: checkfs: Add previous prototype for do_pwr_dn()

+

+### Changed

+ - mkfs.ubifs: re-sync with the kernel code

+ - mkfs.ubifs: move most of the code into a libubifs library

+ - Import a more recent version of libiniparser

+ - mtd-tests: flash_speed: cleanup/refactor

+

+m4_define([RELEASE], 2.3.0)

+AC_ARG_ENABLE([asan],

+ [AS_HELP_STRING([--enable-asan], [Support AddressSanitizer debug])],

+ [], [enable_asan="no"])

+

+AC_ARG_VAR([ASAN_LIBS], [linker flags for lasan])

+AS_IF([test "x$enable_asan" = "xyes"], [

+ AC_CHECK_LIB([asan], [_init], [

+ ASAN_LIBS="-lasan -fsanitize=address -fsanitize-recover=address -g"], [

+ AC_MSG_ERROR([cannot find libasan])

+ ])

+])

+

+AM_CONDITIONAL([WITH_ASAN], [test "x$enable_asan" = "xyes"])

+ asan debug: ${enable_asan}

+ Includes

+

+#ifdef __cplusplus

+extern "C" {

+#endif

+ New types

+ @brief Dictionary object

+ unsigned n ; /** Number of entries in dictionary */

+ size_t size ; /** Storage size */

+ char ** val ; /** List of string values */

+ char ** key ; /** List of string keys */

+ unsigned * hash ; /** List of hash values for keys */

+ Function prototypes

+unsigned dictionary_hash(const char * key);

+ @return 1 newly allocated dictionary object.

+dictionary * dictionary_new(size_t size);

+const char * dictionary_get(const dictionary * d, const char * key, const char * def);

+int dictionary_set(dictionary * vd, const char * key, const char * val);

+void dictionary_unset(dictionary * d, const char * key);

+void dictionary_dump(const dictionary * d, FILE * out);

+

+#ifdef __cplusplus

+}

+#endif

+ Includes

+#include <stdint.h>

+#ifdef __cplusplus

+extern "C" {

+#endif

+int iniparser_getnsec(const dictionary * d);

+const char * iniparser_getsecname(const dictionary * d, int n);

+

+ All values are quoted, these charecters are escaped:

+

+ - ' : the quote character (e.g. "String with \"Quotes\"")

+ - \ : the backslash character (e.g. "C:\\tmp")

+

+void iniparser_dump_ini(const dictionary * d, FILE * f);

+

+/*-------------------------------------------------------------------------*/

+/**

+ @brief Save a dictionary section to a loadable ini file

+ @param d Dictionary to dump

+ @param s Section name of dictionary to dump

+ @param f Opened file pointer to dump to

+

+ This function dumps a given section of a given dictionary into a loadable ini

+ file. It is Ok to specify @c stderr or @c stdout as output files.

+ */

+/*--------------------------------------------------------------------------*/

+

+void iniparser_dumpsection_ini(const dictionary * d, const char * s, FILE * f);

+void iniparser_dump(const dictionary * d, FILE * f);

+const char * iniparser_getstring(const dictionary * d, const char * key, const char * def);

+int iniparser_getint(const dictionary * d, const char * key, int notfound);

+

+/*-------------------------------------------------------------------------*/

+/**

+ @brief Get the string associated to a key, convert to an long int

+ @param d Dictionary to search

+ @param key Key string to look for

+ @param notfound Value to return in case of error

+ @return integer

+

+ This function queries a dictionary for a key. A key as read from an

+ ini file is given as "section:key". If the key cannot be found,

+ the notfound value is returned.

+

+ Supported values for integers include the usual C notation

+ so decimal, octal (starting with 0) and hexadecimal (starting with 0x)

+ are supported. Examples:

+

+ - "42" -> 42

+ - "042" -> 34 (octal -> decimal)

+ - "0x42" -> 66 (hexa -> decimal)

+

+ Warning: the conversion may overflow in various ways. Conversion is

+ totally outsourced to strtol(), see the associated man page for overflow

+ handling.

+ */

+/*--------------------------------------------------------------------------*/

+long int iniparser_getlongint(const dictionary * d, const char * key, long int notfound);

+

+/*-------------------------------------------------------------------------*/

+/**

+ @brief Get the string associated to a key, convert to an int64_t

+ @param d Dictionary to search

+ @param key Key string to look for

+ @param notfound Value to return in case of error

+ @return integer

+

+ This function queries a dictionary for a key. A key as read from an

+ ini file is given as "section:key". If the key cannot be found,

+ the notfound value is returned.

+

+ Supported values for integers include the usual C notation

+ so decimal, octal (starting with 0) and hexadecimal (starting with 0x)

+ are supported. Examples:

+

+ - "42" -> 42

+ - "042" -> 34 (octal -> decimal)

+ - "0x42" -> 66 (hexa -> decimal)

+

+ Warning: the conversion may overflow in various ways. Conversion is

+ totally outsourced to strtoimax(), see the associated man page for overflow

+ handling.

+

+ This function is usefull on 32bit architectures where `long int` is only

+ 32bit.

+ */

+/*--------------------------------------------------------------------------*/

+int64_t iniparser_getint64(const dictionary * d, const char * key, int64_t notfound);

+

+/*-------------------------------------------------------------------------*/

+/**

+ @brief Get the string associated to a key, convert to an uint64_t

+ @param d Dictionary to search

+ @param key Key string to look for

+ @param notfound Value to return in case of error

+ @return integer

+

+ This function queries a dictionary for a key. A key as read from an

+ ini file is given as "section:key". If the key cannot be found,

+ the notfound value is returned.

+

+ Supported values for integers include the usual C notation

+ so decimal, octal (starting with 0) and hexadecimal (starting with 0x)

+ are supported. Examples:

+

+ - "42" -> 42

+ - "042" -> 34 (octal -> decimal)

+ - "0x42" -> 66 (hexa -> decimal)

+

+ Warning: the conversion may overflow in various ways. Conversion is

+ totally outsourced to strtoumax(), see the associated man page for overflow

+ handling.

+

+ This function is usefull on 32bit architectures where `long int` is only

+ 32bit.

+ */

+/*--------------------------------------------------------------------------*/

+uint64_t iniparser_getuint64(const dictionary * d, const char * key, uint64_t notfound);

+int iniparser_getboolean(const dictionary * d, const char * key, int notfound);

+void iniparser_unset(dictionary * ini, const char * entry);

+int iniparser_find_entry(const dictionary * ini, const char * entry) ;

+ Iff the value is a quoted string it supports some escape sequences:

+

+ - \" or ' : the quote character

+ (e.g. 'String with "Quotes"' or "String with 'Quotes'")

+ - \ : the backslash character (e.g. "C:\tmp")

+

+ Escape sequences always start with a backslash. Additional escape sequences

+ might be added in the future. Backslash characters must be escaped. Any other

+ sequence then those outlined above is invalid and may lead to unpredictable

+ results.

+

+ @brief Parse an ini file and return an allocated dictionary object

+ @param in File to read.

+ @param ininame Name of the ini file to read (only used for nicer error messages)

+ @return Pointer to newly allocated dictionary

+

+ This is the parser for ini files. This function is called, providing

+ the file to be read. It returns a dictionary object that should not

+ be accessed directly, but through accessor functions instead.

+

+ Iff the value is a quoted string it supports some escape sequences:

+

+ - \" or ' : the quote character

+ (e.g. 'String with "Quotes"' or "String with 'Quotes'")

+ - \ : the backslash character (e.g. "C:\tmp")

+

+ Escape sequences always start with a backslash. Additional escape sequences

+ might be added in the future. Backslash characters must be escaped. Any other

+ sequence then those outlined above is invalid and may lead to unpredictable

+ results.

+

+ The returned dictionary must be freed using iniparser_freedict().

+ */

+/*--------------------------------------------------------------------------*/

+dictionary * iniparser_load_file(FILE * in, const char * ininame);

+

+/*-------------------------------------------------------------------------*/

+/**

+#ifdef __cplusplus

+}

+#endif

+

+ if (datsize < 0 || oobsize < 0 || datsize > imglen || (long)datsize + oobsize < 0) {

+ fprintf(stderr, "Error: invalid datsize/oobsize.\n");

+ free(data);

+ close (fd);

+ exit(EXIT_FAILURE);

+ }

+

+ len -= (long)datsize + oobsize;

+ if (path == NULL)

+ return NULL;

+

+ @file dictionary.c

+ @author N. Devillard

+ @brief Implements a dictionary for string variables.

+ Includes

+#define DICTMINSZ 128

+ Private functions

+static char * xstrdup(const char * s)

+ size_t len ;

+

+ len = strlen(s) + 1 ;

+ t = (char*) malloc(len) ;

+ memcpy(t, s, len) ;

+/*-------------------------------------------------------------------------*/

+/**

+ @brief Double the size of the dictionary

+ @param d Dictionary to grow

+ @return This function returns non-zero in case of failure

+ */

+/*--------------------------------------------------------------------------*/

+static int dictionary_grow(dictionary * d)

+{

+ char ** new_val ;

+ char ** new_key ;

+ unsigned * new_hash ;

+

+ new_val = (char**) calloc(d->size * 2, sizeof *d->val);

+ new_key = (char**) calloc(d->size * 2, sizeof *d->key);

+ new_hash = (unsigned*) calloc(d->size * 2, sizeof *d->hash);

+ if (!new_val || !new_key || !new_hash) {

+ /* An allocation failed, leave the dictionary unchanged */

+ if (new_val)

+ free(new_val);

+ if (new_key)

+ free(new_key);

+ if (new_hash)

+ free(new_hash);

+ return -1 ;

+ }

+ /* Initialize the newly allocated space */

+ memcpy(new_val, d->val, d->size * sizeof(char *));

+ memcpy(new_key, d->key, d->size * sizeof(char *));

+ memcpy(new_hash, d->hash, d->size * sizeof(unsigned));

+ /* Delete previous data */

+ free(d->val);

+ free(d->key);

+ free(d->hash);

+ /* Actually update the dictionary */

+ d->size *= 2 ;

+ d->val = new_val;

+ d->key = new_key;

+ d->hash = new_hash;

+ return 0 ;

+}

+

+ Function codes

+ @brief Compute the hash key for a string.

+ @param key Character string to use for key.

+ @return 1 unsigned int on at least 32 bits.

+unsigned dictionary_hash(const char * key)

+ size_t len ;

+ unsigned hash ;

+ size_t i ;

+

+ if (!key)

+ return 0 ;

+

+ len = strlen(key);

+ for (hash=0, i=0 ; i<len ; i++) {

+ hash += (unsigned)key[i] ;

+ hash += (hash<<10);

+ hash ^= (hash>>6) ;

+ }

+ hash += (hash <<3);

+ hash ^= (hash >>11);

+ hash += (hash <<15);

+ return hash ;

+ @brief Create a new dictionary object.

+ @param size Optional initial size of the dictionary.

+ @return 1 newly allocated dictionary object.

+/*-------------------------------------------------------------------------*/

+dictionary * dictionary_new(size_t size)

+ dictionary * d ;

+

+ /* If no size was specified, allocate space for DICTMINSZ */

+ if (size<DICTMINSZ) size=DICTMINSZ ;

+

+ d = (dictionary*) calloc(1, sizeof *d) ;

+

+ if (d) {

+ d->size = size ;

+ d->val = (char**) calloc(size, sizeof *d->val);

+ d->key = (char**) calloc(size, sizeof *d->key);

+ d->hash = (unsigned*) calloc(size, sizeof *d->hash);

+ if (!d->size || !d->val || !d->hash) {

+ free((void *) d->size);

+ free((void *) d->val);

+ free((void *) d->hash);

+ free(d);

+ d = NULL;

+ }

+ }

+ return d ;

+ @brief Delete a dictionary object

+ @param d dictionary object to deallocate.

+ @return void

+ size_t i ;

+

+ if (d==NULL) return ;

+ for (i=0 ; i<d->size ; i++) {

+ if (d->key[i]!=NULL)

+ free(d->key[i]);

+ if (d->val[i]!=NULL)

+ free(d->val[i]);

+ }

+ free(d->val);

+ free(d->key);

+ free(d->hash);

+ free(d);

+ return ;

+ @brief Get a value from a dictionary.

+ @param d dictionary object to search.

+ @param key Key to look for in the dictionary.

+ @return 1 pointer to internally allocated character string.

+const char * dictionary_get(const dictionary * d, const char * key, const char * def)

+ unsigned hash ;

+ size_t i ;

+ if(d == NULL || key == NULL)

+ return def ;

+

+ hash = dictionary_hash(key);

+ for (i=0 ; i<d->size ; i++) {

+ if (hash==d->hash[i]) {

+ return d->val[i] ;

+ }

+ }

+ }

+ return def ;

+int dictionary_set(dictionary * d, const char * key, const char * val)

+ size_t i ;

+ unsigned hash ;

+ if (d==NULL || key==NULL) return -1 ;

+ /* Compute hash for this key */

+ hash = dictionary_hash(key) ;

+ /* Find if value is already in dictionary */

+ if (d->n>0) {

+ for (i=0 ; i<d->size ; i++) {

+ if (hash==d->hash[i]) { /* Same hash value */

+ if (!strcmp(key, d->key[i])) { /* Same key */

+ /* Found a value: modify and return */

+ if (d->val[i]!=NULL)

+ free(d->val[i]);

+ d->val[i] = (val ? xstrdup(val) : NULL);

+ return 0 ;

+ }

+ }

+ }

+ /* Add a new value */

+ /* See if dictionary needs to grow */

+ if (d->n==d->size) {

+ /* Reached maximum size: reallocate dictionary */

+ if (dictionary_grow(d) != 0)

+ return -1;

+ }

+ /* Insert key in the first empty slot. Start at d->n and wrap at

+ d->size. Because d->n < d->size this will necessarily

+ terminate. */

+ for (i=d->n ; d->key[i] ; ) {

+ if(++i == d->size) i = 0;

+ /* Copy key */

+ d->key[i] = xstrdup(key);

+ d->val[i] = (val ? xstrdup(val) : NULL) ;

+ d->hash[i] = hash;

+ d->n ++ ;

+ return 0 ;

+ @brief Delete a key in a dictionary

+ @param d dictionary object to modify.

+ @param key Key to remove.

+void dictionary_unset(dictionary * d, const char * key)

+ unsigned hash ;

+ size_t i ;

+ if (key == NULL || d == NULL) {

+ return;

+ }

+ hash = dictionary_hash(key);

+ for (i=0 ; i<d->size ; i++) {

+ if (hash==d->hash[i]) {

+ }

+ }

+ }

+ @brief Dump a dictionary to an opened file pointer.

+ @param d Dictionary to dump

+ @param f Opened file pointer.

+ @return void

+void dictionary_dump(const dictionary * d, FILE * out)

+ size_t i ;

+

+ if (d==NULL || out==NULL) return ;

+ if (d->n<1) {

+ fprintf(out, "empty dictionary\n");

+ return ;

+ }

+ for (i=0 ; i<d->size ; i++) {

+ return ;

+#include <stdarg.h>

+#include <stdlib.h>

+#include <string.h>

+#include <inttypes.h>

+#include "libiniparser.h"

+ @brief Convert a string to lowercase.

+ @param in String to convert.

+ @param out Output buffer.

+ @param len Size of the out buffer.

+ @return ptr to the out buffer or NULL if an error occured.

+

+ This function convert a string into lowercase.

+ At most len - 1 elements of the input string will be converted.

+static const char * strlwc(const char * in, char *out, unsigned len)

+ unsigned i ;

+ if (in==NULL || out == NULL || len==0) return NULL ;

+ while (in[i] != '\0' && i < len-1) {

+ out[i] = (char)tolower((int)in[i]);

+ out[i] = '\0';

+ return out ;

+}

+

+/*-------------------------------------------------------------------------*/

+/**

+ @brief Duplicate a string

+ @param s String to duplicate

+ @return Pointer to a newly allocated string, to be freed with free()

+

+ This is a replacement for strdup(). This implementation is provided

+ for systems that do not have it.

+ */

+/*--------------------------------------------------------------------------*/

+static char * xstrdup(const char * s)

+{

+ char * t ;

+ size_t len ;

+ if (!s)

+ return NULL ;

+

+ len = strlen(s) + 1 ;

+ t = (char*) malloc(len) ;

+ if (t) {

+ memcpy(t, s, len) ;

+ }

+ return t ;

+ @brief Remove blanks at the beginning and the end of a string.

+ @param str String to parse and alter.

+ @return unsigned New size of the string.

+static unsigned strstrip(char * s)

+ char *last = NULL ;

+ char *dest = s;

+

+ if (s==NULL) return 0;

+

+ last = s + strlen(s);

+ while (isspace((int)*s) && *s) s++;

+ while (last > s) {

+ if (!isspace((int)*(last-1)))

+ break ;

+ last -- ;

+ }

+ *last = (char)0;

+

+ memmove(dest,s,last - s + 1);

+ return last - s;

+ @brief Default error callback for iniparser: wraps `fprintf(stderr, ...)`.

+ */

+/*--------------------------------------------------------------------------*/

+static int default_error_callback(const char *format, ...)

+{

+ int ret;

+ va_list argptr;

+ va_start(argptr, format);

+ ret = vfprintf(stderr, format, argptr);

+ va_end(argptr);

+ return ret;

+}

+

+static int (*iniparser_error_callback)(const char*, ...) = default_error_callback;

+

+/*-------------------------------------------------------------------------*/

+/**

+int iniparser_getnsec(const dictionary * d)

+ size_t i ;

+const char * iniparser_getsecname(const dictionary * d, int n)

+ size_t i ;

+void iniparser_dump(const dictionary * d, FILE * f)

+ size_t i ;

+static void escape_value(char *escaped, char *value) {

+ char c;

+ int v = 0;

+ int e = 0;

+

+ if(!escaped || !value)

+ return;

+

+ while((c = value[v]) != '\0') {

+ if(c == '\\' || c == '"') {

+ escaped[e] = '\\';

+ e++;

+ }

+ escaped[e] = c;

+ v++;

+ e++;

+ }

+ escaped[e] = '\0';

+}

+

+void iniparser_dump_ini(const dictionary * d, FILE * f)

+ size_t i ;

+ size_t nsec ;

+ const char * secname ;

+ char escaped[ASCIILINESZ+1] = "";

+ escape_value(escaped, d->val[i]);

+ fprintf(f, "%s = \"%s\"\n", d->key[i], escaped);

+ iniparser_dumpsection_ini(d, secname, f);

+ }

+ fprintf(f, "\n");

+ return ;

+}

+

+/*-------------------------------------------------------------------------*/

+/**

+ @brief Save a dictionary section to a loadable ini file

+ @param d Dictionary to dump

+ @param s Section name of dictionary to dump

+ @param f Opened file pointer to dump to

+ @return void

+

+ This function dumps a given section of a given dictionary into a loadable ini

+ file. It is Ok to specify @c stderr or @c stdout as output files.

+ */

+/*--------------------------------------------------------------------------*/

+void iniparser_dumpsection_ini(const dictionary * d, const char * s, FILE * f)

+{

+ size_t j ;

+ char keym[ASCIILINESZ+1];

+ int seclen ;

+ char escaped[ASCIILINESZ+1] = "";

+

+ if (d==NULL || f==NULL) return ;

+ if (! iniparser_find_entry(d, s)) return ;

+

+ seclen = (int)strlen(s);

+ fprintf(f, "\n[%s]\n", s);

+ sprintf(keym, "%s:", s);

+ for (j=0 ; j<d->size ; j++) {

+ if (d->key[j]==NULL)

+ continue ;

+ if (!strncmp(d->key[j], keym, seclen+1)) {

+ escape_value(escaped, d->val[j]);

+ fprintf(f, "%-30s = \"%s\"\n", d->key[j]+seclen+1, escaped);

+const char * iniparser_getstring(const dictionary * d, const char * key, const char * def)

+ const char * lc_key ;

+ const char * sval ;

+ char tmp_str[ASCIILINESZ+1];

+ lc_key = strlwc(key, tmp_str, sizeof(tmp_str));

+ @brief Get the string associated to a key, convert to an long int

+ @return long integer

+long int iniparser_getlongint(const dictionary * d, const char * key, long int notfound)

+ const char * str ;

+ if (str==NULL || str==INI_INVALID_KEY) return notfound ;

+ return strtol(str, NULL, 0);

+}

+

+int64_t iniparser_getint64(const dictionary * d, const char * key, int64_t notfound)

+{

+ const char * str ;

+

+ str = iniparser_getstring(d, key, INI_INVALID_KEY);

+ if (str==NULL || str==INI_INVALID_KEY) return notfound ;

+ return strtoimax(str, NULL, 0);

+}

+

+uint64_t iniparser_getuint64(const dictionary * d, const char * key, uint64_t notfound)

+{

+ const char * str ;

+

+ str = iniparser_getstring(d, key, INI_INVALID_KEY);

+ if (str==NULL || str==INI_INVALID_KEY) return notfound ;

+ return strtoumax(str, NULL, 0);

+}

+

+

+

+/*-------------------------------------------------------------------------*/

+/**

+ @brief Get the string associated to a key, convert to an int

+ @param d Dictionary to search

+ @param key Key string to look for

+ @param notfound Value to return in case of error

+ @return integer

+

+ This function queries a dictionary for a key. A key as read from an

+ ini file is given as "section:key". If the key cannot be found,

+ the notfound value is returned.

+

+ Supported values for integers include the usual C notation

+ so decimal, octal (starting with 0) and hexadecimal (starting with 0x)

+ are supported. Examples:

+

+ "42" -> 42

+ "042" -> 34 (octal -> decimal)

+ "0x42" -> 66 (hexa -> decimal)

+

+ Warning: the conversion may overflow in various ways. Conversion is

+ totally outsourced to strtol(), see the associated man page for overflow

+ handling.

+

+ Credits: Thanks to A. Becker for suggesting strtol()

+ */

+/*--------------------------------------------------------------------------*/

+int iniparser_getint(const dictionary * d, const char * key, int notfound)

+{

+ return (int)iniparser_getlongint(d, key, notfound);

+int iniparser_getboolean(const dictionary * d, const char * key, int notfound)

+ int ret ;

+ const char * c ;

+ if (c==NULL || c==INI_INVALID_KEY) return notfound ;

+int iniparser_find_entry(const dictionary * ini, const char * entry)

+void iniparser_unset(dictionary * ini, const char * entry)

+ char tmp_str[ASCIILINESZ+1];

+ dictionary_unset(ini, strlwc(entry, tmp_str, sizeof(tmp_str)));

+}

+

+static void parse_quoted_value(char *value, char quote) {

+ char c;

+ char *quoted;

+ int q = 0, v = 0;

+ int esc = 0;

+

+ if(!value)

+ return;

+

+ quoted = xstrdup(value);

+

+ if(!quoted) {

+ iniparser_error_callback("iniparser: memory allocation failure\n");

+ goto end_of_value;

+ }

+

+ while((c = quoted[q]) != '\0') {

+ if(!esc) {

+ if(c == '\\') {

+ esc = 1;

+ q++;

+ continue;

+ }

+

+ if(c == quote) {

+ goto end_of_value;

+ }

+ }

+ esc = 0;

+ value[v] = c;

+ v++;

+ q++;

+ }

+end_of_value:

+ value[v] = '\0';

+ free(quoted);

+ @brief Load a single line from an INI file

+ const char * input_line,

+ char * line = NULL;

+ size_t len ;

+ int d_quote;

+ line = xstrdup(input_line);

+ len = strstrip(line);

+ } else if (line[0]=='#' || line[0]==';') {

+ /* Section name without opening square bracket */

+ sscanf(line, "[%[^\n]", section);

+ len = strlen(section);

+ /* Section name without closing square bracket */

+ if(section[len-1] == ']')

+ {

+ section[len-1] = '\0';

+ }

+ strstrip(section);

+ strlwc(section, section, len);

+ } else if ((d_quote = sscanf (line, "%[^=] = \"%[^\n]\"", key, value)) == 2

+ || sscanf (line, "%[^=] = '%[^\n]'", key, value) == 2) {

+ /* Usual key=value with quotes, with or without comments */

+ strstrip(key);

+ strlwc(key, key, len);

+ if(d_quote == 2)

+ parse_quoted_value(value, '"');

+ else

+ parse_quoted_value(value, '\'');

+ /* Don't strip spaces from values surrounded with quotes */

+ sta = LINE_VALUE ;

+ } else if (sscanf (line, "%[^=] = %[^;#]", key, value) == 2) {

+ /* Usual key=value without quotes, with or without comments */

+ strstrip(key);

+ strlwc(key, key, len);

+ strstrip(value);

+ strstrip(key);

+ strlwc(key, key, len);

+

+ free(line);

+ @param in File to read.

+ @param ininame Name of the ini file to read (only used for nicer error messages)

+ the file to be read. It returns a dictionary object that should not

+ be accessed directly, but through accessor functions instead.

+dictionary * iniparser_load_file(FILE * in, const char * ininame)

+ char tmp [(ASCIILINESZ * 2) + 2] ;

+ int mem_err=0;

+ if (len<=0)

+ continue;

+ if (line[len]!='\n' && !feof(in)) {

+ iniparser_error_callback(

+ "iniparser: input line too long in %s (%d)\n",

+ ininame,

+ lineno);

+ if (len < 0) { /* Line was entirely \n and/or spaces */

+ len = 0;

+ }

+ mem_err = dictionary_set(dict, section, NULL);

+ mem_err = dictionary_set(dict, tmp, val);

+ iniparser_error_callback(

+ "iniparser: syntax error in %s (%d):\n-> %s\n",

+ ininame,

+ lineno,

+ line);

+ if (mem_err<0) {

+ iniparser_error_callback("iniparser: memory allocation failure\n");

+ return dict ;

+}

+

+/*-------------------------------------------------------------------------*/

+/**

+ @brief Parse an ini file and return an allocated dictionary object

+ @param ininame Name of the ini file to read.

+ @return Pointer to newly allocated dictionary

+

+ This is the parser for ini files. This function is called, providing

+ the name of the file to be read. It returns a dictionary object that

+ should not be accessed directly, but through accessor functions

+ instead.

+

+ The returned dictionary must be freed using iniparser_freedict().

+ */

+/*--------------------------------------------------------------------------*/

+dictionary * iniparser_load(const char * ininame)

+{

+ FILE * in ;

+ dictionary * dict ;

+

+ if ((in=fopen(ininame, "r"))==NULL) {

+ iniparser_error_callback("iniparser: cannot open %s\n", ininame);

+ return NULL ;

+ }

+

+ dict = iniparser_load_file(in, ininame);

+

+

+ if (eb_start == 0 && mtd.size == (long long)eb_cnt * mtd.eb_size)

+ unsigned char *src, *dest, *wrlast_buf = NULL;

+ if (!bam) {

+ perror("malloc failed");

+ return;

+ }

+ char *dumpfile_tmp = NULL;

+ free(dumpfile_tmp);

+ dumpfile = dumpfile_tmp = xstrdup(optarg);

+ (unsigned long long)bit_to_flip->block * mtd.eb_size +

+int do_pwr_dn(int fd, int cycleCnt);

+

+ unsigned long long start;

+ start = reginfo->offset + (unsigned long long)i * reginfo->erasesize;

+ printf(" %*i: %08llx ", width, i, start);

+ else if (vi->alignment <= 0)

+ return errmsg("not positive volume alignment %d in section \"%s\"",

+ args.bytes = (long long)vol_info.leb_size * args.lebs;

+ $(DUMP_STACK_LD) $(ASAN_LIBS) -lm -lpthread

+ $(DUMP_STACK_LD) $(ASAN_LIBS) -lm -lpthread

+* crc16.h and crc16.c were copied from the linux kernel(https://elixir.bootlin.com/linux/v5.10.232/source/lib/crc16.c).

+* bitops.h and bitops.c were copied from the linux kernel(https://elixir.bootlin.com/linux/v5.10.232/source/lib/find_bit.c).

+* compiler_attributes.h was copied from the linux kernel(https://elixir.bootlin.com/linux/v5.10.232/source/include/linux/compiler_attributes.h).

+* linux_types.h was copied from the linux kernel(https://elixir.bootlin.com/linux/v5.10.232/source/include/linux/types.h overflow.h fscrypt.h).

+* linux_err.h was copied from the linux kernel(https://elixir.bootlin.com/linux/v5.10.232/source/include/linux/err.h).

+* hexdump.c was copied from the linux kernel(https://elixir.bootlin.com/linux/v5.10.232/source/lib/hexdump.c).

+* kmem.h and kmem.c were partial copied from xfsprogs-dev(https://git.kernel.org/pub/scm/fs/xfs/xfsprogs-dev.git/).

+* sort.h and sort.c were copied from the linux kernel(https://elixir.bootlin.com/linux/v5.10.232/source/lib/sort.c).

+UBIFS Library (Imported from linux kernel 6.13-rc7 aa22f4da2a46)

+ * @arg: information passed to and from the caller of the scan

+ void *arg)

+ struct scan_data *data = arg;

+ err = ubifs_lpt_scan_nolock(c, -1, c->lscan_lnum, scan_for_dirty_cb,

+ * @arg: information passed to and from the caller of the scan

+ void *arg)

+ struct scan_data *data = arg;

+ scan_for_free_cb,

+ * @arg: information passed to and from the caller of the scan

+ void *arg)

+ struct scan_data *data = arg;

+ err = ubifs_lpt_scan_nolock(c, -1, c->lscan_lnum, scan_for_idx_cb,

+static int cmp_dirty_idx(const void *a, const void *b)

+ const struct ubifs_lprops *lpa = *(const struct ubifs_lprops **)a;

+ const struct ubifs_lprops *lpb = *(const struct ubifs_lprops **)b;

+ cmp_dirty_idx, NULL);

+ * @arg: information passed to and from the caller of the scan

+ void *arg)

+ struct scan_data *data = arg;

+ err = ubifs_lpt_scan_nolock(c, -1, c->lscan_lnum, scan_dirty_idx_cb,

+ * @ptr: union of node pointers

+ return ERR_CAST(nnode);

+ return ERR_CAST(nnode);

+ * @hash: node hash

+ ubifs_assert(c, !znode->parent);

+ znode->cparent = NULL;