invented snmp_var_new_integer() because I think snmp memory allocation belongs in...

diff --git a/include/snmp_vars.h b/include/snmp_vars.h
index 434c8956ca8306f703fb53f16288c6bd9ea3b697..614fe7dc88719aa4f84ff518b34e2125612b828a 100644 (file)
--- a/include/snmp_vars.h
+++ b/include/snmp_vars.h
@@ -26,7 +26,7 @@
  * 
  * Author: Ryan Troll <ryan+@andrew.cmu.edu>
  * 
- * $Id: snmp_vars.h,v 1.7 1998/04/04 01:43:51 kostas Exp $
+ * $Id: snmp_vars.h,v 1.8 1999/06/17 22:20:35 wessels Exp $
  * 
  **********************************************************************/
 
@@ -48,6 +48,7 @@ extern "C" {
 #endif
 
     struct variable_list *snmp_var_new(oid *, int);
+    struct variable_list *snmp_var_new_integer(oid *, int, int, unsigned char);
     struct variable_list *snmp_var_clone(struct variable_list *);
     void snmp_var_free(struct variable_list *);
 
@@ -58,8 +59,7 @@ extern "C" {
 }
 
 #endif
-#define MAX_NAME_LEN   64      /* number of subid's in a objid *//*      *RFC 1902:Structure of Management Information for SNMPv2
-*
+#define MAX_NAME_LEN   64      /* number of subid's in a objid *//*      *RFC 1902:Structure of Management Information for SNMPv2      *
       *Defined Types
 *
       */

diff --git a/snmplib/snmp_vars.c b/snmplib/snmp_vars.c
index aa284f5f812fc5a535643d1915e8e3e9b5cfb14e..de4085aa0b9646ad1a6795edf82689af3abc9f08 100644 (file)
--- a/snmplib/snmp_vars.c
+++ b/snmplib/snmp_vars.c
@@ -115,7 +115,8 @@ snmp_var_new(oid * Name, int Len)
     printf("VARS: Creating.\n");
 #endif
 
-    New = (struct variable_list *) xmalloc(sizeof(struct variable_list));
+    New = xmalloc(sizeof(*New));
+    /* XXX xmalloc never returns NULL */
     if (New == NULL) {
        snmp_set_api_error(SNMPERR_OS_ERR);
        return (NULL);
@@ -131,6 +132,7 @@ snmp_var_new(oid * Name, int Len)
        return (New);
     }
     New->name = (oid *) xmalloc(Len * sizeof(oid));
+    /* XXX xmalloc never returns NULL */
     if (New->name == NULL) {
        xfree(New);
        snmp_set_api_error(SNMPERR_OS_ERR);
@@ -147,6 +149,17 @@ snmp_var_new(oid * Name, int Len)
     return (New);
 }
 
+struct variable_list *
+snmp_var_new_integer(oid * Name, int Len, int ival, unsigned char type)
+{
+    variable_list *v = snmp_var_new(Name, Len);
+    v->val_len = sizeof(int);
+    v->val.integer = xmalloc(sizeof(int));
+    v->type = type;
+    *(v->val.integer) = ival;
+    return v;
+}
+
 /* Clone a variable list.
  *
  * Returns NULL upon error.
@@ -214,7 +227,7 @@ snmp_var_clone(struct variable_list *Src)
 
 /* Free a variable_list.
  */
-void 
+void
 snmp_var_free(struct variable_list *Ptr)
 {
     if (Ptr->name && Ptr->name_length > 0)

diff --git a/src/client_db.cc b/src/client_db.cc
index e9672377d852ab07100db9e2f0df47eb7097c6c9..1793d366a8c0d61bddba7b31ce57a50ca641b3fc 100644 (file)
--- a/src/client_db.cc
+++ b/src/client_db.cc
@@ -1,6 +1,6 @@
 
 /*
- * $Id: client_db.cc,v 1.45 1999/06/17 20:23:08 wessels Exp $
+ * $Id: client_db.cc,v 1.46 1999/06/17 22:20:36 wessels Exp $
  *
  * DEBUG: section 0     Client Database
  * AUTHOR: Duane Wessels
@@ -230,18 +230,14 @@ client_entry(struct in_addr *current)
 variable_list *
 snmp_meshCtblFn(variable_list * Var, snint * ErrP)
 {
-    variable_list *Answer;
+    variable_list *Answer = NULL;
     static char key[15];
     ClientInfo *c = NULL;
     int aggr = 0;
     log_type l;
-
-    Answer = snmp_var_new(Var->name, Var->name_length);
     *ErrP = SNMP_ERR_NOERROR;
-
     debug(49, 6) ("snmp_meshCtblFn: Current : \n");
     snmpDebugOid(6, Var->name, Var->name_length);
-
     snprintf(key, sizeof(key), "%d.%d.%d.%d", Var->name[LEN_SQ_NET + 3], Var->name[LEN_SQ_NET + 4],
        Var->name[LEN_SQ_NET + 5], Var->name[LEN_SQ_NET + 6]);
     debug(49, 5) ("snmp_meshCtblFn: [%s] requested!\n", key);
@@ -254,22 +250,19 @@ snmp_meshCtblFn(variable_list * Var, snint * ErrP)
     }
     switch (Var->name[LEN_SQ_NET + 2]) {
     case MESH_CTBL_ADDR:
-       Answer->type = SMI_IPADDRESS;
-       Answer->val_len = sizeof(snint);
-       Answer->val.integer = memAllocate(MEM_SNMP_SNINT);
-       *(Answer->val.integer) = (snint) c->addr.s_addr;
+       Answer = snmp_var_new_integer(Var->name, Var->name_length,
+           (snint) c->addr.s_addr,
+           SMI_IPADDRESS);
        break;
     case MESH_CTBL_HTBYTES:
-       Answer->val_len = sizeof(snint);
-       Answer->val.integer = memAllocate(MEM_SNMP_SNINT);
-       Answer->type = SMI_COUNTER32;
-       *(Answer->val.integer) = (snint) c->Http.kbytes_out.kb;
+       Answer = snmp_var_new_integer(Var->name, Var->name_length,
+           (snint) c->Http.kbytes_out.kb,
+           SMI_COUNTER32);
        break;
     case MESH_CTBL_HTREQ:
-       Answer->val_len = sizeof(snint);
-       Answer->val.integer = memAllocate(MEM_SNMP_SNINT);
-       Answer->type = SMI_COUNTER32;
-       *(Answer->val.integer) = (snint) c->Http.n_requests;
+       Answer = snmp_var_new_integer(Var->name, Var->name_length,
+           (snint) c->Http.n_requests,
+           SMI_COUNTER32);
        break;
     case MESH_CTBL_HTHITS:
        aggr = 0;
@@ -277,47 +270,40 @@ snmp_meshCtblFn(variable_list * Var, snint * ErrP)
            if (isTcpHit(l))
                aggr += c->Http.result_hist[l];
        }
-       Answer->val_len = sizeof(snint);
-       Answer->val.integer = memAllocate(MEM_SNMP_SNINT);
-       Answer->type = SMI_COUNTER32;
-       *(Answer->val.integer) = (snint) aggr;
+       Answer = snmp_var_new_integer(Var->name, Var->name_length,
+           (snint) aggr,
+           SMI_COUNTER32);
        break;
     case MESH_CTBL_HTHITBYTES:
-       Answer->val_len = sizeof(snint);
-       Answer->val.integer = memAllocate(MEM_SNMP_SNINT);
-       Answer->type = SMI_COUNTER32;
-       *(Answer->val.integer) = (snint) c->Http.hit_kbytes_out.kb;
+       Answer = snmp_var_new_integer(Var->name, Var->name_length,
+           (snint) c->Http.hit_kbytes_out.kb,
+           SMI_COUNTER32);
        break;
     case MESH_CTBL_ICPBYTES:
-       Answer->val_len = sizeof(snint);
-       Answer->val.integer = memAllocate(MEM_SNMP_SNINT);
-       Answer->type = SMI_COUNTER32;
-       *(Answer->val.integer) = (snint) c->Icp.kbytes_out.kb;
+       Answer = snmp_var_new_integer(Var->name, Var->name_length,
+           (snint) c->Icp.kbytes_out.kb,
+           SMI_COUNTER32);
        break;
     case MESH_CTBL_ICPREQ:
-       Answer->val_len = sizeof(snint);
-       Answer->val.integer = memAllocate(MEM_SNMP_SNINT);
-       Answer->type = SMI_COUNTER32;
-       *(Answer->val.integer) = (snint) c->Icp.n_requests;
+       Answer = snmp_var_new_integer(Var->name, Var->name_length,
+           (snint) c->Icp.n_requests,
+           SMI_COUNTER32);
        break;
     case MESH_CTBL_ICPHITS:
        aggr = c->Icp.result_hist[LOG_UDP_HIT];
-       Answer->val_len = sizeof(snint);
-       Answer->val.integer = memAllocate(MEM_SNMP_SNINT);
-       Answer->type = SMI_COUNTER32;
-       *(Answer->val.integer) = (snint) aggr;
+       Answer = snmp_var_new_integer(Var->name, Var->name_length,
+           (snint) aggr,
+           SMI_COUNTER32);
        break;
     case MESH_CTBL_ICPHITBYTES:
-       Answer->val_len = sizeof(snint);
-       Answer->val.integer = memAllocate(MEM_SNMP_SNINT);
-       Answer->type = SMI_COUNTER32;
-       *(Answer->val.integer) = (snint) c->Icp.hit_kbytes_out.kb;
+       Answer = snmp_var_new_integer(Var->name, Var->name_length,
+           (snint) c->Icp.hit_kbytes_out.kb,
+           SMI_COUNTER32);
        break;
     default:
        *ErrP = SNMP_ERR_NOSUCHNAME;
-       snmp_var_free(Answer);
        debug(49, 5) ("snmp_meshCtblFn: illegal column.\n");
-       return (NULL);
+       break;
     }
     return Answer;
 }

diff --git a/src/dns.cc b/src/dns.cc
index afc406f7d4afe4a5ce27489104f0f3e5258e31cc..72f479c21cdb873b401f67fa5b13889d799d5991 100644 (file)
--- a/src/dns.cc
+++ b/src/dns.cc
@@ -1,6 +1,6 @@
 
 /*
- * $Id: dns.cc,v 1.78 1999/06/17 20:23:09 wessels Exp $
+ * $Id: dns.cc,v 1.79 1999/06/17 22:20:37 wessels Exp $
  *
  * DEBUG: section 34    Dnsserver interface
  * AUTHOR: Harvest Derived
@@ -105,29 +105,30 @@ dnsSubmit(const char *lookup, HLPCB * callback, void *data)
 variable_list *
 snmp_netDnsFn(variable_list * Var, snint * ErrP)
 {
-    variable_list *Answer;
+    variable_list *Answer = NULL;
     debug(49, 5) ("snmp_netDnsFn: Processing request:\n", Var->name[LEN_SQ_NET +
            1]);
     snmpDebugOid(5, Var->name, Var->name_length);
-    Answer = snmp_var_new(Var->name, Var->name_length);
     *ErrP = SNMP_ERR_NOERROR;
-    Answer->val_len = sizeof(snint);
-    Answer->val.integer = memAllocate(MEM_SNMP_SNINT);
-    Answer->type = SMI_COUNTER32;
     switch (Var->name[LEN_SQ_NET + 1]) {
     case DNS_REQ:
-       *(Answer->val.integer) = dnsservers->stats.requests;
+       Answer = snmp_var_new_integer(Var->name, Var->name_length,
+           dnsservers->stats.requests,
+           SMI_COUNTER32);
        break;
     case DNS_REP:
-       *(Answer->val.integer) = dnsservers->stats.replies;
+       Answer = snmp_var_new_integer(Var->name, Var->name_length,
+           dnsservers->stats.replies,
+           SMI_COUNTER32);
        break;
     case DNS_SERVERS:
-       *(Answer->val.integer) = dnsservers->n_running;
+       Answer = snmp_var_new_integer(Var->name, Var->name_length,
+           dnsservers->n_running,
+           SMI_COUNTER32);
        break;
     default:
        *ErrP = SNMP_ERR_NOSUCHNAME;
-       snmp_var_free(Answer);
-       return (NULL);
+       break;
     }
     return Answer;
 }

diff --git a/src/enums.h b/src/enums.h
index e3a330fa68b0c45e6410842b597088a38b512601..c16695d58ac7a7045ab8d45fcf3b86d6b830f584 100644 (file)
--- a/src/enums.h
+++ b/src/enums.h
@@ -1,6 +1,6 @@
 
 /*
- * $Id: enums.h,v 1.155 1999/06/17 20:23:10 wessels Exp $
+ * $Id: enums.h,v 1.156 1999/06/17 22:20:38 wessels Exp $
  *
  *
  * SQUID Internet Object Cache  http://squid.nlanr.net/Squid/
@@ -558,9 +558,6 @@ typedef enum {
     MEM_STORE_IO,
     MEM_IDNS_QUERY,
     MEM_EVENT,
-#if SQUID_SNMP
-    MEM_SNMP_SNINT,
-#endif
     MEM_MAX
 } mem_type;
 

diff --git a/src/fqdncache.cc b/src/fqdncache.cc
index d883a6f22b74e1a1c7a16e2e0d7118f2bc1670bb..7c26b0dbbc897fb4bbc6ec9cda6b9d493132320a 100644 (file)
--- a/src/fqdncache.cc
+++ b/src/fqdncache.cc
@@ -1,7 +1,7 @@
 
 
 /*
- * $Id: fqdncache.cc,v 1.130 1999/06/17 20:23:11 wessels Exp $
+ * $Id: fqdncache.cc,v 1.131 1999/06/17 22:20:39 wessels Exp $
  *
  * DEBUG: section 35    FQDN Cache
  * AUTHOR: Harvest Derived
@@ -680,46 +680,50 @@ fqdncache_restart(void)
 variable_list *
 snmp_netFqdnFn(variable_list * Var, snint * ErrP)
 {
-    variable_list *Answer;
-
+    variable_list *Answer = NULL;
     debug(49, 5) ("snmp_netFqdnFn: Processing request:\n", Var->name[LEN_SQ_NET +
            1]);
     snmpDebugOid(5, Var->name, Var->name_length);
-
-    Answer = snmp_var_new(Var->name, Var->name_length);
     *ErrP = SNMP_ERR_NOERROR;
-    Answer->val_len = sizeof(snint);
-    Answer->val.integer = memAllocate(MEM_SNMP_SNINT);
-    Answer->type = SMI_COUNTER32;
-
     switch (Var->name[LEN_SQ_NET + 1]) {
     case FQDN_ENT:
-       *(Answer->val.integer) = memInUse(MEM_FQDNCACHE_ENTRY);
-       Answer->type = SMI_GAUGE32;
+       Answer = snmp_var_new_integer(Var->name, Var->name_length,
+           memInUse(MEM_FQDNCACHE_ENTRY),
+           SMI_GAUGE32);
        break;
     case FQDN_REQ:
-       *(Answer->val.integer) = FqdncacheStats.requests;
+       Answer = snmp_var_new_integer(Var->name, Var->name_length,
+           FqdncacheStats.requests,
+           SMI_COUNTER32);
        break;
     case FQDN_HITS:
-       *(Answer->val.integer) = FqdncacheStats.hits;
+       Answer = snmp_var_new_integer(Var->name, Var->name_length,
+           FqdncacheStats.hits,
+           SMI_COUNTER32);
        break;
     case FQDN_PENDHIT:
-       *(Answer->val.integer) = FqdncacheStats.pending_hits;
-       Answer->type = SMI_GAUGE32;
+       Answer = snmp_var_new_integer(Var->name, Var->name_length,
+           FqdncacheStats.pending_hits,
+           SMI_GAUGE32);
        break;
     case FQDN_NEGHIT:
-       *(Answer->val.integer) = FqdncacheStats.negative_hits;
+       Answer = snmp_var_new_integer(Var->name, Var->name_length,
+           FqdncacheStats.negative_hits,
+           SMI_COUNTER32);
        break;
     case FQDN_MISS:
-       *(Answer->val.integer) = FqdncacheStats.misses;
+       Answer = snmp_var_new_integer(Var->name, Var->name_length,
+           FqdncacheStats.misses,
+           SMI_COUNTER32);
        break;
     case FQDN_GHBN:
-       *(Answer->val.integer) = FqdncacheStats.ghba_calls;
+       Answer = snmp_var_new_integer(Var->name, Var->name_length,
+           FqdncacheStats.ghba_calls,
+           SMI_COUNTER32);
        break;
     default:
        *ErrP = SNMP_ERR_NOSUCHNAME;
-       snmp_var_free(Answer);
-       return (NULL);
+       break;
     }
     return Answer;
 }

diff --git a/src/ipcache.cc b/src/ipcache.cc
index 1d7c6bf77f5b3d38e46f17a70f84e4bf07f12876..ff5b13182b3b41b29b7c3e35a16426e309bf3870 100644 (file)
--- a/src/ipcache.cc
+++ b/src/ipcache.cc
@@ -1,6 +1,6 @@
 
 /*
- * $Id: ipcache.cc,v 1.216 1999/06/17 20:23:13 wessels Exp $
+ * $Id: ipcache.cc,v 1.217 1999/06/17 22:20:40 wessels Exp $
  *
  * DEBUG: section 14    IP Cache
  * AUTHOR: Harvest Derived
@@ -865,43 +865,50 @@ ipcache_restart(void)
 variable_list *
 snmp_netIpFn(variable_list * Var, snint * ErrP)
 {
-    variable_list *Answer;
-
+    variable_list *Answer = NULL;
     debug(49, 5) ("snmp_netIpFn: Processing request:\n", Var->name[LEN_SQ_NET + 1]);
     snmpDebugOid(5, Var->name, Var->name_length);
-
-    Answer = snmp_var_new(Var->name, Var->name_length);
     *ErrP = SNMP_ERR_NOERROR;
-    Answer->val_len = sizeof(snint);
-    Answer->val.integer = memAllocate(MEM_SNMP_SNINT);
-    Answer->type = SMI_COUNTER32;
-
     switch (Var->name[LEN_SQ_NET + 1]) {
     case IP_ENT:
-       *(Answer->val.integer) = memInUse(MEM_IPCACHE_ENTRY);
-       Answer->type = SMI_GAUGE32;
+       Answer = snmp_var_new_integer(Var->name, Var->name_length,
+           memInUse(MEM_IPCACHE_ENTRY),
+           SMI_GAUGE32);
        break;
     case IP_REQ:
-       *(Answer->val.integer) = IpcacheStats.requests;
+       Answer = snmp_var_new_integer(Var->name, Var->name_length,
+           IpcacheStats.requests,
+           SMI_COUNTER32);
        break;
     case IP_HITS:
-       *(Answer->val.integer) = IpcacheStats.hits;
+       Answer = snmp_var_new_integer(Var->name, Var->name_length,
+           IpcacheStats.hits,
+           SMI_COUNTER32);
        break;
     case IP_PENDHIT:
-       *(Answer->val.integer) = IpcacheStats.pending_hits;
-       Answer->type = SMI_GAUGE32;
+       Answer = snmp_var_new_integer(Var->name, Var->name_length,
+           IpcacheStats.pending_hits,
+           SMI_GAUGE32);
        break;
     case IP_NEGHIT:
-       *(Answer->val.integer) = IpcacheStats.negative_hits;
+       Answer = snmp_var_new_integer(Var->name, Var->name_length,
+           IpcacheStats.negative_hits,
+           SMI_COUNTER32);
        break;
     case IP_MISS:
-       *(Answer->val.integer) = IpcacheStats.misses;
+       Answer = snmp_var_new_integer(Var->name, Var->name_length,
+           IpcacheStats.misses,
+           SMI_COUNTER32);
        break;
     case IP_GHBN:
-       *(Answer->val.integer) = IpcacheStats.ghbn_calls;
+       Answer = snmp_var_new_integer(Var->name, Var->name_length,
+           IpcacheStats.ghbn_calls,
+           SMI_COUNTER32);
        break;
     case IP_LOC:
-       *(Answer->val.integer) = IpcacheStats.release_locked;
+       Answer = snmp_var_new_integer(Var->name, Var->name_length,
+           IpcacheStats.release_locked,
+           SMI_COUNTER32);
        break;
     default:
        *ErrP = SNMP_ERR_NOSUCHNAME;

diff --git a/src/snmp_agent.cc b/src/snmp_agent.cc
index 371d279b0a5ddaf723920ccbbfcf973c9e5d8b2e..d999b028fb492a10352ab470094c3d474a2b516f 100644 (file)
--- a/src/snmp_agent.cc
+++ b/src/snmp_agent.cc
@@ -1,6 +1,6 @@
 
 /*
- * $Id: snmp_agent.cc,v 1.70 1999/06/17 20:23:14 wessels Exp $
+ * $Id: snmp_agent.cc,v 1.71 1999/06/17 22:20:42 wessels Exp $
  *
  * DEBUG: section 49     SNMP Interface
  * AUTHOR: Kostas Anagnostakis
@@ -48,37 +48,29 @@ extern StatCounters *snmpStatGet(int);
 variable_list *
 snmp_sysFn(variable_list * Var, snint * ErrP)
 {
-    variable_list *Answer;
-
+    variable_list *Answer = NULL;
     debug(49, 5) ("snmp_sysFn: Processing request:\n", Var->name[LEN_SQ_SYS]);
     snmpDebugOid(5, Var->name, Var->name_length);
-
-    Answer = snmp_var_new(Var->name, Var->name_length);
     *ErrP = SNMP_ERR_NOERROR;
-
     switch (Var->name[LEN_SQ_SYS]) {
     case SYSVMSIZ:
-       Answer->val_len = sizeof(snint);
-       Answer->val.integer = memAllocate(MEM_SNMP_SNINT);
-       Answer->type = ASN_INTEGER;
-       *(Answer->val.integer) = store_mem_size >> 10;
+       Answer = snmp_var_new_integer(Var->name, Var->name_length,
+           store_mem_size >> 10,
+           ASN_INTEGER);
        break;
     case SYSSTOR:
-       Answer->val_len = sizeof(snint);
-       Answer->val.integer = memAllocate(MEM_SNMP_SNINT);
-       Answer->type = ASN_INTEGER;
-       *(Answer->val.integer) = store_swap_size;
+       Answer = snmp_var_new_integer(Var->name, Var->name_length,
+           store_swap_size,
+           ASN_INTEGER);
        break;
     case SYS_UPTIME:
-       Answer->val_len = sizeof(snint);
-       Answer->val.integer = memAllocate(MEM_SNMP_SNINT);
-       Answer->type = SMI_TIMETICKS;
-       *(Answer->val.integer) = tvSubDsec(squid_start, current_time) * 100;
+       Answer = snmp_var_new_integer(Var->name, Var->name_length,
+           tvSubDsec(squid_start, current_time) * 100,
+           SMI_TIMETICKS);
        break;
     default:
        *ErrP = SNMP_ERR_NOSUCHNAME;
-       snmp_var_free(Answer);
-       return (NULL);
+       break;
     }
     return Answer;
 }
@@ -86,64 +78,58 @@ snmp_sysFn(variable_list * Var, snint * ErrP)
 variable_list *
 snmp_confFn(variable_list * Var, snint * ErrP)
 {
-    variable_list *Answer;
+    variable_list *Answer = NULL;
     char *cp = NULL;
-    char *pp = NULL;
     debug(49, 5) ("snmp_confFn: Processing request with magic %d!\n", Var->name[8]);
-
-    Answer = snmp_var_new(Var->name, Var->name_length);
     *ErrP = SNMP_ERR_NOERROR;
-
     switch (Var->name[LEN_SQ_CONF]) {
     case CONF_ADMIN:
+       Answer = snmp_var_new(Var->name, Var->name_length);
        Answer->type = ASN_OCTET_STR;
        Answer->val_len = strlen(Config.adminEmail);
        Answer->val.string = (u_char *) xstrdup(Config.adminEmail);
        break;
     case CONF_VERSION:
+       Answer = snmp_var_new(Var->name, Var->name_length);
        Answer->type = ASN_OCTET_STR;
        Answer->val_len = strlen(appname);
        Answer->val.string = (u_char *) xstrdup(appname);
        break;
     case CONF_VERSION_ID:
-       pp = SQUID_VERSION;
+       Answer = snmp_var_new(Var->name, Var->name_length);
        Answer->type = ASN_OCTET_STR;
-       Answer->val_len = strlen(pp);
-       Answer->val.string = (u_char *) xstrdup(pp);
+       Answer->val_len = strlen(SQUID_VERSION);
+       Answer->val.string = (u_char *) xstrdup(SQUID_VERSION);
        break;
     case CONF_STORAGE:
        switch (Var->name[LEN_SQ_CONF + 1]) {
        case CONF_ST_MMAXSZ:
-           Answer->val_len = sizeof(snint);
-           Answer->val.integer = memAllocate(MEM_SNMP_SNINT);
-           Answer->type = ASN_INTEGER;
-           *(Answer->val.integer) = (snint) Config.memMaxSize >> 20;
+           snmp_var_new_integer(Var->name, Var->name_length,
+               (snint) Config.memMaxSize >> 20,
+               ASN_INTEGER);
            break;
        case CONF_ST_SWMAXSZ:
-           Answer->val_len = sizeof(snint);
-           Answer->val.integer = memAllocate(MEM_SNMP_SNINT);
-           Answer->type = ASN_INTEGER;
-           *(Answer->val.integer) = (snint) Config.Swap.maxSize >> 10;
+           snmp_var_new_integer(Var->name, Var->name_length,
+               (snint) Config.Swap.maxSize >> 10,
+               ASN_INTEGER);
            break;
        case CONF_ST_SWHIWM:
-           Answer->val_len = sizeof(snint);
-           Answer->val.integer = memAllocate(MEM_SNMP_SNINT);
-           Answer->type = ASN_INTEGER;
-           *(Answer->val.integer) = (snint) Config.Swap.highWaterMark;
+           snmp_var_new_integer(Var->name, Var->name_length,
+               (snint) Config.Swap.highWaterMark,
+               ASN_INTEGER);
            break;
        case CONF_ST_SWLOWM:
-           Answer->val_len = sizeof(snint);
-           Answer->val.integer = memAllocate(MEM_SNMP_SNINT);
-           Answer->type = ASN_INTEGER;
-           *(Answer->val.integer) = (snint) Config.Swap.lowWaterMark;
+           snmp_var_new_integer(Var->name, Var->name_length,
+               (snint) Config.Swap.lowWaterMark,
+               ASN_INTEGER);
            break;
        default:
            *ErrP = SNMP_ERR_NOSUCHNAME;
-           snmp_var_free(Answer);
-           return (NULL);
+           break;
        }
        break;
     case CONF_LOG_FAC:
+       Answer = snmp_var_new(Var->name, Var->name_length);
        if (!(cp = Config.debugOptions))
            cp = "None";
        Answer->type = ASN_OCTET_STR;
@@ -152,8 +138,7 @@ snmp_confFn(variable_list * Var, snint * ErrP)
        break;
     default:
        *ErrP = SNMP_ERR_NOSUCHNAME;
-       snmp_var_free(Answer);
-       return (NULL);
+       break;
     }
     return Answer;
 }
@@ -161,111 +146,92 @@ snmp_confFn(variable_list * Var, snint * ErrP)
 variable_list *
 snmp_meshPtblFn(variable_list * Var, snint * ErrP)
 {
-    variable_list *Answer;
+    variable_list *Answer = NULL;
     struct in_addr *laddr;
     char *cp = NULL;
     peer *p = NULL;
     int cnt = 0;
     debug(49, 5) ("snmp_meshPtblFn: peer %d requested!\n", Var->name[LEN_SQ_MESH + 3]);
-
-    Answer = snmp_var_new(Var->name, Var->name_length);
     *ErrP = SNMP_ERR_NOERROR;
-
     laddr = oid2addr(&Var->name[LEN_SQ_MESH + 3]);
-
     for (p = Config.peers; p != NULL; p = p->next, cnt++)
        if (p->in_addr.sin_addr.s_addr == laddr->s_addr)
            break;
-
     if (p == NULL) {
        *ErrP = SNMP_ERR_NOSUCHNAME;
-       snmp_var_free(Answer);
-       return (NULL);
+       return NULL;
     }
     switch (Var->name[LEN_SQ_MESH + 2]) {
     case MESH_PTBL_NAME:
        cp = p->host;
+       Answer = snmp_var_new(Var->name, Var->name_length);
        Answer->type = ASN_OCTET_STR;
        Answer->val_len = strlen(cp);
        Answer->val.string = (u_char *) xstrdup(cp);
        break;
     case MESH_PTBL_IP:
-       Answer->type = SMI_IPADDRESS;
-       Answer->val_len = sizeof(snint);
-       Answer->val.integer = memAllocate(MEM_SNMP_SNINT);
-       *(Answer->val.integer) = (snint) (p->in_addr.sin_addr.s_addr);
+       Answer = snmp_var_new_integer(Var->name, Var->name_length,
+           (snint) p->in_addr.sin_addr.s_addr,
+           SMI_IPADDRESS);
        break;
     case MESH_PTBL_HTTP:
-       Answer->val_len = sizeof(snint);
-       Answer->val.integer = memAllocate(MEM_SNMP_SNINT);
-       Answer->type = ASN_INTEGER;
-       *(Answer->val.integer) = (snint) p->http_port;
+       Answer = snmp_var_new_integer(Var->name, Var->name_length,
+           (snint) p->http_port,
+           ASN_INTEGER);
        break;
     case MESH_PTBL_ICP:
-       Answer->val_len = sizeof(snint);
-       Answer->val.integer = memAllocate(MEM_SNMP_SNINT);
-       Answer->type = ASN_INTEGER;
-       *(Answer->val.integer) = (snint) p->icp.port;
+       Answer = snmp_var_new_integer(Var->name, Var->name_length,
+           (snint) p->icp.port,
+           ASN_INTEGER);
        break;
     case MESH_PTBL_TYPE:
-       Answer->val_len = sizeof(snint);
-       Answer->val.integer = memAllocate(MEM_SNMP_SNINT);
-       Answer->type = ASN_INTEGER;
-       *(Answer->val.integer) = (snint) p->type;
+       Answer = snmp_var_new_integer(Var->name, Var->name_length,
+           (snint) p->type,
+           ASN_INTEGER);
        break;
     case MESH_PTBL_STATE:
-       Answer->val_len = sizeof(snint);
-       Answer->val.integer = memAllocate(MEM_SNMP_SNINT);
-       Answer->type = ASN_INTEGER;
-       *(Answer->val.integer) = (snint) neighborUp(p);
+       Answer = snmp_var_new_integer(Var->name, Var->name_length,
+           (snint) neighborUp(p),
+           ASN_INTEGER);
        break;
     case MESH_PTBL_SENT:
-       Answer->val_len = sizeof(snint);
-       Answer->val.integer = memAllocate(MEM_SNMP_SNINT);
-       Answer->type = SMI_COUNTER32;
-       *(Answer->val.integer) = p->stats.pings_sent;
+       Answer = snmp_var_new_integer(Var->name, Var->name_length,
+           p->stats.pings_sent,
+           ASN_INTEGER);
        break;
     case MESH_PTBL_PACKED:
-       Answer->val_len = sizeof(snint);
-       Answer->val.integer = memAllocate(MEM_SNMP_SNINT);
-       Answer->type = SMI_COUNTER32;
-       *(Answer->val.integer) = p->stats.pings_acked;
+       Answer = snmp_var_new_integer(Var->name, Var->name_length,
+           p->stats.pings_acked,
+           ASN_INTEGER);
        break;
     case MESH_PTBL_FETCHES:
-       Answer->val_len = sizeof(snint);
-       Answer->val.integer = memAllocate(MEM_SNMP_SNINT);
-       Answer->type = SMI_COUNTER32;
-       *(Answer->val.integer) = p->stats.fetches;
+       Answer = snmp_var_new_integer(Var->name, Var->name_length,
+           p->stats.fetches,
+           SMI_COUNTER32);
        break;
     case MESH_PTBL_RTT:
-       Answer->val_len = sizeof(snint);
-       Answer->val.integer = memAllocate(MEM_SNMP_SNINT);
-       Answer->type = ASN_INTEGER;
-       *(Answer->val.integer) = p->stats.rtt;
+       Answer = snmp_var_new_integer(Var->name, Var->name_length,
+           p->stats.rtt,
+           ASN_INTEGER);
        break;
     case MESH_PTBL_IGN:
-       Answer->val_len = sizeof(snint);
-       Answer->val.integer = memAllocate(MEM_SNMP_SNINT);
-       Answer->type = SMI_COUNTER32;
-       *(Answer->val.integer) = p->stats.ignored_replies;
+       Answer = snmp_var_new_integer(Var->name, Var->name_length,
+           p->stats.ignored_replies,
+           SMI_COUNTER32);
        break;
     case MESH_PTBL_KEEPAL_S:
-       Answer->val_len = sizeof(snint);
-       Answer->val.integer = memAllocate(MEM_SNMP_SNINT);
-       Answer->type = SMI_COUNTER32;
-       *(Answer->val.integer) = p->stats.n_keepalives_sent;
+       Answer = snmp_var_new_integer(Var->name, Var->name_length,
+           p->stats.n_keepalives_sent,
+           SMI_COUNTER32);
        break;
     case MESH_PTBL_KEEPAL_R:
-       Answer->val_len = sizeof(snint);
-       Answer->val.integer = memAllocate(MEM_SNMP_SNINT);
-       Answer->type = SMI_COUNTER32;
-       *(Answer->val.integer) = p->stats.n_keepalives_recv;
+       Answer = snmp_var_new_integer(Var->name, Var->name_length,
+           p->stats.n_keepalives_recv,
+           SMI_COUNTER32);
        break;
-
     default:
        *ErrP = SNMP_ERR_NOSUCHNAME;
-       snmp_var_free(Answer);
-       return (NULL);
+       break;
     }
     return Answer;
 }
@@ -273,67 +239,73 @@ snmp_meshPtblFn(variable_list * Var, snint * ErrP)
 variable_list *
 snmp_prfSysFn(variable_list * Var, snint * ErrP)
 {
-    variable_list *Answer;
+    variable_list *Answer = NULL;
     static struct rusage rusage;
-
     debug(49, 5) ("snmp_prfSysFn: Processing request with magic %d!\n", Var->name[LEN_SQ_PRF + 1]);
-
-    Answer = snmp_var_new(Var->name, Var->name_length);
     *ErrP = SNMP_ERR_NOERROR;
-    Answer->val_len = sizeof(snint);
-    Answer->val.integer = memAllocate(MEM_SNMP_SNINT);
-    Answer->type = ASN_INTEGER;
-
     switch (Var->name[LEN_SQ_PRF + 1]) {
     case PERF_SYS_PF:
        squid_getrusage(&rusage);
-       *(Answer->val.integer) = rusage_pagefaults(&rusage);
-       Answer->type = SMI_COUNTER32;
+       Answer = snmp_var_new_integer(Var->name, Var->name_length,
+           rusage_pagefaults(&rusage),
+           SMI_COUNTER32);
        break;
     case PERF_SYS_NUMR:
-       *(Answer->val.integer) = IOStats.Http.reads;
-       Answer->type = SMI_COUNTER32;
+       Answer = snmp_var_new_integer(Var->name, Var->name_length,
+           IOStats.Http.reads,
+           SMI_COUNTER32);
        break;
     case PERF_SYS_MEMUSAGE:
-       *(Answer->val.integer) = (snint) memTotalAllocated() >> 10;
+       Answer = snmp_var_new_integer(Var->name, Var->name_length,
+           (snint) memTotalAllocated() >> 10,
+           ASN_INTEGER);
        break;
     case PERF_SYS_CPUTIME:
        squid_getrusage(&rusage);
-       *(Answer->val.integer) = (snint) rusage_cputime(&rusage);
+       Answer = snmp_var_new_integer(Var->name, Var->name_length,
+           (snint) rusage_cputime(&rusage),
+           ASN_INTEGER);
        break;
     case PERF_SYS_CPUUSAGE:
        squid_getrusage(&rusage);
-       *(Answer->val.integer) = (snint)
-           dpercent(rusage_cputime(&rusage), tvSubDsec(squid_start, current_time));
+       Answer = snmp_var_new_integer(Var->name, Var->name_length,
+           (snint) dpercent(rusage_cputime(&rusage), tvSubDsec(squid_start, current_time)),
+           ASN_INTEGER);
        break;
     case PERF_SYS_MAXRESSZ:
        squid_getrusage(&rusage);
-       *(Answer->val.integer) = (snint) rusage_maxrss(&rusage);
+       Answer = snmp_var_new_integer(Var->name, Var->name_length,
+           (snint) rusage_maxrss(&rusage),
+           ASN_INTEGER);
        break;
     case PERF_SYS_CURLRUEXP:
-       Answer->type = SMI_TIMETICKS;
-       *(Answer->val.integer) = (snint) (storeExpiredReferenceAge() * 100);
+       Answer = snmp_var_new_integer(Var->name, Var->name_length,
+           (snint) (storeExpiredReferenceAge() * 100),
+           SMI_TIMETICKS);
        break;
     case PERF_SYS_CURUNLREQ:
-       *(Answer->val.integer) = (snint) Counter.unlink.requests;
-       Answer->type = SMI_COUNTER32;
+       Answer = snmp_var_new_integer(Var->name, Var->name_length,
+           (snint) Counter.unlink.requests,
+           SMI_COUNTER32);
        break;
     case PERF_SYS_CURUNUSED_FD:
-       *(Answer->val.integer) = (snint) Squid_MaxFD - Number_FD;
-       Answer->type = SMI_GAUGE32;
+       Answer = snmp_var_new_integer(Var->name, Var->name_length,
+           (snint) Squid_MaxFD - Number_FD,
+           SMI_GAUGE32);
        break;
     case PERF_SYS_CURRESERVED_FD:
-       *(Answer->val.integer) = (snint) Number_FD;
-       Answer->type = SMI_GAUGE32;
+       Answer = snmp_var_new_integer(Var->name, Var->name_length,
+           (snint) Number_FD,
+           SMI_GAUGE32);
        break;
     case PERF_SYS_NUMOBJCNT:
-       *(Answer->val.integer) = (snint) memInUse(MEM_STOREENTRY);
-       Answer->type = SMI_COUNTER32;
+       Answer = snmp_var_new_integer(Var->name, Var->name_length,
+           (snint) memInUse(MEM_STOREENTRY),
+           SMI_COUNTER32);
        break;
     default:
        *ErrP = SNMP_ERR_NOSUCHNAME;
-       snmp_var_free(Answer);
-       return (NULL);
+       break;
     }
     return Answer;
 }
@@ -341,94 +313,107 @@ snmp_prfSysFn(variable_list * Var, snint * ErrP)
 variable_list *
 snmp_prfProtoFn(variable_list * Var, snint * ErrP)
 {
-    variable_list *Answer;
+    variable_list *Answer = NULL;
     static StatCounters *f = NULL;
     static StatCounters *l = NULL;
     double x;
     int minutes;
-
     debug(49, 5) ("snmp_prfProtoFn: Processing request with magic %d!\n", Var->name[LEN_SQ_PRF]);
-
-    Answer = snmp_var_new(Var->name, Var->name_length);
     *ErrP = SNMP_ERR_NOERROR;
-
     switch (Var->name[LEN_SQ_PRF + 1]) {
     case PERF_PROTOSTAT_AGGR:  /* cacheProtoAggregateStats */
-       Answer->type = SMI_COUNTER32;
-       Answer->val_len = sizeof(snint);
-       Answer->val.integer = memAllocate(MEM_SNMP_SNINT);
        switch (Var->name[LEN_SQ_PRF + 2]) {
        case PERF_PROTOSTAT_AGGR_HTTP_REQ:
-           *(Answer->val.integer) = (snint) Counter.client_http.requests;
+           Answer = snmp_var_new_integer(Var->name, Var->name_length,
+               (snint) Counter.client_http.requests,
+               SMI_COUNTER32);
            break;
        case PERF_PROTOSTAT_AGGR_HTTP_HITS:
-           *(Answer->val.integer) = (snint) Counter.client_http.hits;
+           Answer = snmp_var_new_integer(Var->name, Var->name_length,
+               (snint) Counter.client_http.hits,
+               SMI_COUNTER32);
            break;
        case PERF_PROTOSTAT_AGGR_HTTP_ERRORS:
-           *(Answer->val.integer) = (snint) Counter.client_http.errors;
+           Answer = snmp_var_new_integer(Var->name, Var->name_length,
+               (snint) Counter.client_http.errors,
+               SMI_COUNTER32);
            break;
        case PERF_PROTOSTAT_AGGR_HTTP_KBYTES_IN:
-           *(Answer->val.integer) = (snint) Counter.client_http.kbytes_in.kb;
+           Answer = snmp_var_new_integer(Var->name, Var->name_length,
+               (snint) Counter.client_http.kbytes_in.kb,
+               SMI_COUNTER32);
            break;
        case PERF_PROTOSTAT_AGGR_HTTP_KBYTES_OUT:
-           *(Answer->val.integer) = (snint) Counter.client_http.kbytes_out.kb;
+           Answer = snmp_var_new_integer(Var->name, Var->name_length,
+               (snint) Counter.client_http.kbytes_out.kb,
+               SMI_COUNTER32);
            break;
        case PERF_PROTOSTAT_AGGR_ICP_S:
-           *(Answer->val.integer) = (snint) Counter.icp.pkts_sent;
+           Answer = snmp_var_new_integer(Var->name, Var->name_length,
+               (snint) Counter.icp.pkts_sent,
+               SMI_COUNTER32);
            break;
        case PERF_PROTOSTAT_AGGR_ICP_R:
-           *(Answer->val.integer) = (snint) Counter.icp.pkts_recv;
+           Answer = snmp_var_new_integer(Var->name, Var->name_length,
+               (snint) Counter.icp.pkts_recv,
+               SMI_COUNTER32);
            break;
        case PERF_PROTOSTAT_AGGR_ICP_SKB:
-           *(Answer->val.integer) = (snint) Counter.icp.kbytes_sent.kb;
+           Answer = snmp_var_new_integer(Var->name, Var->name_length,
+               (snint) Counter.icp.kbytes_sent.kb,
+               SMI_COUNTER32);
            break;
        case PERF_PROTOSTAT_AGGR_ICP_RKB:
-           *(Answer->val.integer) = (snint) Counter.icp.kbytes_recv.kb;
+           Answer = snmp_var_new_integer(Var->name, Var->name_length,
+               (snint) Counter.icp.kbytes_recv.kb,
+               SMI_COUNTER32);
            break;
        case PERF_PROTOSTAT_AGGR_REQ:
-           *(Answer->val.integer) = (snint) Counter.server.all.requests;
-           Answer->type = SMI_INTEGER;
+           Answer = snmp_var_new_integer(Var->name, Var->name_length,
+               (snint) Counter.server.all.requests,
+               SMI_INTEGER);
            break;
        case PERF_PROTOSTAT_AGGR_ERRORS:
-           *(Answer->val.integer) = (snint) Counter.server.all.errors;
-           Answer->type = SMI_INTEGER;
+           Answer = snmp_var_new_integer(Var->name, Var->name_length,
+               (snint) Counter.server.all.errors,
+               SMI_INTEGER);
            break;
        case PERF_PROTOSTAT_AGGR_KBYTES_IN:
-           *(Answer->val.integer) = (snint) Counter.server.all.kbytes_in.kb;
+           Answer = snmp_var_new_integer(Var->name, Var->name_length,
+               (snint) Counter.server.all.kbytes_in.kb,
+               SMI_COUNTER32);
            break;
        case PERF_PROTOSTAT_AGGR_KBYTES_OUT:
-           *(Answer->val.integer) = (snint) Counter.server.all.kbytes_out.kb;
+           Answer = snmp_var_new_integer(Var->name, Var->name_length,
+               (snint) Counter.server.all.kbytes_out.kb,
+               SMI_COUNTER32);
            break;
        case PERF_PROTOSTAT_AGGR_CURSWAP:
-           *(Answer->val.integer) = (snint) store_swap_size;
+           Answer = snmp_var_new_integer(Var->name, Var->name_length,
+               (snint) store_swap_size,
+               SMI_COUNTER32);
            break;
        case PERF_PROTOSTAT_AGGR_CLIENTS:
-           *(Answer->val.integer) = (snint) Counter.client_http.clients;
+           Answer = snmp_var_new_integer(Var->name, Var->name_length,
+               (snint) Counter.client_http.clients,
+               SMI_COUNTER32);
            break;
        default:
            *ErrP = SNMP_ERR_NOSUCHNAME;
-           snmp_var_free(Answer);
-           return (NULL);
+           break;
        }
        return Answer;
     case PERF_PROTOSTAT_MEDIAN:
-
        if (Var->name_length == LEN_SQ_PRF + 5)
            minutes = Var->name[LEN_SQ_PRF + 4];
        else
            break;
        if ((minutes < 1) || (minutes > 60))
            break;
-
        f = snmpStatGet(0);
        l = snmpStatGet(minutes);
-
        debug(49, 8) ("median: min= %d, %d l= %x , f = %x\n", minutes,
            Var->name[LEN_SQ_PRF + 3], l, f);
-       Answer->type = SMI_INTEGER;
-       Answer->val_len = sizeof(snint);
-       Answer->val.integer = memAllocate(MEM_SNMP_SNINT);
-
        debug(49, 8) ("median: l= %x , f = %x\n", l, f);
        switch (Var->name[LEN_SQ_PRF + 3]) {
        case PERF_MEDIAN_TIME:
@@ -467,13 +452,12 @@ snmp_prfProtoFn(variable_list * Var, snint * ErrP)
            break;
        default:
            *ErrP = SNMP_ERR_NOSUCHNAME;
-           snmp_var_free(Answer);
-           return (NULL);
+           return NULL;
        }
-       *(Answer->val.integer) = (snint) x;
-       return Answer;
+       return snmp_var_new_integer(Var->name, Var->name_length,
+           (snint) x,
+           SMI_INTEGER);
     }
     *ErrP = SNMP_ERR_NOSUCHNAME;
-    snmp_var_free(Answer);
-    return (NULL);
+    return NULL;
 }

diff --git a/src/snmp_core.cc b/src/snmp_core.cc
index 91e3454da92a11842f693340fd1bf3c91144bce3..a8128370bece5026cc1d76332c649b18bc23acf7 100644 (file)
--- a/src/snmp_core.cc
+++ b/src/snmp_core.cc
@@ -1,6 +1,6 @@
 
 /*
- * $Id: snmp_core.cc,v 1.38 1999/06/17 20:23:15 wessels Exp $
+ * $Id: snmp_core.cc,v 1.39 1999/06/17 22:20:43 wessels Exp $
  *
  * DEBUG: section 49    SNMP support
  * AUTHOR: Glenn Chisholm
@@ -333,7 +333,6 @@ snmpInit(void)
        );
 
     debug(49, 9) ("snmpInit: Completed SNMP mib tree structure\n");
-    memDataInit(MEM_SNMP_SNINT, "snmp_snint", sizeof(snint), 0);
 }
 
 void