Subversion Repositories openrisc_me

//==========================================================================

//

//      ./lib/current/src/read_config.c

//

//

//==========================================================================

//####ECOSGPLCOPYRIGHTBEGIN####

// -------------------------------------------

// This file is part of eCos, the Embedded Configurable Operating System.

// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc.

//

// eCos 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 or (at your option) any later version.

//

// eCos is distributed in the hope that it will be useful, but WITHOUT ANY

// WARRANTY; without even the implied warranty of MERCHANTABILITY or

// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

// for more details.

//

// You should have received a copy of the GNU General Public License along

// with eCos; if not, write to the Free Software Foundation, Inc.,

// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.

//

// As a special exception, if other files instantiate templates or use macros

// or inline functions from this file, or you compile this file and link it

// with other works to produce a work based on this file, this file does not

// by itself cause the resulting work to be covered by the GNU General Public

// License. However the source code for this file must still be made available

// in accordance with section (3) of the GNU General Public License.

//

// This exception does not invalidate any other reasons why a work based on

// this file might be covered by the GNU General Public License.

//

// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.

// at http://sources.redhat.com/ecos/ecos-license/

// -------------------------------------------

//####ECOSGPLCOPYRIGHTEND####

//####UCDSNMPCOPYRIGHTBEGIN####

//

// -------------------------------------------

//

// Portions of this software may have been derived from the UCD-SNMP

// project,  <http://ucd-snmp.ucdavis.edu/>  from the University of

// California at Davis, which was originally based on the Carnegie Mellon

// University SNMP implementation.  Portions of this software are therefore

// covered by the appropriate copyright disclaimers included herein.

//

// The release used was version 4.1.2 of May 2000.  "ucd-snmp-4.1.2"

// -------------------------------------------

//

//####UCDSNMPCOPYRIGHTEND####

//==========================================================================

//#####DESCRIPTIONBEGIN####

//

// Author(s):    hmt

// Contributors: hmt

// Date:         2000-05-30

// Purpose:      Port of UCD-SNMP distribution to eCos.

// Description:  

//              

//

//####DESCRIPTIONEND####

//

//==========================================================================

/********************************************************************

       Copyright 1989, 1991, 1992 by Carnegie Mellon University

                          Derivative Work -

Copyright 1996, 1998, 1999, 2000 The Regents of the University of California

                         All Rights Reserved

Permission to use, copy, modify and distribute this software and its

documentation for any purpose and without fee is hereby granted,

provided that the above copyright notice appears in all copies and

that both that copyright notice and this permission notice appear in

supporting documentation, and that the name of CMU and The Regents of

the University of California not be used in advertising or publicity

pertaining to distribution of the software without specific written

permission.

CMU AND THE REGENTS OF THE UNIVERSITY OF CALIFORNIA DISCLAIM ALL

WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED

WARRANTIES OF MERCHANTABILITY AND FITNESS.  IN NO EVENT SHALL CMU OR

THE REGENTS OF THE UNIVERSITY OF CALIFORNIA BE LIABLE FOR ANY SPECIAL,

INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING

FROM THE LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF

CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN

CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

*********************************************************************/

/*

 * read_config.c

 */

#include <pkgconf/snmplib.h>

#include <config.h>

#include <stdio.h>

#include <ctype.h>

#if HAVE_STDLIB_H

#include <stdlib.h>

#endif

#if HAVE_STRING_H

#include <string.h>

#else

#include <strings.h>

#endif

#if HAVE_UNISTD_H

#include <unistd.h>

#endif

#include <sys/types.h>

#if HAVE_SYS_PARAM_H

#include <sys/param.h>

#endif

#if TIME_WITH_SYS_TIME

# ifdef WIN32

#  include <sys/timeb.h>

# else

#  include <sys/time.h>

# endif

# include <time.h>

#else

# if HAVE_SYS_TIME_H

#  include <sys/time.h>

# else

#  include <time.h>

# endif

#endif

#ifdef HAVE_SYS_STAT_H

#include <sys/stat.h>

#endif

#if HAVE_NETINET_IN_H

#include <netinet/in.h>

#endif

#if HAVE_ARPA_INET_H

#include <arpa/inet.h>

#endif

#if HAVE_SYS_SELECT_H

#include <sys/select.h>

#endif

#if HAVE_WINSOCK_H

#include <winsock.h>

#endif

#if HAVE_SYS_SOCKET_H

#include <sys/socket.h>

#endif

#if HAVE_NETDB_H

#include <netdb.h>

#endif

#include <errno.h>

#if HAVE_DMALLOC_H

#include <dmalloc.h>

#endif

#include "asn1.h"

#include "mib.h"

#include "parse.h"

#include "system.h"

#include "snmp_api.h"

#include "snmp_debug.h"

#include "snmp_logging.h"

#include "snmp_impl.h"

#include "default_store.h"

#include "callback.h"

#include "read_config.h"

#include "tools.h"

int config_errors;

struct config_files *config_files = NULL;

struct config_line *

register_premib_handler(const char *type,

                        const char *token,

                        void (*parser) (const char *, char *),

                        void (*releaser) (void),

                        const char *help)

{

  struct config_line *ltmp;

  ltmp = register_config_handler(type, token, parser, releaser, help);

  if (ltmp != NULL)

    ltmp->config_time = PREMIB_CONFIG;

  return (ltmp);

}

struct config_line *

register_app_premib_handler(const char *token,

                        void (*parser) (const char *, char *),

                        void (*releaser) (void),

                        const char *help)

{

  return(register_premib_handler( NULL, token, parser, releaser, help ));

}

/*******************************************************************-o-******

 * register_config_handler

 *

 * Parameters:

 *      *type

 *      *token

 *      *parser

 *      *releaser

 *

 * Returns:

 *      Pointer to a new config line entry  -OR-  NULL on error.

 */

struct config_line *

register_config_handler(const char *type_param,

                        const char *token,

                        void (*parser) (const char *, char *),

                        void (*releaser) (void),

                        const char *help)

{

  struct config_files **ctmp = &config_files;

  struct config_line **ltmp;

  const char *type = type_param;

  if ( type == NULL )

    type = ds_get_string(DS_LIBRARY_ID, DS_LIB_APPTYPE);

  /*

   * Find type in current list  -OR-  create a new file type.

   */

  while (*ctmp != NULL && strcmp((*ctmp)->fileHeader, type)) {

    ctmp = &((*ctmp)->next);

  }

  if (*ctmp == NULL) {

    *ctmp = (struct config_files *)

      malloc(sizeof(struct config_files));

    if ( !*ctmp ) {

      return NULL;

    }

    (*ctmp)->next                = NULL;

    (*ctmp)->start               = NULL;

    (*ctmp)->fileHeader  = strdup(type);

  }

  /*

   * Find parser type in current list  -OR-  create a new

   * line parser entry.

   */

  ltmp = &((*ctmp)->start);

  while (*ltmp != NULL && strcmp((*ltmp)->config_token, token)) {

    ltmp = &((*ltmp)->next);

  }

  if (*ltmp == NULL) {

    *ltmp = (struct config_line *)

      malloc(sizeof(struct config_line));

    if ( !*ltmp ) {

      return NULL;

    }

    (*ltmp)->next                = NULL;

    (*ltmp)->config_time         = NORMAL_CONFIG;

    (*ltmp)->parse_line  = 0;

    (*ltmp)->free_func   = 0;

    (*ltmp)->config_token        = strdup(token);

    if (help != NULL)

      (*ltmp)->help = strdup(help);

  }

  /*

   * Add/Replace the parse/free functions for the given line type

   * in the given file type.

   */

  (*ltmp)->parse_line = parser;

  (*ltmp)->free_func  = releaser;

  return (*ltmp);

}  /* end register_config_handler() */

struct config_line *

register_app_config_handler(const char *token,

                        void (*parser) (const char *, char *),

                        void (*releaser) (void),

                        const char *help)

{

  return(register_config_handler( NULL, token, parser, releaser, help ));

}

void

unregister_config_handler(const char *type_param,

                          const char *token)

{

  struct config_files **ctmp = &config_files;

  struct config_line **ltmp, *ltmp2;

  const char *type = type_param;

  if ( type == NULL )

    type = ds_get_string(DS_LIBRARY_ID, DS_LIB_APPTYPE);

  /* find type in current list */

  while (*ctmp != NULL && strcmp((*ctmp)->fileHeader,type)) {

    ctmp = &((*ctmp)->next);

  }

  if (*ctmp == NULL) {

    /* Not found, return. */

    return;

  }

  ltmp = &((*ctmp)->start);

  if (*ltmp == NULL) {

    /* Not found, return. */

    return;

  }

  if (strcmp((*ltmp)->config_token,token) == 0) {

    /* found it at the top of the list */

    (*ctmp)->start = (*ltmp)->next;

    free((*ltmp)->config_token);

    SNMP_FREE((*ltmp)->help);

    free(*ltmp);

    return;

  }

  while ((*ltmp)->next != NULL && strcmp((*ltmp)->next->config_token,token)) {

    ltmp = &((*ltmp)->next);

  }

  if (*ltmp == NULL) {

    free((*ltmp)->config_token);

    SNMP_FREE((*ltmp)->help);

    ltmp2 = (*ltmp)->next->next;

    free((*ltmp)->next);

    (*ltmp)->next = ltmp2;

  }

}

void

unregister_app_config_handler(const char *token)

{

  unregister_config_handler( NULL, token );

}

#ifdef TESTING

void print_config_handlers (void)

{

  struct config_files *ctmp = config_files;

  struct config_line *ltmp;

  for(;ctmp != NULL; ctmp = ctmp->next) {

    DEBUGMSGTL(("read_config", "read_conf: %s\n", ctmp->fileHeader));

    for(ltmp = ctmp->start; ltmp != NULL; ltmp = ltmp->next)

      DEBUGMSGTL(("read_config", "                   %s\n", ltmp->config_token));

  }

}

#endif

int linecount;

const char *curfilename;

void read_config_with_type(const char *filename,

                           const char *type)

{

  struct config_files *ctmp = config_files;

  for(;ctmp != NULL && strcmp(ctmp->fileHeader,type); ctmp = ctmp->next);

  if (ctmp)

    read_config(filename, ctmp->start, EITHER_CONFIG);

  else

    DEBUGMSGTL(("read_config", "read_config: I have no registrations for type:%s,file:%s\n",

           type, filename));

}

/*******************************************************************-o-******

 * read_config

 *

 * Parameters:

 *      *filename

 *      *line_handler

 *       when

 *

 * Read <filename> and process each line in accordance with the list of

 * <line_handler> functions.

 *

 *

 * For each line in <filename>, search the list of <line_handler>'s

 * for an entry that matches the first token on the line.  This comparison is

 * case insensitive.

 *

 * For each match, check that <when> is the designated time for the

 * <line_handler> function to be executed before processing the line.

 */

void read_config(const char *filename,

                 struct config_line *line_handler,

                 int when)

{

#ifdef CYGPKG_SNMPLIB_FILESYSTEM_SUPPORT

  FILE *ifile;

  char line[STRINGMAX], token[STRINGMAX], tmpbuf[STRINGMAX];

  char *cptr;

  int i, done;

  struct config_line *lptr;

  linecount = 0;

  curfilename = filename;

  if ((ifile = fopen(filename, "r")) == NULL) {

#ifdef ENOENT

    if (errno == ENOENT) {

      DEBUGMSGTL(("read_config", "%s: %s\n", filename, strerror(errno)));

    } else

#endif /* ENOENT */

#ifdef EACCES

    if (errno == EACCES) {

      DEBUGMSGTL(("read_config", "%s: %s\n", filename, strerror(errno)));

    } else

#endif /* EACCES */

#if defined(ENOENT) || defined(EACCES)

    {

      snmp_log_perror(filename);

    }

#else /* defined(ENOENT) || defined(EACCES) */

    snmp_log_perror(filename);

#endif /* ENOENT */

    return;

  } else {

    DEBUGMSGTL(("read_config", "Reading configuration %s\n", filename));

  }

  while (fgets(line, sizeof(line), ifile) != NULL)

    {

      lptr = line_handler;

      linecount++;

      cptr = line;

      i = strlen(line)-1;

      if (line[i] == '\n')

        line[i] = 0;

      /* check blank line or # comment */

      if ((cptr = skip_white(cptr)))

        {

          cptr = copy_word(cptr,token);

          if (cptr == NULL) {

            sprintf(tmpbuf,"Blank line following %s token.", token);

            config_perror(tmpbuf);

          } else {

            for(lptr = line_handler, done=0;

                lptr != NULL && !done;

                lptr = lptr->next) {

              if (!strcasecmp(token,lptr->config_token)) {

                if (when == EITHER_CONFIG || lptr->config_time == when) {

                    DEBUGMSGTL(("read_config", "%s:%d Parsing: %s\n",

                                filename, linecount, line));

                    (*(lptr->parse_line))(token,cptr);

                }

                done = 1;

              }

            }

            if (!done && when != PREMIB_CONFIG &&

                !ds_get_boolean(DS_LIBRARY_ID, DS_LIB_NO_TOKEN_WARNINGS)) {

              sprintf(tmpbuf,"Unknown token: %s.", token);

              config_pwarn(tmpbuf);

            }

          }

        }

    }

  fclose(ifile);

#endif

  return;

}  /* end read_config() */

void

free_config (void)

{

  struct config_files *ctmp = config_files;

  struct config_line *ltmp;

  for(;ctmp != NULL; ctmp = ctmp->next)

    for(ltmp = ctmp->start; ltmp != NULL; ltmp = ltmp->next)

      if (ltmp->free_func)

        (*(ltmp->free_func))();

}

void

read_configs (void)

{

  char *optional_config = ds_get_string(DS_LIBRARY_ID, DS_LIB_OPTIONALCONFIG);

  char *type = ds_get_string(DS_LIBRARY_ID, DS_LIB_APPTYPE);

  DEBUGMSGTL(("read_config","reading normal configuration tokens\n"));

  if (!ds_get_boolean(DS_LIBRARY_ID, DS_LIB_DONT_READ_CONFIGS))

    read_config_files(NORMAL_CONFIG);

 /* do this even when the normal above wasn't done */

  if (optional_config && type)

    read_config_with_type(optional_config, type);

  snmp_call_callbacks(SNMP_CALLBACK_LIBRARY, SNMP_CALLBACK_POST_READ_CONFIG,

                      NULL);

}

void

read_premib_configs (void)

{

  DEBUGMSGTL(("read_config","reading premib configuration tokens\n"));

  if (!ds_get_boolean(DS_LIBRARY_ID, DS_LIB_DONT_READ_CONFIGS))

    read_config_files(PREMIB_CONFIG);

  snmp_call_callbacks(SNMP_CALLBACK_LIBRARY,

                      SNMP_CALLBACK_POST_PREMIB_READ_CONFIG,

                      NULL);

}

/*******************************************************************-o-******

 * read_config_files

 *

 * Parameters:

 *      when    == PREMIB_CONFIG, NORMAL_CONFIG  -or-  EITHER_CONFIG

 *

 *

 * Traverse the list of config file types, performing the following actions

 * for each --

 *

 * First, build a search path for config files.  If the contents of

 * environment variable SNMPCONFPATH are NULL, then use the following

 * path list (where the last entry exists only if HOME is non-null):

 *

 *      SNMPSHAREPATH:SNMPLIBPATH:${HOME}/.snmp

 *

 * Then, In each of these directories, read config files by the name of:

 *

 *      <dir>/<fileHeader>.conf         -AND-

 *      <dir>/<fileHeader>.local.conf

 *

 * where <fileHeader> is taken from the config file type structure.

 *

 *

 * PREMIB_CONFIG causes free_config() to be invoked prior to any other action.

 *

 *

 * EXITs if any 'config_errors' are logged while parsing config file lines.

 */

void

read_config_files (int when)

{

#ifdef CYGPKG_SNMPLIB_FILESYSTEM_SUPPORT

  int i, j;

  char configfile[300];

  char *envconfpath, *homepath;

  char *cptr1, *cptr2;

  char defaultPath[SPRINT_MAX_LEN];

  struct config_files *ctmp = config_files;

  struct config_line *ltmp;

  struct stat statbuf;

  if (when == PREMIB_CONFIG)

    free_config();

  /* read all config file types */

  for(;ctmp != NULL; ctmp = ctmp->next) {

    ltmp = ctmp->start;

    /* read the config files */

    if ((envconfpath = getenv("SNMPCONFPATH")) == NULL) {

      homepath=getenv("HOME");

      sprintf(defaultPath,"%s%c%s%c%s%s%s%s%c%s",

              SNMPCONFPATH, ENV_SEPARATOR_CHAR,

              SNMPSHAREPATH, ENV_SEPARATOR_CHAR, SNMPLIBPATH,

              ((homepath == NULL) ? "" : ENV_SEPARATOR),

              ((homepath == NULL) ? "" : homepath),

              ((homepath == NULL) ? "" : "/.snmp"),

              ENV_SEPARATOR_CHAR, PERSISTENT_DIRECTORY);

      envconfpath = defaultPath;

    }

    envconfpath = strdup(envconfpath);  /* prevent actually writing in env */

    DEBUGMSGTL(("read_config","config path used:%s\n", envconfpath));

    cptr1 = cptr2 = envconfpath;

    i = 1;

    while (i && *cptr2 != 0) {

      while(*cptr1 != 0 && *cptr1 != ENV_SEPARATOR_CHAR)

        cptr1++;

      if (*cptr1 == 0)

        i = 0;

      else

        *cptr1 = 0;

      /*

       * for proper persistent storage retrival, we need to read old backup

       * copies of the previous storage files.  If the application in

       * question has died without the proper call to snmp_clean_persistent,

       * then we read all the configuration files we can, starting with

       * the oldest first.

       */

#ifdef CYGPKG_SNMPLIB_PERSISTENT_FILESYSTEM

      if (strncmp(cptr2, PERSISTENT_DIRECTORY,

                  strlen(PERSISTENT_DIRECTORY)) == 0 ||

          (getenv("SNMP_PERSISTENT_FILE") != NULL &&

           strncmp(cptr2, getenv("SNMP_PERSISTENT_FILE"),

                   strlen(getenv("SNMP_PERSISTENT_FILE"))) == 0)) {

        /* limit this to the known storage directory only */

        for(j=0; j <= MAX_PERSISTENT_BACKUPS; j++) {

          sprintf(configfile,"%s/%s.%d.conf",cptr2, ctmp->fileHeader, j);

          if (stat(configfile, &statbuf) != 0) {

            /* file not there, continue */

            break;

          } else {

            /* backup exists, read it */

            DEBUGMSGTL(("read_config_files","old config file found: %s, parsing\n", configfile));

            read_config (configfile, ltmp, when);

          }

        }

      }

#endif

      sprintf(configfile,"%s/%s.conf",cptr2, ctmp->fileHeader);

      read_config (configfile, ltmp, when);

      sprintf(configfile,"%s/%s.local.conf",cptr2, ctmp->fileHeader);

      read_config (configfile, ltmp, when);

      cptr2 = ++cptr1;

    }

    free(envconfpath);

  }

#ifdef CYGPKG_SNMPLIB_PERSISTENT_FILESYSTEM

  if (config_errors) {

    snmp_log(LOG_ERR, "ucd-snmp: %d errors in config file\n", config_errors);

/*    exit(1); */

  }

#endif

#endif

}

void read_config_print_usage(const char *lead)

{

  struct config_files *ctmp = config_files;

  struct config_line *ltmp;

  if (lead == NULL)

    lead = "";

  for(ctmp = config_files; ctmp != NULL; ctmp = ctmp->next) {

    snmp_log(LOG_INFO, "%sIn %s.conf and %s.local.conf:\n", lead, ctmp->fileHeader,

            ctmp->fileHeader);

    for(ltmp = ctmp->start; ltmp != NULL; ltmp = ltmp->next) {

      if (ltmp->help != NULL)

        snmp_log(LOG_INFO, "%s%s%-15s %s\n", lead, lead, ltmp->config_token,

                 ltmp->help);

    }

  }

}

/*******************************************************************-o-******

 * read_config_store

 *

 * Parameters:

 *      *type

 *      *line

 *

 *

 * Append line to a file named either ENV(SNMP_PERSISTENT_FILE) or

 *   "<PERSISTENT_DIRECTORY>/<type>.conf".

 * Add a trailing newline to the stored file if necessary.

 *

 * Intended for use by applications to store permenant configuration

 * information generated by sets or persistent counters.

 *

 */

void

read_config_store(const char *type, const char *line)

{

#ifdef CYGPKG_SNMPLIB_PERSISTENT_FILESYSTEM

  char file[512], *filep;

  FILE *fout;

#ifdef PERSISTENT_MASK

  mode_t oldmask;

#endif

  /* store configuration directives in the following order of preference:

     1. ENV variable SNMP_PERSISTENT_FILE

     2. configured <PERSISTENT_DIRECTORY>/<type>.conf

  */

  if ((filep = getenv("SNMP_PERSISTENT_FILE")) == NULL) {