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

/*
 * Copyright (C) 1996-2025 The Squid Software Foundation and contributors
 *
 * Squid software is distributed under GPLv2+ license and includes
 * contributions from numerous individuals and organizations.
 * Please see the COPYING and CONTRIBUTORS files for details.
 */

/* DEBUG: section 49    SNMP Interface */

#include "squid.h"
#include "cache_snmp.h"
#include "CachePeer.h"
#include "CachePeers.h"
#include "globals.h"
#include "mem/Meter.h"
#include "mem/Stats.h"
#include "mem_node.h"
#include "neighbors.h"
#include "snmp_agent.h"
#include "snmp_core.h"
#include "SquidConfig.h"
#include "SquidMath.h"
#include "stat.h"
#include "StatCounters.h"
#include "StatHist.h"
#include "Store.h"
#include "store/Controller.h"
#include "StoreStats.h"
#include "tools.h"
#include "util.h"

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

 SQUID MIB Implementation

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

/*
 * cacheSystem group
 */

variable_list *
snmp_sysFn(variable_list * Var, snint * ErrP)
{
    variable_list *Answer = nullptr;
    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 = nullptr;
    const char *cp = nullptr;
    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 = nullptr;

    Ip::Address laddr;
    char *cp = nullptr;
    CachePeer *p = nullptr;
    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 (const auto &peer: CurrentCachePeers()) {
        if (peer->index == index) {
            laddr = peer->in_addr ;
            p = peer.get();
            break;
        }
    }

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

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

    case MESH_PTBL_NAME:
        cp = p->host;
        Answer = snmp_var_new(Var->name, Var->name_length);
        Answer->type = ASN_OCTET_STR;
        Answer->val_len = strlen(cp);
        Answer->val.string = (u_char *) xstrdup(cp);

        break;

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

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

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

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

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

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

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

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

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

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

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

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

    default:
        *ErrP = SNMP_ERR_NOSUCHNAME;
        break;
    }

    return Answer;
}

variable_list *
snmp_prfSysFn(variable_list * Var, snint * ErrP)
{
    variable_list *Answer = nullptr;

    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: {
        Mem::PoolStats stats;
        Mem::GlobalStats(stats);
        Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                      (snint) stats.meter->alloc.currentLevel() >> 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: {
        StoreInfoStats stats;
        Store::Root().getStats(stats);
        Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                      (snint) (stats.mem.count + stats.swap.count),
                                      SMI_GAUGE32);
        break;
    }

    default:
        *ErrP = SNMP_ERR_NOSUCHNAME;
        break;
    }

    return Answer;
}

variable_list *
snmp_prfProtoFn(variable_list * Var, snint * ErrP)
{
    variable_list *Answer = nullptr;
    static StatCounters *f = nullptr;
    static StatCounters *l = nullptr;
    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 nullptr;
        }

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

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