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

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