config.c File Reference

Configuration parser definitions. More...

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include "rnr/rnrconfig.h"
#include "rnr/log.h"
#include "rnr/new.h"
#include "rnr/hash.h"
#include "rnr/config.h"

Go to the source code of this file.

Classes
struct	config_section_t
struct	config_t
struct	config_iter_t

Macros
#define	HASH_MIN_SECTIONS   (hashcount_t)8
	min. num. of database sections More...
#define	HASH_MAX_SECTIONS   HASHCOUNT_T_MAX
	max. num. of database sections
#define	HASH_MIN_ENTRIES   (hashcount_t)8
	min. num. of section entries
#define	HASH_MAX_ENTRIES   HASHCOUNT_T_MAX
	max. num. of section entries
#define	HASH_INPUT_BUF_SIZE   1024
	Maximum input line size.

Functions
static int	ConfigSectionAddPair (ConfigSection_T *pSect, const char *sKey, const char *sVal)
	Add or update a key-value pair in the given section. More...
static void	ConfigSectionHashDeleteCb (void *pKey, void *pData)
	Delete section entry hash callback. More...
static void	ConfigMainHashDeleteCb (void *pKey, void *pData)
	Delete section hash callback. More...
Config_T *	ConfigDbNew (const char *sMainName)
	Create and initialize a new empty configuration database. More...
void	ConfigDbDelete (Config_T *pConfig)
	Delete the configuration database. More...
Config_T *	ConfigDbRead (const char *sFileName)
	Create a new configuration database from a configuration file. More...
Config_T *	ConfigDbReadFp (FILE *fp, const char *sFileName)
	Create a new configuration database from a opened configuration file. More...
const char *	ConfigDbGetName (Config_T *pConfig)
	Get the current name assigned to the configuration database. More...
void	ConfigDbSetName (Config_T *pConfig, const char *sMainName)
	Assign a new name for the configuration database. More...
void	ConfigDbPrint (Config_T *pConfig, FILE *fp)
	Print configuration database to the output file stream. More...
ConfigSection_T *	ConfigSectionNew (Config_T *pConfig, const char *sSectionName)
	Add a new empty section to the configuration database. More...
int	ConfigSectionDelete (Config_T *pConfig, ConfigSection_T *pSect)
	Delete a section from the configuration database. More...
ConfigSection_T *	ConfigSectionGet (Config_T *pConfig, const char *sSectionName)
	Get a section from the configuration database. More...
void	ConfigSectionPrint (ConfigSection_T *pSect, FILE *fp)
	Print one section to the output file stream. More...
const char *	ConfigGetStr (Config_T *pConfig, const char *sSectionName, const char *sKey)
	Get a string value from the configuration database. More...
int	ConfigGetLong (Config_T *pConfig, const char *sSectionName, const char *sKey, long *pVal)
	Get and convert a long value from the configuration database. More...
int	ConfigGetDouble (Config_T *pConfig, const char *sSectionName, const char *sKey, double *pVal)
	Get and convert a double value from the configuration database. More...
int	ConfigSetStr (Config_T *pConfig, const char *sSectionName, const char *sKey, const char *sVal)
	Set or update a string value in the configuration database. More...
int	ConfigSetLong (Config_T *pConfig, const char *sSectionName, const char *sKey, long lVal)
	Set or update a long value in the configuration database. More...
int	ConfigSetULong (Config_T *pConfig, const char *sSectionName, const char *sKey, unsigned long ulVal)
	Set or update an unsigned long value in the configuration database. More...
int	ConfigSetDouble (Config_T *pConfig, const char *sSectionName, const char *sKey, double fVal)
	Set or update a double value in the configuration database. More...
int	ConfigDelete (Config_T *pConfig, const char *sSectionName, const char *sKey)
	Delete entry from the configuration database. More...
ConfigIter_T *	ConfigDbIterNew (Config_T *pConfig)
	Create a new configuration database iterator. More...
ConfigIter_T *	ConfigSectionIterNew (Config_T *pConfig, const char *sSectionName)
	Create a new configuration section iterator. More...
void	ConfigIterDelete (ConfigIter_T *pIter)
	Delete a configuration iterator. More...
const char *	ConfigIterNext (ConfigIter_T *pIter)
	Get the next value in iteration. More...

Variables
static int	ConfigMainCounter = 0

Detailed Description

Configuration parser definitions.

LastChangedDate

2014-12-06 13:48:30 -0700 (Sat, 06 Dec 2014)

Rev

3823

This file has been modified from the original source (see below).

Author

Robin Knight (robin.nosp@m..kni.nosp@m.ght@r.nosp@m.oadn.nosp@m.arrow.nosp@m.s.co.nosp@m.m)

Copyright

© 2005-2018. RoadNarrows LLC..
http://www.roadnarrows.com
All Rights Reserved

---

Original Source and Copyright:

Original Author:

Jon Travis (jtrav.nosp@m.is@p.nosp@m.00p.o.nosp@m.rg)

Original Copyright:

(C) 1992-2002

Original Header:

See "Original Source Header EULA" in source file.

---

Definition in file config.c.

Macro Definition Documentation

#define HASH_MIN_SECTIONS   (hashcount_t)8

min. num. of database sections

Configuration limits.

Definition at line 101 of file config.c.

Referenced by ConfigDbNew().

Function Documentation

void ConfigDbDelete

(

Config_T *

pConfig

)

Delete the configuration database.

All sections, section key=value entries, plus the database itself are deleted.

Parameters

pConfig

Configuration database.

Definition at line 295 of file config.c.

References _TSTR, hash_table_destroy(), LOGDIAG4CALL, config_t::m_hashMain, config_t::m_sMainName, and NULL.

Referenced by CmdDbDelete(), and ConfigDbReadFp().

{
  LOGDIAG4CALL(_TSTR(pConfig));

  if( pConfig == NULL )
  {
    return;
  }

  // delete all sections and section entries
  hash_table_destroy(pConfig->m_hashMain);

  // now delete the structure
  delete(pConfig->m_sMainName);
  delete(pConfig);
}

const char* ConfigDbGetName

(

Config_T *

pConfig

)

Get the current name assigned to the configuration database.

Parameters

pConfig

Configuration database.

Returns

Returns current name.

Definition at line 486 of file config.c.

References CHKPTR, config_t::m_sMainName, and NULL.

Referenced by CmdDelete(), CmdFind(), CmdGetd(), CmdGeti(), CmdGets(), CmdSectDelete(), CmdSectNew(), CmdSetd(), CmdSeti(), and CmdSets().

{
  CHKPTR(pConfig, NULL);
  return pConfig->m_sMainName;
}

ConfigIter_T* ConfigDbIterNew

(

Config_T *

pConfig

)

Create a new configuration database iterator.

The iterator will iterator over section names.

Parameters

pConfig

Configuration database.

Returns

New iterator.

Definition at line 943 of file config.c.

References hash_scan_begin(), config_t::m_hashMain, config_iter_t::m_scanHash, and NEW.

Referenced by CmdFind(), and ConfigSetInt().

{
  ConfigIter_T    *pIter;

  pIter = NEW(ConfigIter_T);
  hash_scan_begin(&pIter->m_scanHash, pConfig->m_hashMain);

  return pIter;
}

Config_T* ConfigDbNew

(

const char *

sMainName

)

Create and initialize a new empty configuration database.

Parameters

sMainName

Name of configuration database. If Null, then a name will be auto-generated.

Returns

Returns new configuration database on success.
Returns NULL on failure.

Definition at line 243 of file config.c.

References _TPTR, _TSTR, ConfigMainCounter, ConfigMainHashDeleteCb(), HASH_MAX_SECTIONS, HASH_MIN_SECTIONS, hash_table_create(), LOGDIAG3, LOGDIAG4CALL, LOGERROR, config_t::m_hashMain, config_t::m_sMainName, NEW, new_strdup(), and NULL.

Referenced by CmdDbNew(), and ConfigDbReadFp().

{
  Config_T *pConfig;
  char      buf[32];

  LOGDIAG4CALL(_TSTR(sMainName));

  // new main configuration structure
  pConfig = NEW(Config_T);

  // new empty main hash table of sections
  pConfig->m_hashMain = hash_table_create(true,
                                       HASH_MIN_SECTIONS,
                                       HASH_MAX_SECTIONS,
                                       NULL,
                                       NULL,
                                       ConfigMainHashDeleteCb);

  if( pConfig->m_hashMain == NULL )
  {
    LOGERROR("failed to create new configuration main hash table");
    delete(pConfig);
    return NULL;
  }

  // create internal name
  if( sMainName == NULL )
  {
    snprintf(buf, sizeof(buf), "__config.%d", ConfigMainCounter++);
    buf[sizeof(buf)-1] = 0;
    pConfig->m_sMainName = new_strdup(buf);
  }

  // use given name
  else
  {
    pConfig->m_sMainName = new_strdup(sMainName);
  }

  LOGDIAG3(_TPTR(pConfig));

  return pConfig;
}

void ConfigDbPrint	(	Config_T *	pConfig,
		FILE *	fp
	)

Print configuration database to the output file stream.

The output format is valid for input.

Parameters

pConfig	Configuration database.
fp	Output file pointer.

Definition at line 514 of file config.c.

References ConfigSectionPrint(), hash_scan_begin(), hash_scan_next(), hnode_get, config_t::m_hashMain, config_t::m_sMainName, and NULL.

Referenced by CmdDbPrint(), and test_config().

{
  hscan_t          scanHash;
  hnode_t         *pHashNode;
  ConfigSection_T *pSect;

  fprintf(fp, "# Configuration %s\n", pConfig->m_sMainName);
  hash_scan_begin(&scanHash, pConfig->m_hashMain);
  while((pHashNode = hash_scan_next(&scanHash)) != NULL )
  {
    pSect = (ConfigSection_T *)hnode_get(pHashNode);
    ConfigSectionPrint(pSect, fp);
    fprintf(fp, "\n");
  }
}

Config_T* ConfigDbRead

(

const char *

sFileName

)

Create a new configuration database from a configuration file.

The file syntax must conform to the simplified 'INI' format supported by librnr config.

The file is closed upon exiting this function.

Parameters

sFileName

File path name of configuration file.

Returns

Returns populated configuration database on success.
Returns NULL on failure.

Definition at line 326 of file config.c.

References _TPTR, _TSTR, CHKPTR, ConfigDbReadFp(), LOGDIAG4, LOGDIAG4CALL, LOGSYSERROR, and NULL.

Referenced by CmdDbRead(), and test_config().

{
  FILE      *fp;
  Config_T  *pConfig;

  LOGDIAG4CALL(_TSTR(sFileName));

  CHKPTR(sFileName, NULL);

  if( (fp = fopen(sFileName, "r")) == NULL )
  {
    LOGSYSERROR("%s", sFileName);
    return NULL;
  }
  else
  {
    pConfig = ConfigDbReadFp(fp, sFileName);
    fclose(fp);
    LOGDIAG4(_TPTR(pConfig));
    return pConfig;
  }
}

Config_T* ConfigDbReadFp	(	FILE *	fp,
		const char *	sFileName
	)

Create a new configuration database from a opened configuration file.

The file syntax must conform to the simplified 'INI' format supported by librnr config.

The file is remains open upon exiting this function.

Parameters

fp	Input file pointer.
sFileName	Input file name. NULL is okay.

Returns

Returns populated configuration database on success.
Returns NULL on failure.

Definition at line 364 of file config.c.

References _TPTR, _TSTR, CHKPTR, ConfigDbDelete(), ConfigDbNew(), ConfigSectionAddPair(), ConfigSectionNew(), HASH_INPUT_BUF_SIZE, LOGDIAG4, LOGDIAG4CALL, LOGERROR, config_t::m_sMainName, config_section_t::m_sSectionName, NULL, and RC_ERROR.

Referenced by ConfigDbRead().

{
  Config_T        *pConfig;
  ConfigSection_T *pCurSect;
  char             bufGet[HASH_INPUT_BUF_SIZE];
  char             bufKey[HASH_INPUT_BUF_SIZE];
  char             bufSep[HASH_INPUT_BUF_SIZE];
  char             bufVal[HASH_INPUT_BUF_SIZE];
  char            *s, *t; 
  int              nLineNum;
  int              i;

  LOGDIAG4CALL(_TPTR(fp), _TSTR(sFileName));

  CHKPTR(fp, NULL);

  // New configuration
  if( (pConfig = ConfigDbNew(sFileName)) == NULL )
  {
    return NULL;
  }

  pCurSect = NULL;
  nLineNum = 0;

  while( fgets(bufGet, (int)sizeof(bufGet), fp) != NULL )
  {
    nLineNum++;

    // eat white-space
    for(i=0; isspace((int)bufGet[i]); ++i); 

    // comment or white space
    if( (bufGet[i] == 0) || (bufGet[i] == '#') || (bufGet[0] == '\n') ) 
    {
      continue; // empty or comment line
    }

    // 
    // Begin a section
    //
    if( bufGet[i] == '[' )
    {
      if( (t = strrchr(bufGet+i, ']' )) == NULL )
      {
        LOGERROR("Config %s: Line %d: malformed section statement: %d",
            pConfig->m_sMainName, nLineNum );
        continue; // recoverable error
      }
      s = &bufGet[i+1];
      *t = '\0';

      if( (pCurSect = ConfigSectionNew(pConfig, s)) == NULL )
      {
        LOGERROR("Config %s: [%s]: Line %d: failed adding section",
            pConfig->m_sMainName, s, nLineNum);
        ConfigDbDelete(pConfig);
        return NULL;  // non-recoverable error
      }
      continue;
    }

    //
    // Orphaned Key-Value Pair
    //
    if( pCurSect == NULL )
    {
      LOGERROR("Config %s: Line %d: not in a section",
          pConfig->m_sMainName, nLineNum );
      continue; // recoverable error
    }

    //
    // Key-Value Pair
    //
    bufKey[0] = bufSep[0] = bufVal[0] = 0;
    if( sscanf(bufGet+i, "%[^:= \t]%[:= \t]%[^\n#]", bufKey, bufSep, bufVal)
                                                                      != 3)
    {
      LOGERROR("Config %s: [%s]: Line %d: malformed input", 
          pConfig->m_sMainName, pCurSect->m_sSectionName, nLineNum );
      continue; // recoverable error
    }

    // strip any trailing white-space
    i = (int)strlen(bufVal) - 1;
    while( (i >= 0) && isspace((int)bufVal[i]) )
    {
      --i;
    }
    if( i < 0 )
    {
      LOGERROR("Config %s: [%s]: Line %d: malformed input", 
          pConfig->m_sMainName, pCurSect->m_sSectionName, nLineNum );
      continue; // recoverable error
    }
    else
    {
      bufVal[i+1] = 0;
    }

    if( ConfigSectionAddPair(pCurSect, bufKey, bufVal) == RC_ERROR )
    {
      LOGERROR("Config %s: [%s]: Line %d: failed to add key=value enttry", 
          pConfig->m_sMainName, pCurSect->m_sSectionName, nLineNum );
      ConfigDbDelete(pConfig);
      return NULL; // non-recoverable error
    }
  }

  LOGDIAG4(_TPTR(pConfig));

  return pConfig;
}

void ConfigDbSetName	(	Config_T *	pConfig,
		const char *	sMainName
	)

Assign a new name for the configuration database.

Parameters

pConfig	Configuration database.
sMainName	New database name.

Definition at line 498 of file config.c.

References CHKPTR, config_t::m_sMainName, and new_strdup().

{
  CHKPTR(pConfig);
  CHKPTR(sMainName);
  delete(pConfig->m_sMainName);
  pConfig->m_sMainName = new_strdup(sMainName);
}

int ConfigDelete	(	Config_T *	pConfig,
		const char *	sSectionName,
		const char *	sKey
	)

Delete entry from the configuration database.

Parameters

pConfig	Configuration database.
sSectionName	Configuration section name.
sKey	Section key.

Returns

Returns OK(0) on success, RC_ERROR(-1) on failure.

Definition at line 906 of file config.c.

References ConfigSectionGet(), hash_delete(), LOGDIAG4, config_section_t::m_hashSection, config_t::m_sMainName, NULL, OK, and RC_ERROR.

Referenced by CmdDelete(), and ConfigSetInt().

{
  ConfigSection_T *pSect;

  /* Can't add to an undefined section! */
  if( (pSect = ConfigSectionGet(pConfig, sSectionName)) == NULL )
  {
    LOGDIAG4("%s: [%s]: section not defined",
        pConfig->m_sMainName, sSectionName);
    return RC_ERROR;
  }
  else if( !hash_delete(pSect->m_hashSection, (char *)sKey) )
  {
    LOGDIAG4("%s: [%s]: %s could not delete",
        pConfig->m_sMainName, sSectionName, sKey);
    return RC_ERROR;
  }
  else
  {
    return OK;
  }
}

int ConfigGetDouble	(	Config_T *	pConfig,
		const char *	sSectionName,
		const char *	sKey,
		double *	pVal
	)

Get and convert a double value from the configuration database.

Parameters

pConfig	Configuration database.
sSectionName	Configuration section name.
sKey	Section key.
pVal	Converted value.

Returns

Returns OK(0) on success, RC_ERROR(-1) on failure.

Definition at line 759 of file config.c.

References ConfigGetStr(), LOGERROR, config_t::m_sMainName, NULL, OK, and RC_ERROR.

Referenced by CmdGetd().

{
  const char  *sVal;
  double       fVal;
  char        *sEnd;

  if( (sVal = ConfigGetStr(pConfig, sSectionName, sKey)) == NULL )
  {
    return RC_ERROR;
  }
  else if( (sVal == NULL) || (*sVal == 0) )
  {
    LOGERROR("Config %s: [%s]: value is null",
          pConfig->m_sMainName, sSectionName);
    return RC_ERROR;
  }
  else
  { 
    fVal = strtod(sVal, &sEnd);

    if( *sEnd != 0 )
    {
      LOGERROR("Config %s: [%s]: %s=%s: not a float",
          pConfig->m_sMainName, sSectionName, sKey, sVal);
      return RC_ERROR;
    }
    else
    {
      *pVal = fVal;
      return OK;
    }
  }
}

int ConfigGetLong	(	Config_T *	pConfig,
		const char *	sSectionName,
		const char *	sKey,
		long *	pVal
	)

Get and convert a long value from the configuration database.

Parameters

pConfig	Configuration database.
sSectionName	Configuration section name.
sKey	Section key.
pVal	Converted value.

Returns

Returns OK(0) on success, RC_ERROR(-1) on failure.

Definition at line 714 of file config.c.

References ConfigGetStr(), LOGERROR, config_t::m_sMainName, NULL, OK, and RC_ERROR.

Referenced by ConfigGetInt(), and ConfigGetULong().

{
  const char  *sVal;
  long         lVal;
  char        *sEnd;

  if( (sVal = ConfigGetStr(pConfig, sSectionName, sKey)) == NULL )
  {
    return RC_ERROR;
  }
  else if( (sVal == NULL) || (*sVal == 0) )
  {
    LOGERROR("Config %s: [%s]: value is null",
          pConfig->m_sMainName, sSectionName);
    return RC_ERROR;
  }
  else
  { 
    lVal = strtol(sVal, &sEnd, 0);

    if( *sEnd != 0 )
    {
      LOGERROR("Config %s: [%s]: %s=%s: not an integer",
          pConfig->m_sMainName, sSectionName, sKey, sVal);
      return RC_ERROR;
    }
    else
    {
      *pVal = lVal;
      return OK;
    }
  }
}

const char* ConfigGetStr	(	Config_T *	pConfig,
		const char *	sSectionName,
		const char *	sKey
	)

Get a string value from the configuration database.

Parameters

pConfig	Configuration database.
sSectionName	Configuration section name.
sKey	Section key.

Returns

Returns string value one success, NULL on failure.

Definition at line 682 of file config.c.

References ConfigSectionGet(), hash_lookup(), hnode_get, config_section_t::m_hashSection, and NULL.

Referenced by CmdFind(), CmdGets(), ConfigGetDouble(), ConfigGetLong(), and ConfigGetStrDft().

{
  ConfigSection_T *pSect;
  hnode_t         *pHashNode;

  if( (pSect = ConfigSectionGet(pConfig, sSectionName)) == NULL )
  {
    return NULL;
  }

  else if( (pHashNode = hash_lookup(pSect->m_hashSection, sKey)) == NULL )
  {
    return NULL;
  }
  
  else
  {
    return hnode_get(pHashNode);
  }
}

void ConfigIterDelete

(

ConfigIter_T *

pIter

)

Delete a configuration iterator.

Parameters

pIter

Configuration iterator.

Definition at line 985 of file config.c.

Referenced by CmdFind(), and ConfigSetInt().

{
  delete(pIter);
}

const char* ConfigIterNext

(

ConfigIter_T *

pIter

)

Get the next value in iteration.

After an iterator is created, the first call will return the first vale. Subsequent calls return the next values.

If iterator was created to iterate over the section names, then the values returned are section names. If the iterator was created to iterate over section keys, then the values returned are keys.

Parameters

pIter

Configuration iterator.

Returns

Returns next value on success, NULL at end of iteration.

Definition at line 1004 of file config.c.

References hash_scan_next(), hnode_getkey, config_iter_t::m_scanHash, and NULL.

Referenced by CmdFind(), and ConfigSetInt().

{
  hnode_t *pHashNode;

  if( pIter == NULL )
  {
    return NULL;
  }
  else if( (pHashNode = hash_scan_next(&pIter->m_scanHash)) == NULL )
  {
    return NULL;
  }
  else
  {
    return hnode_getkey(pHashNode);
  }
}

static void ConfigMainHashDeleteCb ( void *  pKey, void *  pData  )

static

Delete section hash callback.

When a section or configuration datatbase is deleted, the hash will make a callback to this function to delete the hash key and data (section).

Parameters

pKey	Section key to main hash.
pData	Key data to delete (ConfigSection_T *).

Definition at line 212 of file config.c.

References hash_table_destroy(), config_section_t::m_hashSection, and config_section_t::m_sSectionName.

Referenced by ConfigDbNew().

{
  ConfigSection_T *pSect;

  // main hash key points to section name, so don't delete here

  pSect = (ConfigSection_T *)pData;         // main hash data
  hash_table_destroy(pSect->m_hashSection); // section hash table
  delete(pSect->m_sSectionName);            // section name
  delete(pSect);                            // section
}

static int ConfigSectionAddPair ( ConfigSection_T *  pSect, const char *  sKey, const char *  sVal  )

static

Add or update a key-value pair in the given section.

Parameters

pSect	Configuration section to update.
sKey	Section key to add or update.
sVal	Key value to add

Returns

Returns OK(0) on success, RC_ERROR(-1) on failure.

Definition at line 151 of file config.c.

References hash_insert(), hash_lookup(), hnode_get, hnode_put, config_section_t::m_hashSection, new_strdup(), NULL, OK, and RC_ERROR.

Referenced by ConfigDbReadFp(), and ConfigSetStr().

{
  hnode_t *pHashNode;
  char    *sKeyDup;
  char    *sValDup;

  // Lookup key in section. If it exists, then replace with new value
  if( (pHashNode = hash_lookup(pSect->m_hashSection, sKey)) != NULL )
  {
    sValDup = new_strdup(sVal);

    // delete old value
    delete(hnode_get(pHashNode));

    // replacing with new value
    hnode_put(pHashNode, sValDup);
  }

  // New section key
  else
  {
    sKeyDup = new_strdup(sKey);
    sValDup = new_strdup(sVal);

    if( !hash_insert(pSect->m_hashSection, sKeyDup, sValDup) )
    {
      delete(sKeyDup);
      delete(sValDup);
      return RC_ERROR;
    }
  }

  return OK;
}

int ConfigSectionDelete	(	Config_T *	pConfig,
		ConfigSection_T *	pSect
	)

Delete a section from the configuration database.

Parameters

pConfig	Configuration database.
pSect	Configuration section to delete.

Returns

Returns OK(0) on success, RC_ERROR(-1) on failure.

Definition at line 600 of file config.c.

References _TPTR, hash_delete(), hash_lookup(), LOGDIAG4CALL, LOGERROR, config_t::m_hashMain, config_t::m_sMainName, config_section_t::m_sSectionName, NULL, OK, and RC_ERROR.

Referenced by CmdSectDelete().

{
  LOGDIAG4CALL(_TPTR(pConfig), _TPTR(pSect));

  if( pSect == NULL )
  {
    return OK;
  }

  // make sure section exist
  if( hash_lookup(pConfig->m_hashMain, pSect->m_sSectionName) == NULL )
  {
    LOGERROR("%s: [%s]: section not define",
        pConfig->m_sMainName, pSect->m_sSectionName);
    return RC_ERROR;
  }
    
  // delete all section entries
  else
  {
    hash_delete(pConfig->m_hashMain, pSect->m_sSectionName);
    return OK;
  }
}

ConfigSection_T* ConfigSectionGet	(	Config_T *	pConfig,
		const char *	sSectionName
	)

Get a section from the configuration database.

Parameters

pConfig	Configuration database.
sSectionName	Configuration section name.

Returns

Returns configuration section on success.
NULL on failure.

Definition at line 635 of file config.c.

References hash_lookup(), hnode_get, config_t::m_hashMain, and NULL.

Referenced by CmdSectDelete(), ConfigDelete(), ConfigGetStr(), ConfigSectionIterNew(), and ConfigSetStr().

{
  hnode_t *pHashNode;

  if( (pHashNode = hash_lookup(pConfig->m_hashMain, sSectionName)) != NULL )
  {
    return (ConfigSection_T *)hnode_get(pHashNode);
  }
  return NULL;
}

static void ConfigSectionHashDeleteCb ( void *  pKey, void *  pData  )

static

Delete section entry hash callback.

When a key-value entry or section is deleted, the hash will make a callback to this function to delete the hash key and data.

Parameters

pKey	Section key to delete.
pData	Key value to delete.

Definition at line 197 of file config.c.

Referenced by ConfigSectionNew().

{
  delete(pKey);   // section hash key (char *)
  delete(pData);  // section hash data (char *)
}

ConfigIter_T* ConfigSectionIterNew	(	Config_T *	pConfig,
		const char *	sSectionName
	)

Create a new configuration section iterator.

The iterator will iterator over section keys.

Parameters

pConfig	Configuration database.
sSectionName	Configuration section name.

Returns

New iterator.

Definition at line 963 of file config.c.

References ConfigSectionGet(), hash_scan_begin(), config_section_t::m_hashSection, config_iter_t::m_scanHash, NEW, and NULL.

Referenced by CmdFind(), and ConfigSetInt().

{
  ConfigSection_T *pSect;
  ConfigIter_T    *pIter;

  if( (pSect = ConfigSectionGet(pConfig, sSectionName)) == NULL )
  {
    return NULL;
  }
  else
  {
    pIter = NEW(ConfigIter_T);
    hash_scan_begin(&pIter->m_scanHash, pSect->m_hashSection);
    return pIter;
  }
}

ConfigSection_T* ConfigSectionNew	(	Config_T *	pConfig,
		const char *	sSectionName
	)

Add a new empty section to the configuration database.

The section cannot already exist.

Parameters

pConfig	Configuration database.
sSectionName	Configuration section name.

Returns

Returns configuration section on success.
NULL on failure.

Definition at line 547 of file config.c.

References _TPTR, _TSTR, CHKPTR, ConfigSectionHashDeleteCb(), hash_insert(), hash_lookup(), HASH_MAX_ENTRIES, HASH_MIN_ENTRIES, hash_table_create(), LOGDIAG4CALL, LOGERROR, config_t::m_hashMain, config_section_t::m_hashSection, config_t::m_sMainName, config_section_t::m_sSectionName, NEW, new_strdup(), and NULL.

Referenced by CmdSectNew(), and ConfigDbReadFp().

{
  ConfigSection_T *pSect;

  LOGDIAG4CALL(_TPTR(pConfig), _TSTR(sSectionName));

  CHKPTR(pConfig, NULL);
  CHKPTR(sSectionName, NULL);

  // make sure section does not already exist
  if( hash_lookup(pConfig->m_hashMain, sSectionName) != NULL )
  {
    LOGERROR("%s: [%s]: section multiply defined",
        pConfig->m_sMainName, sSectionName);
    return NULL;
  }
    
  // new section structure 
  pSect = NEW(ConfigSection_T);

  // new section hash table of key=value entries
  pSect->m_hashSection = hash_table_create(true,
                                       HASH_MIN_ENTRIES,
                                       HASH_MAX_ENTRIES,
                                       NULL,
                                       NULL,
                                       ConfigSectionHashDeleteCb);

  if( pSect->m_hashSection == NULL )
  {
    LOGERROR("%s: [%s]: failed to create new section hash table",
        pConfig->m_sMainName, sSectionName);
    delete(pSect);
    return NULL;
  }

  // section name
  pSect->m_sSectionName = new_strdup(sSectionName);

  // insert section into main hash table
  hash_insert(pConfig->m_hashMain, (char *)pSect->m_sSectionName, pSect);

  return pSect;
}

void ConfigSectionPrint	(	ConfigSection_T *	pSect,
		FILE *	fp
	)

Print one section to the output file stream.

The output format is valid for input.

Parameters

pSect	Configuration section.
fp	Output file pointer.

Definition at line 654 of file config.c.

References hash_scan_begin(), hash_scan_next(), hnode_get, hnode_getkey, config_section_t::m_hashSection, config_section_t::m_sSectionName, and NULL.

Referenced by ConfigDbPrint().

{
  hscan_t          scanHash;
  hnode_t         *pHashNode;

  fprintf(fp, "[%s]\n", pSect->m_sSectionName);
  hash_scan_begin(&scanHash, pSect->m_hashSection);
  while( (pHashNode = hash_scan_next(&scanHash)) != NULL )
  {
    fprintf(fp, "%s=%s\n",
        (char *)hnode_getkey(pHashNode), (char *)hnode_get(pHashNode));
  }
}

int ConfigSetDouble	(	Config_T *	pConfig,
		const char *	sSectionName,
		const char *	sKey,
		double	fVal
	)

Set or update a double value in the configuration database.

The double value is converted to a string prior to adding to the database.

Parameters

pConfig	Configuration database.
sSectionName	Configuration section name.
sKey	Section key.
fVal	Section key double value.

Returns

Returns OK(0) on success, RC_ERROR(-1) on failure.

Definition at line 883 of file config.c.

References ConfigSetStr().

Referenced by CmdSetd(), and ConfigGetStrDft().

{
  char buf[64];

  sprintf(buf, "%.16f", fVal);
  return ConfigSetStr(pConfig, sSectionName, sKey, buf);
}

int ConfigSetLong	(	Config_T *	pConfig,
		const char *	sSectionName,
		const char *	sKey,
		long	lVal
	)

Set or update a long value in the configuration database.

The long value is converted to a string prior to adding to the database.

Parameters

pConfig	Configuration database.
sSectionName	Configuration section name.
sKey	Section key.
lVal	Section key long value.

Returns

Returns OK(0) on success, RC_ERROR(-1) on failure.

Definition at line 841 of file config.c.

References ConfigSetStr().

Referenced by ConfigGetStrDft(), and ConfigSetInt().

{
  char buf[64];

  sprintf(buf, "%ld", lVal);
  return ConfigSetStr(pConfig, sSectionName, sKey, buf);
}

int ConfigSetStr	(	Config_T *	pConfig,
		const char *	sSectionName,
		const char *	sKey,
		const char *	sVal
	)

Set or update a string value in the configuration database.

Parameters

pConfig	Configuration database.
sSectionName	Configuration section name.
sKey	Section key.
sVal	Section key value.

Returns

Returns OK(0) on success, RC_ERROR(-1) on failure.

Definition at line 809 of file config.c.

References _TPTR, _TSTR, ConfigSectionAddPair(), ConfigSectionGet(), LOGDIAG4, LOGDIAG4CALL, config_t::m_sMainName, NULL, and RC_ERROR.

Referenced by CmdSets(), ConfigGetStrDft(), ConfigSetDouble(), ConfigSetLong(), and ConfigSetULong().

{
  ConfigSection_T *pSect;

  LOGDIAG4CALL(_TPTR(pConfig), _TSTR(sSectionName), _TSTR(sKey), _TSTR(sVal));

  /* Can't add to an undefined section! */
  if( (pSect = ConfigSectionGet(pConfig, sSectionName)) == NULL )
  {
    LOGDIAG4("%s: [%s]: section not defined",
        pConfig->m_sMainName, sSectionName);
    return RC_ERROR;
  }
  else
  {
    return ConfigSectionAddPair(pSect, sKey, sVal);
  }
}

int ConfigSetULong	(	Config_T *	pConfig,
		const char *	sSectionName,
		const char *	sKey,
		unsigned long	ulVal
	)

Set or update an unsigned long value in the configuration database.

The long value is converted to a string prior to adding to the database.

Parameters

pConfig	Configuration database.
sSectionName	Configuration section name.
sKey	Section key.
ulVal	Section key unsigned long value.

Returns

Returns OK(0) on success, RC_ERROR(-1) on failure.

Definition at line 862 of file config.c.

References ConfigSetStr().

Referenced by ConfigGetStrDft().

{
  char buf[64];

  sprintf(buf, "%lu", ulVal);
  return ConfigSetStr(pConfig, sSectionName, sKey, buf);
}

Variable Documentation

int ConfigMainCounter = 0

static

Internal counter to make configuration names unique.

Definition at line 140 of file config.c.

Referenced by ConfigDbNew().