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

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