xdasd_conf.c

Go to the documentation of this file.

/*----------------------------------------------------------------------------
 * Copyright (c) 2006, Novell, Inc.
 * All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without 
 * modification, are permitted provided that the following conditions are 
 * met:
 * 
 *     * Redistributions of source code must retain the above copyright 
 *       notice, this list of conditions and the following disclaimer.
 *     * 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.
 *     * Neither the name of the Novell 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.
 *--------------------------------------------------------------------------*/

#include "xdas_base.h"
#include "xdasd_conf.h"
#include "xdasd_list.h"

#include <xdas_debug.h>

#include <stdio.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

#ifdef _WIN32
# define WIN32_LEAN_AND_MEAN
# include <windows.h>
# define strnenv(d,s,n) (ExpandEnvironmentStringsA((LPCSTR)(s),(LPSTR)(d),(n)-1),(d))
# define XDASD_DEF_SLMOD_PATH "%SystemRoot%\\xdm_syslog.dll"
#else
# define strnenv(d,s,n) ((strncpy((d),(s),(n)-1)[(n)-1] = 0),(d))
# define XDASD_DEF_SLMOD_PATH LIBDIR "/openxdas/libxdm_syslog.so"
#endif

typedef struct XDProp_tag
{
   XDLItem listitem; 
   char * value;     
   char name[1];     
} XDProp;

static char g_config[FILENAME_MAX] = "";

static XDList g_proplist = {0, 0, 0};

static XDProp * xdasd_conf_find(const char * name)
{
   XDProp * property = (XDProp *)g_proplist.head;

   /* property names are case sensitive, so use strcmp */
   while (property && strcmp(property->name, name) != 0)
      property = (XDProp *)property->listitem.next;

   return property;
}

static int xdasd_conf_setstr(const char * name, const char * value)
{
   XDProp * oldprop;
   XDProp * newprop = 0;

   /* property names must not be null or empty */
   xdas_assert(name && *name);

   if (value)
   {
      size_t nsz, vsz;

#ifdef _WIN32
      char xvbuf[4096];

      /* expand any env vars from value into xvbuf - point value to xvbuf */
      ExpandEnvironmentStringsA(value, xvbuf, sizeof(xvbuf)-1);
      value = xvbuf;
#endif

      /* allocate property entry for this new value */
      nsz = strlen(name) + 1;
      vsz = strlen(value) + 1;
      if ((newprop = (XDProp *)malloc(sizeof(*newprop) - 1 + nsz + vsz)) == 0)
         return -1;

      /* set internal pointers to trailing buffer space, copy values */
      memcpy(newprop->name, name, nsz);
      newprop->value = newprop->name + nsz;
      memcpy(newprop->value, value, vsz);
   }

   /* locate and possibly remove old property */
   if ((oldprop = xdasd_conf_find(name))!= 0)
   {
      xdasd_list_unlink(&g_proplist, (XDLItem *)oldprop);
      free(oldprop);
   }

   /* link in new property, if specified and old property was removed */
   if (newprop)
      xdasd_list_link_head(&g_proplist, (XDLItem *)newprop);

   return 0;
}

#ifdef _WIN32

static int xdas_get_w32reg_default(const char * name, char * buf, size_t bufsz)
{
   HKEY key;
   LONG lerr = ERROR_SUCCESS;

   /* read registry time server name for time_source field */
   if ((lerr = RegOpenKeyA(HKEY_LOCAL_MACHINE, 
         "SYSTEM\\CurrentControlSet\\Services\\xdasd\\Parameters", 
         &key)) == ERROR_SUCCESS) 
   {
      DWORD dwBufSz = (DWORD)bufsz;
      lerr = RegQueryValueExA(key, name, 0, 0, (LPBYTE)buf, &dwBufSz);
      RegCloseKey(key);
   }
   return lerr == ERROR_SUCCESS? 0: -1;
}
#endif

static int xdasd_conf_set_defaults(void)
{
   static struct { const char * name; const char * value; } hard_defaults[] =
   {
      {"xdasd.loggers", XDASD_DEF_SLMOD_PATH},

   };

   int err = 0;
   unsigned i;
   char vbuf[2048];

   for (i = 0; i < xdas_elemcount(hard_defaults); i++)
   {
#ifdef _WIN32
      if (xdas_get_w32reg_default(hard_defaults[i].name, vbuf, sizeof(vbuf)) < 0)
#endif
         (void)strnenv(vbuf, hard_defaults[i].value, sizeof(vbuf));

      if (xdasd_conf_setstr(hard_defaults[i].name, vbuf) < 0)
         err = -1;
   }
   return err; /* -1 if at least one default value failed to be set. */
}

/*--------------------------------------------------------------------------*/

char * xdasd_conf_getstr(const char * name, char * buffer, size_t * bufszp)
{
   XDProp * property;
   size_t bufsz;

   /* parameter sanity check */
   xdas_assert(name && bufszp && (*bufszp || !buffer));
   if (!name || !bufszp || (buffer && !*bufszp))
      return 0;

   bufsz = *bufszp;
   *bufszp = 0;

   if ((property = xdasd_conf_find(name)) != 0)
   {
      size_t valsz = strlen(property->value) + 1;
      *bufszp = valsz;
      if (valsz > bufsz)
         valsz = bufsz;
      memcpy(buffer, property->value, valsz);
      if (valsz)
         buffer[valsz - 1] = 0;
   }
   return buffer;
}

int xdasd_conf_getint(const char * name)
{
   XDProp * property = 0;
   int ivalue = 0;

   /* parameter sanity check */
   xdas_assert(name);
   if (name && (property = xdasd_conf_find(name)) != 0)
      ivalue = atoi(property->value);

   return property? ivalue: -1;
}

int xdasd_conf_init(const char * cfgpath)
{
   FILE * fp;

   /* remove existing property list (if any) */
   xdasd_conf_exit();

   /* set default values */
   xdasd_conf_set_defaults();

   /* reset property file name (if specified) */
   if (cfgpath && *cfgpath)
      strcpy(g_config, cfgpath);

   /* there'd better be a file name in the buffer by now */
   xdas_assert(g_config && *g_config);

   if ((fp = fopen(g_config, "r")) != 0)
   {
      char buf[4096]; /* line buffer */

      while (fgets(buf, sizeof(buf), fp) != 0)
      {
         char * ep;
         char * name = buf;
         char * value;

         /* remove trailing '\n' chars, and fold continued lines */
         for(;;)
         {
            buf[sizeof(buf) - 1] = 0;  /* terminate in case too long */
            ep = buf + strlen(buf);    /* find string limit */
            if (*--ep == '\n')         /* remove trailing '\n' char */
               *ep = 0;
            if (ep <= buf || *--ep != '\\')  /* break if not continued */
               break;
            fgets(ep, (int)(sizeof(buf) - (ep - buf)), fp);
         }

         /* trim leading line white space */
         while (isspace(*name))
            name++;

         /* skip empty and comment lines */
         if (!*name || *name == '#')
            continue;

         /* remove trailing line comments */
         if ((ep = strchr(name, '#')) != 0)
            *ep = 0;

         /* skip ill-formatted lines (missing '=' sign) */
         if ((value = strchr(name, '=')) == 0)
            continue;

         /* terminate name, trim leading value white space */
         *value++ = 0;
         while (isspace(*value))
            value++;

         /* trim trailing name white space */
         ep = name + strlen(name);
         while (ep > name && isspace(ep[-1]))
            *--ep = 0;

         /* skip empty name or value lines */
         if (!*name || !*value)
            continue;

         /* trim trailing value whitespace */
         ep = value + strlen(value);
         while (ep > value && isspace(ep[-1]))
            *--ep = 0;

         /* add name,value pair to property list */
         xdasd_conf_setstr(name, value);
      }
      fclose(fp);
   }
   return fp? -1: 0;
}

void xdasd_conf_exit(void)
{
   XDLItem * ip = g_proplist.head;
   while (ip)
   {
      XDLItem * del = ip;
      ip = ip->next;
      free(del);
   }
}