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

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

SNMP编程

开发平台：

Unix_Linux

pass.c：源码内容
  1. #include <net-snmp/net-snmp-config.h>
  3. #if HAVE_STDLIB_H
  4. #include <stdlib.h>
  5. #endif
  6. #include <stdio.h>
  7. #if HAVE_STRING_H
  8. #include <string.h>
  9. #else
  10. #include <strings.h>
  11. #endif
  12. #if HAVE_UNISTD_H
  13. #include <unistd.h>
  14. #endif
  15. #include <ctype.h>
  16. #include <sys/types.h>
  17. #if HAVE_NETINET_IN_H
  18. #include <netinet/in.h>
  19. #endif
  20. #if HAVE_SYS_WAIT_H
  21. # include <sys/wait.h>
  22. #endif
  23. #if HAVE_WINSOCK_H
  24. #include <winsock.h>
  25. #endif
  27. #if HAVE_DMALLOC_H
  28. #include <dmalloc.h>
  29. #endif
  31. #include <net-snmp/net-snmp-includes.h>
  32. #include <net-snmp/agent/net-snmp-agent-includes.h>
  34. #include "struct.h"
  35. #include "pass.h"
  36. #include "extensible.h"
  37. #include "util_funcs.h"
  39. struct extensible *passthrus = NULL;
  40. int             numpassthrus = 0;
  42. /*
  43.  * the relocatable extensible commands variables 
  44.  */
  45. struct variable2 extensible_passthru_variables[] = {
  46.     /*
  47.      * bogus entry.  Only some of it is actually used. 
  48.      */
  49.     {MIBINDEX, ASN_INTEGER, RWRITE, var_extensible_pass, 0, {MIBINDEX}},
  50. };
  54. /*
  55.  * lexicographical compare two object identifiers.
  56.  * * Returns -1 if name1 < name2,
  57.  * *          0 if name1 = name2,
  58.  * *          1 if name1 > name2
  59.  * *
  60.  * * This method differs from snmp_oid_compare
  61.  * * in that the comparison stops at the length
  62.  * * of the smallest object identifier.
  63.  */
  64. int
  65. snmp_oid_min_compare(const oid * in_name1,
  66.                      size_t len1, const oid * in_name2, size_t len2)
  67. {
  68.     register int    len;
  69.     register const oid *name1 = in_name1;
  70.     register const oid *name2 = in_name2;
  72.     /*
  73.      * len = minimum of len1 and len2 
  74.      */
  75.     if (len1 < len2)
  76.         len = len1;
  77.     else
  78.         len = len2;
  79.     /*
  80.      * find first non-matching OID 
  81.      */
  82.     while (len-- > 0) {
  83.         /*
  84.          * these must be done in seperate comparisons, since
  85.          * subtracting them and using that result has problems with
  86.          * subids > 2^31. 
  87.          */
  88.         if (*(name1) < *(name2))
  89.             return -1;
  90.         if (*(name1++) > *(name2++))
  91.             return 1;
  92.     }
  93.     /*
  94.      * both OIDs equal up to length of shorter OID 
  95.      */
  97.     return 0;
  98. }
  101. /*
  102.  * This is also called from pass_persist.c 
  103.  */
  104. int
  105. asc2bin(char *p)
  106. {
  107.     char           *r, *q = p;
  108.     char            c;
  109.     int             n = 0;
  111.     for (;;) {
  112.         c = (char) strtol(q, &r, 16);
  113.         if (r == q)
  114.             break;
  115.         *p++ = c;
  116.         q = r;
  117.         n++;
  118.     }
  119.     return n;
  120. }
  122. /*
  123.  * This is also called from pass_persist.c 
  124.  */
  125. int
  126. bin2asc(char *p, size_t n)
  127. {
  128.     int             i, flag = 0;
  129.     char            buffer[SNMP_MAXBUF];
  131.     /* prevent buffer overflow */
  132.     if ((int)n > (sizeof(buffer) - 1))
  133.         n = sizeof(buffer) - 1;
  135.     for (i = 0; i < (int) n; i++) {
  136.         buffer[i] = p[i];
  137.         if (!isprint(p[i]))
  138.             flag = 1;
  139.     }
  140.     if (flag == 0) {
  141.         p[n] = 0;
  142.         return n;
  143.     }
  144.     for (i = 0; i < (int) n; i++) {
  145.         sprintf(p, "%02x ", (unsigned char) (buffer[i] & 0xff));
  146.         p += 3;
  147.     }
  148.     *--p = 0;
  149.     return 3 * n - 1;
  150. }
  152. void
  153. init_pass(void)
  154. {
  155.     snmpd_register_config_handler("pass", pass_parse_config,
  156.                                   pass_free_config, "miboid command");
  157. }
  159. void
  160. pass_parse_config(const char *token, char *cptr)
  161. {
  162.     struct extensible **ppass = &passthrus, **etmp, *ptmp;
  163.     char           *tcptr;
  164.     int             i;
  166.     if (*cptr == '.')
  167.         cptr++;
  168.     if (!isdigit(*cptr)) {
  169.         config_perror("second token is not a OID");
  170.         return;
  171.     }
  172.     numpassthrus++;
  174.     while (*ppass != NULL)
  175.         ppass = &((*ppass)->next);
  176.     (*ppass) = (struct extensible *) malloc(sizeof(struct extensible));
  177.     if (*ppass == NULL)
  178.         return;
  179.     (*ppass)->type = PASSTHRU;
  181.     (*ppass)->miblen = parse_miboid(cptr, (*ppass)->miboid);
  182.     while (isdigit(*cptr) || *cptr == '.')
  183.         cptr++;
  184.     /*
  185.      * name 
  186.      */
  187.     cptr = skip_white(cptr);
  188.     if (cptr == NULL) {
  189.         config_perror("No command specified on pass line");
  190.         (*ppass)->command[0] = 0;
  191.     } else {
  192.         for (tcptr = cptr; *tcptr != 0 && *tcptr != '#' && *tcptr != ';';
  193.              tcptr++);
  194.         strncpy((*ppass)->command, cptr, tcptr - cptr);
  195.         (*ppass)->command[tcptr - cptr] = 0;
  196.     }
  197.     strncpy((*ppass)->name, (*ppass)->command, sizeof((*ppass)->name));
  198.     (*ppass)->name[ sizeof((*ppass)->name)-1 ] = 0;
  199.     (*ppass)->next = NULL;
  201.     register_mib("pass", (struct variable *) extensible_passthru_variables,
  202.                  sizeof(struct variable2),
  203.                  1, (*ppass)->miboid, (*ppass)->miblen);
  205.     /*
  206.      * argggg -- pasthrus must be sorted 
  207.      */
  208.     if (numpassthrus > 1) {
  209.         etmp = (struct extensible **)
  210.             malloc(((sizeof(struct extensible *)) * numpassthrus));
  211.         if (etmp == NULL)
  212.             return;
  214.         for (i = 0, ptmp = (struct extensible *) passthrus;
  215.              i < numpassthrus && ptmp != 0; i++, ptmp = ptmp->next)
  216.             etmp[i] = ptmp;
  217.         qsort(etmp, numpassthrus, sizeof(struct extensible *),
  218.               pass_compare);
  219.         passthrus = (struct extensible *) etmp[0];
  220.         ptmp = (struct extensible *) etmp[0];
  222.         for (i = 0; i < numpassthrus - 1; i++) {
  223.             ptmp->next = etmp[i + 1];
  224.             ptmp = ptmp->next;
  225.         }
  226.         ptmp->next = NULL;
  227.         free(etmp);
  228.     }
  229. }
  231. void
  232. pass_free_config(void)
  233. {
  234.     struct extensible *etmp, *etmp2;
  236.     for (etmp = passthrus; etmp != NULL;) {
  237.         etmp2 = etmp;
  238.         etmp = etmp->next;
  239.         unregister_mib(etmp2->miboid, etmp2->miblen);
  240.         free(etmp2);
  241.     }
  242.     passthrus = NULL;
  243.     numpassthrus = 0;
  244. }
  246. u_char         *
  247. var_extensible_pass(struct variable *vp,
  248.                     oid * name,
  249.                     size_t * length,
  250.                     int exact,
  251.                     size_t * var_len, WriteMethod ** write_method)
  252. {
  253.     oid             newname[MAX_OID_LEN];
  254.     int             i, rtest, fd, newlen;
  255.     static long     long_ret;
  256.     char            buf[SNMP_MAXBUF];
  257.     static char     buf2[SNMP_MAXBUF];
  258.     static oid      objid[MAX_OID_LEN];
  259.     struct extensible *passthru;
  260.     FILE           *file;
  262.     long_ret = *length;
  263.     for (i = 1; i <= numpassthrus; i++) {
  264.         passthru = get_exten_instance(passthrus, i);
  265.         rtest = snmp_oid_min_compare(name, *length,
  266.                                      passthru->miboid, passthru->miblen);
  267.         if ((exact && rtest == 0) || (!exact && rtest <= 0)) {
  268.             /*
  269.              * setup args 
  270.              */
  271.             if (passthru->miblen >= *length || rtest < 0)
  272.                 sprint_mib_oid(buf, passthru->miboid, passthru->miblen);
  273.             else
  274.                 sprint_mib_oid(buf, name, *length);
  275.             if (exact)
  276.                 snprintf(passthru->command, sizeof(passthru->command),
  277.                          "%s -g %s", passthru->name, buf);
  278.             else
  279.                 snprintf(passthru->command, sizeof(passthru->command),
  280.                          "%s -n %s", passthru->name, buf);
  281.             passthru->command[ sizeof(passthru->command)-1 ] = 0;
  282.             DEBUGMSGTL(("ucd-snmp/pass", "pass-running:  %sn",
  283.                         passthru->command));
  284.             /*
  285.              * valid call.  Exec and get output 
  286.              */
  287.             if ((fd = get_exec_output(passthru)) != -1) {
  288.                 file = fdopen(fd, "r");
  289.                 if (fgets(buf, sizeof(buf), file) == NULL) {
  290.                     fclose(file);
  291.                     wait_on_exec(passthru);
  292.                     if (exact) {
  293.                         /*
  294.                          * to enable creation
  295.                          */
  296.                         *write_method = setPass;
  297.                         *var_len = 0;
  298.                         return (NULL);
  299.                     }
  300.                     continue;
  301.                 }
  302.                 newlen = parse_miboid(buf, newname);
  304.                 /*
  305.                  * its good, so copy onto name/length 
  306.                  */
  307.                 memcpy((char *) name, (char *) newname,
  308.                        (int) newlen * sizeof(oid));
  309.                 *length = newlen;
  311.                 /*
  312.                  * set up return pointer for setable stuff 
  313.                  */
  314.                 *write_method = setPass;
  316.                 if (newlen == 0 || fgets(buf, sizeof(buf), file) == NULL
  317.                     || fgets(buf2, sizeof(buf2), file) == NULL) {
  318.                     *var_len = 0;
  319.                     fclose(file);
  320.                     wait_on_exec(passthru);
  321.                     return (NULL);
  322.                 }
  323.                 fclose(file);
  324.                 wait_on_exec(passthru);
  326.                 /*
  327.                  * buf contains the return type, and buf2 contains the data 
  328.                  */
  329.                 if (!strncasecmp(buf, "string", 6)) {
  330.                     buf2[strlen(buf2) - 1] = 0; /* zap the linefeed */
  331.                     *var_len = strlen(buf2);
  332.                     vp->type = ASN_OCTET_STR;
  333.                     return ((unsigned char *) buf2);
  334.                 } else if (!strncasecmp(buf, "integer", 7)) {
  335.                     *var_len = sizeof(long_ret);
  336.                     long_ret = strtol(buf2, NULL, 10);
  337.                     vp->type = ASN_INTEGER;
  338.                     return ((unsigned char *) &long_ret);
  339.                 } else if (!strncasecmp(buf, "unsigned", 8)) {
  340.                     *var_len = sizeof(long_ret);
  341.                     long_ret = strtoul(buf2, NULL, 10);
  342.                     vp->type = ASN_UNSIGNED;
  343.                     return ((unsigned char *) &long_ret);
  344.                 } else if (!strncasecmp(buf, "counter", 7)) {
  345.                     *var_len = sizeof(long_ret);
  346.                     long_ret = strtoul(buf2, NULL, 10);
  347.                     vp->type = ASN_COUNTER;
  348.                     return ((unsigned char *) &long_ret);
  349.                 } else if (!strncasecmp(buf, "octet", 5)) {
  350.                     *var_len = asc2bin(buf2);
  351.                     vp->type = ASN_OCTET_STR;
  352.                     return ((unsigned char *) buf2);
  353.                 } else if (!strncasecmp(buf, "opaque", 6)) {
  354.                     *var_len = asc2bin(buf2);
  355.                     vp->type = ASN_OPAQUE;
  356.                     return ((unsigned char *) buf2);
  357.                 } else if (!strncasecmp(buf, "gauge", 5)) {
  358.                     *var_len = sizeof(long_ret);
  359.                     long_ret = strtoul(buf2, NULL, 10);
  360.                     vp->type = ASN_GAUGE;
  361.                     return ((unsigned char *) &long_ret);
  362.                 } else if (!strncasecmp(buf, "objectid", 8)) {
  363.                     newlen = parse_miboid(buf2, objid);
  364.                     *var_len = newlen * sizeof(oid);
  365.                     vp->type = ASN_OBJECT_ID;
  366.                     return ((unsigned char *) objid);
  367.                 } else if (!strncasecmp(buf, "timetick", 8)) {
  368.                     *var_len = sizeof(long_ret);
  369.                     long_ret = strtoul(buf2, NULL, 10);
  370.                     vp->type = ASN_TIMETICKS;
  371.                     return ((unsigned char *) &long_ret);
  372.                 } else if (!strncasecmp(buf, "ipaddress", 9)) {
  373.                     newlen = parse_miboid(buf2, objid);
  374.                     if (newlen != 4) {
  375.                         snmp_log(LOG_ERR,
  376.                                  "invalid ipaddress returned:  %sn",
  377.                                  buf2);
  378.                         *var_len = 0;
  379.                         return (NULL);
  380.                     }
  381.                     long_ret =
  382.                         (objid[0] << (8 * 3)) + (objid[1] << (8 * 2)) +
  383.                         (objid[2] << 8) + objid[3];
  384.                     long_ret = htonl(long_ret);
  385.                     *var_len = sizeof(long_ret);
  386.                     vp->type = ASN_IPADDRESS;
  387.                     return ((unsigned char *) &long_ret);
  388.                 }
  389.             }
  390.             *var_len = 0;
  391.             return (NULL);
  392.         }
  393.     }
  394.     if (var_len)
  395.         *var_len = 0;
  396.     *write_method = NULL;
  397.     return (NULL);
  398. }
  400. int
  401. setPass(int action,
  402.         u_char * var_val,
  403.         u_char var_val_type,
  404.         size_t var_val_len, u_char * statP, oid * name, size_t name_len)
  405. {
  406.     int             i, rtest;
  407.     struct extensible *passthru;
  409.     char            buf[SNMP_MAXBUF], buf2[SNMP_MAXBUF];
  410.     long            tmp;
  411.     unsigned long   utmp;
  413.     for (i = 1; i <= numpassthrus; i++) {
  414.         passthru = get_exten_instance(passthrus, i);
  415.         rtest = snmp_oid_min_compare(name, name_len,
  416.                                      passthru->miboid, passthru->miblen);
  417.         if (rtest <= 0) {
  418.             if (action != ACTION)
  419.                 return SNMP_ERR_NOERROR;
  420.             /*
  421.              * setup args 
  422.              */
  423.             if (passthru->miblen >= name_len || rtest < 0)
  424.                 sprint_mib_oid(buf, passthru->miboid, passthru->miblen);
  425.             else
  426.                 sprint_mib_oid(buf, name, name_len);
  427.             snprintf(passthru->command, sizeof(passthru->command),
  428.                      "%s -s %s ", passthru->name, buf);
  429.             passthru->command[ sizeof(passthru->command)-1 ] = 0;
  430.             switch (var_val_type) {
  431.             case ASN_INTEGER:
  432.             case ASN_COUNTER:
  433.             case ASN_GAUGE:
  434.             case ASN_TIMETICKS:
  435.                 tmp = *((long *) var_val);
  436.                 switch (var_val_type) {
  437.                 case ASN_INTEGER:
  438.                     sprintf(buf, "integer %dn", (int) tmp);
  439.                     break;
  440.                 case ASN_COUNTER:
  441.                     sprintf(buf, "counter %dn", (int) tmp);
  442.                     break;
  443.                 case ASN_GAUGE:
  444.                     sprintf(buf, "gauge %dn", (int) tmp);
  445.                     break;
  446.                 case ASN_TIMETICKS:
  447.                     sprintf(buf, "timeticks %dn", (int) tmp);
  448.                     break;
  449.                 }
  450.                 break;
  451.             case ASN_IPADDRESS:
  452.                 utmp = *((u_long *) var_val);
  453.                 utmp = ntohl(utmp);
  454.                 sprintf(buf, "ipaddress %d.%d.%d.%dn",
  455.                         (int) ((utmp & 0xff000000) >> (8 * 3)),
  456.                         (int) ((utmp & 0xff0000) >> (8 * 2)),
  457.                         (int) ((utmp & 0xff00) >> (8)),
  458.                         (int) ((utmp & 0xff)));
  459.                 break;
  460.             case ASN_OCTET_STR:
  461.                 memcpy(buf2, var_val, var_val_len);
  462.                 if (var_val_len == 0)
  463.                     sprintf(buf, "string ""n");
  464.                 else if (bin2asc(buf2, var_val_len) == (int) var_val_len)
  465.                     snprintf(buf, sizeof(buf), "string "%s"n", buf2);
  466.                 else
  467.                     snprintf(buf, sizeof(buf), "octet "%s"n", buf2);
  468.                 buf[ sizeof(buf)-1 ] = 0;
  469.                 break;
  470.             case ASN_OBJECT_ID:
  471.                 sprint_mib_oid(buf2, (oid *) var_val, var_val_len);
  472.                 snprintf(buf, sizeof(buf), "objectid "%s"n", buf2);
  473.                 buf[ sizeof(buf)-1 ] = 0;
  474.                 break;
  475.             }
  476.             strncat(passthru->command, buf, sizeof(passthru->command));
  477.             passthru->command[ sizeof(passthru->command)-1 ] = 0;
  478.             DEBUGMSGTL(("ucd-snmp/pass", "pass-running:  %s",
  479.                         passthru->command));
  480.             exec_command(passthru);
  481.             DEBUGMSGTL(("ucd-snmp/pass", "pass-running returned: %s",
  482.                         passthru->output));
  483.             if (!strncasecmp(passthru->output, "not-writable", 12)) {
  484.                 return SNMP_ERR_NOTWRITABLE;
  485.             } else if (!strncasecmp(passthru->output, "wrong-type", 10)) {
  486.                 return SNMP_ERR_WRONGTYPE;
  487.             }
  488.             return SNMP_ERR_NOERROR;
  489.         }
  490.     }
  491.     if (snmp_get_do_debugging()) {
  492.         sprint_mib_oid(buf2, name, name_len);
  493.         DEBUGMSGTL(("ucd-snmp/pass", "pass-notfound:  %sn", buf2));
  494.     }
  495.     return SNMP_ERR_NOSUCHNAME;
  496. }
  498. int
  499. pass_compare(const void *a, const void *b)
  500. {
  501.     const struct extensible *const *ap, *const *bp;
  502.     ap = (const struct extensible * const *) a;
  503.     bp = (const struct extensible * const *) b;
  504.     return snmp_oid_compare((*ap)->miboid, (*ap)->miblen, (*bp)->miboid,
  505.                             (*bp)->miblen);
  506. }