---

config.c

Go to the documentation of this file.

/*! \file config.c
          Configuration parser interface.
 */

#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <dlfcn.h>
#include "chtbl.h"

#define PRIVATE_CODE_ONLY
#include "config.h"
#undef PRIVATE_CODE_ONLY

/*! \brief Number of characters for the buffer used to store the last error message.
 */

#define CONFIG_H_ERROR_SIZE 2048

/*! \brief Buffer that contains the last error message.
 */

static char last_error[CONFIG_H_ERROR_SIZE];

/*! \brief Return the last error message.
    \author Denis BEURIVE
    \return The function returns a zero terminated, statically allocated, string of characters that represents the last
            error message.
 */

char* conf_get_last_error() { return last_error; }

/*! \brief This flag indicates wether the memory allocated for the hash table is freed or not.
 */

static int allochtab = 0;

/*! \brief Hash function used by the hash table module.
    \author Denis BEURIVE
    \remark See example for the hash table module.
 */

int config_hash_function (const void *key)
{
  struct user_data *data;
  int              index, i;

  data = (struct user_data*)key;
  index = 0;

  for (i=0; i<strlen(data->tag); i++) { index *= (int)(data->tag[i]); }

  if (index < 0) { index *= - 1; }

  return index;
}

/*! \brief Function used to free allocated memory in the hash table.
    \author Denis BEURIVE
    \remark See example for the hash table module.
 */

void config_free_user_data (void *d)
{
  struct user_data *data;

  data = (struct user_data*)d;
  free (data->tag);
  free (data->value);
  free (data);

  return;
}

/*! \brief Function used to compare 2 elements in the hash table.
    \author Denis BEURIVE
    \remark See example for the hash table module.
 */

int config_compare_user_data (const void *d1, const void *d2)
{
  struct user_data *data1, *data2;

  data1 = (struct user_data*)d1;
  data2 = (struct user_data*)d2;

  return !strcmp(data1->tag, data2->tag);
}

/*! \brief Handler to the hash table.
 */

CHTbl htab;

/*! \brief This array contains the modems' configuration.
           The first record is associated with the default configuration.
 */

struct modem_conf_struct modem_configuration_list[MODEM_CONF_MAX_ENTRY];

/*! \brief Number of configured modems. This integer represents the number of records in the array
           "modem_configuration_list".
 */

int nb_modem;

/*! \brief Return the number of records in the modems' configuration file.
    \author Denis BEURIVE
    \return The function returns the number of modems' configuration records.
 */

int get_number_of_modem_conf() { return nb_modem; } 

/*! \brief Dummy MAC address calculator.
    \author Denis BEURIVE
    \param addr Pointer to a zero terminated string of characters that represents the original MAC address.
    \return The function returns a pointer to a zero terminated, statically allocated, string of characters. This
            string contains a copy of the original MAC address.
    \remark Make sure that the buffer "mac" is big enough.
 */

char* dummy_mac_processor (char* addr)
{
  static char mac[128];

  memset((void*)mac, 0, 128);
  strncpy (mac, addr, 127);
  return mac;
}

/*! \brief Flex generated parser.
 */

extern int configlex();

/*! \brief Flex input file descriptor.
 */

extern FILE *configin;

/*! \brief Load a given configuration file.
    \author Denis BEURIVE
    \param path Path to the configuration file to load.
    \param err Pointer to an integer that will be used to store the value of 'errno' if an error occured.
    \return Upon successful completion, the function returns tha value PARSE_CONFIGURATION_OK.
            Otherwise the function may return one of the following values:
            <UL>
               <LI>PARSE_CONFIGURATION_NO_MEM: Could not allocate memory.
               <LI>PARSE_CONFIGURATION_FILE_NOT_FOUND: Could not open configuration file. "errno' is set. 
               <LI>PARSE_CONFIGURATION_SYNTAX_ERROR: Syntax error in configuration file.
               <LI>PARSE_CONFIGURATION_DUPLICATED_TAG: Configuration contains a duplicated tag.
               <LI>PARSE_CONFIGURATION_DLL_OPEN_ERROR: Could not load DLL.
               <LI>PARSE_CONFIGURATION_DLL_INVALID: DLL is not valid.
               <LI>PARSE_CONFIGURATION_MODEM_CONF_NOT_VALID: Modem's configuration record is not valid.
               <LI>PARSE_CONFIGURATION_OK: Success.
            </UL>
    \warning <UL>
               <LI>If the returned value is PARSE_CONFIGURATION_NO_MEM, the module does not free
                   allocated memory. You should abort the program.
               <LI>If the returned value is PARSE_CONFIGURATION_FILE_NOT_FOUND, PARSE_CONFIGURATION_SYNTAX_ERROR,
                   PARSE_CONFIGURATION_DUPLICATED_TAG, PARSE_CONFIGURATION_DLL_OPEN_ERROR,
                   PARSE_CONFIGURATION_DLL_INVALID, PARSE_CONFIGURATION_MODEM_CONF_NOT_VALID, 
                   the module free all allocated memory.
             </UL>
    \remark In case you think that the same DLL is loaded multiple times, consider this:
            Only a single copy of an shared library file is brought into the address space, even if dlopen is
            invoked multiple times in reference to the file, and even if different pathnames are used to reference
            the file. 
 */

int parse_configuration_file (char *path, int *err)
{
  int rc, i;

  *err   = 0;

  memset((void*)last_error, 0, CONFIG_H_ERROR_SIZE);

  memset ((void*)&modem_configuration_list, 0, sizeof(struct modem_conf_struct)*MODEM_CONF_MAX_ENTRY);

  modem_configuration_list[0].id = 0;
  strncpy (modem_configuration_list[0].identifier, "XXXXXX",   MODEM_CONF_IDENTIFIER_SIZE-1);
  strncpy (modem_configuration_list[0].tag_name,   "UNKNOWN",  MODEM_CONF_TAG_NAME_SIZE-1);
  strncpy (modem_configuration_list[0].autoconf,   "no",       MODEM_CONF_AUTOCONF_SIZE-1);
  strncpy (modem_configuration_list[0].action,     "dummy",    MODEM_CONF_ACTION_SIZE-1);
  modem_configuration_list[0].dll = NULL;
  modem_configuration_list[0].calculate_mac_address = dummy_mac_processor;

  nb_modem = 1;

  /* ------------------------------------------------ */
  /* Initialize the hash table                        */
  /* ------------------------------------------------ */

  if (
       chtbl_init (
                    &htab,
                    10,
                    config_hash_function,
                    config_compare_user_data,
                    config_free_user_data
                  ) == -1
     )
  { return PARSE_CONFIGURATION_NO_MEM; }

  allochtab = 1;
 
  /* ------------------------------------------------ */
  /* Parse configuration file                         */
  /* ------------------------------------------------ */

  configin = fopen (path, "r");
  if (configin == NULL) { *err = errno; return PARSE_CONFIGURATION_FILE_NOT_FOUND; }

  rc = configlex();
  switch (rc)
  {
    case CONF_PARSER_SYNTAX_ERROR:        free_all_configuration_data();
                                          fclose (configin);
                                          return PARSE_CONFIGURATION_SYNTAX_ERROR; 
    case CONF_PARSER_DUPLICATED_TAG: free_all_configuration_data();
                                          fclose (configin);
                                          return PARSE_CONFIGURATION_DUPLICATED_TAG;
    case CONF_PARSER_NO_MEM:              fclose (configin);
                                          return PARSE_CONFIGURATION_NO_MEM;
    case CONF_PARSER_IDENTIFIER_TOO_LONG: free_all_configuration_data();
                                          fclose (configin);
                                          return PARSE_CONFIGURATION_MODEM_CONF_NOT_VALID;
    case CONF_PARSER_TAG_NAME_TOO_LONG:   free_all_configuration_data();
                                          fclose (configin);
                                          return PARSE_CONFIGURATION_MODEM_CONF_NOT_VALID;
    case CONF_PARSER_AUTOCONF_TOO_LONG:   free_all_configuration_data();
                                          fclose (configin);
                                          return PARSE_CONFIGURATION_MODEM_CONF_NOT_VALID;
    case CONF_PARSER_ACTION_TOO_LONG:     free_all_configuration_data();
                                          fclose (configin);
                                          return PARSE_CONFIGURATION_MODEM_CONF_NOT_VALID;
    case CONF_PARSER_TOO_MANY_ENTRIES:    free_all_configuration_data();
                                          fclose (configin);
                                          return PARSE_CONFIGURATION_MODEM_CONF_NOT_VALID;
  }

  fclose (configin);

  /* ------------------------------------------------ */
  /* Load all plugins                                 */
  /* ------------------------------------------------ */

  for (i=1; i<get_number_of_modem_conf(); i++)
  {
    if (strcasecmp(modem_configuration_list[i].action, "dummy") == 0)
    { modem_configuration_list[i].calculate_mac_address = dummy_mac_processor; }
    else {
           modem_configuration_list[i].dll = dlopen (modem_configuration_list[i].action, RTLD_LAZY);
           if (modem_configuration_list[i].dll == NULL)
           {
             if (dlerror() != NULL) { strncpy (last_error, dlerror(), CONFIG_H_ERROR_SIZE-1); }
             free_all_configuration_data();
             return PARSE_CONFIGURATION_DLL_OPEN_ERROR;
           }

           modem_configuration_list[i].calculate_mac_address = dlsym (modem_configuration_list[i].dll, "calculate_mac");
           if (dlerror() != NULL) {
                                    strncpy (last_error, dlerror(), CONFIG_H_ERROR_SIZE-1);
                                    free_all_configuration_data();
                                    return PARSE_CONFIGURATION_DLL_INVALID;
                                  }
         }

  }

  return PARSE_CONFIGURATION_OK;
}

/*! \brief Returns the ID of a given MAC address.
    \author Denis BEURIVE
    \param mac Pointer to a zero terminated string of characters that represents the modem's MAC address.
    \return The function returns a integer that represents the modem's ID.
 */

int modem_conf_get_id (char *mac)
{
  int i;

  for (i=0; i<get_number_of_modem_conf(); i++)
  { if (strncmp(modem_configuration_list[i].identifier, mac, 6) == 0) { return i; } }

  return 0;
}

/*! \brief Returns the tag name of a given MAC address, representd by its ID.
    \author Denis BEURIVE
    \param id ID of the MAC address (as returned by the function modem_conf_get_id()).
    \return The function returns a pointer to a zero terminated string of characters that represents the tag name.
 */

char* modem_conf_get_tag_name (int id) { return modem_configuration_list[id].tag_name; }

/*! \brief Returns a value that indicates if a given modem supports auto-configuration.
    \author Denis BEURIVE
    \param id ID of the MAC address (as returned by the function modem_conf_get_id()).
    \return The function returns one of the following values:
            <UL>
                <li>1: The modem supports auto-configuration.
                <li>0: The modem does not support auto-configuration.
            </UL>
 */

int modem_conf_is_autoconf (int id)
{
  if (strcasecmp (modem_configuration_list[id].autoconf, "yes") == 0) { return 1; }
  return 0;
}

/*! \brief Returns the MAC processor for a given MAC address.
    \author Denis BEURIVE
    \param id ID of the MAC address (as returned by the function modem_conf_get_id()).
    \return The function returns a pointer to a function used to calculate the new MAC address.
 */

void* modem_conf_get_function (int id)
{
  return modem_configuration_list[id].calculate_mac_address;
}

/*! \brief Free all data allocated for the hash table.
    \author Denis BEURIVE
 */

void free_all_configuration_data() { if (allochtab == 1) { chtbl_destroy (&htab); allochtab = 0; } }

/*! \brief Return the value associated with a given tag.
    \author Denis BEURIVE
    \param tag Pointer to a zero terminated string of characters that represents the tag to look for.
    \param value Pointer that will point to the corresponding value (if the tag was found).
    \return <UL>
              <LI>If the tag could not be find, the function returns the value 0. 'value' is NULL.
              <LI>If the tag has been found, the function returns the value 1.
              <LI>If the function ran out of memory, the function returns the value -1. 'value' is NULL.
            </UL> 
 */

int get_value (char *tag, char **value)
{
  struct user_data *ud, sud;
  int              cr, retval;

  /* ------------------------------------------------ */
  /* Initialise values                                */
  /* ------------------------------------------------ */

  *value  = NULL;
  retval  = 0;
 
  /* ------------------------------------------------ */
  /* Prepare user data for lookup                     */
  /* ------------------------------------------------ */

  sud.tag   = tag;
  sud.value = NULL;

  ud = &sud;

  /* ------------------------------------------------ */
  /* Lookup hash table                                */
  /* ------------------------------------------------ */

  cr = chtbl_lookup (&htab, (void**)&ud);

  if (cr == 0) { retval = 1; *value = ud->value; }

  return retval;
}

---