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

/*
 * 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 "CachePeer.h"
#include "cache_snmp.h"
#include "globals.h"
#include "mem_node.h"
#include "neighbors.h"
#include "snmp_agent.h"
#include "snmp_core.h"
#include "StatCounters.h"
#include "StatHist.h"
#include "SquidConfig.h"
#include "SquidMath.h"
#include "SquidTime.h"
#include "stat.h"
#include "Store.h"
#include "tools.h"

/************************************************************************

 SQUID MIB Implementation

 ************************************************************************/

/*
 * cacheSystem group
 */

variable_list *
snmp_sysFn(variable_list * Var, snint * ErrP)
{
    variable_list *Answer = NULL;
    MemBuf tmp;
    debugs(49, 5, "snmp_sysFn: Processing request:" << snmpDebugOid(Var->name, Var->name_length, tmp));
    *ErrP = SNMP_ERR_NOERROR;

    switch (Var->name[LEN_SQ_SYS]) {

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

    case SYSSTOR:
        Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                      Store::Root().currentSize() >> 10,
                                      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;
}

/*
 * cacheConfig group
 */
variable_list *
snmp_confFn(variable_list * Var, snint * ErrP)
{
    variable_list *Answer = NULL;
    const char *cp = NULL;
    debugs(49, 5, "snmp_confFn: Processing request with magic " << 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(APP_SHORTNAME);
        Answer->val.string = (u_char *) xstrdup(APP_SHORTNAME);
        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) (Store::Root().maxSize() >> 20),
                                          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 = Debug::debugOptions))
            cp = "None";

        Answer->type = ASN_OCTET_STR;

        Answer->val_len = strlen(cp);

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

        break;

    case CONF_UNIQNAME:
        Answer = snmp_var_new(Var->name, Var->name_length);

        cp = uniqueHostname();

        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;
}

/*
 * cacheMesh group
 *   - cachePeerTable
 */
variable_list *
snmp_meshPtblFn(variable_list * Var, snint * ErrP)
{
    variable_list *Answer = NULL;

    Ip::Address laddr;
    char *cp = NULL;
    CachePeer *p = NULL;
    int cnt = 0;
    debugs(49, 5, "snmp_meshPtblFn: peer " << Var->name[LEN_SQ_MESH + 3] << " requested!");
    *ErrP = SNMP_ERR_NOERROR;

    u_int index = Var->name[LEN_SQ_MESH + 3] ;
    for (p = Config.peers; p != NULL; p = p->next, ++cnt) {
        if (p->index == index) {
            laddr = p->in_addr ;
            break;
        }
    }

    if (p == NULL) {
        *ErrP = SNMP_ERR_NOSUCHNAME;
        return NULL;
    }

    switch (Var->name[LEN_SQ_MESH + 2]) {
    case MESH_PTBL_INDEX: { // FIXME INET6: Should be visible?
        Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                      (snint)p->index, SMI_INTEGER);
    }
    break;

    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_ADDR_TYPE: {
        int ival;
        ival = laddr.isIPv4() ? INETADDRESSTYPE_IPV4 : INETADDRESSTYPE_IPV6 ;
        Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                      ival, SMI_INTEGER);
    }
    break;
    case MESH_PTBL_ADDR: {
        Answer = snmp_var_new(Var->name, Var->name_length);
        // InetAddress doesn't have its own ASN.1 type,
        // like IpAddr does (SMI_IPADDRESS)
        // See: rfc4001.txt
        Answer->type = ASN_OCTET_STR;
        char host[MAX_IPSTRLEN];
        laddr.toStr(host,MAX_IPSTRLEN);
        Answer->val_len = strlen(host);
        Answer->val.string =  (u_char *) xstrdup(host);
    }
    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,
                                      SMI_COUNTER32);
        break;

    case MESH_PTBL_PACKED:
        Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                      p->stats.pings_acked,
                                      SMI_COUNTER32);
        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;
    debugs(49, 5, "snmp_prfSysFn: Processing request with magic " << 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) Math::doublePercent(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_CURUSED_FD:
        Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                      (snint) Number_FD,
                                      SMI_GAUGE32);
        break;

    case PERF_SYS_CURMAX_FD:
        Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                      (snint) Biggest_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;
    debugs(49, 5, "snmp_prfProtoFn: Processing request with magic " << 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::Root().currentSize() >> 10,
                                          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);

        debugs(49, 8, "median: min= " << minutes << ", " << Var->name[LEN_SQ_PRF + 3] << " l= " << l << " , f = " << f);
        debugs(49, 8, "median: l= " << l << " , f = " << 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.allSvcTime,
                                    f->client_http.allSvcTime);
            break;

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

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

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

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

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

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

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

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

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