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