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

/*
 * $Id$
 *
 * DEBUG: section 49    SNMP Interface
 * AUTHOR: Kostas Anagnostakis
 *
 * SQUID Web Proxy Cache          http://www.squid-cache.org/
 * ----------------------------------------------------------
 *
 *  Squid is the result of efforts by numerous individuals from
 *  the Internet community; see the CONTRIBUTORS file for full
 *  details.   Many organizations have provided support for Squid's
 *  development; see the SPONSORS file for full details.  Squid is
 *  Copyrighted (C) 2001 by the Regents of the University of
 *  California; see the COPYRIGHT file for full details.  Squid
 *  incorporates software developed and/or copyrighted by other
 *  sources; see the CREDITS file for full details.
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.
 *
 */

#include "squid.h"
#include "cache_snmp.h"
#include "Store.h"
#include "mem_node.h"
#include "SquidMath.h"
#include "SquidTime.h"

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

 SQUID MIB Implementation

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

/*
 * cacheSystem group
 */

variable_list *
snmp_sysFn(variable_list * Var, snint * ErrP)
{
    variable_list *Answer = NULL;
    MemBuf tmp;
    debugs(49, 5, "snmp_sysFn: Processing request:" << snmpDebugOid(Var->name, Var->name_length, tmp));
    *ErrP = SNMP_ERR_NOERROR;

    switch (Var->name[LEN_SQ_SYS]) {

    case SYSVMSIZ:
        Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                      mem_node::StoreMemSize() >> 10,
                                      ASN_INTEGER);
        break;

    case SYSSTOR:
        Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                      Store::Root().currentSize(),
                                      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() >> 10),
                                          ASN_INTEGER);
            break;

        case CONF_ST_SWHIWM:
            Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                          (snint) Config.Swap.highWaterMark,
                                          ASN_INTEGER);
            break;

        case CONF_ST_SWLOWM:
            Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                          (snint) Config.Swap.lowWaterMark,
                                          ASN_INTEGER);
            break;

        default:
            *ErrP = SNMP_ERR_NOSUCHNAME;
            break;
        }

        break;

    case CONF_LOG_FAC:
        Answer = snmp_var_new(Var->name, Var->name_length);

        if (!(cp = Debug::debugOptions))
            cp = "None";

        Answer->type = ASN_OCTET_STR;

        Answer->val_len = strlen(cp);

        Answer->val.string = (u_char *) xstrdup(cp);

        break;

    case CONF_UNIQNAME:
        Answer = snmp_var_new(Var->name, Var->name_length);

        cp = uniqueHostname();

        Answer->type = ASN_OCTET_STR;

        Answer->val_len = strlen(cp);

        Answer->val.string = (u_char *) xstrdup(cp);

        break;

    default:
        *ErrP = SNMP_ERR_NOSUCHNAME;

        break;
    }

    return Answer;
}


/*
 * cacheMesh group
 *   - cachePeerTable
 */
variable_list *
snmp_meshPtblFn(variable_list * Var, snint * ErrP)
{
    variable_list *Answer = NULL;

    Ip::Address laddr;
    char *cp = NULL;
    peer *p = NULL;
    int cnt = 0;
    debugs(49, 5, "snmp_meshPtblFn: peer " << Var->name[LEN_SQ_MESH + 3] << " requested!");
    *ErrP = SNMP_ERR_NOERROR;

    u_int index = Var->name[LEN_SQ_MESH + 3] ;
    for (p = Config.peers; p != NULL; p = p->next, cnt++) {
        if (p->index == index) {
            laddr = p->in_addr ;
            break;
        }
    }

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


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


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

        break;

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

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

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

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

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

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

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

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

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

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

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

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

    default:
        *ErrP = SNMP_ERR_NOSUCHNAME;
        break;
    }

    return Answer;
}

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

    static struct rusage rusage;
    debugs(49, 5, "snmp_prfSysFn: Processing request with magic " << Var->name[LEN_SQ_PRF + 1] << "!");
    *ErrP = SNMP_ERR_NOERROR;

    switch (Var->name[LEN_SQ_PRF + 1]) {

    case PERF_SYS_PF:
        squid_getrusage(&rusage);
        Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                      rusage_pagefaults(&rusage),
                                      SMI_COUNTER32);
        break;

    case PERF_SYS_NUMR:
        Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                      IOStats.Http.reads,
                                      SMI_COUNTER32);
        break;

    case PERF_SYS_MEMUSAGE:
        Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                      (snint) statMemoryAccounted() >> 10,
                                      ASN_INTEGER);
        break;

    case PERF_SYS_CPUTIME:
        squid_getrusage(&rusage);
        Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                      (snint) rusage_cputime(&rusage),
                                      ASN_INTEGER);
        break;

    case PERF_SYS_CPUUSAGE:
        squid_getrusage(&rusage);
        Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                      (snint) Math::doublePercent(rusage_cputime(&rusage), tvSubDsec(squid_start, current_time)),
                                      ASN_INTEGER);
        break;

    case PERF_SYS_MAXRESSZ:
        squid_getrusage(&rusage);
        Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                      (snint) rusage_maxrss(&rusage),
                                      ASN_INTEGER);
        break;

    case PERF_SYS_CURLRUEXP:
        /* No global LRU info anymore */
        Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                      0,
                                      SMI_TIMETICKS);
        break;

    case PERF_SYS_CURUNLREQ:
        Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                      (snint) statCounter.unlink.requests,
                                      SMI_GAUGE32);
        break;

    case PERF_SYS_CURUNUSED_FD:
        Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                      (snint) Squid_MaxFD - Number_FD,
                                      SMI_GAUGE32);
        break;

    case PERF_SYS_CURRESERVED_FD:
        Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                      (snint) RESERVED_FD,
                                      SMI_GAUGE32);
        break;

    case PERF_SYS_CURUSED_FD:
        Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                      (snint) Number_FD,
                                      SMI_GAUGE32);
        break;

    case PERF_SYS_CURMAX_FD:
        Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                      (snint) Biggest_FD,
                                      SMI_GAUGE32);
        break;

    case PERF_SYS_NUMOBJCNT:
        Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                      (snint) StoreEntry::inUseCount(),
                                      SMI_GAUGE32);
        break;

    default:
        *ErrP = SNMP_ERR_NOSUCHNAME;
        break;
    }

    return Answer;
}

variable_list *
snmp_prfProtoFn(variable_list * Var, snint * ErrP)
{
    variable_list *Answer = NULL;
    static StatCounters *f = NULL;
    static StatCounters *l = NULL;
    double x;
    int minutes;
    debugs(49, 5, "snmp_prfProtoFn: Processing request with magic " << Var->name[LEN_SQ_PRF] << "!");
    *ErrP = SNMP_ERR_NOERROR;

    switch (Var->name[LEN_SQ_PRF + 1]) {

    case PERF_PROTOSTAT_AGGR:	/* cacheProtoAggregateStats */

        switch (Var->name[LEN_SQ_PRF + 2]) {

        case PERF_PROTOSTAT_AGGR_HTTP_REQ:
            Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                          (snint) statCounter.client_http.requests,
                                          SMI_COUNTER32);
            break;

        case PERF_PROTOSTAT_AGGR_HTTP_HITS:
            Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                          (snint) statCounter.client_http.hits,
                                          SMI_COUNTER32);
            break;

        case PERF_PROTOSTAT_AGGR_HTTP_ERRORS:
            Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                          (snint) statCounter.client_http.errors,
                                          SMI_COUNTER32);
            break;

        case PERF_PROTOSTAT_AGGR_HTTP_KBYTES_IN:
            Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                          (snint) statCounter.client_http.kbytes_in.kb,
                                          SMI_COUNTER32);
            break;

        case PERF_PROTOSTAT_AGGR_HTTP_KBYTES_OUT:
            Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                          (snint) statCounter.client_http.kbytes_out.kb,
                                          SMI_COUNTER32);
            break;

        case PERF_PROTOSTAT_AGGR_ICP_S:
            Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                          (snint) statCounter.icp.pkts_sent,
                                          SMI_COUNTER32);
            break;

        case PERF_PROTOSTAT_AGGR_ICP_R:
            Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                          (snint) statCounter.icp.pkts_recv,
                                          SMI_COUNTER32);
            break;

        case PERF_PROTOSTAT_AGGR_ICP_SKB:
            Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                          (snint) statCounter.icp.kbytes_sent.kb,
                                          SMI_COUNTER32);
            break;

        case PERF_PROTOSTAT_AGGR_ICP_RKB:
            Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                          (snint) statCounter.icp.kbytes_recv.kb,
                                          SMI_COUNTER32);
            break;

        case PERF_PROTOSTAT_AGGR_REQ:
            Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                          (snint) statCounter.server.all.requests,
                                          SMI_INTEGER);
            break;

        case PERF_PROTOSTAT_AGGR_ERRORS:
            Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                          (snint) statCounter.server.all.errors,
                                          SMI_INTEGER);
            break;

        case PERF_PROTOSTAT_AGGR_KBYTES_IN:
            Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                          (snint) statCounter.server.all.kbytes_in.kb,
                                          SMI_COUNTER32);
            break;

        case PERF_PROTOSTAT_AGGR_KBYTES_OUT:
            Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                          (snint) statCounter.server.all.kbytes_out.kb,
                                          SMI_COUNTER32);
            break;

        case PERF_PROTOSTAT_AGGR_CURSWAP:
            Answer = snmp_var_new_integer(Var->name, Var->name_length,
                                          (snint) Store::Root().currentSize(),
                                          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.all_svc_time,
                                    &f->client_http.all_svc_time);
            break;

        case PERF_MEDIAN_HTTP_MISS:
            x = statHistDeltaMedian(&l->client_http.miss_svc_time,
                                    &f->client_http.miss_svc_time);
            break;

        case PERF_MEDIAN_HTTP_NM:
            x = statHistDeltaMedian(&l->client_http.nm_svc_time,
                                    &f->client_http.nm_svc_time);
            break;

        case PERF_MEDIAN_HTTP_HIT:
            x = statHistDeltaMedian(&l->client_http.hit_svc_time,
                                    &f->client_http.hit_svc_time);
            break;

        case PERF_MEDIAN_ICP_QUERY:
            x = statHistDeltaMedian(&l->icp.query_svc_time, &f->icp.query_svc_time);
            break;

        case PERF_MEDIAN_ICP_REPLY:
            x = statHistDeltaMedian(&l->icp.reply_svc_time, &f->icp.reply_svc_time);
            break;

        case PERF_MEDIAN_DNS:
            x = statHistDeltaMedian(&l->dns.svc_time, &f->dns.svc_time);
            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.nh_svc_time,
                                    &f->client_http.nh_svc_time);
            break;

        default:
            *ErrP = SNMP_ERR_NOSUCHNAME;
            return NULL;
        }

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

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