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

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

SNMP编程

开发平台：

Unix_Linux

expValueTable.c：源码内容
  1. /*
  2.  *Copyright(c)2004,Cisco URP imburses and Network Information Center in Beijing University of Posts and Telecommunications researches.
  3.  *
  4.  *All right reserved
  5.  *
  6.  *File Name: expValueTable.c
  7.  *File Description: expValueTable MIB operation.
  8.  *
  9.  *Current Version:1.0
  10.  *Author:JianShun Tong
  11.  *Date:2004.8.20
  12.  */
  15. /*
  16.  * This file was generated by mib2c and is intended for use as
  17.  * a mib module for the ucd-snmp snmpd agent. 
  18.  */
  21. /*
  22.  * This should always be included first before anything else 
  23.  */
  24. #include <net-snmp/net-snmp-config.h>
  25. #if HAVE_STDLIB_H
  26. #include <stdlib.h>
  27. #endif
  29. #include <stdio.h>
  31. #if HAVE_STRING_H
  32. #include <string.h>
  33. #else
  34. #include <strings.h>
  35. #endif
  36. #ifdef HAVE_LIMITS_H
  37. #include <limits.h>
  38. #endif
  41. /*
  42.  * minimal include directives 
  43.  */
  44. #include <net-snmp/net-snmp-includes.h>
  45. #include <net-snmp/agent/net-snmp-agent-includes.h>
  46. #include "header_complex.h"
  47. #include "expExpressionTable.h"
  48. #include "expValueTable.h"
  49. #include "expObjectTable.h"
  52. /*
  53.  * expValueTable_variables_oid:
  54.  *   this is the top level oid that we want to register under.  This
  55.  *   is essentially a prefix, with the suffix appearing in the
  56.  *   variable below.
  57.  */
  59. oid             expValueTable_variables_oid[] =
  60.     { 1, 3, 6, 1, 2, 1, 90, 1, 3, 1 };
  62. struct s_node {
  63.     unsigned        data;
  64.     struct s_node  *next;
  65. };
  66. typedef struct s_node link;
  67. link           *operater = NULL;
  68. link           *operand = NULL;
  70. /*
  71.  * variable2 expObjectTable_variables:
  72.  */
  74. struct variable2 expValueTable_variables[] = {
  75.     /*
  76.      * magic number        , variable type , ro/rw , callback fn  , L, oidsuffix 
  77.      */
  78. #define EXPVALUECOUNTER32VAL 2
  79.     {EXPVALUECOUNTER32VAL,  ASN_COUNTER,  RONLY, var_expValueTable, 2, {1, 2}},
  80. #define EXPVALUEUNSIGNED32VAL 3
  81.     {EXPVALUEUNSIGNED32VAL, ASN_UNSIGNED, RONLY, var_expValueTable, 2, {1, 3}},
  82. #define EXPVALUETIMETICKSVAL 4
  83.     {EXPVALUETIMETICKSVAL,  ASN_UNSIGNED, RONLY, var_expValueTable, 2, {1, 4}},
  84. #define EXPVALUEINTEGER32VAL 5
  85.     {EXPVALUEINTEGER32VAL,  ASN_INTEGER,  RONLY, var_expValueTable, 2, {1, 5}},
  86. #define EXPVALUEIPADDRESSVAL 6
  87.     {EXPVALUEIPADDRESSVAL, ASN_IPADDRESS, RONLY, var_expValueTable, 2, {1, 6}},
  88. #define EXPVALUEOCTETSTRINGVAL 7
  89.     {EXPVALUEOCTETSTRINGVAL, ASN_OCTET_STR, RONLY, var_expValueTable, 2, {1, 7}},
  90. #define EXPVALUEOIDVAL  8
  91.     {EXPVALUEOIDVAL,       ASN_OBJECT_ID, RONLY, var_expValueTable, 2, {1, 8}},
  92. #define EXPVALUECOUNTER64VAL  9
  93.     {EXPVALUECOUNTER64VAL, ASN_INTEGER,   RONLY, var_expValueTable, 2, {1, 9}}
  94. };
  97. /*
  98.  * global storage of our data, saved in and configured by header_complex() 
  99.  */
  100. extern struct header_complex_index *expExpressionTableStorage;
  101. extern struct header_complex_index *expObjectTableStorage;
  102. struct header_complex_index *expValueTableStorage = NULL;
  103. struct snmp_session session;
  105. /*
  106.  * init_expValueTable():
  107.  *   Initialization routine.  This is called when the agent starts up.
  108.  *   At a minimum, registration of your variables should take place here.
  109.  */
  110. void
  111. init_expValueTable(void)
  112. {
  113.     DEBUGMSGTL(("expValueTable", "initializing...  "));
  116.     /*
  117.      * register ourselves with the agent to handle our mib tree 
  118.      */
  119.     REGISTER_MIB("expValueTable",
  120.                  expValueTable_variables, variable2,
  121.                  expValueTable_variables_oid);
  122.     init_snmp("snmpapp");
  124.     /*
  125.      * Initialize a "session" that defines who we're going to talk to
  126.      */
  127.     snmp_sess_init(&session);   /* set up defaults */
  128.     session.peername = "localhost";
  130.     DEBUGMSGTL(("expValueTable", "done.n"));
  131. }
  133. struct expValueTable_data *
  134. create_expValueTable_data(void)
  135. {
  136.     struct expValueTable_data *StorageNew;
  138.     StorageNew = SNMP_MALLOC_STRUCT(expValueTable_data);
  140.     /*
  141.      * fill in default row values here into StorageNew 
  142.      */
  143.     /*
  144.      * fill in values for all tables (even if not
  145.      * appropriate), since its easier to do here than anywhere
  146.      * else 
  147.      */
  148.     StorageNew->expExpressionOwner = strdup("");
  149.     StorageNew->expExpressionName = strdup("");
  150.     StorageNew->expValueInstance = calloc(1, sizeof(oid) * sizeof(2));  /* 0.0.0 */
  151.     StorageNew->expValueInstanceLen = 3;
  152.     return StorageNew;
  153. }
  155. /*
  156.  * mteTriggerTable_add(): adds a structure node to our data set 
  157.  */
  158. int
  159. expValueTable_add(struct expExpressionTable_data *expression_data,
  160.                   char *owner, size_t owner_len, char *name,
  161.                   size_t name_len, oid * index, size_t index_len)
  162. {
  163.     netsnmp_variable_list *vars = NULL;
  164.     struct expValueTable_data *thedata, *StorageTmp;
  165.     struct header_complex_index *hcindex;
  166.     int             founded = 0;
  167.     thedata = create_expValueTable_data();
  168.     thedata->expValueCounter32Val = 0;
  169.     thedata->expExpressionOwner = owner;
  170.     thedata->expExpressionOwnerLen = owner_len;
  171.     thedata->expExpressionName = name;
  172.     thedata->expExpressionNameLen = name_len;
  173.     thedata->expValueInstance = index;
  174.     thedata->expValueInstanceLen = index_len;
  175.     thedata->expression_data = expression_data;
  176.     DEBUGMSGTL(("expValueTable", "adding data...  "));
  177.     /*
  178.      * add the index variables to the varbind list, which is 
  179.      * used by header_complex to index the data 
  180.      */
  183.     snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, (char *) thedata->expExpressionOwner, thedata->expExpressionOwnerLen);     /* expExpressionOwner */
  184.     snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, (char *) thedata->expExpressionName, thedata->expExpressionNameLen);       /* expExpressionName */
  185.     snmp_varlist_add_variable(&vars, NULL, 0, ASN_PRIV_IMPLIED_OBJECT_ID,
  186.                               (u_char *) thedata->expValueInstance,
  187.                               thedata->expValueInstanceLen * sizeof(oid));
  189.     for (hcindex = expValueTableStorage; hcindex != NULL;
  190.          hcindex = hcindex->next) {
  191.         StorageTmp = (struct expValueTable_data *) hcindex->data;
  192.         if (!strcmp
  193.             (StorageTmp->expExpressionOwner, thedata->expExpressionOwner)
  194.             && (StorageTmp->expExpressionOwnerLen ==
  195.                 thedata->expExpressionOwnerLen)
  196.             && !strcmp(StorageTmp->expExpressionName,
  197.                        thedata->expExpressionName)
  198.             && (StorageTmp->expExpressionNameLen ==
  199.                 thedata->expExpressionNameLen)
  200.             && !snmp_oid_compare(StorageTmp->expValueInstance,
  201.                                  StorageTmp->expValueInstanceLen,
  202.                                  thedata->expValueInstance,
  203.                                  thedata->expValueInstanceLen)) {
  204.             founded = 1;
  205.             break;
  206.         }
  208.     }
  209.     if (!founded) {
  210.         header_complex_add_data(&expValueTableStorage, vars, thedata);
  211.         DEBUGMSGTL(("expValueTable", "registered an entryn"));
  212.     } else {
  213.         SNMP_FREE(thedata);
  214.         DEBUGMSGTL(("expValueTable",
  215.                     "already have an entry, dont registen"));
  216.     }
  219.     DEBUGMSGTL(("expValueTable", "done.n"));
  220.     return SNMPERR_SUCCESS;
  221. }
  227. unsigned long
  228. Evaluate_Expression(struct expValueTable_data *vtable_data)
  229. {
  231.     struct header_complex_index *hcindex;
  232.     struct expObjectTable_data *objstorage, *objfound;
  233.     struct expValueTable_data *valstorage;
  234.     valstorage = vtable_data;
  236.     char           *expression;
  237.     char           *result, *resultbak;
  238.     char           *temp, *tempbak;
  239.     char            intchar[10];
  240.     int             dollar1, dollar2;
  241.     int             i = 0, j, k, l;
  242.     long            value;
  243.     unsigned long   result_u_long;
  244.     temp = malloc(100);
  245.     result = malloc(100);
  246.     tempbak = temp;
  247.     memset(result, 0, 100);
  248.     *result = '';
  249.     resultbak = result;
  251.     expression = vtable_data->expression_data->expExpression;
  253.     while (*expression != '') {
  254.         if (*expression == '$') {
  255.             objfound = NULL;
  256.             i++;
  257.             for (j = 1; j < 100; j++) {
  258.                 if ((*(expression + j) == '+') ||
  259.                     (*(expression + j) == '-') ||
  260.                     (*(expression + j) == '*') ||
  261.                     (*(expression + j) == '/') ||
  262.                     (*(expression + j) == '(') ||
  263.                     (*(expression + j) == ')') ||
  264.                     *(expression + j) == '') {
  265.                     break;
  266.                 }
  267.             }
  268.             strncpy(temp, expression + 1, j - 1);
  269.             *(temp + j - 1) = '';
  270.             l = atoi(temp);
  271.             expression = expression + j;
  272.             /*
  273.              *   here use snmpget to get value
  274.              */
  275.             for (hcindex = expObjectTableStorage; hcindex != NULL;
  276.                  hcindex = hcindex->next) {
  277.                 objstorage = (struct expObjectTable_data *) hcindex->data;
  278.                 if (!strcmp
  279.                     (objstorage->expExpressionOwner,
  280.                      valstorage->expExpressionOwner)
  281.                     && (objstorage->expExpressionOwnerLen ==
  282.                         valstorage->expExpressionOwnerLen)
  283.                     && !strcmp(objstorage->expExpressionName,
  284.                                valstorage->expExpressionName)
  285.                     && (objstorage->expExpressionNameLen ==
  286.                         valstorage->expExpressionNameLen)
  287.                     && (l == objstorage->expObjectIndex)) {
  288.                     objfound = objstorage;
  289.                     break;
  290.                 }
  291.             }
  294.             if (!objfound) {
  295.                 /* have err */
  296.                 return 0;
  297.             }
  298.             struct snmp_session *ss;
  299.             struct snmp_pdu *pdu;
  300.             struct snmp_pdu *response;
  302.             oid             anOID[MAX_OID_LEN];
  303.             size_t          anOID_len;
  305.             memcpy(anOID, objfound->expObjectID,
  306.                    objfound->expObjectIDLen * sizeof(oid));
  307.             anOID_len = objfound->expObjectIDLen;
  308.             if (objfound->expObjectIDWildcard == EXPOBJCETIDWILDCARD_TRUE) {
  309.                 anOID_len =
  310.                     anOID_len + valstorage->expValueInstanceLen - 2;
  311.                 memcpy(anOID + objfound->expObjectIDLen,
  312.                        valstorage->expValueInstance + 2,
  313.                        (valstorage->expValueInstanceLen -
  314.                         2) * sizeof(oid));
  315.             }
  316.             struct variable_list *vars;
  317.             int             status;
  318.             int             count = 1;
  320.             /*
  321.              * Initialize the SNMP library
  322.              */
  324.             /*
  325.              * Initialize a "session" that defines who we're going to talk to
  326.              */
  327.             session.version = vtable_data->expression_data->pdu_version;
  329.             /*
  330.              * set the SNMPv1 community name used for authentication 
  331.              */
  332.             session.community =
  333.                 vtable_data->expression_data->pdu_community;
  334.             session.community_len =
  335.                 vtable_data->expression_data->pdu_community_len;
  336.             /*
  337.              * Open the session
  338.              */
  339.             SOCK_STARTUP;
  340.             ss = snmp_open(&session);   /* establish the session */
  342.             if (!ss) {
  343.                 /* err */
  344.                 exit(2);
  345.             }
  346.             pdu = snmp_pdu_create(SNMP_MSG_GET);
  347.             snmp_add_null_var(pdu, anOID, anOID_len);
  349.             /*
  350.              * Send the Request out.
  351.              */
  352.             status = snmp_synch_response(ss, pdu, &response);
  354.             /*
  355.              * Process the response.
  356.              */
  357.             if (status == STAT_SUCCESS
  358.                 && response->errstat == SNMP_ERR_NOERROR) {
  359.                 /*
  360.                  * SUCCESS: Print the result variables
  361.                  */
  363.                 vars = response->variables;
  364.                 value = *(vars->val.integer);
  365.                 sprintf(intchar, "%u", value);
  366.                 for (k = 1; k <= strlen(intchar); k++) {
  367.                     *result = intchar[k - 1];
  368.                     result++;
  369.                 }
  371.             } else {
  372.                 /*
  373.                  * FAILURE: print what went wrong!
  374.                  */
  376.                 if (status == STAT_SUCCESS)
  377.                     fprintf(stderr, "Error in packetnReason: %sn",
  378.                             snmp_errstring(response->errstat));
  379.                 else
  380.                     snmp_sess_perror("snmpget", ss);
  382.             }
  384.             /*
  385.              * Clean up:
  386.              *  1) free the response.
  387.              *  2) close the session.
  388.              */
  389.             if (response)
  390.                 snmp_free_pdu(response);
  391.             snmp_close(ss);
  393.             SOCK_CLEANUP;
  395.         } else {
  396.             *result = *expression;
  397.             result++;
  398.             expression++;
  399.         }
  400.     }
  401.     result_u_long = get_result(resultbak);
  402.     free(tempbak);
  403.     free(resultbak);
  404.     return result_u_long;
  405. }
  414. void
  415. expValueTable_clean(void *data)
  416. {
  417.     struct expValueTable_data *cleanme =
  418.         (struct expValueTable_data *) data;
  419.     SNMP_FREE(cleanme->expValueInstance);
  420.     SNMP_FREE(cleanme->expValueIpAddressVal);
  421.     SNMP_FREE(cleanme->expValueOctetStringVal);
  422.     SNMP_FREE(cleanme->expValueOidVal);
  423.     SNMP_FREE(cleanme);
  424. }
  428. void
  429. build_valuetable()
  430. {
  431.     struct expExpressionTable_data *expstorage, *expfound;
  432.     struct expObjectTable_data *objstorage, *objfound = NULL;
  433.     struct header_complex_index *hcindex, *object_hcindex;
  434.     char           *owner;
  435.     size_t          owner_len;
  436.     char           *name;
  437.     size_t          name_len;
  438.     char           *expression;
  439.     size_t          expression_len;
  440.     oid            *index;
  443.     char           *result, *resultbak;
  444.     char           *temp, *tempbak;
  445.     int             i = 0, j, k, l;
  446.     temp = malloc(100);
  447.     result = malloc(100);
  448.     tempbak = temp;
  449.     memset(result, 0, 100);
  450.     *result = '';
  451.     resultbak = result;
  454.     DEBUGMSGTL(("expValueTable", "building valuetable...  n"));
  456.     for (hcindex = expExpressionTableStorage; hcindex != NULL;
  457.          hcindex = hcindex->next) {
  458.         expstorage = (struct expExpressionTable_data *) hcindex->data;
  459.         if (expstorage->expExpressionEntryStatus == RS_ACTIVE) {
  460.             expression = expstorage->expExpression;
  461.             expression_len = expstorage->expExpressionLen;
  462.             while (*expression != '') {
  463.                 if (*expression == '$') {
  464.                     i++;
  465.                     for (j = 1; j < 100; j++) {
  466.                         if ((*(expression + j) == '+') ||
  467.                             (*(expression + j) == '-') ||
  468.                             (*(expression + j) == '*') ||
  469.                             (*(expression + j) == '/') ||
  470.                             (*(expression + j) == '(') ||
  471.                             (*(expression + j) == ')') ||
  472.                             *(expression + j) == '') {
  473.                             break;
  474.                         }
  475.                     }
  476.                     strncpy(temp, expression + 1, j - 1);
  477.                     *(temp + j - 1) = '';
  478.                     l = atoi(temp);
  479.                     for (object_hcindex = expObjectTableStorage;
  480.                          object_hcindex != NULL;
  481.                          object_hcindex = object_hcindex->next) {
  482.                         objstorage =
  483.                             (struct expObjectTable_data *) object_hcindex->
  484.                             data;
  485.                         if (!strcmp
  486.                             (objstorage->expExpressionOwner,
  487.                              expstorage->expExpressionOwner)
  488.                             && (objstorage->expExpressionOwnerLen ==
  489.                                 expstorage->expExpressionOwnerLen)
  490.                             && !strcmp(objstorage->expExpressionName,
  491.                                        expstorage->expExpressionName)
  492.                             && (objstorage->expExpressionNameLen ==
  493.                                 expstorage->expExpressionNameLen)
  494.                             && (l == objstorage->expObjectIndex)) {
  495.                             if (objfound == NULL) {
  496.                                 expfound = expstorage;
  497.                                 objfound = objstorage;
  498.                             }
  499.                             if (objstorage->expObjectIDWildcard ==
  500.                                 EXPOBJCETIDWILDCARD_TRUE)
  501.                                 objfound = objstorage;
  502.                         }
  503.                     }
  504.                     expression = expression + j;
  505.                 } else {
  506.                     expression++;
  507.                 }
  508.             };
  509.         }
  511.         if (!objfound) {
  512.             continue;
  513.         }
  514.         if (objfound->expObjectIDWildcard == EXPOBJCETIDWILDCARD_FALSE) {
  515.             index = calloc(1, MAX_OID_LEN);
  516.             *index = 0;
  517.             *(index + 1) = 0;
  518.             *(index + 2) = 0;
  519.             expValueTable_add(expstorage, objfound->expExpressionOwner,
  520.                               objfound->expExpressionOwnerLen,
  521.                               objfound->expExpressionName,
  522.                               objfound->expExpressionNameLen, index, 3);
  523.         } else {
  524.             oid            *targetOID;
  525.             size_t          taggetOID_len;
  526.             targetOID = objfound->expObjectID;
  527.             struct snmp_pdu *pdu;
  528.             struct snmp_pdu *response;
  529.             oid            *next_OID;
  530.             size_t          next_OID_len;
  531.             taggetOID_len = objfound->expObjectIDLen;
  532.             struct variable_list *vars;
  533.             int             status;
  534.             int             count = 1;
  535.             struct snmp_session *ss;
  536.             /*
  537.              * Initialize the SNMP library
  538.              */
  541.             /*
  542.              * set the SNMP version number 
  543.              */
  544.             session.version = expstorage->pdu_version;
  546.             /*
  547.              * set the SNMPv1 community name used for authentication 
  548.              */
  549.             session.community = expstorage->pdu_community;
  550.             session.community_len = expstorage->pdu_community_len;
  552.             /*
  553.              * Open the session
  554.              */
  555.             SOCK_STARTUP;
  556.             ss = snmp_open(&session);   /* establish the session */
  557.             if (!ss) {
  558.                 snmp_perror("ack");
  559.                 snmp_log(LOG_ERR, "something horrible happened!!!n");
  560.                 exit(2);
  561.             }
  563.             next_OID = targetOID;
  564.             next_OID_len = taggetOID_len;
  565.             do {
  566.                 index = calloc(1, MAX_OID_LEN);
  567.                 pdu = snmp_pdu_create(SNMP_MSG_GETNEXT);
  569.                 snmp_add_null_var(pdu, next_OID, next_OID_len);
  571.                 /*
  572.                  * Send the Request out.
  573.                  */
  574.                 status = snmp_synch_response(ss, pdu, &response);
  576.                 /*
  577.                  * Process the response.
  578.                  */
  579.                 if (status == STAT_SUCCESS
  580.                     && response->errstat == SNMP_ERR_NOERROR) {
  581.                     /*
  582.                      * SUCCESS: Print the result variables
  583.                      */
  585.                     if (((response->variables->type >= SNMP_NOSUCHOBJECT &&
  586.                           response->variables->type <= SNMP_ENDOFMIBVIEW)
  587.                          || snmp_oid_compare(targetOID, taggetOID_len,
  588.                                              response->variables->name,
  589.                                              taggetOID_len) != 0)) {
  590.                         break;
  591.                     }
  592.                     /* add to expValueTable */
  594.                     *index = 0;
  595.                     *(index + 1) = 0;
  596.                     memcpy(index + 2,
  597.                            response->variables->name + taggetOID_len,
  598.                            (response->variables->name_length -
  599.                             taggetOID_len) * sizeof(oid));
  600.                     expValueTable_add(expstorage,
  601.                                       objfound->expExpressionOwner,
  602.                                       objfound->expExpressionOwnerLen,
  603.                                       objfound->expExpressionName,
  604.                                       objfound->expExpressionNameLen,
  605.                                       index,
  606.                                       response->variables->name_length -
  607.                                       taggetOID_len + 2);
  609.                     next_OID = response->variables->name;
  611.                     next_OID_len = response->variables->name_length;
  616.                 } else {
  617.                     /*
  618.                      * FAILURE: print what went wrong!
  619.                      */
  620.                     if (status == STAT_SUCCESS)
  621.                         fprintf(stderr, "Error in packetnReason: %sn",
  622.                                 snmp_errstring(response->errstat));
  623.                     else
  624.                         snmp_sess_perror("snmpget", ss);
  625.                 }
  626.             } while (TRUE);
  628.         }
  630.     }
  632. }
  636. /*
  637.  * var_expValueTable():
  638.  */
  639. unsigned char  *
  640. var_expValueTable(struct variable *vp,
  641.                   oid * name,
  642.                   size_t *length,
  643.                   int exact, size_t *var_len, WriteMethod ** write_method)
  644. {
  646.     static netsnmp_variable_list *vars;
  647.     size_t          newlen =
  648.         *length - (sizeof(expValueTable_variables_oid) / sizeof(oid) +
  649.                    3 - 1);
  650.     struct expValueTable_data *StorageTmp = NULL;
  651.     unsigned int    counter32;
  656.     DEBUGMSGTL(("expValueTable", "var_expValueTable: Entering...  n"));
  658.     /*
  659.      *  before we build valuetable we must free any other valutable if exist
  660.      */
  661.     header_complex_free_all(expValueTableStorage, expValueTable_clean);
  662.     expValueTableStorage = NULL;
  665.     build_valuetable();
  668.     /*
  669.      * this assumes you have registered all your data properly
  670.      */
  671.     if ((StorageTmp =
  672.          header_complex(expValueTableStorage, vp, name, length, exact,
  673.                         var_len, write_method)) == NULL)
  674.         return NULL;
  677.     /*
  678.      * this is where we do the value assignments for the mib results.
  679.      */
  680.     switch (vp->magic) {
  681.         /*
  682.          *   we only support counter32val
  683.          */
  685.     case EXPVALUECOUNTER32VAL:
  686.         StorageTmp->expValueCounter32Val = Evaluate_Expression(StorageTmp);
  687.         *var_len = sizeof(StorageTmp->expValueCounter32Val);
  688.         return (u_char *) & StorageTmp->expValueCounter32Val;
  690.     case EXPVALUEUNSIGNED32VAL:
  691.         /* var_len = sizeof(StorageTmp->expValueUnsigned32Val); */
  692.         /* return (u_char *) & StorageTmp->expValueUnsigned32Val;         */
  693.         return NULL;
  695.     case EXPVALUETIMETICKSVAL:
  696.         /* var_len = sizeof(StorageTmp->expValueTimeTicksVal); */
  697.         /* return (u_char *) & StorageTmp->expValueTimeTicksVal; */
  698.         return NULL;
  700.     case EXPVALUEINTEGER32VAL:
  701.         /* var_len = sizeof(StorageTmp->expValueInteger32Val); */
  702.         /* return (u_char *) & StorageTmp->expValueInteger32Val; */
  703.         return NULL;
  705.     case EXPVALUEIPADDRESSVAL:
  706.         /* var_len = sizeof(StorageTmp->expValueIpAddressVal); */
  707.         /* return (u_char *) & StorageTmp->expValueIpAddressVal; */
  708.         return NULL;
  710.     case EXPVALUEOCTETSTRINGVAL:
  711.         /* var_len = sizeof(StorageTmp->expValueOctetStringVal); */
  712.         /* return (u_char *) & StorageTmp->expValueOctetStringVal;        */
  713.         return NULL;
  715.     case EXPVALUEOIDVAL:
  716.         /* var_len = StorageTmp->expValueOidValLen; */
  717.         /* return (u_char *) & StorageTmp->expValueOidVal; */
  718.         return NULL;
  720.     case EXPVALUECOUNTER64VAL:
  721.         /* var_len = sizeof(StorageTmp->expValueCounter64Val); */
  722.         /* return (u_char *) & StorageTmp->expValueCounter64Val; */
  723.         return NULL;
  724.     default:
  725.         ERROR_MSG("");
  726.     }
  727. }
  733. void
  734. push(link ** stack, unsigned long value)
  735. {
  736.     link           *newnode;
  737.     newnode = (link *) malloc(sizeof(link));
  738.     if (!newnode) {
  739.         printf("nMemory allocation failure!");
  740.         return;
  741.     }
  742.     newnode->data = value;
  743.     newnode->next = *stack;
  744.     *stack = newnode;
  745. }
  747. unsigned long
  748. pop(link ** stack)
  749. {
  750.     unsigned long   value;
  751.     link           *top;
  752.     top = *stack;
  753.     *stack = (*stack)->next;
  754.     value = top->data;
  755.     free(top);
  756.     return value;
  757. }
  759. int
  760. priority(char operater)
  761. {
  762.     switch (operater) {
  763.     case '*':
  764.     case '/':
  765.         return 4;
  766.     case '+':
  767.     case '-':
  768.         return 3;
  769.     case ')':
  770.         return 2;
  771.     case '(':
  772.         return 1;
  773.     default:
  774.         return 0;
  775.     }
  776. }
  778. unsigned long
  779. calculate(int operater, unsigned long a, unsigned long b)
  780. {
  781.     switch (operater) {
  782.     case '+':
  783.         return (a + b);
  784.     case '-':
  785.         return (a - b);
  786.     case '*':
  787.         return (a * b);
  788.     case '/':
  789.         if (operater == '/' && b == 0) {
  790.             printf("nDivision mustn't be 0!");
  791.             exit(0);
  792.         } else
  793.             return (a / b);
  794.     }
  795. }
  797. unsigned long
  798. get_operand(char *p, int *length)
  799. {
  800.     char            c[13];
  801.     int             i = 0, k = 1;
  802.     unsigned long   result = 0;
  803.     while (*p <= 57 && *p >= 48)
  804.         c[i++] = *(p++);
  805.     *length += --i;
  806.     for (; i >= 0; i--) {
  807.         result += (c[i] - 48) * k;
  808.         k *= 10;
  809.     }
  810.     return result;
  811. }
  813. int
  814. operator_class(char c)
  815. {
  816.     if (c <= 57 && c >= 48)
  817.         return 1;
  818.     if (c == 42 || c == 43 || c == 45 || c == 47)
  819.         return 2;
  820.     if (c == 41)
  821.         return 3;
  822.     if (c == 40)
  823.         return 4;
  824.     return 0;
  825. }
  827. unsigned long
  828. get_result(char *expr)
  829. {
  830.     int             position = 0;
  831.     unsigned long   op = 0, a = 0, b = 0, result = 0;
  832.     char           *expression;
  833.     expression = expr;
  834.     while (*(expression + position) != ''
  835.            && *(expression + position) != 'n') {
  836.         switch (operator_class(*(expression + position))) {
  837.         case 1:
  838.             push(&operand, get_operand(expression + position, &position));
  839.             break;
  840.         case 2:
  841.             if (operater != NULL)
  842.                 while (operater != NULL
  843.                        && priority(*(expression + position)) <=
  844.                        priority(operater->data)) {
  845.                     a = pop(&operand);
  846.                     b = pop(&operand);
  847.                     op = pop(&operater);
  848.                     push(&operand, calculate(op, b, a));
  849.                 }
  850.             push(&operater, *(expression + position));
  851.             break;
  852.         case 3:
  853.             while (operater != NULL && operater->data != '(') {
  854.                 a = pop(&operand);
  855.                 b = pop(&operand);
  856.                 op = pop(&operater);
  857.                 push(&operand, calculate(op, b, a));
  858.             }
  859.             if (operater->data == '(')
  860.                 pop(&operater);
  861.             break;
  862.         case 4:
  863.             push(&operater, '(');
  864.             break;
  865.         default:
  866.             printf("nInvalid character in expression:");
  867.             a = 0;
  868.             while (*(expression + (int) a) != 'n'
  869.                    && *(expression + (int) a) != '') {
  870.                 if (a != position)
  871.                     printf("%c", *(expression + (int) a));
  872.                 else
  873.                     printf("<%c>", *(expression + (int) a));
  874.                 a++;
  875.             }
  876.             exit(0);
  877.         }                       /* end switch */
  878.         position++;
  879.     }
  880.     while (operater != NULL) {
  881.         op = pop(&operater);
  882.         a = pop(&operand);
  883.         b = pop(&operand);
  884.         push(&operand, calculate(op, b, a));
  885.     }
  886.     result = pop(&operand);
  887.     return result;
  888. }