---

conftable.c

Go to the documentation of this file.

/***************************************************************************
                                 conftable.c
                             -------------------
    begin                : Sun Nov 4 2001
    copyright            : (C) 2001-2002 by Christian Hoenig & Gunter Ohrner
    email                : pdepp@CustomCDROM.de
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#include "common.h"

#include <errno.h>
#include <limits.h>
// logger.h includes stdio.h for us. Even more importantly it includes stdarg.h
// BEFORE including stdio.h which avoids tons of warnings on Solaris... :-(
#include <sys/types.h>
#include <regex.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>

#include "logger.h"

#include "conftable.h"

#include "keypvalplist.h"
#include "misc.h"
#include "xmalloc.h"

KeypValpList list;

//inits the Conftable
int initConftable()
{
  list = kpvpListInit();
  return 0;
}

//terminates the Conftable and frees the allocatet memory
int terminateConftable()
{
  kpvpListFirst(list);
  while(!kpvpListIsTail(list))
  {
    //free content
    pd_free(kpvpListGetPayload(list).key);
    pd_free(kpvpListGetPayload(list).val);
    //free list
    kpvpListDelete(list);
  }
  kpvpListTerminate(list);
  return 0;
}

//Sets a value to a key.
//If the key doesn't exist, it will be created
int setEntry(const int priority, char *const pkey, char *const pvalue)
{
  char* value, * key;

  //first make a copy of the char*'s, we don't wonna work on the originals
  int buf_size =  strlen(pkey)+1;
   key = (char*)pd_malloc(buf_size);
   strncpy(key, pkey, buf_size);
  buf_size =  strlen(pvalue)+1;
   value = (char*)pd_malloc(buf_size);
   strncpy(value, pvalue, buf_size);

  kpvpListFirst(list);
  while(!kpvpListIsTail(list))
  {
    if (strcmp(kpvpListGetPayload(list).key, key) == 0)
      break;
    kpvpListNext(list);
  }

  if (kpvpListIsTail(list))
  {
    //add new element
    struct KeyValuePair kvp;
    kvp.key = key;
    kvp.val = value;

    kpvpListAppend(list, kvp);
  }
  else
  {
    //overwrite old one, if priority allows
    if (priority == PRIO_CMDLINE || priority == PRIO_PRGCALL)
    {
      struct KeyValuePair kvp;
      kvp.key = key;
      kvp.val = value;
      
      pd_free(kpvpListGetPayload(list).key);
      pd_free(kpvpListGetPayload(list).val);
      
      kpvpListSetPayload(list, kvp);
    }
    else
    {
      pd_free(key);
      pd_free(value);
    }
  }
  return 0;
}

int setEntryL(const int priority, char *const key, const long value)
{
  const int size = 128;
  char ch_value[size];
  
  if (snprintf(ch_value,size, "%ld",value) < 0)
    return - 1;
  else
    setEntry(priority, key, ch_value);
  return 0;
}


//Returns the value to a key.
//if key doesn't exist, 'null' is returned.
const char* getEntry(const char *const key)
{
  kpvpListFirst(list);
  while(!kpvpListIsTail(list))
  {
    if (strcmp(kpvpListGetPayload(list).key, key) == 0)
      break;
    kpvpListNext(list);
  }

  return kpvpListIsTail(list) ? NULL : kpvpListGetPayload(list).val;
}

//returns a value to a given key or \c defl_data of the key cannot be found
const char* getEntryDefl(const char *const key, const char *const defl_data)
{
  const char* data = getEntry(key);
  return (data != NULL) ? data : defl_data;
}

//returns the value of key as long.
//If key doesn't exist or a range error has occured, it returns 0 and sets ERRNO to ERANGE
long getEntryL(const char *const key)
{
  long val;
  const char* tmp = getEntry(key);
  errno = 0;
  if (tmp != NULL)
    val = strtol(tmp,NULL,10);
  else
  {
    errno = ERANGE;
    return 0;
  }
    

  return ((val == LONG_MIN || val == LONG_MAX) && errno == ERANGE) ? 0 : val;
}

//returns a value to a given key or \c defl_data of the key cannot be found
long int getEntryDeflL(const char *const key, long int defl_data)
{
  long int data = getEntryL(key);
  return (errno == ERANGE) ? defl_data : data;
  
  
}

//Returns the value of key as int.
//If key doesn't exist or a range error has occured, it returns 0 and sets ERRNO to ERANGE
int getEntryI(const char *const key)
{
  long val = getEntryL(key);

  if ((val == 0 && errno == ERANGE) || val < INT_MIN || val > INT_MAX)
  {
    errno = ERANGE;
    return  0;
  }
  else
    return (int) val;
}

//returns a value to a given key or \c defl_data of the key cannot be found
int getEntryDeflI(const char *const key, int defl_data)
{
  int data = getEntryI(key);
  return (errno == ERANGE) ? defl_data : data;
}

//returns a value to a given key or \c defl_data of the key cannot be found
unsigned int getEntryDeflUI(const char *const key, unsigned int defl_data)
{
  int data = getEntryI(key);
  return (data <= 0 || errno == ERANGE) ? defl_data : data;
}


//read the configfile
int readConfigFile()
{
  const char* cfg_file_name = getEntryDefl(CONFENTRY_KEY_CONFIGFILE,
                                           STD_CONFENTRY_VAL_CONFIGFILE);
  char* line;
  FILE* cfg_file;
  regex_t* cfg_regex = (regex_t*)pd_malloc(sizeof(regex_t));
  int regex_ret;

  cfg_file = fopen(cfg_file_name, "r");
  if (cfg_file == NULL)
  {
    logerr(CONF_TABLE, WARNING, errno, "could not open config file \"%s\"", cfg_file_name);
    pd_free(cfg_regex);
    return -1;
  }

  regex_ret = regcomp(cfg_regex,
                                "^[[:blank:]]*([[:alnum:]._-]+)[[:space:]]*="
                                "[[:blank:]]*([[:alnum:][:punct:]]+|\".+\")"
                                "[[:blank:]]*(#.*)?$",
  REG_ICASE | REG_EXTENDED);

#ifndef NDEBUG
//  #define LEN 1024
//  line = (char*)pd_malloc(LEN);
//  regerror(regex_ret, cfg_regex, line, LEN);
//
//  log(PDEPP_CORE, CRITICAL, line);
//
//  pd_free(line);
#endif

  //cycle thru the lines and parse each
  while ((line = getLine(cfg_file)))
  {
    regmatch_t sub_exps[3];
    if (regexec(cfg_regex, line, 3, sub_exps, 0) == 0)
    {
      char* key_start, * key_end, * val_start, * val_end;

      if (sub_exps[1].rm_so > -1 && sub_exps[2].rm_so > -1)
      {
        key_start = line + sub_exps[1].rm_so;
        key_end   = line + sub_exps[1].rm_eo;
        val_start = line + sub_exps[2].rm_so;
        val_end   = line + sub_exps[2].rm_eo;

        // if we find "..."
        if (*(val_start) == '\"' && *(val_end-1) == '\"')
        {
          val_start++;
          val_end--;
        }

        *key_end = '\0';
        *val_end = '\0';

#ifndef NDEBUG
//        // Tell me what you've found!
//        logger(CONF_TABLE, CRITICAL, "read key '%s' with value '%s'",
//                                  key_start, val_start);
#endif

        setEntry(PRIO_CFGFILE, key_start, val_start);
      }
    }
    pd_free(line);
    if (feof(cfg_file))
      break;
  }

  regfree(cfg_regex);
  pd_free(cfg_regex);
  fclose(cfg_file);
  return 0;
}

---