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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > SNMP编程 > 查看源码
util_funcs.c
资源名称：net-snmp-5.2.2.rar　[点击查看]
上传用户：wxp200602
上传日期：2007-10-30
资源大小：4028k
文件大小：26k
源码类别：

SNMP编程

开发平台：

Unix_Linux

util_funcs.c：源码内容
  1. /*
  2.  * util_funcs.c
  3.  */
  4. /*
  5.  * Portions of this file are copyrighted by:
  6.  * Copyright Copyright 2003 Sun Microsystems, Inc. All rights reserved.
  7.  * Use is subject to license terms specified in the COPYING file
  8.  * distributed with the Net-SNMP package.
  9.  */
  11. #include <net-snmp/net-snmp-config.h>
  13. #if HAVE_IO_H
  14. #include <io.h>
  15. #endif
  16. #include <stdio.h>
  17. #if HAVE_STDLIB_H
  18. #include <stdlib.h>
  19. #endif
  20. #if HAVE_MALLOC_H
  21. #include <malloc.h>
  22. #endif
  23. #include <sys/types.h>
  24. #ifdef __alpha
  25. #ifndef _BSD
  26. #define _BSD
  27. #define _myBSD
  28. #endif
  29. #endif
  30. #if HAVE_SYS_WAIT_H
  31. # include <sys/wait.h>
  32. #endif
  33. #ifdef __alpha
  34. #ifdef _myBSD
  35. #undef _BSD
  36. #undef _myBSD
  37. #endif
  38. #endif
  39. #ifndef WEXITSTATUS
  40. # define WEXITSTATUS(stat_val) ((unsigned)(stat_val) >> 8)
  41. #endif
  42. #ifndef WIFEXITED
  43. # define WIFEXITED(stat_val) (((stat_val) & 255) == 0)
  44. #endif
  45. #if TIME_WITH_SYS_TIME
  46. # ifdef WIN32
  47. #  include <sys/timeb.h>
  48. # else
  49. #  include <sys/time.h>
  50. # endif
  51. # include <time.h>
  52. #else
  53. # if HAVE_SYS_TIME_H
  54. #  include <sys/time.h>
  55. # else
  56. #  include <time.h>
  57. # endif
  58. #endif
  59. #if HAVE_UNISTD_H
  60. #include <unistd.h>
  61. #endif
  62. #if HAVE_FCNTL_H
  63. #include <fcntl.h>
  64. #endif
  65. #include <errno.h>
  66. #include <signal.h>
  67. #if HAVE_STRING_H
  68. #include <string.h>
  69. #else
  70. #include <strings.h>
  71. #endif
  72. #include <ctype.h>
  73. #if HAVE_WINSOCK_H
  74. #include <winsock.h>
  75. #endif
  76. #if HAVE_NETINET_IN_H
  77. #include <netinet/in.h>
  78. #endif
  79. #if HAVE_BASETSD_H
  80. #include <basetsd.h>
  81. #define ssize_t SSIZE_T
  82. #endif
  83. #if HAVE_RAISE
  84. #define alarm raise
  85. #endif
  86. #ifdef HAVE_SYS_STAT_H
  87. #include <sys/stat.h>
  88. #endif
  90. #include <net-snmp/net-snmp-includes.h>
  91. #include <net-snmp/agent/net-snmp-agent-includes.h>
  93. #include "struct.h"
  94. #include "util_funcs.h"
  96. #if HAVE_LIMITS_H
  97. #include "limits.h"
  98. #endif
  99. #ifdef USING_UCD_SNMP_ERRORMIB_MODULE
  100. #include "ucd-snmp/errormib.h"
  101. #else
  102. #define setPerrorstatus(x) snmp_log_perror(x)
  103. #endif
  106. #ifdef EXCACHETIME
  107. static long     cachetime;
  108. #endif
  110. extern int      numprocs, numextens;
  112. void
  113. Exit(int var)
  114. {
  115.     snmp_log(LOG_ERR, "Server Exiting with code %dn", var);
  116.     exit(var);
  117. }
  119. const char *
  120. make_tempfile(void)
  121. {
  122.     static char     name[32];
  123.     int             fd = -1;
  125.     strcpy(name, get_temp_file_pattern());
  126. #ifdef HAVE_MKSTEMP
  127.     fd = mkstemp(name);
  128. #else
  129.     if (mktemp(name)) {
  130. # ifndef WIN32        
  131.         fd = open(name, O_CREAT | O_EXCL | O_WRONLY);
  132. # else
  133.         /*
  134.           Win32 needs _S_IREAD | _S_IWRITE to set permissions on file after closing
  135.          */
  136.         fd = _open(name, _O_CREAT, _S_IREAD | _S_IWRITE | _O_EXCL | _O_WRONLY);
  137. # endif
  138.     }
  139. #endif
  140.     if (fd >= 0) {
  141.         close(fd);
  142.         DEBUGMSGTL(("make_tempfile", "temp file created: %sn", name));
  143.         return name;
  144.     }
  145.     snmp_log(LOG_ERR,"make_tempfile: error creating file %sn", name);
  146.     return NULL;
  147. }
  149. int
  150. shell_command(struct extensible *ex)
  151. {
  152. #if HAVE_SYSTEM
  153.     const char     *ofname;
  154.     char            shellline[STRMAX];
  155.     FILE           *shellout;
  157.     ofname = make_tempfile();
  158.     if (ofname == NULL) {
  159.         ex->output[0] = 0;
  160.         ex->result = 127;
  161.         return ex->result;
  162.     }
  164.     snprintf(shellline, sizeof(shellline), "%s > %s", ex->command, ofname);
  165.     shellline[ sizeof(shellline)-1 ] = 0;
  166.     ex->result = system(shellline);
  167.     ex->result = WEXITSTATUS(ex->result);
  168.     shellout = fopen(ofname, "r");
  169.     if (shellout != NULL) {
  170.         if (fgets(ex->output, sizeof(ex->output), shellout) == NULL) {
  171.             ex->output[0] = 0;
  172.         }
  173.         fclose(shellout);
  174.     }
  175.     unlink(ofname);
  176. #else
  177.     ex->output[0] = 0;
  178.     ex->result = 0;
  179. #endif
  180.     return (ex->result);
  181. }
  183. #define MAXOUTPUT 300
  185. int
  186. exec_command(struct extensible *ex)
  187. {
  188. #if HAVE_EXECV
  189.     int             fd;
  190.     FILE           *file;
  192.     if ((fd = get_exec_output(ex)) != -1) {
  193.         file = fdopen(fd, "r");
  194.         if (fgets(ex->output, sizeof(ex->output), file) == NULL) {
  195.             ex->output[0] = 0;
  196.         }
  197.         fclose(file);
  198.         wait_on_exec(ex);
  199.     } else
  200. #endif
  201.     {
  202.         ex->output[0] = 0;
  203.         ex->result = 0;
  204.     }
  205.     return (ex->result);
  206. }
  208. struct extensible *
  209. get_exten_instance(struct extensible *exten, size_t inst)
  210. {
  211.     int             i;
  213.     if (exten == NULL)
  214.         return (NULL);
  215.     for (i = 1; i != (int) inst && exten != NULL; i++)
  216.         exten = exten->next;
  217.     return (exten);
  218. }
  220. void
  221. wait_on_exec(struct extensible *ex)
  222. {
  223. #ifndef EXCACHETIME
  224.     if (ex->pid && waitpid(ex->pid, &ex->result, 0) < 0) {
  225.         setPerrorstatus("waitpid");
  226.     }
  227.     ex->pid = 0;
  228. #endif
  229. }
  231. #define MAXARGS 30
  233. int
  234. get_exec_output(struct extensible *ex)
  235. {
  236. #if HAVE_EXECV
  237.     int             fd[2], i, cnt;
  238.     char            ctmp[STRMAX], *cptr1, *cptr2, argvs[STRMAX], **argv,
  239.         **aptr;
  240. #ifdef EXCACHETIME
  241.     char            cachefile[STRMAX];
  242.     char            cache[MAXCACHESIZE];
  243.     ssize_t         cachebytes;
  244.     long            curtime;
  245.     static char     lastcmd[STRMAX];
  246.     int             cfd;
  247.     static int      lastresult;
  248.     int             readcount;
  249. #endif
  251.     DEBUGMSGTL(("exec:get_exec_output","calling %sn", ex->command));
  253. #ifdef EXCACHETIME
  254.     sprintf(cachefile, "%s/%s", get_persistent_directory(), CACHEFILE);
  255.     curtime = time(NULL);
  256.     if (curtime > (cachetime + EXCACHETIME) ||
  257.         strcmp(ex->command, lastcmd) != 0) {
  258.         strcpy(lastcmd, ex->command);
  259.         cachetime = curtime;
  260. #endif
  261.         if (pipe(fd)) {
  262.             setPerrorstatus("pipe");
  263. #ifdef EXCACHETIME
  264.             cachetime = 0;
  265. #endif
  266.             return -1;
  267.         }
  268.         if ((ex->pid = fork()) == 0) {
  269.             close(1);
  270.             if (dup(fd[1]) != 1) {
  271.                 setPerrorstatus("dup");
  272.                 return -1;
  273.             }
  275.             /*
  276.              * write standard output and standard error to pipe. 
  277.              */
  278.             /*
  279.              * close all other file descriptors. 
  280.              */
  281.             for (cnt = getdtablesize() - 1; cnt >= 2; --cnt)
  282.                 (void) close(cnt);
  283.             (void) dup(1);      /* stderr */
  285.             /*
  286.              * set standard input to /dev/null 
  287.              */
  288.             close(0);
  289.             (void) open("/dev/null", O_RDWR);
  291.             for (cnt = 1, cptr1 = ex->command, cptr2 = argvs;
  292.                  cptr1 && *cptr1 != 0; cptr2++, cptr1++) {
  293.                 *cptr2 = *cptr1;
  294.                 if (*cptr1 == ' ') {
  295.                     *(cptr2++) = 0;
  296.                     if ((cptr1 = skip_white(cptr1)) == NULL)
  297.                         break;
  298.                     if (cptr1) {
  299.                         *cptr2 = *cptr1;
  300.                         if (*cptr1 != 0)
  301.                             cnt++;
  302.                     }
  303.                 }
  304.             }
  305.             *cptr2 = 0;
  306.             *(cptr2 + 1) = 0;
  307.             argv = (char **) malloc((cnt + 2) * sizeof(char *));
  308.             if (argv == NULL)
  309.                 return 0;       /* memory alloc error */
  310.             aptr = argv;
  311.             *(aptr++) = argvs;
  312.             for (cptr2 = argvs, i = 1; i != cnt; cptr2++)
  313.                 if (*cptr2 == 0) {
  314.                     *(aptr++) = cptr2 + 1;
  315.                     i++;
  316.                 }
  317.             while (*cptr2 != 0)
  318.                 cptr2++;
  319.             *(aptr++) = NULL;
  320.             copy_nword(ex->command, ctmp, sizeof(ctmp));
  321.             execv(ctmp, argv);
  322.             perror(ctmp);
  323.             exit(1);
  324.         } else {
  325.             close(fd[1]);
  326.             if (ex->pid < 0) {
  327.                 close(fd[0]);
  328.                 setPerrorstatus("fork");
  329. #ifdef EXCACHETIME
  330.                 cachetime = 0;
  331. #endif
  332.                 return -1;
  333.             }
  334. #ifdef EXCACHETIME
  335.             unlink(cachefile);
  336.             /*
  337.              * XXX  Use SNMP_FILEMODE_CLOSED instead of 644? 
  338.              */
  339.             if ((cfd =
  340.                  open(cachefile, O_WRONLY | O_TRUNC | O_CREAT,
  341.                       0644)) < 0) {
  342.                 snmp_log(LOG_ERR,"can not create cache filen");
  343.                 setPerrorstatus(cachefile);
  344.                 cachetime = 0;
  345.                 return -1;
  346.             }
  347.             fcntl(fd[0], F_SETFL, O_NONBLOCK);  /* don't block on reads */
  348. #ifdef HAVE_USLEEP
  349.             for (readcount = 0; readcount <= MAXREADCOUNT * 100 &&
  350.                  (cachebytes = read(fd[0], (void *) cache, MAXCACHESIZE));
  351.                  readcount++) {
  352. #else
  353.             for (readcount = 0; readcount <= MAXREADCOUNT &&
  354.                  (cachebytes = read(fd[0], (void *) cache, MAXCACHESIZE));
  355.                  readcount++) {
  356. #endif
  357.                 if (cachebytes > 0)
  358.                     write(cfd, (void *) cache, cachebytes);
  359.                 else if (cachebytes == -1 && errno != EAGAIN) {
  360.                     setPerrorstatus("read");
  361.                     break;
  362.                 } else
  363. #ifdef HAVE_USLEEP
  364.                     usleep(10000);      /* sleeps for 0.01 sec */
  365. #else
  366.                     sleep(1);
  367. #endif
  368.             }
  369.             close(cfd);
  370.             close(fd[0]);
  371.             /*
  372.              * wait for the child to finish 
  373.              */
  374.             if (ex->pid > 0 && waitpid(ex->pid, &ex->result, 0) < 0) {
  375.                 setPerrorstatus("waitpid()");
  376.                 cachetime = 0;
  377.                 return -1;
  378.             }
  379.             ex->pid = 0;
  380.             ex->result = WEXITSTATUS(ex->result);
  381.             lastresult = ex->result;
  382. #else                           /* !EXCACHETIME */
  383.             return (fd[0]);
  384. #endif
  385.         }
  386. #ifdef EXCACHETIME
  387.     } else {
  388.         ex->result = lastresult;
  389.     }
  390.     DEBUGMSGTL(("exec:get_exec_output","using cached valuen"));
  391.     if ((cfd = open(cachefile, O_RDONLY)) < 0) {
  392.         snmp_log(LOG_ERR,"can not open cache filen");
  393.         setPerrorstatus(cachefile);
  394.         return -1;
  395.     }
  396.     return (cfd);
  397. #endif
  399. #else                           /* !HAVE_EXECV */
  400.     return -1;
  401. #endif
  402. }
  404. int
  405. get_exec_pipes(char *cmd, int *fdIn, int *fdOut, int *pid)
  406. {
  407. #if HAVE_EXECV
  408.     int             fd[2][2], i, cnt;
  409.     char            ctmp[STRMAX], *cptr1, *cptr2, argvs[STRMAX], **argv,
  410.         **aptr;
  411.     /*
  412.      * Setup our pipes 
  413.      */
  414.     if (pipe(fd[0]) || pipe(fd[1])) {
  415.         setPerrorstatus("pipe");
  416.         return 0;
  417.     }
  418.     if ((*pid = fork()) == 0) { /* First handle for the child */
  419.         close(0);
  420.         if (dup(fd[0][0]) != 0) {
  421.             setPerrorstatus("dup 0");
  422.             return 0;
  423.         }
  424.         close(1);
  425.         if (dup(fd[1][1]) != 1) {
  426.             setPerrorstatus("dup 1");
  427.             return 0;
  428.         }
  430.         /*
  431.          * write standard output and standard error to pipe. 
  432.          */
  433.         /*
  434.          * close all non-standard open file descriptors 
  435.          */
  436.         for (cnt = getdtablesize() - 1; cnt >= 2; --cnt)
  437.             (void) close(cnt);
  438.         (void) dup(1);          /* stderr */
  440.         for (cnt = 1, cptr1 = cmd, cptr2 = argvs; *cptr1 != 0;
  441.              cptr2++, cptr1++) {
  442.             *cptr2 = *cptr1;
  443.             if (*cptr1 == ' ') {
  444.                 *(cptr2++) = 0;
  445.                 if ((cptr1 = skip_white(cptr1)) == NULL)
  446.                     break;
  447.                 *cptr2 = *cptr1;
  448.                 if (*cptr1 != 0)
  449.                     cnt++;
  450.             }
  451.         }
  452.         *cptr2 = 0;
  453.         *(cptr2 + 1) = 0;
  454.         argv = (char **) malloc((cnt + 2) * sizeof(char *));
  455.         if (argv == NULL)
  456.             return 0;           /* memory alloc error */
  457.         aptr = argv;
  458.         *(aptr++) = argvs;
  459.         for (cptr2 = argvs, i = 1; i != cnt; cptr2++)
  460.             if (*cptr2 == 0) {
  461.                 *(aptr++) = cptr2 + 1;
  462.                 i++;
  463.             }
  464.         while (*cptr2 != 0)
  465.             cptr2++;
  466.         *(aptr++) = NULL;
  467.         copy_nword(cmd, ctmp, sizeof(ctmp));
  468.         execv(ctmp, argv);
  469.         perror(ctmp);
  470.         exit(1);
  471.     } else {
  472.         close(fd[0][0]);
  473.         close(fd[1][1]);
  474.         if (*pid < 0) {
  475.             close(fd[0][1]);
  476.             close(fd[1][0]);
  477.             setPerrorstatus("fork");
  478.             return 0;
  479.         }
  480.         *fdIn = fd[1][0];
  481.         *fdOut = fd[0][1];
  482.         return (1);             /* We are returning 0 for error... */
  483.     }
  484. #endif                          /* !HAVE_EXECV */
  485.     return 0;
  486. }
  488. int
  489. clear_cache(int action,
  490.             u_char * var_val,
  491.             u_char var_val_type,
  492.             size_t var_val_len,
  493.             u_char * statP, oid * name, size_t name_len)
  494. {
  496.     long            tmp = 0;
  498.     if (var_val_type != ASN_INTEGER) {
  499.         snmp_log(LOG_NOTICE, "Wrong type != intn");
  500.         return SNMP_ERR_WRONGTYPE;
  501.     }
  502.     tmp = *((long *) var_val);
  503.     if (tmp == 1 && action == COMMIT) {
  504. #ifdef EXCACHETIME
  505.         cachetime = 0;          /* reset the cache next read */
  506. #endif
  507.     }
  508.     return SNMP_ERR_NOERROR;
  509. }
  511. char          **argvrestartp, *argvrestartname, *argvrestart;
  513. RETSIGTYPE
  514. restart_doit(int a)
  515. {
  516.     snmp_shutdown("snmpd");
  518.     /*
  519.      * do the exec 
  520.      */
  521. #if HAVE_EXECV
  522.     execv(argvrestartname, argvrestartp);
  523.     setPerrorstatus(argvrestartname);
  524. #endif
  525. }
  527. int
  528. restart_hook(int action,
  529.              u_char * var_val,
  530.              u_char var_val_type,
  531.              size_t var_val_len,
  532.              u_char * statP, oid * name, size_t name_len)
  533. {
  535.     long            tmp = 0;
  537.     if (var_val_type != ASN_INTEGER) {
  538.         snmp_log(LOG_NOTICE, "Wrong type != intn");
  539.         return SNMP_ERR_WRONGTYPE;
  540.     }
  541.     tmp = *((long *) var_val);
  542.     if (tmp == 1 && action == COMMIT) {
  543. #ifdef SIGALRM
  544.         signal(SIGALRM, restart_doit);
  545. #endif
  546.         alarm(RESTARTSLEEP);
  547.     }
  548.     return SNMP_ERR_NOERROR;
  549. }
  551. void
  552. print_mib_oid(oid name[], size_t len)
  553. {
  554.     char           *buffer;
  555.     buffer = (char *) malloc(11 * len); /* maximum digit lengths for int32 + a '.' */
  556.     if (!buffer) {
  557.         snmp_log(LOG_ERR, "Malloc failed - out of memory?");
  558.         return;
  559.     }
  560.     sprint_mib_oid(buffer, name, len);
  561.     snmp_log(LOG_NOTICE, "Mib: %sn", buffer);
  562.     free(buffer);
  563. }
  565. void
  566. sprint_mib_oid(char *buf, oid name[], size_t len)
  567. {
  568.     int             i;
  569.     for (i = 0; i < (int) len; i++) {
  570.         sprintf(buf, ".%d", (int) name[i]);
  571.         while (*buf != 0)
  572.             buf++;
  573.     }
  574. }
  576. /*******************************************************************-o-******
  577.  * header_simple_table
  578.  *
  579.  * Parameters:
  580.  *   *vp  Variable data.
  581.  *   *name  Fully instantiated OID name.
  582.  *   *length  Length of name.
  583.  *    exact  TRUE if an exact match is desired.
  584.  *   *var_len  Hook for size of returned data type.
  585.  * (**write_method) Hook for write method (UNUSED).
  586.  *    max
  587.  *      
  588.  * Returns:
  589.  * 0 If name matches vp->name (accounting for 'exact') and is
  590.  * not greater in length than 'max'.
  591.  * 1 Otherwise.
  592.  *
  593.  *
  594.  * Compare 'name' to vp->name for the best match or an exact match (if
  595.  * requested).  Also check that 'name' is not longer than 'max' if
  596.  * max is greater-than/equal 0.
  597.  * Store a successful match in 'name', and increment the OID instance if
  598.  * the match was not exact.  
  599.  *
  600.  * 'name' and 'length' are undefined upon failure.
  601.  *
  602.  */
  603. int
  604. header_simple_table(struct variable *vp, oid * name, size_t * length,
  605.                     int exact, size_t * var_len,
  606.                     WriteMethod ** write_method, int max)
  607. {
  608.     int             i, rtest;   /* Set to:      -1      If name < vp->name,
  609.                                  *              1       If name > vp->name,
  610.                                  *              0       Otherwise.
  611.                                  */
  612.     oid             newname[MAX_OID_LEN];
  614.     for (i = 0, rtest = 0;
  615.          i < (int) vp->namelen && i < (int) (*length) && !rtest; i++) {
  616.         if (name[i] != vp->name[i]) {
  617.             if (name[i] < vp->name[i])
  618.                 rtest = -1;
  619.             else
  620.                 rtest = 1;
  621.         }
  622.     }
  623.     if (rtest > 0 ||
  624.         (exact == 1
  625.          && (rtest || (int) *length != (int) (vp->namelen + 1)))) {
  626.         if (var_len)
  627.             *var_len = 0;
  628.         return MATCH_FAILED;
  629.     }
  631.     memset(newname, 0, sizeof(newname));
  633.     if (((int) *length) <= (int) vp->namelen || rtest == -1) {
  634.         memmove(newname, vp->name, (int) vp->namelen * sizeof(oid));
  635.         newname[vp->namelen] = 1;
  636.         *length = vp->namelen + 1;
  637.     } else if (((int) *length) > (int) vp->namelen + 1) {       /* exact case checked earlier */
  638.         *length = vp->namelen + 1;
  639.         memmove(newname, name, (*length) * sizeof(oid));
  640.         if (name[*length - 1] < ULONG_MAX) {
  641.             newname[*length - 1] = name[*length - 1] + 1;
  642.         } else {
  643.             /*
  644.              * Careful not to overflow...  
  645.              */
  646.             newname[*length - 1] = name[*length - 1];
  647.         }
  648.     } else {
  649.         *length = vp->namelen + 1;
  650.         memmove(newname, name, (*length) * sizeof(oid));
  651.         if (!exact) {
  652.             if (name[*length - 1] < ULONG_MAX) {
  653.                 newname[*length - 1] = name[*length - 1] + 1;
  654.             } else {
  655.                 /*
  656.                  * Careful not to overflow...  
  657.                  */
  658.                 newname[*length - 1] = name[*length - 1];
  659.             }
  660.         } else {
  661.             newname[*length - 1] = name[*length - 1];
  662.         }
  663.     }
  664.     if ((max >= 0 && ((int)newname[*length - 1] > max)) ||
  665.                ( 0 == newname[*length - 1] )) {
  666.         if (var_len)
  667.             *var_len = 0;
  668.         return MATCH_FAILED;
  669.     }
  671.     memmove(name, newname, (*length) * sizeof(oid));
  672.     if (write_method)
  673.         *write_method = 0;
  674.     if (var_len)
  675.         *var_len = sizeof(long);        /* default */
  676.     return (MATCH_SUCCEEDED);
  677. }
  679. /*
  680.  * header_generic(...
  681.  * Arguments:
  682.  * vp     IN      - pointer to variable entry that points here
  683.  * name    IN/OUT  - IN/name requested, OUT/name found
  684.  * length  IN/OUT  - length of IN/OUT oid's 
  685.  * exact   IN      - TRUE if an exact match was requested
  686.  * var_len OUT     - length of variable or 0 if function returned
  687.  * write_method
  688.  * 
  689.  */
  691. /*******************************************************************-o-******
  692.  * generic_header
  693.  *
  694.  * Parameters:
  695.  *   *vp    (I)     Pointer to variable entry that points here.
  696.  *   *name    (I/O)   Input name requested, output name found.
  697.  *   *length  (I/O)   Length of input and output oid's.
  698.  *    exact   (I)     TRUE if an exact match was requested.
  699.  *   *var_len (O)     Length of variable or 0 if function returned.
  700.  * (**write_method)   Hook to name a write method (UNUSED).
  701.  *      
  702.  * Returns:
  703.  * MATCH_SUCCEEDED If vp->name matches name (accounting for exact bit).
  704.  * MATCH_FAILED Otherwise,
  705.  *
  706.  *
  707.  * Check whether variable (vp) matches name.
  708.  */
  709. int
  710. header_generic(struct variable *vp,
  711.                oid * name,
  712.                size_t * length,
  713.                int exact, size_t * var_len, WriteMethod ** write_method)
  714. {
  715.     oid             newname[MAX_OID_LEN];
  716.     int             result;
  718.     DEBUGMSGTL(("util_funcs", "header_generic: "));
  719.     DEBUGMSGOID(("util_funcs", name, *length));
  720.     DEBUGMSG(("util_funcs", " exact=%dn", exact));
  722.     memcpy((char *) newname, (char *) vp->name,
  723.            (int) vp->namelen * sizeof(oid));
  724.     newname[vp->namelen] = 0;
  725.     result = snmp_oid_compare(name, *length, newname, vp->namelen + 1);
  726.     DEBUGMSGTL(("util_funcs", "  result: %dn", result));
  727.     if ((exact && (result != 0)) || (!exact && (result >= 0)))
  728.         return (MATCH_FAILED);
  729.     memcpy((char *) name, (char *) newname,
  730.            ((int) vp->namelen + 1) * sizeof(oid));
  731.     *length = vp->namelen + 1;
  733.     *write_method = 0;
  734.     *var_len = sizeof(long);    /* default to 'long' results */
  735.     return (MATCH_SUCCEEDED);
  736. }
  738. /*
  739.  * checkmib(): provided for backwards compatibility, do not use: 
  740.  */
  741. int
  742. checkmib(struct variable *vp, oid * name, size_t * length,
  743.          int exact, size_t * var_len, WriteMethod ** write_method, int max)
  744. {
  745.     /*
  746.      * checkmib used to be header_simple_table, with reveresed boolean
  747.      * return output.  header_simple_table() was created to match
  748.      * header_generic(). 
  749.      */
  750.     return (!header_simple_table(vp, name, length, exact, var_len,
  751.                                  write_method, max));
  752. }
  754. char           *
  755. find_field(char *ptr, int field)
  756. {
  757.     int             i;
  758.     char           *init = ptr;
  760.     if (field == LASTFIELD) {
  761.         /*
  762.          * skip to end 
  763.          */
  764.         while (*ptr++);
  765.         ptr = ptr - 2;
  766.         /*
  767.          * rewind a field length 
  768.          */
  769.         while (*ptr != 0 && isspace(*ptr) && init <= ptr)
  770.             ptr--;
  771.         while (*ptr != 0 && !isspace(*ptr) && init <= ptr)
  772.             ptr--;
  773.         if (isspace(*ptr))
  774.             ptr++;              /* past space */
  775.         if (ptr < init)
  776.             ptr = init;
  777.         if (!isspace(*ptr) && *ptr != 0)
  778.             return (ptr);
  779.     } else {
  780.         if ((ptr = skip_white(ptr)) == NULL)
  781.             return (NULL);
  782.         for (i = 1; *ptr != 0 && i != field; i++) {
  783.             if ((ptr = skip_not_white(ptr)) == NULL)
  784.                 return (NULL);
  785.             if ((ptr = skip_white(ptr)) == NULL)
  786.                 return (NULL);
  787.         }
  788.         if (*ptr != 0 && i == field)
  789.             return (ptr);
  790.         return (NULL);
  791.     }
  792.     return (NULL);
  793. }
  795. int
  796. parse_miboid(const char *buf, oid * oidout)
  797. {
  798.     int             i;
  800.     if (!buf)
  801.         return 0;
  802.     if (*buf == '.')
  803.         buf++;
  804.     for (i = 0; isdigit(*buf); i++) {
  805.         oidout[i] = atoi(buf);
  806.         while (isdigit(*buf++));
  807.         if (*buf == '.')
  808.             buf++;
  809.     }
  810.     /*
  811.      * oidout[i] = -1; hmmm 
  812.      */
  813.     return i;
  814. }
  816. void
  817. string_append_int(char *s, int val)
  818. {
  819.     char            textVal[16];
  821.     if (val < 10) {
  822.         *s++ = '0' + val;
  823.         *s = '';
  824.         return;
  825.     }
  826.     sprintf(textVal, "%d", val);
  827.     strcpy(s, textVal);
  828.     return;
  829. }
  831. struct internal_mib_table {
  832.     int             max_size;   /* Size of the current data table */
  833.     int             next_index; /* Index of the next free entry */
  834.     int             current_index;      /* Index of the 'current' entry */
  835.     int             cache_timeout;
  836.     marker_t        cache_marker;
  837.     RELOAD         *reload;     /* Routine to read in the data */
  838.     COMPARE        *compare;    /* Routine to compare two entries */
  839.     int             data_size;  /* Size of an individual entry */
  840.     void           *data;       /* The table itself */
  841. };
  843. mib_table_t
  844. Initialise_Table(int size, int timeout, RELOAD *reload, COMPARE *compare)
  845. {
  846.     struct internal_mib_table *t;
  848.     t = (struct internal_mib_table *)
  849.         malloc(sizeof(struct internal_mib_table));
  850.     if (t == NULL)
  851.         return NULL;
  853.     t->max_size = 0;
  854.     t->next_index = 1;          /* Don't use index 0 */
  855.     t->current_index = 1;
  856.     t->cache_timeout = timeout;
  857.     t->cache_marker = NULL;
  858.     t->reload = reload;
  859.     t->compare = compare;
  860.     t->data_size = size;
  861.     t->data = NULL;
  863.     return (mib_table_t) t;
  864. }
  866. #define TABLE_ADD( x, y ) ((void*)((char*)(x) + y))
  867. #define TABLE_INDEX(t, i) (TABLE_ADD(t->data, i * t->data_size))
  868. #define TABLE_START(t) (TABLE_INDEX(t, 1))
  869. #define TABLE_NEXT(t) (TABLE_INDEX(t, t->next_index))
  870. #define TABLE_CURRENT(t) (TABLE_INDEX(t, t->current_index))
  872. int
  873. check_and_reload_table(struct internal_mib_table *table)
  874. {
  875.     /*
  876.      * If the saved data is fairly recent,
  877.      *    we don't need to reload it
  878.      */
  879.     if (table->cache_marker &&
  880.         !(atime_ready(table->cache_marker, table->cache_timeout * 1000)))
  881.         return 1;
  884.     /*
  885.      * Call the routine provided to read in the data
  886.      *
  887.      * N.B:  Update the cache marker *before* calling
  888.      *   this routine, to avoid problems with recursion
  889.      */
  890.     if (!table->cache_marker)
  891.         table->cache_marker = atime_newMarker();
  892.     else
  893.         atime_setMarker(table->cache_marker);
  895.     table->next_index = 1;
  896.     if (table->reload((mib_table_t) table) < 0) {
  897.         free(table->cache_marker);
  898.         table->cache_marker = NULL;
  899.         return 0;
  900.     }
  901.     table->current_index = 1;
  902.     if (table->compare != NULL) /* Sort the table */
  903.         qsort(TABLE_START(table), table->next_index,
  904.               table->data_size, table->compare);
  905.     return 1;
  906. }
  908. int
  909. Search_Table(mib_table_t t, void *entry, int exact)
  910. {
  911.     struct internal_mib_table *table = (struct internal_mib_table *) t;
  912.     void           *entry2;
  913.     int             res;
  915.     if (!check_and_reload_table(table))
  916.         return -1;
  918.     if (table->compare == NULL) {
  919.         /*
  920.          * XXX - not sure this is right ? 
  921.          */
  922.         memcpy(entry, table->data, table->data_size);
  923.         return 0;
  924.     }
  926.     if (table->next_index == table->current_index)
  927.         table->current_index = 1;
  929.     entry2 = TABLE_CURRENT(table);
  930.     res = table->compare(entry, entry2);
  931.     if ((res < 0) && (table->current_index != 1)) {
  932.         table->current_index = 1;
  933.         entry2 = TABLE_CURRENT(table);
  934.         res = table->compare(entry, entry2);
  935.     }
  937.     while (res > 0) {
  938.         table->current_index++;
  939.         if (table->next_index == table->current_index)
  940.             return -1;
  941.         entry2 = TABLE_CURRENT(table);
  942.         res = table->compare(entry, entry2);
  943.     }
  945.     if (exact && res != 0)
  946.         return -1;
  948.     if (!exact && res == 0) {
  949.         table->current_index++;
  950.         if (table->next_index == table->current_index)
  951.             return -1;
  952.         entry2 = TABLE_CURRENT(table);
  953.     }
  954.     memcpy(entry, entry2, table->data_size);
  955.     return 0;
  956. }
  958. int
  959. Add_Entry(mib_table_t t, void *entry)
  960. {
  961.     struct internal_mib_table *table = (struct internal_mib_table *) t;
  962.     int             new_max;
  963.     void           *new_data;   /* Used for
  964.                                  *      a) extending the data table
  965.                                  *      b) the next entry to use
  966.                                  */
  968.     if (table->max_size <= table->next_index) {
  969.         /*
  970.          * Table is full, so extend it to double the size
  971.          */
  972.         new_max = 2 * table->max_size;
  973.         if (new_max == 0)
  974.             new_max = 10;       /* Start with 10 entries */
  976.         new_data = (void *) malloc(new_max * table->data_size);
  977.         if (new_data == NULL)
  978.             return -1;
  980.         if (table->data) {
  981.             memcpy(new_data, table->data,
  982.                    table->max_size * table->data_size);
  983.             free(table->data);
  984.         }
  985.         table->data = new_data;
  986.         table->max_size = new_max;
  987.     }
  989.     /*
  990.      * Insert the new entry into the data array
  991.      */
  992.     new_data = TABLE_NEXT(table);
  993.     memcpy(new_data, entry, table->data_size);
  994.     table->next_index++;
  995.     return 0;
  996. }
  998. void           *
  999. Retrieve_Table_Data(mib_table_t t, int *max_idx)
  1000. {
  1001.     struct internal_mib_table *table = (struct internal_mib_table *) t;
  1003.     if (!check_and_reload_table(table))
  1004.         return NULL;
  1005.     *max_idx = table->next_index - 1;
  1006.     return table->data;
  1007. }