[thirdparty/squid.git] / src / snmp_agent.cc


/*
 * $Id: snmp_agent.cc,v 1.88 2003/05/02 09:57:54 hno Exp $
 *
 * DEBUG: section 49     SNMP Interface
 * AUTHOR: Kostas Anagnostakis
 *
 * SQUID Web Proxy Cache          http://www.squid-cache.org/
 * ----------------------------------------------------------
 *
 *  Squid is the result of efforts by numerous individuals from
 *  the Internet community; see the CONTRIBUTORS file for full
 *  details.   Many organizations have provided support for Squid's
 *  development; see the SPONSORS file for full details.  Squid is
 *  Copyrighted (C) 2001 by the Regents of the University of
 *  California; see the COPYRIGHT file for full details.  Squid
 *  incorporates software developed and/or copyrighted by other
 *  sources; see the CREDITS file for full details.
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *  
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *  
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.
 *
 */


#include "squid.h"
#include "cache_snmp.h"
#include "Store.h"
#include "mem_node.h"

/************************************************************************
 
 SQUID MIB Implementation
 
 ************************************************************************/

variable_list *
snmp_sysFn(variable_list * Var, snint * ErrP)
{
    variable_list *Answer = NULL;
    debug(49, 5) ("snmp_sysFn: Processing request:\n");
    snmpDebugOid(5, Var->name, Var->name_length);
    *ErrP = SNMP_ERR_NOERROR;

    switch (Var->name[LEN_SQ_SYS]) {

    case SYSVMSIZ:
        Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                      mem_node::store_mem_size >> 10,
                                      ASN_INTEGER);
        break;

    case SYSSTOR:
        Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                      store_swap_size,
                                      ASN_INTEGER);
        break;

    case SYS_UPTIME:
        Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                      (int)(tvSubDsec(squid_start, current_time) * 100),
                                      SMI_TIMETICKS);
        break;

    default:
        *ErrP = SNMP_ERR_NOSUCHNAME;
        break;
    }

    return Answer;
}

variable_list *
snmp_confFn(variable_list * Var, snint * ErrP)
{
    variable_list *Answer = NULL;
    const char *cp = NULL;
    debug(49, 5) ("snmp_confFn: Processing request with magic %d!\n", Var->name[8]);
    *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:
        Answer = snmp_var_new(Var->name, Var->name_length);
        Answer->type = ASN_OCTET_STR;
        Answer->val_len = strlen(VERSION);
        Answer->val.string = (u_char *) xstrdup(VERSION);
        break;

    case CONF_STORAGE:

        switch (Var->name[LEN_SQ_CONF + 1]) {

        case CONF_ST_MMAXSZ:
            Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                          (snint) Config.memMaxSize >> 20,
                                          ASN_INTEGER);
            break;

        case CONF_ST_SWMAXSZ:
            Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                          (snint) Config.Swap.maxSize >> 10,
                                          ASN_INTEGER);
            break;

        case CONF_ST_SWHIWM:
            Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                          (snint) Config.Swap.highWaterMark,
                                          ASN_INTEGER);
            break;

        case CONF_ST_SWLOWM:
            Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                          (snint) Config.Swap.lowWaterMark,
                                          ASN_INTEGER);
            break;

        default:
            *ErrP = SNMP_ERR_NOSUCHNAME;
            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;

        Answer->val_len = strlen(cp);

        Answer->val.string = (u_char *) xstrdup(cp);

        break;

    default:
        *ErrP = SNMP_ERR_NOSUCHNAME;

        break;
    }

    return Answer;
}

variable_list *
snmp_meshPtblFn(variable_list * Var, snint * ErrP)
{
    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]);
    *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;
        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 = 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 = snmp_var_new_integer(Var->name, Var->name_length,
                                      (snint) p->http_port,
                                      ASN_INTEGER);
        break;

    case MESH_PTBL_ICP:
        Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                      (snint) p->icp.port,
                                      ASN_INTEGER);
        break;

    case MESH_PTBL_TYPE:
        Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                      (snint) p->type,
                                      ASN_INTEGER);
        break;

    case MESH_PTBL_STATE:
        Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                      (snint) neighborUp(p),
                                      ASN_INTEGER);
        break;

    case MESH_PTBL_SENT:
        Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                      p->stats.pings_sent,
                                      ASN_INTEGER);
        break;

    case MESH_PTBL_PACKED:
        Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                      p->stats.pings_acked,
                                      ASN_INTEGER);
        break;

    case MESH_PTBL_FETCHES:
        Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                      p->stats.fetches,
                                      SMI_COUNTER32);
        break;

    case MESH_PTBL_RTT:
        Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                      p->stats.rtt,
                                      ASN_INTEGER);
        break;

    case MESH_PTBL_IGN:
        Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                      p->stats.ignored_replies,
                                      SMI_COUNTER32);
        break;

    case MESH_PTBL_KEEPAL_S:
        Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                      p->stats.n_keepalives_sent,
                                      SMI_COUNTER32);
        break;

    case MESH_PTBL_KEEPAL_R:
        Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                      p->stats.n_keepalives_recv,
                                      SMI_COUNTER32);
        break;

    default:
        *ErrP = SNMP_ERR_NOSUCHNAME;
        break;
    }

    return Answer;
}

variable_list *
snmp_prfSysFn(variable_list * Var, snint * ErrP)
{
    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]);
    *ErrP = SNMP_ERR_NOERROR;

    switch (Var->name[LEN_SQ_PRF + 1]) {

    case PERF_SYS_PF:
        squid_getrusage(&rusage);
        Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                      rusage_pagefaults(&rusage),
                                      SMI_COUNTER32);
        break;

    case PERF_SYS_NUMR:
        Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                      IOStats.Http.reads,
                                      SMI_COUNTER32);
        break;

    case PERF_SYS_MEMUSAGE:
        Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                      (snint) statMemoryAccounted() >> 10,
                                      ASN_INTEGER);
        break;

    case PERF_SYS_CPUTIME:
        squid_getrusage(&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 = 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 = snmp_var_new_integer(Var->name, Var->name_length,
                                      (snint) rusage_maxrss(&rusage),
                                      ASN_INTEGER);
        break;

    case PERF_SYS_CURLRUEXP:
        /* No global LRU info anymore */
        Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                      0,
                                      SMI_TIMETICKS);
        break;

    case PERF_SYS_CURUNLREQ:
        Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                      (snint) statCounter.unlink.requests,
                                      SMI_GAUGE32);
        break;

    case PERF_SYS_CURUNUSED_FD:
        Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                      (snint) Squid_MaxFD - Number_FD,
                                      SMI_GAUGE32);
        break;

    case PERF_SYS_CURRESERVED_FD:
        Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                      (snint) RESERVED_FD,
                                      SMI_GAUGE32);
        break;

    case PERF_SYS_NUMOBJCNT:
        Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                      (snint) StoreEntry::inUseCount(),
                                      SMI_GAUGE32);
        break;

    default:
        *ErrP = SNMP_ERR_NOSUCHNAME;
        break;
    }

    return Answer;
}

variable_list *
snmp_prfProtoFn(variable_list * Var, snint * ErrP)
{
    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]);
    *ErrP = SNMP_ERR_NOERROR;

    switch (Var->name[LEN_SQ_PRF + 1]) {

    case PERF_PROTOSTAT_AGGR:	/* cacheProtoAggregateStats */

        switch (Var->name[LEN_SQ_PRF + 2]) {

        case PERF_PROTOSTAT_AGGR_HTTP_REQ:
            Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                          (snint) statCounter.client_http.requests,
                                          SMI_COUNTER32);
            break;

        case PERF_PROTOSTAT_AGGR_HTTP_HITS:
            Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                          (snint) statCounter.client_http.hits,
                                          SMI_COUNTER32);
            break;

        case PERF_PROTOSTAT_AGGR_HTTP_ERRORS:
            Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                          (snint) statCounter.client_http.errors,
                                          SMI_COUNTER32);
            break;

        case PERF_PROTOSTAT_AGGR_HTTP_KBYTES_IN:
            Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                          (snint) statCounter.client_http.kbytes_in.kb,
                                          SMI_COUNTER32);
            break;

        case PERF_PROTOSTAT_AGGR_HTTP_KBYTES_OUT:
            Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                          (snint) statCounter.client_http.kbytes_out.kb,
                                          SMI_COUNTER32);
            break;

        case PERF_PROTOSTAT_AGGR_ICP_S:
            Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                          (snint) statCounter.icp.pkts_sent,
                                          SMI_COUNTER32);
            break;

        case PERF_PROTOSTAT_AGGR_ICP_R:
            Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                          (snint) statCounter.icp.pkts_recv,
                                          SMI_COUNTER32);
            break;

        case PERF_PROTOSTAT_AGGR_ICP_SKB:
            Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                          (snint) statCounter.icp.kbytes_sent.kb,
                                          SMI_COUNTER32);
            break;

        case PERF_PROTOSTAT_AGGR_ICP_RKB:
            Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                          (snint) statCounter.icp.kbytes_recv.kb,
                                          SMI_COUNTER32);
            break;

        case PERF_PROTOSTAT_AGGR_REQ:
            Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                          (snint) statCounter.server.all.requests,
                                          SMI_INTEGER);
            break;

        case PERF_PROTOSTAT_AGGR_ERRORS:
            Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                          (snint) statCounter.server.all.errors,
                                          SMI_INTEGER);
            break;

        case PERF_PROTOSTAT_AGGR_KBYTES_IN:
            Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                          (snint) statCounter.server.all.kbytes_in.kb,
                                          SMI_COUNTER32);
            break;

        case PERF_PROTOSTAT_AGGR_KBYTES_OUT:
            Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                          (snint) statCounter.server.all.kbytes_out.kb,
                                          SMI_COUNTER32);
            break;

        case PERF_PROTOSTAT_AGGR_CURSWAP:
            Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                          (snint) store_swap_size,
                                          SMI_GAUGE32);
            break;

        case PERF_PROTOSTAT_AGGR_CLIENTS:
            Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                          (snint) statCounter.client_http.clients,
                                          SMI_GAUGE32);
            break;

        default:
            *ErrP = SNMP_ERR_NOSUCHNAME;
            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= %p , f = %p\n", minutes,
                      Var->name[LEN_SQ_PRF + 3], l, f);

        debug(49, 8) ("median: l= %p , f = %p\n", l, f);

        switch (Var->name[LEN_SQ_PRF + 3]) {

        case PERF_MEDIAN_TIME:
            x = minutes;
            break;

        case PERF_MEDIAN_HTTP_ALL:
            x = statHistDeltaMedian(&l->client_http.all_svc_time,
                                    &f->client_http.all_svc_time);
            break;

        case PERF_MEDIAN_HTTP_MISS:
            x = statHistDeltaMedian(&l->client_http.miss_svc_time,
                                    &f->client_http.miss_svc_time);
            break;

        case PERF_MEDIAN_HTTP_NM:
            x = statHistDeltaMedian(&l->client_http.nm_svc_time,
                                    &f->client_http.nm_svc_time);
            break;

        case PERF_MEDIAN_HTTP_HIT:
            x = statHistDeltaMedian(&l->client_http.hit_svc_time,
                                    &f->client_http.hit_svc_time);
            break;

        case PERF_MEDIAN_ICP_QUERY:
            x = statHistDeltaMedian(&l->icp.query_svc_time, &f->icp.query_svc_time);
            break;

        case PERF_MEDIAN_ICP_REPLY:
            x = statHistDeltaMedian(&l->icp.reply_svc_time, &f->icp.reply_svc_time);
            break;

        case PERF_MEDIAN_DNS:
            x = statHistDeltaMedian(&l->dns.svc_time, &f->dns.svc_time);
            break;

        case PERF_MEDIAN_RHR:
            x = statRequestHitRatio(minutes);
            break;

        case PERF_MEDIAN_BHR:
            x = statByteHitRatio(minutes);
            break;

        default:
            *ErrP = SNMP_ERR_NOSUCHNAME;
            return NULL;
        }

        return snmp_var_new_integer(Var->name, Var->name_length,
                                    (snint) x,
                                    SMI_INTEGER);
    }

    *ErrP = SNMP_ERR_NOSUCHNAME;
    return NULL;
}
Commit	Line	Data
43d4303e	1
43d4303e	2	/*
e1d20533	3	* $Id: snmp_agent.cc,v 1.88 2003/05/02 09:57:54 hno Exp $
43d4303e	4	*
	5	* DEBUG: section 49 SNMP Interface
	6	* AUTHOR: Kostas Anagnostakis
	7	*
2b6662ba	8	* SQUID Web Proxy Cache http://www.squid-cache.org/
e25c139f	9	* ----------------------------------------------------------
43d4303e	10	*
2b6662ba	11	* Squid is the result of efforts by numerous individuals from
	12	* the Internet community; see the CONTRIBUTORS file for full
	13	* details. Many organizations have provided support for Squid's
	14	* development; see the SPONSORS file for full details. Squid is
	15	* Copyrighted (C) 2001 by the Regents of the University of
	16	* California; see the COPYRIGHT file for full details. Squid
	17	* incorporates software developed and/or copyrighted by other
	18	* sources; see the CREDITS file for full details.
43d4303e	19	*
	20	* This program is free software; you can redistribute it and/or modify
	21	* it under the terms of the GNU General Public License as published by
	22	* the Free Software Foundation; either version 2 of the License, or
	23	* (at your option) any later version.
	24	*
	25	* This program is distributed in the hope that it will be useful,
	26	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	27	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	28	* GNU General Public License for more details.
	29	*
	30	* You should have received a copy of the GNU General Public License
	31	* along with this program; if not, write to the Free Software
cbdec147	32	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.
e25c139f	33	*
43d4303e	34	*/
	35
	36
25c1b8b7	37	#include "squid.h"
571c3b88	38	#include "cache_snmp.h"
e6ccf245	39	#include "Store.h"
528b2c61	40	#include "mem_node.h"
25c1b8b7	41
571c3b88	42	/************************************************************************
62e76326	43
571c3b88	44	SQUID MIB Implementation
62e76326	45
571c3b88	46	************************************************************************/
25c1b8b7	47
d0e0c8d2	48	variable_list *
6f47fbc7	49	snmp_sysFn(variable_list * Var, snint * ErrP)
571c3b88	50	{
736eb6ad	51	variable_list *Answer = NULL;
38650cc8	52	debug(49, 5) ("snmp_sysFn: Processing request:\n");
43d4303e	53	snmpDebugOid(5, Var->name, Var->name_length);
d0e0c8d2	54	*ErrP = SNMP_ERR_NOERROR;
62e76326	55
f763bb01	56	switch (Var->name[LEN_SQ_SYS]) {
62e76326	57
d0e0c8d2	58	case SYSVMSIZ:
62e76326	59	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	60	mem_node::store_mem_size >> 10,
	61	ASN_INTEGER);
	62	break;
	63
d0e0c8d2	64	case SYSSTOR:
62e76326	65	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	66	store_swap_size,
	67	ASN_INTEGER);
	68	break;
	69
f763bb01	70	case SYS_UPTIME:
62e76326	71	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	72	(int)(tvSubDsec(squid_start, current_time) * 100),
	73	SMI_TIMETICKS);
	74	break;
	75
d0e0c8d2	76	default:
62e76326	77	*ErrP = SNMP_ERR_NOSUCHNAME;
62e76326	78	break;
d0e0c8d2	79	}
62e76326	80
d0e0c8d2	81	return Answer;
25c1b8b7	82	}
25c1b8b7	83
d0e0c8d2	84	variable_list *
6f47fbc7	85	snmp_confFn(variable_list * Var, snint * ErrP)
25c1b8b7	86	{
736eb6ad	87	variable_list *Answer = NULL;
a2c963ae	88	const char *cp = NULL;
d0e0c8d2	89	debug(49, 5) ("snmp_confFn: Processing request with magic %d!\n", Var->name[8]);
d0e0c8d2	90	*ErrP = SNMP_ERR_NOERROR;
62e76326	91
f763bb01	92	switch (Var->name[LEN_SQ_CONF]) {
62e76326	93
571c3b88	94	case CONF_ADMIN:
62e76326	95	Answer = snmp_var_new(Var->name, Var->name_length);
	96	Answer->type = ASN_OCTET_STR;
	97	Answer->val_len = strlen(Config.adminEmail);
	98	Answer->val.string = (u_char *) xstrdup(Config.adminEmail);
	99	break;
	100
81d0c856	101	case CONF_VERSION:
62e76326	102	Answer = snmp_var_new(Var->name, Var->name_length);
	103	Answer->type = ASN_OCTET_STR;
	104	Answer->val_len = strlen(appname);
	105	Answer->val.string = (u_char *) xstrdup(appname);
	106	break;
	107
81d0c856	108	case CONF_VERSION_ID:
62e76326	109	Answer = snmp_var_new(Var->name, Var->name_length);
	110	Answer->type = ASN_OCTET_STR;
	111	Answer->val_len = strlen(VERSION);
	112	Answer->val.string = (u_char *) xstrdup(VERSION);
	113	break;
	114
571c3b88	115	case CONF_STORAGE:
62e76326	116
	117	switch (Var->name[LEN_SQ_CONF + 1]) {
	118
	119	case CONF_ST_MMAXSZ:
	120	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	121	(snint) Config.memMaxSize >> 20,
	122	ASN_INTEGER);
	123	break;
	124
	125	case CONF_ST_SWMAXSZ:
	126	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	127	(snint) Config.Swap.maxSize >> 10,
	128	ASN_INTEGER);
	129	break;
	130
	131	case CONF_ST_SWHIWM:
	132	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	133	(snint) Config.Swap.highWaterMark,
	134	ASN_INTEGER);
	135	break;
	136
	137	case CONF_ST_SWLOWM:
	138	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	139	(snint) Config.Swap.lowWaterMark,
	140	ASN_INTEGER);
	141	break;
	142
	143	default:
	144	*ErrP = SNMP_ERR_NOSUCHNAME;
	145	break;
	146	}
	147
	148	break;
	149
81d0c856	150	case CONF_LOG_FAC:
62e76326	151	Answer = snmp_var_new(Var->name, Var->name_length);
	152
	153	if (!(cp = Config.debugOptions))
	154	cp = "None";
	155
	156	Answer->type = ASN_OCTET_STR;
	157
	158	Answer->val_len = strlen(cp);
	159
	160	Answer->val.string = (u_char *) xstrdup(cp);
	161
	162	break;
	163
571c3b88	164	default:
62e76326	165	*ErrP = SNMP_ERR_NOSUCHNAME;
	166
	167	break;
25c1b8b7	168	}
62e76326	169
571c3b88	170	return Answer;
571c3b88	171	}
25c1b8b7	172
d0e0c8d2	173	variable_list *
6f47fbc7	174	snmp_meshPtblFn(variable_list * Var, snint * ErrP)
571c3b88	175	{
736eb6ad	176	variable_list *Answer = NULL;
62e76326	177
81d0c856	178	struct in_addr *laddr;
d0e0c8d2	179	char *cp = NULL;
d0e0c8d2	180	peer *p = NULL;
6f47fbc7	181	int cnt = 0;
f763bb01	182	debug(49, 5) ("snmp_meshPtblFn: peer %d requested!\n", Var->name[LEN_SQ_MESH + 3]);
d0e0c8d2	183	*ErrP = SNMP_ERR_NOERROR;
f763bb01	184	laddr = oid2addr(&Var->name[LEN_SQ_MESH + 3]);
62e76326	185
6f47fbc7	186	for (p = Config.peers; p != NULL; p = p->next, cnt++)
62e76326	187	if (p->in_addr.sin_addr.s_addr == laddr->s_addr)
	188	break;
	189
d0e0c8d2	190	if (p == NULL) {
62e76326	191	*ErrP = SNMP_ERR_NOSUCHNAME;
62e76326	192	return NULL;
d0e0c8d2	193	}
62e76326	194
f763bb01	195	switch (Var->name[LEN_SQ_MESH + 2]) {
62e76326	196
81d0c856	197	case MESH_PTBL_NAME:
62e76326	198	cp = p->host;
	199	Answer = snmp_var_new(Var->name, Var->name_length);
	200	Answer->type = ASN_OCTET_STR;
	201	Answer->val_len = strlen(cp);
	202	Answer->val.string = (u_char *) xstrdup(cp);
	203	break;
	204
81d0c856	205	case MESH_PTBL_IP:
62e76326	206	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	207	(snint) p->in_addr.sin_addr.s_addr,
	208	SMI_IPADDRESS);
	209	break;
	210
81d0c856	211	case MESH_PTBL_HTTP:
62e76326	212	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	213	(snint) p->http_port,
	214	ASN_INTEGER);
	215	break;
	216
81d0c856	217	case MESH_PTBL_ICP:
62e76326	218	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	219	(snint) p->icp.port,
	220	ASN_INTEGER);
	221	break;
	222
81d0c856	223	case MESH_PTBL_TYPE:
62e76326	224	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	225	(snint) p->type,
	226	ASN_INTEGER);
	227	break;
	228
81d0c856	229	case MESH_PTBL_STATE:
62e76326	230	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	231	(snint) neighborUp(p),
	232	ASN_INTEGER);
	233	break;
	234
81d0c856	235	case MESH_PTBL_SENT:
62e76326	236	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	237	p->stats.pings_sent,
	238	ASN_INTEGER);
	239	break;
	240
81d0c856	241	case MESH_PTBL_PACKED:
62e76326	242	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	243	p->stats.pings_acked,
	244	ASN_INTEGER);
	245	break;
	246
81d0c856	247	case MESH_PTBL_FETCHES:
62e76326	248	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	249	p->stats.fetches,
	250	SMI_COUNTER32);
	251	break;
	252
81d0c856	253	case MESH_PTBL_RTT:
62e76326	254	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	255	p->stats.rtt,
	256	ASN_INTEGER);
	257	break;
	258
81d0c856	259	case MESH_PTBL_IGN:
62e76326	260	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	261	p->stats.ignored_replies,
	262	SMI_COUNTER32);
	263	break;
	264
81d0c856	265	case MESH_PTBL_KEEPAL_S:
62e76326	266	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	267	p->stats.n_keepalives_sent,
	268	SMI_COUNTER32);
	269	break;
	270
81d0c856	271	case MESH_PTBL_KEEPAL_R:
62e76326	272	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	273	p->stats.n_keepalives_recv,
	274	SMI_COUNTER32);
	275	break;
	276
571c3b88	277	default:
62e76326	278	*ErrP = SNMP_ERR_NOSUCHNAME;
62e76326	279	break;
d0e0c8d2	280	}
62e76326	281
d0e0c8d2	282	return Answer;
571c3b88	283	}
25c1b8b7	284
d0e0c8d2	285	variable_list *
6f47fbc7	286	snmp_prfSysFn(variable_list * Var, snint * ErrP)
571c3b88	287	{
736eb6ad	288	variable_list *Answer = NULL;
62e76326	289
d0e0c8d2	290	static struct rusage rusage;
f763bb01	291	debug(49, 5) ("snmp_prfSysFn: Processing request with magic %d!\n", Var->name[LEN_SQ_PRF + 1]);
d0e0c8d2	292	*ErrP = SNMP_ERR_NOERROR;
62e76326	293
f763bb01	294	switch (Var->name[LEN_SQ_PRF + 1]) {
62e76326	295
571c3b88	296	case PERF_SYS_PF:
62e76326	297	squid_getrusage(&rusage);
	298	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	299	rusage_pagefaults(&rusage),
	300	SMI_COUNTER32);
	301	break;
	302
571c3b88	303	case PERF_SYS_NUMR:
62e76326	304	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	305	IOStats.Http.reads,
	306	SMI_COUNTER32);
	307	break;
	308
571c3b88	309	case PERF_SYS_MEMUSAGE:
62e76326	310	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	311	(snint) statMemoryAccounted() >> 10,
	312	ASN_INTEGER);
	313	break;
	314
eba4a24f	315	case PERF_SYS_CPUTIME:
62e76326	316	squid_getrusage(&rusage);
	317	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	318	(snint) rusage_cputime(&rusage),
	319	ASN_INTEGER);
	320	break;
	321
eba4a24f	322	case PERF_SYS_CPUUSAGE:
62e76326	323	squid_getrusage(&rusage);
	324	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	325	(snint) dpercent(rusage_cputime(&rusage), tvSubDsec(squid_start, current_time)),
	326	ASN_INTEGER);
	327	break;
	328
571c3b88	329	case PERF_SYS_MAXRESSZ:
62e76326	330	squid_getrusage(&rusage);
	331	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	332	(snint) rusage_maxrss(&rusage),
	333	ASN_INTEGER);
	334	break;
	335
571c3b88	336	case PERF_SYS_CURLRUEXP:
62e76326	337	/* No global LRU info anymore */
	338	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	339	0,
	340	SMI_TIMETICKS);
	341	break;
	342
571c3b88	343	case PERF_SYS_CURUNLREQ:
62e76326	344	Answer = snmp_var_new_integer(Var->name, Var->name_length,
62e76326	345	(snint) statCounter.unlink.requests,
e1d20533	346	SMI_GAUGE32);
62e76326	347	break;
62e76326	348
571c3b88	349	case PERF_SYS_CURUNUSED_FD:
62e76326	350	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	351	(snint) Squid_MaxFD - Number_FD,
	352	SMI_GAUGE32);
	353	break;
	354
571c3b88	355	case PERF_SYS_CURRESERVED_FD:
62e76326	356	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	357	(snint) RESERVED_FD,
	358	SMI_GAUGE32);
	359	break;
	360
571c3b88	361	case PERF_SYS_NUMOBJCNT:
62e76326	362	Answer = snmp_var_new_integer(Var->name, Var->name_length,
62e76326	363	(snint) StoreEntry::inUseCount(),
e1d20533	364	SMI_GAUGE32);
62e76326	365	break;
62e76326	366
571c3b88	367	default:
62e76326	368	*ErrP = SNMP_ERR_NOSUCHNAME;
62e76326	369	break;
d0e0c8d2	370	}
62e76326	371
d0e0c8d2	372	return Answer;
25c1b8b7	373	}
25c1b8b7	374
d0e0c8d2	375	variable_list *
6f47fbc7	376	snmp_prfProtoFn(variable_list * Var, snint * ErrP)
25c1b8b7	377	{
736eb6ad	378	variable_list *Answer = NULL;
2ac76861	379	static StatCounters *f = NULL;
2ac76861	380	static StatCounters *l = NULL;
451b07c5	381	double x;
451b07c5	382	int minutes;
f763bb01	383	debug(49, 5) ("snmp_prfProtoFn: Processing request with magic %d!\n", Var->name[LEN_SQ_PRF]);
d0e0c8d2	384	*ErrP = SNMP_ERR_NOERROR;
62e76326	385
f763bb01	386	switch (Var->name[LEN_SQ_PRF + 1]) {
62e76326	387
2ac76861	388	case PERF_PROTOSTAT_AGGR: /* cacheProtoAggregateStats */
62e76326	389
	390	switch (Var->name[LEN_SQ_PRF + 2]) {
	391
	392	case PERF_PROTOSTAT_AGGR_HTTP_REQ:
	393	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	394	(snint) statCounter.client_http.requests,
	395	SMI_COUNTER32);
	396	break;
	397
	398	case PERF_PROTOSTAT_AGGR_HTTP_HITS:
	399	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	400	(snint) statCounter.client_http.hits,
	401	SMI_COUNTER32);
	402	break;
	403
	404	case PERF_PROTOSTAT_AGGR_HTTP_ERRORS:
	405	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	406	(snint) statCounter.client_http.errors,
	407	SMI_COUNTER32);
	408	break;
	409
	410	case PERF_PROTOSTAT_AGGR_HTTP_KBYTES_IN:
	411	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	412	(snint) statCounter.client_http.kbytes_in.kb,
	413	SMI_COUNTER32);
	414	break;
	415
	416	case PERF_PROTOSTAT_AGGR_HTTP_KBYTES_OUT:
	417	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	418	(snint) statCounter.client_http.kbytes_out.kb,
	419	SMI_COUNTER32);
	420	break;
	421
	422	case PERF_PROTOSTAT_AGGR_ICP_S:
	423	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	424	(snint) statCounter.icp.pkts_sent,
	425	SMI_COUNTER32);
	426	break;
	427
	428	case PERF_PROTOSTAT_AGGR_ICP_R:
	429	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	430	(snint) statCounter.icp.pkts_recv,
	431	SMI_COUNTER32);
	432	break;
	433
	434	case PERF_PROTOSTAT_AGGR_ICP_SKB:
	435	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	436	(snint) statCounter.icp.kbytes_sent.kb,
	437	SMI_COUNTER32);
	438	break;
	439
	440	case PERF_PROTOSTAT_AGGR_ICP_RKB:
	441	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	442	(snint) statCounter.icp.kbytes_recv.kb,
	443	SMI_COUNTER32);
	444	break;
	445
	446	case PERF_PROTOSTAT_AGGR_REQ:
	447	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	448	(snint) statCounter.server.all.requests,
	449	SMI_INTEGER);
	450	break;
	451
	452	case PERF_PROTOSTAT_AGGR_ERRORS:
453	Answer = snmp_var_new_integer(Var->name, Var->name_length,
454	(snint) statCounter.server.all.errors,
455	SMI_INTEGER);
456	break;
457
458	case PERF_PROTOSTAT_AGGR_KBYTES_IN:
459	Answer = snmp_var_new_integer(Var->name, Var->name_length,
460	(snint) statCounter.server.all.kbytes_in.kb,
461	SMI_COUNTER32);
462	break;
463
464	case PERF_PROTOSTAT_AGGR_KBYTES_OUT:
465	Answer = snmp_var_new_integer(Var->name, Var->name_length,
466	(snint) statCounter.server.all.kbytes_out.kb,
467	SMI_COUNTER32);
468	break;
469
470	case PERF_PROTOSTAT_AGGR_CURSWAP:
471	Answer = snmp_var_new_integer(Var->name, Var->name_length,
472	(snint) store_swap_size,
e1d20533	473	SMI_GAUGE32);
62e76326	474	break;
	475
	476	case PERF_PROTOSTAT_AGGR_CLIENTS:
	477	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	478	(snint) statCounter.client_http.clients,
e1d20533	479	SMI_GAUGE32);
62e76326	480	break;
	481
	482	default:
	483	*ErrP = SNMP_ERR_NOSUCHNAME;
	484	break;
	485	}
	486
	487	return Answer;
	488
451b07c5	489	case PERF_PROTOSTAT_MEDIAN:
62e76326	490
	491	if (Var->name_length == LEN_SQ_PRF + 5)
	492	minutes = Var->name[LEN_SQ_PRF + 4];
	493	else
	494	break;
	495
	496	if ((minutes < 1) \|\| (minutes > 60))
	497	break;
	498
	499	f = snmpStatGet(0);
	500
	501	l = snmpStatGet(minutes);
	502
	503	debug(49, 8) ("median: min= %d, %d l= %p , f = %p\n", minutes,
	504	Var->name[LEN_SQ_PRF + 3], l, f);
	505
	506	debug(49, 8) ("median: l= %p , f = %p\n", l, f);
	507
	508	switch (Var->name[LEN_SQ_PRF + 3]) {
	509
	510	case PERF_MEDIAN_TIME:
	511	x = minutes;
	512	break;
	513
	514	case PERF_MEDIAN_HTTP_ALL:
	515	x = statHistDeltaMedian(&l->client_http.all_svc_time,
	516	&f->client_http.all_svc_time);
	517	break;
	518
	519	case PERF_MEDIAN_HTTP_MISS:
	520	x = statHistDeltaMedian(&l->client_http.miss_svc_time,
	521	&f->client_http.miss_svc_time);
	522	break;
	523
	524	case PERF_MEDIAN_HTTP_NM:
	525	x = statHistDeltaMedian(&l->client_http.nm_svc_time,
	526	&f->client_http.nm_svc_time);
	527	break;
	528
	529	case PERF_MEDIAN_HTTP_HIT:
	530	x = statHistDeltaMedian(&l->client_http.hit_svc_time,
	531	&f->client_http.hit_svc_time);
	532	break;
	533
	534	case PERF_MEDIAN_ICP_QUERY:
	535	x = statHistDeltaMedian(&l->icp.query_svc_time, &f->icp.query_svc_time);
	536	break;
	537
	538	case PERF_MEDIAN_ICP_REPLY:
	539	x = statHistDeltaMedian(&l->icp.reply_svc_time, &f->icp.reply_svc_time);
	540	break;
	541
	542	case PERF_MEDIAN_DNS:
	543	x = statHistDeltaMedian(&l->dns.svc_time, &f->dns.svc_time);
	544	break;
	545
	546	case PERF_MEDIAN_RHR:
	547	x = statRequestHitRatio(minutes);
	548	break;
	549
	550	case PERF_MEDIAN_BHR:
	551	x = statByteHitRatio(minutes);
	552	break;
	553
554	default:
555	*ErrP = SNMP_ERR_NOSUCHNAME;
556	return NULL;
557	}
558
559	return snmp_var_new_integer(Var->name, Var->name_length,
560	(snint) x,
561	SMI_INTEGER);
d0e0c8d2	562	}
62e76326	563
451b07c5	564	*ErrP = SNMP_ERR_NOSUCHNAME;
736eb6ad	565	return NULL;
25c1b8b7	566	}