[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 "SquidTime.h"

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

 SQUID MIB Implementation

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

/*
 * cacheSystem group
 */

variable_list *
snmp_sysFn(variable_list * Var, snint * ErrP)
{
    variable_list *Answer = NULL;
    debugs(49, 5, "snmp_sysFn: Processing request:");
    snmpDebugOid(5, Var->name, Var->name_length);
    *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_swap_size,
                                      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;

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