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

/*
 * $Id: snmp_agent.cc,v 1.98 2007/12/27 01:58:19 hno Exp $
 *
 * 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(appname);
        Answer->val.string = (u_char *) xstrdup(appname);
        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 = Config.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	/*
2415e202	2	* $Id: snmp_agent.cc,v 1.98 2007/12/27 01:58:19 hno Exp $
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.
	23	*
	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.
	28	*
	29	* You should have received a copy of the GNU General Public License
	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	/************************************************************************
62e76326	42
571c3b88	43	SQUID MIB Implementation
62e76326	44
571c3b88	45	************************************************************************/
25c1b8b7	46
cc192b50	47	/*
	48	* cacheSystem group
	49	*/
	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
cc192b50	87	/*
	88	* cacheConfig group
	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);
	109	Answer->type = ASN_OCTET_STR;
	110	Answer->val_len = strlen(appname);
	111	Answer->val.string = (u_char *) xstrdup(appname);
	112	break;
	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,
	127	(snint) Config.memMaxSize >> 20,
	128	ASN_INTEGER);
	129	break;
	130
	131	case CONF_ST_SWMAXSZ:
	132	Answer = snmp_var_new_integer(Var->name, Var->name_length,
c8f4eac4	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);
	158
	159	if (!(cp = Config.debugOptions))
	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
	193	/*
	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
cc192b50	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
cc192b50	209	u_int index = Var->name[LEN_SQ_MESH + 3] ;
6f47fbc7	210	for (p = Config.peers; p != NULL; p = p->next, cnt++)
cc192b50	211	{
	212	if (p->index == index)
	213	{
	214	laddr = p->in_addr ;
	215	break;
	216	}
	217	}
62e76326	218
d0e0c8d2	219	if (p == NULL) {
cc192b50	220	*ErrP = SNMP_ERR_NOSUCHNAME;
cc192b50	221	return NULL;
d0e0c8d2	222	}
62e76326	223
cc192b50	224
f763bb01	225	switch (Var->name[LEN_SQ_MESH + 2]) {
cc192b50	226	case MESH_PTBL_INDEX: // FIXME INET6: Should be visible?
	227	{
	228	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	229	(snint)p->index, SMI_INTEGER);
	230	}
	231	break;
	232
62e76326	233
81d0c856	234	case MESH_PTBL_NAME:
62e76326	235	cp = p->host;
	236	Answer = snmp_var_new(Var->name, Var->name_length);
	237	Answer->type = ASN_OCTET_STR;
	238	Answer->val_len = strlen(cp);
	239	Answer->val.string = (u_char *) xstrdup(cp);
cc192b50	240
62e76326	241	break;
62e76326	242
cc192b50	243	case MESH_PTBL_ADDR_TYPE:
	244	{
	245	int ival;
	246	ival = laddr.IsIPv4() ? INETADDRESSTYPE_IPV4 : INETADDRESSTYPE_IPV6 ;
	247	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	248	ival, SMI_INTEGER);
	249	}
	250	break;
	251	case MESH_PTBL_ADDR:
	252	{
	253	Answer = snmp_var_new(Var->name, Var->name_length);
	254	// InetAddress doesn't have its own ASN.1 type,
	255	// like IpAddr does (SMI_IPADDRESS)
	256	// See: rfc4001.txt
	257	Answer->type = ASN_OCTET_STR;
	258	char host[MAX_IPSTRLEN];
	259	laddr.NtoA(host,MAX_IPSTRLEN);
	260	Answer->val_len = strlen(host);
	261	Answer->val.string = (u_char *) xstrdup(host);
	262	}
62e76326	263	break;
62e76326	264
81d0c856	265	case MESH_PTBL_HTTP:
62e76326	266	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	267	(snint) p->http_port,
	268	ASN_INTEGER);
	269	break;
	270
81d0c856	271	case MESH_PTBL_ICP:
62e76326	272	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	273	(snint) p->icp.port,
	274	ASN_INTEGER);
	275	break;
	276
81d0c856	277	case MESH_PTBL_TYPE:
62e76326	278	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	279	(snint) p->type,
	280	ASN_INTEGER);
	281	break;
	282
81d0c856	283	case MESH_PTBL_STATE:
62e76326	284	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	285	(snint) neighborUp(p),
	286	ASN_INTEGER);
	287	break;
	288
81d0c856	289	case MESH_PTBL_SENT:
62e76326	290	Answer = snmp_var_new_integer(Var->name, Var->name_length,
62e76326	291	p->stats.pings_sent,
3a0cbfb5	292	SMI_COUNTER32);
62e76326	293	break;
62e76326	294
81d0c856	295	case MESH_PTBL_PACKED:
62e76326	296	Answer = snmp_var_new_integer(Var->name, Var->name_length,
62e76326	297	p->stats.pings_acked,
3a0cbfb5	298	SMI_COUNTER32);
62e76326	299	break;
62e76326	300
81d0c856	301	case MESH_PTBL_FETCHES:
62e76326	302	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	303	p->stats.fetches,
	304	SMI_COUNTER32);
	305	break;
	306
81d0c856	307	case MESH_PTBL_RTT:
62e76326	308	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	309	p->stats.rtt,
	310	ASN_INTEGER);
	311	break;
	312
81d0c856	313	case MESH_PTBL_IGN:
62e76326	314	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	315	p->stats.ignored_replies,
	316	SMI_COUNTER32);
	317	break;
	318
81d0c856	319	case MESH_PTBL_KEEPAL_S:
62e76326	320	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	321	p->stats.n_keepalives_sent,
	322	SMI_COUNTER32);
	323	break;
	324
81d0c856	325	case MESH_PTBL_KEEPAL_R:
62e76326	326	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	327	p->stats.n_keepalives_recv,
	328	SMI_COUNTER32);
	329	break;
	330
571c3b88	331	default:
62e76326	332	*ErrP = SNMP_ERR_NOSUCHNAME;
62e76326	333	break;
d0e0c8d2	334	}
62e76326	335
d0e0c8d2	336	return Answer;
571c3b88	337	}
25c1b8b7	338
d0e0c8d2	339	variable_list *
6f47fbc7	340	snmp_prfSysFn(variable_list * Var, snint * ErrP)
571c3b88	341	{
736eb6ad	342	variable_list *Answer = NULL;
62e76326	343
d0e0c8d2	344	static struct rusage rusage;
bf8fe701	345	debugs(49, 5, "snmp_prfSysFn: Processing request with magic " << Var->name[LEN_SQ_PRF + 1] << "!");
d0e0c8d2	346	*ErrP = SNMP_ERR_NOERROR;
62e76326	347
f763bb01	348	switch (Var->name[LEN_SQ_PRF + 1]) {
62e76326	349
571c3b88	350	case PERF_SYS_PF:
62e76326	351	squid_getrusage(&rusage);
	352	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	353	rusage_pagefaults(&rusage),
	354	SMI_COUNTER32);
	355	break;
	356
571c3b88	357	case PERF_SYS_NUMR:
62e76326	358	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	359	IOStats.Http.reads,
	360	SMI_COUNTER32);
	361	break;
	362
571c3b88	363	case PERF_SYS_MEMUSAGE:
62e76326	364	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	365	(snint) statMemoryAccounted() >> 10,
	366	ASN_INTEGER);
	367	break;
	368
eba4a24f	369	case PERF_SYS_CPUTIME:
62e76326	370	squid_getrusage(&rusage);
	371	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	372	(snint) rusage_cputime(&rusage),
	373	ASN_INTEGER);
	374	break;
	375
eba4a24f	376	case PERF_SYS_CPUUSAGE:
62e76326	377	squid_getrusage(&rusage);
	378	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	379	(snint) dpercent(rusage_cputime(&rusage), tvSubDsec(squid_start, current_time)),
	380	ASN_INTEGER);
	381	break;
	382
571c3b88	383	case PERF_SYS_MAXRESSZ:
62e76326	384	squid_getrusage(&rusage);
	385	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	386	(snint) rusage_maxrss(&rusage),
	387	ASN_INTEGER);
	388	break;
	389
571c3b88	390	case PERF_SYS_CURLRUEXP:
62e76326	391	/* No global LRU info anymore */
	392	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	393	0,
	394	SMI_TIMETICKS);
	395	break;
	396
571c3b88	397	case PERF_SYS_CURUNLREQ:
62e76326	398	Answer = snmp_var_new_integer(Var->name, Var->name_length,
62e76326	399	(snint) statCounter.unlink.requests,
e1d20533	400	SMI_GAUGE32);
62e76326	401	break;
62e76326	402
571c3b88	403	case PERF_SYS_CURUNUSED_FD:
62e76326	404	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	405	(snint) Squid_MaxFD - Number_FD,
	406	SMI_GAUGE32);
	407	break;
	408
571c3b88	409	case PERF_SYS_CURRESERVED_FD:
62e76326	410	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	411	(snint) RESERVED_FD,
	412	SMI_GAUGE32);
	413	break;
	414
146e5e78	415	case PERF_SYS_CURUSED_FD:
	416	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	417	(snint) Number_FD,
	418	SMI_GAUGE32);
	419	break;
	420
	421	case PERF_SYS_CURMAX_FD:
	422	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	423	(snint) Biggest_FD,
	424	SMI_GAUGE32);
	425	break;
	426
571c3b88	427	case PERF_SYS_NUMOBJCNT:
62e76326	428	Answer = snmp_var_new_integer(Var->name, Var->name_length,
62e76326	429	(snint) StoreEntry::inUseCount(),
e1d20533	430	SMI_GAUGE32);
62e76326	431	break;
62e76326	432
571c3b88	433	default:
62e76326	434	*ErrP = SNMP_ERR_NOSUCHNAME;
62e76326	435	break;
d0e0c8d2	436	}
62e76326	437
d0e0c8d2	438	return Answer;
25c1b8b7	439	}
25c1b8b7	440
d0e0c8d2	441	variable_list *
6f47fbc7	442	snmp_prfProtoFn(variable_list * Var, snint * ErrP)
25c1b8b7	443	{
736eb6ad	444	variable_list *Answer = NULL;
2ac76861	445	static StatCounters *f = NULL;
2ac76861	446	static StatCounters *l = NULL;
451b07c5	447	double x;
451b07c5	448	int minutes;
bf8fe701	449	debugs(49, 5, "snmp_prfProtoFn: Processing request with magic " << Var->name[LEN_SQ_PRF] << "!");
d0e0c8d2	450	*ErrP = SNMP_ERR_NOERROR;
62e76326	451
f763bb01	452	switch (Var->name[LEN_SQ_PRF + 1]) {
62e76326	453
2ac76861	454	case PERF_PROTOSTAT_AGGR: /* cacheProtoAggregateStats */
62e76326	455
	456	switch (Var->name[LEN_SQ_PRF + 2]) {
	457
	458	case PERF_PROTOSTAT_AGGR_HTTP_REQ:
	459	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	460	(snint) statCounter.client_http.requests,
	461	SMI_COUNTER32);
	462	break;
	463
	464	case PERF_PROTOSTAT_AGGR_HTTP_HITS:
	465	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	466	(snint) statCounter.client_http.hits,
	467	SMI_COUNTER32);
	468	break;
	469
	470	case PERF_PROTOSTAT_AGGR_HTTP_ERRORS:
	471	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	472	(snint) statCounter.client_http.errors,
	473	SMI_COUNTER32);
	474	break;
	475
	476	case PERF_PROTOSTAT_AGGR_HTTP_KBYTES_IN:
	477	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	478	(snint) statCounter.client_http.kbytes_in.kb,
	479	SMI_COUNTER32);
	480	break;
	481
	482	case PERF_PROTOSTAT_AGGR_HTTP_KBYTES_OUT:
	483	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	484	(snint) statCounter.client_http.kbytes_out.kb,
	485	SMI_COUNTER32);
	486	break;
	487
	488	case PERF_PROTOSTAT_AGGR_ICP_S:
	489	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	490	(snint) statCounter.icp.pkts_sent,
	491	SMI_COUNTER32);
	492	break;
	493
	494	case PERF_PROTOSTAT_AGGR_ICP_R:
	495	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	496	(snint) statCounter.icp.pkts_recv,
	497	SMI_COUNTER32);
	498	break;
	499
	500	case PERF_PROTOSTAT_AGGR_ICP_SKB:
	501	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	502	(snint) statCounter.icp.kbytes_sent.kb,
	503	SMI_COUNTER32);
	504	break;
	505
	506	case PERF_PROTOSTAT_AGGR_ICP_RKB:
	507	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	508	(snint) statCounter.icp.kbytes_recv.kb,
	509	SMI_COUNTER32);
	510	break;
	511
	512	case PERF_PROTOSTAT_AGGR_REQ:
	513	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	514	(snint) statCounter.server.all.requests,
	515	SMI_INTEGER);
	516	break;
	517
	518	case PERF_PROTOSTAT_AGGR_ERRORS:
519	Answer = snmp_var_new_integer(Var->name, Var->name_length,
520	(snint) statCounter.server.all.errors,
521	SMI_INTEGER);
522	break;
523
524	case PERF_PROTOSTAT_AGGR_KBYTES_IN:
525	Answer = snmp_var_new_integer(Var->name, Var->name_length,
526	(snint) statCounter.server.all.kbytes_in.kb,
527	SMI_COUNTER32);
528	break;
529
530	case PERF_PROTOSTAT_AGGR_KBYTES_OUT:
531	Answer = snmp_var_new_integer(Var->name, Var->name_length,
532	(snint) statCounter.server.all.kbytes_out.kb,
533	SMI_COUNTER32);
534	break;
535
536	case PERF_PROTOSTAT_AGGR_CURSWAP:
537	Answer = snmp_var_new_integer(Var->name, Var->name_length,
538	(snint) store_swap_size,
e1d20533	539	SMI_GAUGE32);
62e76326	540	break;
	541
	542	case PERF_PROTOSTAT_AGGR_CLIENTS:
	543	Answer = snmp_var_new_integer(Var->name, Var->name_length,
	544	(snint) statCounter.client_http.clients,
e1d20533	545	SMI_GAUGE32);
62e76326	546	break;
	547
	548	default:
	549	*ErrP = SNMP_ERR_NOSUCHNAME;
	550	break;
	551	}
	552
	553	return Answer;
	554
451b07c5	555	case PERF_PROTOSTAT_MEDIAN:
62e76326	556
	557	if (Var->name_length == LEN_SQ_PRF + 5)
	558	minutes = Var->name[LEN_SQ_PRF + 4];
	559	else
	560	break;
	561
	562	if ((minutes < 1) \|\| (minutes > 60))
	563	break;
	564
	565	f = snmpStatGet(0);
	566
	567	l = snmpStatGet(minutes);
	568
bf8fe701	569	debugs(49, 8, "median: min= " << minutes << ", " << Var->name[LEN_SQ_PRF + 3] << " l= " << l << " , f = " << f);
bf8fe701	570	debugs(49, 8, "median: l= " << l << " , f = " << f);
62e76326	571
	572	switch (Var->name[LEN_SQ_PRF + 3]) {
	573
	574	case PERF_MEDIAN_TIME:
	575	x = minutes;
	576	break;
	577
	578	case PERF_MEDIAN_HTTP_ALL:
	579	x = statHistDeltaMedian(&l->client_http.all_svc_time,
	580	&f->client_http.all_svc_time);
	581	break;
	582
	583	case PERF_MEDIAN_HTTP_MISS:
	584	x = statHistDeltaMedian(&l->client_http.miss_svc_time,
	585	&f->client_http.miss_svc_time);
	586	break;
	587
	588	case PERF_MEDIAN_HTTP_NM:
	589	x = statHistDeltaMedian(&l->client_http.nm_svc_time,
	590	&f->client_http.nm_svc_time);
	591	break;
	592
	593	case PERF_MEDIAN_HTTP_HIT:
	594	x = statHistDeltaMedian(&l->client_http.hit_svc_time,
	595	&f->client_http.hit_svc_time);
	596	break;
	597
	598	case PERF_MEDIAN_ICP_QUERY:
	599	x = statHistDeltaMedian(&l->icp.query_svc_time, &f->icp.query_svc_time);
	600	break;
	601
	602	case PERF_MEDIAN_ICP_REPLY:
	603	x = statHistDeltaMedian(&l->icp.reply_svc_time, &f->icp.reply_svc_time);
	604	break;
	605
	606	case PERF_MEDIAN_DNS:
	607	x = statHistDeltaMedian(&l->dns.svc_time, &f->dns.svc_time);
	608	break;
	609
	610	case PERF_MEDIAN_RHR:
	611	x = statRequestHitRatio(minutes);
	612	break;
	613
	614	case PERF_MEDIAN_BHR:
	615	x = statByteHitRatio(minutes);
	616	break;
	617
146e5e78	618	case PERF_MEDIAN_HTTP_NH:
146e5e78	619	x = statHistDeltaMedian(&l->client_http.nh_svc_time,
a56d882c	620	&f->client_http.nh_svc_time);
146e5e78	621	break;
146e5e78	622
62e76326	623	default:
	624	*ErrP = SNMP_ERR_NOSUCHNAME;
	625	return NULL;
	626	}
	627
	628	return snmp_var_new_integer(Var->name, Var->name_length,
	629	(snint) x,
	630	SMI_INTEGER);
d0e0c8d2	631	}
62e76326	632
451b07c5	633	*ErrP = SNMP_ERR_NOSUCHNAME;
736eb6ad	634	return NULL;
25c1b8b7	635	}