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