671 lines
20 KiB
C
671 lines
20 KiB
C
/****************************************************************************
|
|
* apps/system/inifile/inifile.c
|
|
*
|
|
* Copyright (C) 2014 Gregory Nutt. All rights reserved.
|
|
* Author: Gregory Nutt <gnutt@nuttx.org>
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in
|
|
* the documentation and/or other materials provided with the
|
|
* distribution.
|
|
* 3. Neither the name NuttX nor the names of its contributors may be
|
|
* used to endorse or promote products derived from this software
|
|
* without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
|
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
|
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
|
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
|
|
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
|
|
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
|
|
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
* POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
****************************************************************************/
|
|
|
|
/****************************************************************************
|
|
* Included Files
|
|
****************************************************************************/
|
|
|
|
#include <nuttx/config.h>
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <debug.h>
|
|
|
|
#include <apps/inifile.h>
|
|
|
|
/****************************************************************************
|
|
* Pre-processor Definitions
|
|
****************************************************************************/
|
|
|
|
/* The maximum size of a line in the INI file */
|
|
|
|
#ifndef CONFIG_SYSTEM_INIFILE_MAXLINE
|
|
# define CONFIG_SYSTEM_INIFILE_MAXLINE 256
|
|
#endif
|
|
|
|
#ifndef CONFIG_SYSTEM_INIFILE_DEBUGLEVEL
|
|
# define CONFIG_SYSTEM_INIFILE_DEBUGLEVEL 0
|
|
#endif
|
|
|
|
#ifdef CONFIG_CPP_HAVE_VARARGS
|
|
# if CONFIG_SYSTEM_INIFILE_DEBUGLEVEL > 0
|
|
# define inidbg(format, ...) \
|
|
printf(EXTRA_FMT format EXTRA_ARG, ##__VA_ARGS__)
|
|
# else
|
|
# define inidbg(x...)
|
|
# endif
|
|
|
|
# if CONFIG_SYSTEM_INIFILE_DEBUGLEVEL > 1
|
|
# define inivdbg(format, ...) \
|
|
printf(EXTRA_FMT format EXTRA_ARG, ##__VA_ARGS__)
|
|
# else
|
|
# define inivdbg(x...)
|
|
# endif
|
|
#else
|
|
# if CONFIG_SYSTEM_INIFILE_DEBUGLEVEL > 0
|
|
# define inidbg printf
|
|
# else
|
|
# define inidbg (void)
|
|
# endif
|
|
|
|
# if CONFIG_SYSTEM_INIFILE_DEBUGLEVEL > 1
|
|
# define inivdbg printf
|
|
# else
|
|
# define inivdbg (void)
|
|
# endif
|
|
#endif
|
|
|
|
/****************************************************************************
|
|
* Private Types
|
|
****************************************************************************/
|
|
|
|
/* A structure that describes one entry from the INI file */
|
|
|
|
struct inifile_var_s
|
|
{
|
|
FAR char *variable;
|
|
FAR char *value;
|
|
};
|
|
|
|
/* This structure describes the state of one instance of the INI file parser */
|
|
|
|
struct inifile_state_s
|
|
{
|
|
FILE *instream;
|
|
int nextch;
|
|
char line[CONFIG_SYSTEM_INIFILE_MAXLINE+1];
|
|
};
|
|
|
|
/****************************************************************************
|
|
* Private Data
|
|
****************************************************************************/
|
|
|
|
/****************************************************************************
|
|
* Private Function Prototypes
|
|
****************************************************************************/
|
|
|
|
static bool inifile_next_line(FAR struct inifile_state_s *priv);
|
|
static int inifile_read_line(FAR struct inifile_state_s *priv);
|
|
static int inifile_read_noncomment_line(FAR struct inifile_state_s *priv);
|
|
static bool inifile_seek_to_section(FAR struct inifile_state_s *priv,
|
|
FAR const char *section);
|
|
static bool inifile_read_variable(FAR struct inifile_state_s *priv,
|
|
FAR struct inifile_var_s *varinfo);
|
|
static FAR char *
|
|
inifile_find_section_variable(FAR struct inifile_state_s *priv,
|
|
FAR const char *variable);
|
|
static FAR char *
|
|
inifile_find_variable(FAR struct inifile_state_s *priv,
|
|
FAR const char *section, FAR const char *variable);
|
|
|
|
/****************************************************************************
|
|
* Private Functions
|
|
****************************************************************************/
|
|
|
|
/****************************************************************************
|
|
* Name: inifile_next_line
|
|
*
|
|
* Description:
|
|
* Skip to the first character of the next line. Returns true if the end
|
|
* of file was not encountered.
|
|
*
|
|
****************************************************************************/
|
|
|
|
static bool inifile_next_line(FAR struct inifile_state_s *priv)
|
|
{
|
|
/* Search ahead for the end of line mark (or possibly the end of file mark) */
|
|
|
|
while ((priv->nextch != '\n') && (priv->nextch != EOF))
|
|
{
|
|
priv->nextch = getc(priv->instream);
|
|
}
|
|
|
|
/* Re-prime the pump with the first character from the next line. NOTE:
|
|
* this logic depends on the fact that getc() will return EOF repeatedly.
|
|
*/
|
|
|
|
priv->nextch = getc(priv->instream);
|
|
return (priv->nextch != EOF);
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Name: inifile_read_line
|
|
*
|
|
* Description:
|
|
* Read the next line from the INI file into the line buffer and return
|
|
* the number of characters read into the buffer. If we hit the end of a
|
|
* section (or the end of a file), this function will return a count of
|
|
* zero.
|
|
*
|
|
****************************************************************************/
|
|
|
|
static int inifile_read_line(FAR struct inifile_state_s *priv)
|
|
{
|
|
int nbytes;
|
|
|
|
/* Assuming that the file pointer is correctly positioned at the beginning
|
|
* of the next line, read until the end of line indication is found (or
|
|
* until the line buffer is full). This is basically fgets().
|
|
*/
|
|
|
|
nbytes = 0;
|
|
while ((nbytes < CONFIG_SYSTEM_INIFILE_MAXLINE) &&
|
|
(priv->nextch != EOF) &&
|
|
(priv->nextch != '\n'))
|
|
{
|
|
/* Always ignore carriage returns */
|
|
|
|
if (priv->nextch != '\r')
|
|
{
|
|
/* Ignore any leading whitespace on the line */
|
|
|
|
if (nbytes || (priv->nextch != ' ' && priv->nextch != '\t'))
|
|
{
|
|
/* Add the new character to the line buffer */
|
|
|
|
priv->line[nbytes] = priv->nextch;
|
|
nbytes++;
|
|
}
|
|
}
|
|
|
|
/* Get the next character from the INI file */
|
|
|
|
priv->nextch = getc(priv->instream);
|
|
}
|
|
|
|
/* NUL terminate the string */
|
|
|
|
priv->line[nbytes] = '\0';
|
|
|
|
/* Skip to the first character of the next line. This should normally
|
|
* just amount to skipping over the newline, but could be more involved
|
|
* if we had to truncate the line to fit into the line buffer.
|
|
*/
|
|
|
|
if (priv->nextch != EOF)
|
|
{
|
|
(void)inifile_next_line(priv);
|
|
}
|
|
|
|
/* And return the number of bytes read (excluding the NUL terminator and
|
|
* leading whitespace).
|
|
*/
|
|
|
|
return nbytes;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Name: inifile_read_noncomment_line
|
|
*
|
|
* Description:
|
|
* Read until either a (1) no further lines are found in the file, or (2)
|
|
* a line that does not begin with a semi-colon is found
|
|
*
|
|
****************************************************************************/
|
|
|
|
static int inifile_read_noncomment_line(FAR struct inifile_state_s *priv)
|
|
{
|
|
int nbytes;
|
|
|
|
/* Read until either a (1) no further lines are found in
|
|
* the file, or (2) a line that does not begin with a semi-colon
|
|
* is found */
|
|
|
|
do nbytes = inifile_read_line(priv);
|
|
while (nbytes > 0 && priv->line[0] == ';');
|
|
|
|
return nbytes;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Name: inifile_seek_to_section
|
|
*
|
|
* Description:
|
|
* Positions the file pointer to the line containing the first variable
|
|
* description within the INI file. Returns 1 if the section was found.
|
|
* In this case, the file pointer will be positioned at the beginning of
|
|
* the first variable line.
|
|
*
|
|
****************************************************************************/
|
|
|
|
static bool inifile_seek_to_section(FAR struct inifile_state_s *priv,
|
|
FAR const char *section)
|
|
{
|
|
int nbytes;
|
|
|
|
/* Rewind to the beginning of the INI file and re-prime the pump with the
|
|
* first character from the INI file.
|
|
*/
|
|
|
|
rewind(priv->instream);
|
|
priv->nextch = getc(priv->instream);
|
|
|
|
/* Loop until either the section is found, or until we hit the end of the
|
|
* INI file.
|
|
*/
|
|
|
|
do
|
|
{
|
|
/* Read the next line into the input buffer. A returned value of zero
|
|
* bytes means nothing special here -- could be EOF or a blank line.
|
|
*/
|
|
|
|
nbytes = inifile_read_noncomment_line(priv);
|
|
|
|
/* It takes at least three bytes of data to be a candidate for a
|
|
* section header.
|
|
*/
|
|
|
|
if (nbytes >= 3)
|
|
{
|
|
/* A section header must begin with a left bracket */
|
|
|
|
if (priv->line[0] == '[')
|
|
{
|
|
/* The section name should start with the first character
|
|
* after the left bracket.
|
|
*/
|
|
|
|
FAR char *sectend;
|
|
|
|
/* The section name should extend to the right bracket. */
|
|
|
|
sectend = strchr(&priv->line[1], ']');
|
|
|
|
/* Replace the right bracket (if found) with a NULL
|
|
* terminator.
|
|
*/
|
|
|
|
if (sectend)
|
|
{
|
|
*sectend = '\0';
|
|
}
|
|
|
|
/* Then compare the section name to the one we are looking for */
|
|
|
|
if (strcasecmp(&priv->line[1], section) == 0)
|
|
{
|
|
/* The section names match! Return success */
|
|
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
while (priv->nextch != EOF);
|
|
|
|
/* If we got here, we search the whole INI file without finding
|
|
* the requested section
|
|
*/
|
|
|
|
inidbg("ERROR: Section \"%s\" not found\n", section);
|
|
return false;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Name: inifile_read_variable
|
|
*
|
|
* Description:
|
|
* Obtain variable info from the next line in the section. This assumes
|
|
* that the file pointer is pointing to the beginning of the next line.
|
|
* If there is no further data in the section, false is returned.
|
|
*
|
|
****************************************************************************/
|
|
|
|
static bool inifile_read_variable(FAR struct inifile_state_s *priv,
|
|
FAR struct inifile_var_s *varinfo)
|
|
{
|
|
FAR char *ptr;
|
|
|
|
/* Read until either (1) the end of file is found, (2) the end of
|
|
* the section is found, or (3) a valid variable assignment is found.
|
|
*/
|
|
|
|
for (;;)
|
|
{
|
|
/* Read the next line in the buffer */
|
|
|
|
int nbytes = inifile_read_noncomment_line(priv);
|
|
|
|
/* Make sure that the line is non-NULL and that this is not the
|
|
* beginning of a new section
|
|
*/
|
|
|
|
if (!nbytes || priv->line[0] == '[')
|
|
{
|
|
return false;
|
|
}
|
|
|
|
/* Search for the '=' delimiter. NOTE the line is guaranteed to
|
|
* be NULL terminated by inifile_read_noncomment_line().
|
|
*/
|
|
|
|
ptr = strchr(&priv->line[1], '=');
|
|
|
|
/* If the delimiter was found, return success */
|
|
|
|
if (ptr)
|
|
{
|
|
/* Put NUL termination between the variable name and the
|
|
* variable value (replacing the equal sign).
|
|
*/
|
|
|
|
*ptr = '\0';
|
|
|
|
/* Set up the return structure. NOTE: value may point at
|
|
* a NULL string
|
|
*/
|
|
|
|
varinfo->variable = (char*)priv->line;
|
|
varinfo->value = (ptr + 1);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Name: inifile_find_section_variable
|
|
*
|
|
* Description:
|
|
* Find the value string associated with the variable name. This function
|
|
* will return NULL on failure to find the variable. It will return a
|
|
* pointer to an empty string is the variable is found, but not assigned a
|
|
* value.
|
|
*
|
|
****************************************************************************/
|
|
|
|
static FAR char *
|
|
inifile_find_section_variable(FAR struct inifile_state_s *priv,
|
|
FAR const char *variable)
|
|
{
|
|
/* Loop until either (1) we hit the end of file, (2) we hit the end
|
|
* of the section, or (3) we find the variable that we are looking
|
|
* for/
|
|
*/
|
|
|
|
inivdbg("variable=\"%s\"\n", variable);
|
|
|
|
for (;;)
|
|
{
|
|
/* Get the next variable from this section. */
|
|
|
|
struct inifile_var_s varinfo;
|
|
bool found = inifile_read_variable(priv, &varinfo);
|
|
|
|
/* Is there anything left in the section? */
|
|
|
|
if (!found)
|
|
{
|
|
inivdbg("Returning NULL\n");
|
|
return NULL;
|
|
}
|
|
|
|
inivdbg("varinfo.variable=\"%s\"\n", varinfo.variable);
|
|
|
|
/* Does the the variable name match the one we are looking for? */
|
|
|
|
if (strcasecmp(varinfo.variable, variable) == 0)
|
|
{
|
|
/* Yes... then we have it! */
|
|
|
|
inivdbg("Returning \"%s\"\n", varinfo.value);
|
|
return varinfo.value;
|
|
}
|
|
}
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Name: inifile_find_variable
|
|
*
|
|
* Description:
|
|
* Obtains the specified string value for the specified variable name
|
|
* within the specified section of the INI file.
|
|
*
|
|
****************************************************************************/
|
|
|
|
static FAR char *inifile_find_variable(FAR struct inifile_state_s *priv,
|
|
FAR const char *section,
|
|
FAR const char *variable)
|
|
{
|
|
FAR char *ret = NULL;
|
|
|
|
inivdbg("section=\"%s\" variable=\"%s\"\n", section, variable);
|
|
|
|
/* Seek to the first variable in the specified section of the INI file */
|
|
|
|
if (priv->instream && inifile_seek_to_section(priv, section))
|
|
{
|
|
/* If the seek was successful, then find the value string within
|
|
* the section
|
|
*/
|
|
|
|
FAR char *value = inifile_find_section_variable(priv, variable);
|
|
inivdbg("variable_value=0x%p\n", value);
|
|
|
|
if (value && *value)
|
|
{
|
|
inivdbg("variable_value=\"%s\"\n", value);
|
|
ret = value;
|
|
}
|
|
}
|
|
|
|
/* Return the string that we found. */
|
|
|
|
inivdbg("Returning 0x%p\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Public Functions
|
|
****************************************************************************/
|
|
|
|
/****************************************************************************
|
|
* Name: inifile_initialize
|
|
*
|
|
* Description:
|
|
* Initialize for access to the INI file 'inifile_name'
|
|
*
|
|
****************************************************************************/
|
|
|
|
INIHANDLE inifile_initialize(FAR const char *inifile_name)
|
|
{
|
|
/* Allocate an INI file parser state structure */
|
|
|
|
FAR struct inifile_state_s *priv =
|
|
(FAR struct inifile_state_s *)malloc(sizeof(struct inifile_state_s));
|
|
|
|
if (!priv)
|
|
{
|
|
inidbg("ERROR: Failed to allocate state structure\n");
|
|
return (INIHANDLE)NULL;
|
|
}
|
|
|
|
/* Open the specified INI file for reading */
|
|
|
|
priv->instream = fopen(inifile_name, "r");
|
|
|
|
/* Prime the pump */
|
|
|
|
if (priv->instream)
|
|
{
|
|
priv->nextch = getc(priv->instream);
|
|
return (INIHANDLE)priv;
|
|
}
|
|
else
|
|
{
|
|
inidbg("ERROR: Could not open \"%s\"\n", inifile_name);
|
|
return (INIHANDLE)NULL;
|
|
}
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Name: inifile_uninitialize
|
|
*
|
|
* Description:
|
|
* Free resources commit to INI file parsing
|
|
*
|
|
****************************************************************************/
|
|
|
|
void inifile_uninitialize(INIHANDLE handle)
|
|
{
|
|
FAR struct inifile_state_s *priv = (FAR struct inifile_state_s *)handle;
|
|
|
|
if (priv)
|
|
{
|
|
/* Close the INI file stream */
|
|
|
|
if (priv->instream)
|
|
{
|
|
fclose(priv->instream);
|
|
}
|
|
|
|
/* Release the state structure */
|
|
|
|
free(priv);
|
|
}
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Name: inifile_read_string
|
|
*
|
|
* Description:
|
|
* Obtains the specified string value for the specified variable name
|
|
* within the specified section of the INI file. The receiver of the
|
|
* value string should call inifile_free_string when it no longer needs
|
|
* the memory held by the value string.
|
|
*
|
|
****************************************************************************/
|
|
|
|
FAR char *inifile_read_string(INIHANDLE handle,
|
|
FAR const char *section,
|
|
FAR const char *variable,
|
|
FAR const char *defvalue)
|
|
{
|
|
FAR struct inifile_state_s *priv = (FAR struct inifile_state_s *)handle;
|
|
FAR char *ret = NULL;
|
|
FAR const char *value;
|
|
|
|
/* Get a reference to the volatile version of the string */
|
|
|
|
value = inifile_find_variable(priv, section, variable);
|
|
|
|
/* If the variable was not found, then use the default value */
|
|
|
|
if (!value)
|
|
{
|
|
/* Selecting the default string */
|
|
|
|
value = defvalue;
|
|
}
|
|
|
|
/* If this was successful, create a non-volatile copy of the string
|
|
* We do this even if the default value is used because the caller
|
|
* will (eventually) deallocate it.
|
|
*/
|
|
|
|
if (value)
|
|
{
|
|
ret = strdup(value);
|
|
}
|
|
|
|
/* Return the string that we found. */
|
|
|
|
return ret;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Name: inifile_read_integer
|
|
*
|
|
* Description:
|
|
* Obtains the specified integer value for the specified variable name
|
|
* within the specified section of the INI file
|
|
*
|
|
****************************************************************************/
|
|
|
|
long inifile_read_integer(INIHANDLE handle,
|
|
FAR const char *section,
|
|
FAR const char *variable,
|
|
FAR long defvalue)
|
|
{
|
|
FAR struct inifile_state_s *priv = (FAR struct inifile_state_s *)handle;
|
|
FAR char *value;
|
|
long ret = defvalue;
|
|
|
|
/* Assume failure to find the requested value */
|
|
|
|
inivdbg("section=\"%s\" variable=\"%s\" defvalue=%d\n",
|
|
section, variable, defvalue);
|
|
|
|
/* Get the value as a string first */
|
|
|
|
value = inifile_find_variable(priv, section, variable);
|
|
|
|
/* If this was successful, then convert the string to an integer value. */
|
|
|
|
if (value)
|
|
{
|
|
/* Then convert the string to an integer value (accept any base, and
|
|
* ignore all conversion errors.
|
|
*/
|
|
|
|
inivdbg("%s=\"%s\"\n", variable, value);
|
|
ret = strtol(value, NULL, 0);
|
|
}
|
|
|
|
/* Return the value that we found. */
|
|
|
|
inivdbg("Returning %d\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Name: inifile_free_string
|
|
*
|
|
* Description:
|
|
* Release resources allocated for the value string previously obtained
|
|
* from inifile_read_string. The purpose of this inline function is to
|
|
* hide the memory allocator used by this implementation.
|
|
*
|
|
****************************************************************************/
|
|
|
|
void inifile_free_string(FAR char *value)
|
|
{
|
|
if (value)
|
|
{
|
|
free(value);
|
|
}
|
|
}
|