开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > SNMP编程 > 查看源码
read_config.c
资源名称：snmp.src.rar　[点击查看]
上传用户：cxs890
上传日期：2021-05-22
资源大小：347k
文件大小：28k
源码类别：

SNMP编程

开发平台：

C/C++

read_config.c：源码内容
  1. /*
  2.  * read_config.c
  3.  */
  5. #include <config.h>
  7. #include <stdio.h>
  8. #include <ctype.h>
  9. #if HAVE_STDLIB_H
  10. #include <stdlib.h>
  11. #endif
  12. #if HAVE_STRING_H
  13. #include <string.h>
  14. #else
  15. #include <strings.h>
  16. #endif
  17. #if HAVE_UNISTD_H
  18. #include <unistd.h>
  19. #endif
  20. #include <sys/types.h>
  21. #if HAVE_SYS_PARAM_H
  22. #include <sys/param.h>
  23. #endif
  24. #if TIME_WITH_SYS_TIME
  25. # ifdef WIN32
  26. #  include <sys/timeb.h>
  27. # else
  28. #  include <time.h>
  29. # endif
  30. # include <time.h>
  31. #else
  32. # if HAVE_SYS_TIME_H
  33. #  include <sys/time.h>
  34. # else
  35. #  include <time.h>
  36. # endif
  37. #endif
  38. #ifdef HAVE_SYS_STAT_H
  39. #endif
  40. #if HAVE_NETINET_IN_H
  41. #include <netinet/in.h>
  42. #endif
  43. #if HAVE_ARPA_INET_H
  44. #include <arpa/inet.h>
  45. #endif
  46. #if HAVE_SYS_SELECT_H
  47. #include <sys/select.h>
  48. #endif
  49. #if HAVE_WINSOCK_H
  50. #include <ip/socket.h>
  51. #endif
  52. #if HAVE_SYS_SOCKET_H
  53. #include <sys/socket.h>
  54. #endif
  55. #if HAVE_NETDB_H
  56. #include <netdb.h>
  57. #endif
  58. #include <errno.h>
  60. #if HAVE_DMALLOC_H
  61. #include <dmalloc.h>
  62. #endif
  64. #include "asn1.h"
  65. #include "mib.h"
  66. #include "parse.h"
  67. #include "system.h"
  68. #include "snmp_api.h"
  69. #include "snmp_debug.h"
  70. #include "snmp_logging.h"
  71. #include "snmp_impl.h"
  72. #include "default_store.h"
  73. #include "callback.h"
  75. #include "read_config.h"
  76. #include "tools.h"
  77. #include <libsys/misc.h>
  79. int config_errors;
  81. struct config_files *config_files = NULL;
  82. extern char *strdup (const char *);
  83. extern char *staticstrdup(const char *);
  84. extern void vacm_parse_view (const char *, char *);
  86. struct config_line *
  87. register_premib_handler(const char *type,
  88. const char *token,
  89. void (*parser) (const char *, char *),
  90. void (*releaser) (void),
  91. const char *help)
  92. {
  93.   struct config_line *ltmp;
  94.   ltmp = register_config_handler(type, token, parser, releaser, help);
  95.   if (ltmp != NULL)
  96.     ltmp->config_time = PREMIB_CONFIG;
  97.   return (ltmp);
  98. }
  100. struct config_line *
  101. register_app_premib_handler(const char *token,
  102. void (*parser) (const char *, char *),
  103. void (*releaser) (void),
  104. const char *help)
  105. {
  106.   return(register_premib_handler( NULL, token, parser, releaser, help ));
  107. }
  109. /*******************************************************************-o-******
  110.  * register_config_handler
  111.  *
  112.  * Parameters:
  113.  * *type
  114.  * *token
  115.  * *parser
  116.  * *releaser
  117.  *      
  118.  * Returns:
  119.  * Pointer to a new config line entry  -OR-  NULL on error.
  120.  */
  121. struct config_line *
  122. register_config_handler(const char *type_param,
  123. const char *token,
  124. void (*parser) (const char *, char *),
  125. void (*releaser) (void),
  126. const char *help)
  127. {
  128.   struct config_files **ctmp = &config_files;
  129.   struct config_line **ltmp;
  130.   const char *type = type_param;
  132.   if ( type == NULL )
  133.     type = ds_get_string(DS_LIBRARY_ID, DS_LIB_APPTYPE);
  135.   /* 
  136.    * Find type in current list  -OR-  create a new file type.
  137.    */
  138.   while (*ctmp != NULL && strcmp((*ctmp)->fileHeader, type)) {
  139.     ctmp = &((*ctmp)->next);
  140.   }
  142.   if (*ctmp == NULL) {
  143.     *ctmp = (struct config_files *)
  144.       malloc(sizeof(struct config_files));
  145.     if ( !*ctmp ) {
  146.       return NULL;
  147.     }
  149.     (*ctmp)->next  = NULL;
  150.     (*ctmp)->start  = NULL;
  151.     (*ctmp)->fileHeader  = strdup(type);
  152.   }
  154.   /* 
  155.    * Find parser type in current list  -OR-  create a new
  156.    * line parser entry.
  157.    */
  158.   ltmp = &((*ctmp)->start);
  160.   while (*ltmp != NULL && strcmp((*ltmp)->config_token, token)) {
  161.     ltmp = &((*ltmp)->next);
  162.   }
  164.   if (*ltmp == NULL) {
  165.     *ltmp = (struct config_line *)
  166.       malloc(sizeof(struct config_line));
  167.     if ( !*ltmp ) {
  168.       return NULL;
  169.     }
  171.     (*ltmp)->next  = NULL;
  172.     (*ltmp)->config_time  = NORMAL_CONFIG;
  173.     (*ltmp)->parse_line  = 0;
  174.     (*ltmp)->free_func  = 0;
  175.     (*ltmp)->config_token  = staticstrdup(token);
  176.     if (help != NULL)
  177.       (*ltmp)->help = staticstrdup(help);
  179.   }
  181.   /* 
  182.    * Add/Replace the parse/free functions for the given line type
  183.    * in the given file type.
  184.    */
  185.   (*ltmp)->parse_line = parser;
  186.   (*ltmp)->free_func  = releaser;
  188.   return (*ltmp);
  190. }  /* end register_config_handler() */
  192. struct config_line *
  193. register_app_config_handler(const char *token,
  194. void (*parser) (const char *, char *),
  195. void (*releaser) (void),
  196. const char *help)
  197. {
  198.   return(register_config_handler( NULL, token, parser, releaser, help ));
  199. }
  200. #if 0
  201. void
  202. unregister_config_handler(const char *type_param, 
  203.   const char *token)
  204. {
  205.   struct config_files **ctmp = &config_files;
  206.   struct config_line **ltmp, *ltmp2;
  207.   const char *type = type_param;
  209.   if ( type == NULL )
  210.     type = ds_get_string(DS_LIBRARY_ID, DS_LIB_APPTYPE);
  212.   /* find type in current list */
  213.   while (*ctmp != NULL && strcmp((*ctmp)->fileHeader,type)) {
  214.     ctmp = &((*ctmp)->next);
  215.   }
  217.   if (*ctmp == NULL) {
  218.     /* Not found, return. */
  219.     return;
  220.   }
  221.   
  222.   ltmp = &((*ctmp)->start);
  223.   if (*ltmp == NULL) {
  224.     /* Not found, return. */
  225.     return;
  226.   }
  227.   if (strcmp((*ltmp)->config_token,token) == 0) {
  228.     /* found it at the top of the list */
  229.     (*ctmp)->start = (*ltmp)->next;
  230.     free((*ltmp)->config_token);
  231.     SNMP_FREE((*ltmp)->help);
  232.     free(*ltmp);
  233.     return;
  234.   }
  235.   while ((*ltmp)->next != NULL && strcmp((*ltmp)->next->config_token,token)) {
  236.     ltmp = &((*ltmp)->next);
  237.   }
  238.   if (*ltmp == NULL) {
  239.     free((*ltmp)->config_token);
  240.     SNMP_FREE((*ltmp)->help);
  241.     ltmp2 = (*ltmp)->next->next;
  242.     free((*ltmp)->next);
  243.     (*ltmp)->next = ltmp2;
  244.   }
  245. }
  247. void
  248. unregister_app_config_handler(const char *token)
  249. {
  250.   unregister_config_handler( NULL, token );
  251. }
  252. #endif
  253. #ifdef TESTING
  254. void print_config_handlers (void)
  255. {
  256.   struct config_files *ctmp = config_files;
  257.   struct config_line *ltmp;
  259.   for(;ctmp != NULL; ctmp = ctmp->next) {
  260.     DEBUGMSGTL(("read_config", "read_conf: %sn", ctmp->fileHeader));
  261.     for(ltmp = ctmp->start; ltmp != NULL; ltmp = ltmp->next)
  262.       DEBUGMSGTL(("read_config", "                   %sn", ltmp->config_token));
  263.   }
  264. }
  265. #endif
  267. int linecount;
  268. const char *curfilename;
  270. void read_config_with_type(const char *filename, 
  271.    const char *type)
  272. {
  273.   struct config_files *ctmp = config_files;
  274.   for(;ctmp != NULL && strcmp(ctmp->fileHeader,type); ctmp = ctmp->next);
  275.   if (ctmp)
  276.     read_config(filename, ctmp->start, EITHER_CONFIG);
  277.   else
  278.     DEBUGMSGTL(("read_config", "read_config: I have no registrations for type:%s,file:%sn",
  279.            type, filename));
  280. }
  282. /*******************************************************************-o-******
  283.  * read_config
  284.  *
  285.  * Parameters:
  286.  * *filename
  287.  * *line_handler
  288.  *  when
  289.  *
  290.  * Read <filename> and process each line in accordance with the list of
  291.  * <line_handler> functions.
  292.  *
  293.  *
  294.  * For each line in <filename>, search the list of <line_handler>'s 
  295.  * for an entry that matches the first token on the line.  This comparison is
  296.  * case insensitive.
  297.  *
  298.  * For each match, check that <when> is the designated time for the
  299.  * <line_handler> function to be executed before processing the line.
  300.  */
  301. void read_config(const char *filename,
  302.  struct config_line *line_handler,
  303.  int when)
  304. {
  305. #ifdef UCD_SNMP
  306.   FILE *ifile;
  307.   char line[STRINGMAX], token[STRINGMAX], tmpbuf[STRINGMAX];
  308.   char *cptr;
  309.   int i, done;
  310.   struct config_line *lptr;
  312.   linecount = 0;
  313.   curfilename = filename;
  314.   
  315.   if ((ifile = fopen(filename, "r")) == NULL) {
  316. #ifdef ENOENT
  317.     if (errno == ENOENT) {
  318.       DEBUGMSGTL(("read_config", "%s: %sn", filename, strerror(errno)));
  319.     } else
  320. #endif /* ENOENT */
  321. #ifdef EACCES
  322.     if (errno == EACCES) {
  323.       DEBUGMSGTL(("read_config", "%s: %sn", filename, strerror(errno)));
  324.     } else
  325. #endif /* EACCES */
  326. #if defined(ENOENT) || defined(EACCES)
  327.     {
  328.       snmp_log_perror(filename);
  329.     }
  330. #else /* defined(ENOENT) || defined(EACCES) */
  331.     snmp_log_perror(filename);
  332. #endif /* ENOENT */
  333.     return;
  334.   } else {
  335.     DEBUGMSGTL(("read_config", "Reading configuration %sn", filename));
  336.   }
  338.   while (fgets(line, sizeof(line), ifile) != NULL) 
  339.     {
  340.       lptr = line_handler;
  341.       linecount++;
  342.       cptr = line;
  343.       i = strlen(line)-1;
  344.       if (line[i] == 'n')
  345.         line[i] = 0;
  346.       /* check blank line or # comment */
  347.       if ((cptr = skip_white(cptr)))
  348. {
  349.           cptr = copy_word(cptr,token);
  350.           if (cptr == NULL) {
  351.             sprintf(tmpbuf,"Blank line following %s token.", token);
  352.             config_perror(tmpbuf);
  353.           } else {
  354.             for(lptr = line_handler, done=0;
  355.                 lptr != NULL && !done;
  356.                 lptr = lptr->next) {
  357.               if (!strcasecmp(token,lptr->config_token)) {
  358.                 if (when == EITHER_CONFIG || lptr->config_time == when) {
  359.                     DEBUGMSGTL(("read_config", "%s:%d Parsing: %sn",
  360.                                 filename, linecount, line));
  361.                     (*(lptr->parse_line))(token,cptr);
  362.                 }
  363.                 done = 1;
  364.               }
  365.             }
  366.             if (!done && when != PREMIB_CONFIG &&
  367.                 !ds_get_boolean(DS_LIBRARY_ID, DS_LIB_NO_TOKEN_WARNINGS)) {
  368.               sprintf(tmpbuf,"Unknown token: %s.", token);
  369.               config_pwarn(tmpbuf);
  370.             }
  371.           }
  372. }
  373.     }
  374.   fclose(ifile);
  375.   return;
  376. #endif
  377. }  /* end read_config() */
  381. void
  382. free_config (void)
  383. {
  384.   struct config_files *ctmp = config_files;
  385.   struct config_line *ltmp;
  387.   for(;ctmp != NULL; ctmp = ctmp->next)
  388.     for(ltmp = ctmp->start; ltmp != NULL; ltmp = ltmp->next)
  389.       if (ltmp->free_func)
  390.         (*(ltmp->free_func))();
  391. }
  393. static char snmpv3_default_view_str[] = SNMPV3_DEFAULT_VIEW" included .1.3.6.1";
  394. void
  395. read_configs (void)
  396. {
  398.   char *optional_config = ds_get_string(DS_LIBRARY_ID, DS_LIB_OPTIONALCONFIG);
  399.   char *type = ds_get_string(DS_LIBRARY_ID, DS_LIB_APPTYPE);
  401.   DEBUGMSGTL(("read_config","reading normal configuration tokensn"));
  402.   
  403.   if (!ds_get_boolean(DS_LIBRARY_ID, DS_LIB_DONT_READ_CONFIGS))
  404.     read_config_files(NORMAL_CONFIG);
  406.  /* do this even when the normal above wasn't done */
  407.   if (optional_config && type)
  408.     read_config_with_type(optional_config, type);
  410.   snmp_call_callbacks(SNMP_CALLBACK_LIBRARY, SNMP_CALLBACK_POST_READ_CONFIG,
  411.                       NULL);
  412.   vacm_parse_view("view",snmpv3_default_view_str/*SNMPV3_DEFAULT_VIEW" included .1.3.6.1"*/);
  413. }
  415. void
  416. read_premib_configs (void)
  417. {
  418.   DEBUGMSGTL(("read_config","reading premib configuration tokensn"));
  420.   if (!ds_get_boolean(DS_LIBRARY_ID, DS_LIB_DONT_READ_CONFIGS))
  421.     read_config_files(PREMIB_CONFIG);
  423.   snmp_call_callbacks(SNMP_CALLBACK_LIBRARY,
  424.                       SNMP_CALLBACK_POST_PREMIB_READ_CONFIG,
  425.                       NULL);
  426. }
  431. /*******************************************************************-o-******
  432.  * read_config_files
  433.  *
  434.  * Parameters:
  435.  * when == PREMIB_CONFIG, NORMAL_CONFIG  -or-  EITHER_CONFIG
  436.  *
  437.  *
  438.  * Traverse the list of config file types, performing the following actions
  439.  * for each --
  440.  *
  441.  * First, build a search path for config files.  If the contents of 
  442.  * environment variable SNMPCONFPATH are NULL, then use the following
  443.  * path list (where the last entry exists only if HOME is non-null):
  444.  *
  445.  * SNMPSHAREPATH:SNMPLIBPATH:${HOME}/.snmp
  446.  *
  447.  * Then, In each of these directories, read config files by the name of:
  448.  *
  449.  * <dir>/<fileHeader>.conf -AND-
  450.  * <dir>/<fileHeader>.local.conf
  451.  *
  452.  * where <fileHeader> is taken from the config file type structure.
  453.  *
  454.  *
  455.  * PREMIB_CONFIG causes free_config() to be invoked prior to any other action.
  456.  *
  457.  *
  458.  * EXITs if any 'config_errors' are logged while parsing config file lines.
  459.  */
  460. void
  461. read_config_files (int when)
  462. {
  463. #ifdef UCD_SNMP
  464.   int i, j;
  465.   char configfile[300];
  466.   char *envconfpath, *homepath;
  467.   char *cptr1, *cptr2;
  468.   char defaultPath[SPRINT_MAX_LEN];
  470.   struct config_files *ctmp = config_files;
  471.   struct config_line *ltmp;
  472.   struct stat statbuf;
  473.   
  474.   if (when == PREMIB_CONFIG)
  475.     free_config();
  477.   /* read all config file types */
  478.   for(;ctmp != NULL; ctmp = ctmp->next) {
  480.     ltmp = ctmp->start;
  482.     /* read the config files */
  483.     if ((envconfpath = getenv("SNMPCONFPATH")) == NULL) {
  484.       homepath=getenv("HOME");
  485.       sprintf(defaultPath,"%s%c%s%c%s%s%s%s%c%s",
  486.       SNMPCONFPATH, ENV_SEPARATOR_CHAR,
  487.               SNMPSHAREPATH, ENV_SEPARATOR_CHAR, SNMPLIBPATH,
  488.               ((homepath == NULL) ? "" : ENV_SEPARATOR),
  489.               ((homepath == NULL) ? "" : homepath),
  490.               ((homepath == NULL) ? "" : "/.snmp"),
  491.               ENV_SEPARATOR_CHAR, PERSISTENT_DIRECTORY);
  492.       envconfpath = defaultPath;
  493.     }
  494.     envconfpath = strdup(envconfpath);  /* prevent actually writing in env */
  495.     DEBUGMSGTL(("read_config","config path used:%sn", envconfpath));
  496.     cptr1 = cptr2 = envconfpath;
  497.     i = 1;
  498.     while (i && *cptr2 != 0) {
  499.       while(*cptr1 != 0 && *cptr1 != ENV_SEPARATOR_CHAR)
  500.         cptr1++;
  501.       if (*cptr1 == 0)
  502.         i = 0;
  503.       else
  504.         *cptr1 = 0;
  505.       /*
  506.        * for proper persistent storage retrival, we need to read old backup
  507.        * copies of the previous storage files.  If the application in
  508.        * question has died without the proper call to snmp_clean_persistent,
  509.        * then we read all the configuration files we can, starting with
  510.        * the oldest first.
  511.        */
  512.       if (strncmp(cptr2, PERSISTENT_DIRECTORY,
  513.                   strlen(PERSISTENT_DIRECTORY)) == 0 ||
  514.           (getenv("SNMP_PERSISTENT_FILE") != NULL &&
  515.            strncmp(cptr2, getenv("SNMP_PERSISTENT_FILE"),
  516.                    strlen(getenv("SNMP_PERSISTENT_FILE"))) == 0)) {
  517.         /* limit this to the known storage directory only */
  518.         for(j=0; j <= MAX_PERSISTENT_BACKUPS; j++) {
  519.           sprintf(configfile,"%s/%s.%d.conf",cptr2, ctmp->fileHeader, j);
  520.           if (stat(configfile, &statbuf) != 0) {
  521.             /* file not there, continue */
  522.             break;
  523.           } else {
  524.             /* backup exists, read it */
  525.             DEBUGMSGTL(("read_config_files","old config file found: %s, parsingn", configfile));
  526.             read_config (configfile, ltmp, when);
  527.           }
  528.         }
  529.       }
  530.       sprintf(configfile,"%s/%s.conf",cptr2, ctmp->fileHeader);
  531.       read_config (configfile, ltmp, when);
  532.       sprintf(configfile,"%s/%s.local.conf",cptr2, ctmp->fileHeader);
  533.       read_config (configfile, ltmp, when);
  534.       cptr2 = ++cptr1;
  535.     }
  536.     free(envconfpath);
  537.   }
  538.   
  539.   if (config_errors) {
  540.     snmp_log(LOG_ERR, "ucd-snmp: %d errors in config filen", config_errors);
  541. /*    exit(1); */
  542.   }
  543. #endif
  544. }
  546. void read_config_print_usage(const char *lead)
  547. {
  548.   struct config_files *ctmp = config_files;
  549.   struct config_line *ltmp;
  551.   if (lead == NULL)
  552.     lead = "";
  554.   for(ctmp = config_files; ctmp != NULL; ctmp = ctmp->next) {
  555.     snmp_log(LOG_INFO, "%sIn %s.conf and %s.local.conf:n", lead, ctmp->fileHeader,
  556.             ctmp->fileHeader);
  557.     for(ltmp = ctmp->start; ltmp != NULL; ltmp = ltmp->next) {
  558.       if (ltmp->help != NULL)
  559.         snmp_log(LOG_INFO, "%s%s%-15s %sn", lead, lead, ltmp->config_token,
  560.                  ltmp->help);
  561.     }
  562.   }
  563. }
  565. /*******************************************************************-o-******
  566.  * read_config_store
  567.  *
  568.  * Parameters:
  569.  * *type
  570.  * *line
  571.  *      
  572.  * 
  573.  * Append line to a file named either ENV(SNMP_PERSISTENT_FILE) or
  574.  *   "<PERSISTENT_DIRECTORY>/<type>.conf".
  575.  * Add a trailing newline to the stored file if necessary.
  576.  *
  577.  * Intended for use by applications to store permenant configuration 
  578.  * information generated by sets or persistent counters.
  579.  *
  580.  */
  581. void
  582. read_config_store(const char *type, const char *line)
  583. {
  584. #ifdef UCD_SNMP
  585. #ifdef PERSISTENT_DIRECTORY
  586.   char file[512], *filep;
  587.   FILE *fout;
  588. #ifdef PERSISTENT_MASK
  589.   mode_t oldmask;
  590. #endif
  592.   /* store configuration directives in the following order of preference:
  593.      1. ENV variable SNMP_PERSISTENT_FILE
  594.      2. configured <PERSISTENT_DIRECTORY>/<type>.conf
  595.   */
  596.   if ((filep = getenv("SNMP_PERSISTENT_FILE")) == NULL) {
  597.     sprintf(file,"%s/%s.conf",PERSISTENT_DIRECTORY,type);
  598.     filep = file;
  599.   }
  600.   
  601. #ifdef PERSISTENT_MASK
  602.   oldmask = umask(PERSISTENT_MASK);
  603. #endif
  604.   if (mkdirhier(filep, AGENT_DIRECTORY_MODE, 1)) {
  605.       snmp_log(LOG_ERR, "Failed to create the persistent directory for %sn",
  606.                file);
  607.   }
  608.   if ((fout = fopen(filep, "a")) != NULL) {
  609.     fprintf(fout,line);
  610.     if (line[strlen(line)] != 'n')
  611.       fprintf(fout,"n");
  612.     DEBUGMSGTL(("read_config","storing: %sn",line));
  613.     fclose(fout);
  614.   } else {
  615.     DEBUGMSGTL(("read_config","open failure"));
  616.   }
  617. #ifdef PERSISTENT_MASK
  618.   umask(oldmask);
  619. #endif
  621. #endif
  622. #endif
  623. }  /* end read_config_store() */
  625. void
  626. read_app_config_store(const char *line)
  627. {
  628.   read_config_store(ds_get_string(DS_LIBRARY_ID, DS_LIB_APPTYPE), line);
  629. }
  634. /*******************************************************************-o-******
  635.  * snmp_save_persistent
  636.  *
  637.  * Parameters:
  638.  * *type
  639.  *      
  640.  *
  641.  * Save the file "<PERSISTENT_DIRECTORY>/<type>.conf" into a backup copy
  642.  * called "<PERSISTENT_DIRECTORY>/<type>.%d.conf", which %d is an
  643.  * incrementing number on each call, but less than MAX_PERSISTENT_BACKUPS.
  644.  *
  645.  * Should be called just before all persistent information is supposed to be
  646.  * written to move aside the existing persistent cache.
  647.  * snmp_clean_persistent should then be called afterward all data has been
  648.  * saved to remove these backup files.
  649.  *
  650.  * Note: on an rename error, the files are removed rather than saved.
  651.  *
  652.  */
  653. void
  654. snmp_save_persistent(const char *type)
  655. {
  656. #ifdef UCD_SNMP
  657.   char file[512], fileold[512];
  658.   struct stat statbuf;
  659.   int j;
  661.   DEBUGMSGTL(("snmp_save_persistent","saving %s files...n", type));
  662.   sprintf(file,"%s/%s.conf", PERSISTENT_DIRECTORY, type);
  663.   if (stat(file, &statbuf) == 0) {
  664.     for(j=0; j <= MAX_PERSISTENT_BACKUPS; j++) {
  665.       sprintf(fileold,"%s/%s.%d.conf", PERSISTENT_DIRECTORY, type, j);
  666.       if (stat(fileold, &statbuf) != 0) {
  667.         DEBUGMSGTL(("snmp_save_persistent"," saving old config file: %s -> %s.n", file, fileold));
  668.         if (rename(file, fileold)) {
  669.           unlink(file);/* moving it failed, try nuking it, as leaving
  670.                           it around is very bad. */
  671.         }
  672.         break;
  673.       }
  674.     }
  675.   }
  676. #endif
  677. }
  680. /*******************************************************************-o-******
  681.  * snmp_clean_persistent
  682.  *
  683.  * Parameters:
  684.  * *type
  685.  *      
  686.  *
  687.  * Unlink all backup files called "<PERSISTENT_DIRECTORY>/<type>.%d.conf".
  688.  *
  689.  * Should be called just after we successfull dumped the last of the
  690.  * persistent data, to remove the backup copies of previous storage dumps.
  691.  *
  692.  * XXX  Worth overwriting with random bytes first?  This would
  693.  * ensure that the data is destroyed, even a buffer containing the
  694.  * data persists in memory or swap.  Only important if secrets
  695.  * will be stored here.
  696.  */
  697. void
  698. snmp_clean_persistent(const char *type)
  699. {
  700. #ifdef UCD_SNMP
  701.   char file[512];
  702.   struct stat statbuf;
  703.   int j;
  705.   DEBUGMSGTL(("snmp_clean_persistent","cleaning %s files...n", type));
  706.   sprintf(file,"%s/%s.conf",PERSISTENT_DIRECTORY,type);
  707.   if (stat(file, &statbuf) == 0) {
  708.     for(j=0; j <= MAX_PERSISTENT_BACKUPS; j++) {
  709.       sprintf(file,"%s/%s.%d.conf", PERSISTENT_DIRECTORY, type, j);
  710.       if (stat(file, &statbuf) == 0) {
  711.         DEBUGMSGTL(("snmp_clean_persistent"," removing old config file: %sn", file));
  712.         unlink(file);
  713.       }
  714.     }
  715.   }
  716. #endif
  717. }
  718.   
  722. /* config_perror: prints a warning string associated with a file and
  723.    line number of a .conf file and increments the error count. */
  724. void config_perror(const char *string)
  725. {
  726.   config_pwarn(string);
  727.   config_errors++;
  728. }
  730. void config_pwarn(const char *string)
  731. {
  732.   snmp_log(LOG_WARNING, "%s: line %d: %sn", curfilename, linecount, string);
  733. }
  735. /* skip all white spaces and return 1 if found something either end of
  736.    line or a comment character */
  737. char *skip_white(char *ptr)
  738. {
  740.   if (ptr == NULL) return (NULL);
  741.   while (*ptr != 0 && isspace(*ptr)) ptr++;
  742.   if (*ptr == 0 || *ptr == '#') return (NULL);
  743.   return (ptr);
  744. }
  746. char *skip_not_white(char *ptr)
  747. {
  748.   
  749.   if (ptr == NULL) return (NULL);
  750.   while (*ptr != 0 && !isspace(*ptr)) ptr++;
  751.   if (*ptr == 0 || *ptr == '#') return (NULL);
  752.   return (ptr);
  753. }
  755. char *skip_token(char *ptr)
  756. {
  757.   ptr = skip_white(ptr);
  758.   ptr = skip_not_white(ptr);
  759.   ptr = skip_white(ptr);
  760.   return (ptr);
  761. }
  763. /* copy_word
  764.    copies the next 'token' from 'from' into 'to'.
  765.    currently a token is anything seperate by white space
  766.    or within quotes (double or single) (i.e. "the red rose" 
  767.    is one token, "the red rose" is three tokens)
  768.    a '' character will allow a quote character to be treated
  769.    as a regular character 
  770.    It returns a pointer to first non-white space after the end of the token
  771.    being copied or to 0 if we reach the end.*/
  773. char *copy_word(char *from, char *to)
  774. {
  775.   char quote;
  776.   if ( (*from == '"') || (*from ==''') ){
  777.     quote = *(from++);
  778.     while ( (*from != quote) && (*from != 0) ) {
  779.       if ((*from == '\') && (*(from+1) != 0)) {
  780. *to++ = *(from+1);
  781. from = from +2;
  782.       }
  783.       else  *to++ = *from++;
  784.     }
  785.     if (*from == 0) {
  786.       DEBUGMSGTL(("read_config_copy_word",
  787.                   "no end quote found in config stringn"));
  788.     } else from++;
  789.   }
  790.   else {
  791.     while (*from != 0 && !isspace(*from)) {
  792.       if ((*from == '\') && (*(from+1) != 0)) {
  793. *to++ = *(from+1);
  794. from = from +2;
  795.       }
  796.       else  *to++ = *from++;
  797.     }
  798.   }
  799.   *to = 0;
  800.   from = skip_white(from);
  801.   return(from);
  802. }  /* copy_word */
  804. /* read_config_save_octet_string(): saves an octet string as a length
  805.    followed by a string of hex */
  806. char *read_config_save_octet_string(char *saveto, u_char *str, size_t len) {
  807.   int i;
  808.   if (str != NULL) {
  809.     sprintf(saveto, "0x");
  810.     saveto += 2;
  811.     for(i = 0; i < (int)len; i++) {
  812.       sprintf(saveto,"%02x", str[i]);
  813.       saveto = saveto + 2;
  814.     }
  815.     return saveto;
  816.   } else {
  817.     sprintf(saveto,"""");
  818.     saveto += 2;
  819.   }
  820.   return saveto;
  821. }
  823. /* read_config_read_octet_string(): reads an octet string that was
  824.    saved by the read_config_save_octet_string() function */
  825. char *read_config_read_octet_string(char *readfrom, u_char **str, size_t *len) {
  826.   u_char *cptr=NULL;
  827.   char *cptr1;
  828.   u_int tmp;
  829.   int i;
  831.   if (readfrom == NULL || str == NULL)
  832.     return NULL;
  833.   
  834.   if (strncasecmp(readfrom,"0x",2) == 0) {
  835.     /* A hex string submitted. How long? */
  836.     readfrom += 2;
  837.     cptr1 = skip_not_white(readfrom);
  838.     if (cptr1)
  839.       *len = (cptr1 - readfrom);
  840.     else
  841.       *len = strlen(readfrom);
  843.     if (*len % 2) {
  844.       DEBUGMSGTL(("read_config_read_octet_string","invalid hex string: wrong length"));
  845.       return NULL;
  846.     }
  847.     *len = *len / 2;
  849.     /* malloc data space if needed */
  850.     if (*str == NULL) {
  851.       if (*len == 0) {
  852.         /* null length string found */
  853.         cptr = NULL;
  855.       } else if (*len > 0 && (str == NULL || (cptr = (u_char *)malloc(*len)) == NULL)) {
  856.         return NULL;
  857.       }
  858.       *str = cptr;
  859.     } else {
  860.       cptr = *str;
  861.     }
  863.     /* copy data */
  864.     for(i = 0; i < (int)*len; i++) {
  865.       sscanf(readfrom,"%2x",&tmp);
  866.       *cptr++ = (u_char) tmp;
  867.       readfrom += 2;
  868.     }
  869.     readfrom = skip_white(readfrom);
  870.   } else {
  871.     /* Normal string */
  873.     /* malloc data space if needed */
  874.     if (*str == NULL) {
  875.       char buf[SNMP_MAXBUF];
  876.       readfrom = copy_word(readfrom, buf);
  878.       *len = strlen(buf);
  879.       /* malloc an extra space to add a null */
  880.       if (*len > 0 && (str == NULL ||
  881.                        (cptr = (u_char *) malloc(*len + 1))
  882.                        == NULL))
  883.         return NULL;
  884.       *str = cptr;
  885.       if (cptr)
  886.         memcpy(cptr, buf, (*len+1));
  887.     } else {
  888.       readfrom = copy_word(readfrom, (char *)*str);
  889.     }
  890.   }
  892.   return readfrom;
  893. }
  896. /* read_config_save_objid(): saves an objid as a numerical string */
  897. char *read_config_save_objid(char *saveto, oid *objid, size_t len) {
  898.   int i;
  899.   
  900.   if (len == 0) {
  901.     strcat(saveto, "NULL");
  902.     saveto += strlen(saveto);
  903.     return saveto;
  904.   }
  906.   /* in case len=0, this makes it easier to read it back in */
  907.   for(i=0; i < (int)len; i++) {
  908.     sprintf(saveto,".%ld", objid[i]);
  909.     saveto += strlen(saveto);
  910.   }
  911.   return saveto;
  912. }
  914. /* read_config_read_objid(): reads an objid from a format saved by the above */
  915. char *read_config_read_objid(char *readfrom, oid **objid, size_t *len) {
  917.   if (objid == NULL || readfrom == NULL)
  918.     return NULL;
  920.   if (*objid != NULL) {
  921.     char buf[SPRINT_MAX_LEN];
  923.     if (strncmp(readfrom,"NULL",4) == 0) {
  924.       /* null length oid */
  925.       *len = 0;
  926.     } else {
  927.       /* read_objid is touchy with trailing stuff */
  928.       copy_word(readfrom, buf);
  930.       /* read the oid into the buffer passed to us */
  931.       if (!read_objid(buf, *objid, len)) {
  932.         DEBUGMSGTL(("read_config_read_objid","Invalid OID"));
  933.         return NULL;
  934.       }
  935.     }
  936.     
  937.     readfrom = skip_token(readfrom);
  938.   } else {
  939.     if (strncmp(readfrom,"NULL",4) == 0) {
  940.       /* null length oid */
  941.       *len = 0;
  942.       readfrom = skip_token(readfrom);
  943.     } else {
  944.       /* space needs to be malloced.  Call ourself recursively to figure
  945.        out how long the oid actually is */
  946.       oid obuf[MAX_OID_LEN];
  947.       size_t obuflen = MAX_OID_LEN;
  948.       oid *oidp = obuf;
  949.       oid **oidpp = &oidp;   /* done this way for odd, untrue, gcc warnings */
  951.       readfrom = read_config_read_objid(readfrom, oidpp, &obuflen);
  953.       /* Then malloc and copy the results */
  954.       *len = obuflen;
  955.       if (*len > 0 && (*objid = (oid*)malloc(*len * sizeof(oid))) == NULL)
  956.         return NULL;
  958.       if (obuflen > 0)
  959.         memcpy(*objid, obuf, obuflen*sizeof(oid));
  960.     }
  961.   }
  962.   return readfrom;
  963. }
  965. /* read_config_read_data():
  966.    reads data of a given type from a token(s) on a configuration line.
  968.    Returns: character pointer to the next token in the configuration line.
  969.             NULL if none left.
  970.             NULL if an unknown type.
  971. */
  972. char *read_config_read_data(int type, char *readfrom, void *dataptr, size_t *len) {
  974.   int *intp;
  975.   char **charpp;
  976.   oid  **oidpp;
  978.   if (dataptr == NULL || readfrom == NULL)
  979.     return NULL;
  980.   
  981.   switch(type) {
  982.     case ASN_INTEGER:
  983.       intp = (int *) dataptr;
  984.       *intp = atoi(readfrom);
  985.       readfrom = skip_token(readfrom);
  986.       return readfrom;
  987.       
  988.     case ASN_OCTET_STR:
  989.       charpp = (char **) dataptr;
  990.       return read_config_read_octet_string(readfrom, (u_char **) charpp, len);
  992.     case ASN_OBJECT_ID:
  993.       oidpp = (oid **) dataptr;
  994.       return read_config_read_objid(readfrom, oidpp, len);
  996.     default:
  997.       DEBUGMSGTL(("read_config_read_data","Fail: Unknown type: %d", type));
  998.       return NULL;
  999.   }
  1000.   return NULL;
  1001. }
  1003. /* read_config_read_data():
  1004.    reads data of a given type from a token(s) on a configuration line.
  1006.    Returns: character pointer to the next token in the configuration line.
  1007.             NULL if none left.
  1008.             NULL if an unknown type.
  1009. */
  1010. char *read_config_store_data(int type, char *storeto, void *dataptr, size_t *len) {
  1012.   int *intp;
  1013.   u_char **charpp;
  1014.   oid  **oidpp;
  1016.   if (dataptr == NULL || storeto == NULL)
  1017.     return NULL;
  1018.   
  1019.   switch(type) {
  1020.     case ASN_INTEGER:
  1021.       intp = (int *) dataptr;
  1022.       sprintf(storeto," %d", *intp);
  1023.       return (storeto + strlen(storeto));
  1024.       
  1025.     case ASN_OCTET_STR:
  1026.       charpp = (u_char **) dataptr;
  1027.       return read_config_save_octet_string(storeto, *charpp, *len);
  1029.     case ASN_OBJECT_ID:
  1030.       oidpp = (oid **) dataptr;
  1031.       return read_config_save_objid(storeto, *oidpp, *len);
  1033.     default:
  1034.       DEBUGMSGTL(("read_config_store_data","Fail: Unknown type: %d", type));
  1035.       return NULL;
  1036.   }
  1037.   return NULL;
  1038. }