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

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