src/snmp_agent.cc

   1
   2 /*
   3  * $Id: snmp_agent.cc,v 1.80 2001/02/07 18:56:52 hno Exp $
   4  *
   5  * DEBUG: section 49     SNMP Interface
   6  * AUTHOR: Kostas Anagnostakis
   7  *
   8  * SQUID Web Proxy Cache          http://www.squid-cache.org/
   9  * ----------------------------------------------------------
  10  *
  11  *  Squid is the result of efforts by numerous individuals from
  12  *  the Internet community; see the CONTRIBUTORS file for full
  13  *  details.   Many organizations have provided support for Squid's
  14  *  development; see the SPONSORS file for full details.  Squid is
  15  *  Copyrighted (C) 2001 by the Regents of the University of
  16  *  California; see the COPYRIGHT file for full details.  Squid
  17  *  incorporates software developed and/or copyrighted by other
  18  *  sources; see the CREDITS file for full details.
  19  *
  20  *  This program is free software; you can redistribute it and/or modify
  21  *  it under the terms of the GNU General Public License as published by
  22  *  the Free Software Foundation; either version 2 of the License, or
  23  *  (at your option) any later version.
  24  *
  25  *  This program is distributed in the hope that it will be useful,
  26  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  27  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  28  *  GNU General Public License for more details.
  29  *
  30  *  You should have received a copy of the GNU General Public License
  31  *  along with this program; if not, write to the Free Software
  32  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.
  33  *
  34  */
  35
  36
  37 #include "squid.h"
  38 #include "cache_snmp.h"
  39
  40 /************************************************************************
  41
  42  SQUID MIB Implementation
  43
  44  ************************************************************************/
  45
  46 variable_list *
  47 snmp_sysFn(variable_list * Var, snint * ErrP)
  48 {
  49     variable_list *Answer = NULL;
  50     debug(49, 5) ("snmp_sysFn: Processing request:\n", Var->name[LEN_SQ_SYS]);
  51     snmpDebugOid(5, Var->name, Var->name_length);
  52     *ErrP = SNMP_ERR_NOERROR;
  53     switch (Var->name[LEN_SQ_SYS]) {
  54     case SYSVMSIZ:
  55         Answer = snmp_var_new_integer(Var->name, Var->name_length,
  56             store_mem_size >> 10,
  57             ASN_INTEGER);
  58         break;
  59     case SYSSTOR:
  60         Answer = snmp_var_new_integer(Var->name, Var->name_length,
  61             store_swap_size,
  62             ASN_INTEGER);
  63         break;
  64     case SYS_UPTIME:
  65         Answer = snmp_var_new_integer(Var->name, Var->name_length,
  66             tvSubDsec(squid_start, current_time) * 100,
  67             SMI_TIMETICKS);
  68         break;
  69     default:
  70         *ErrP = SNMP_ERR_NOSUCHNAME;
  71         break;
  72     }
  73     return Answer;
  74 }
  75
  76 variable_list *
  77 snmp_confFn(variable_list * Var, snint * ErrP)
  78 {
  79     variable_list *Answer = NULL;
  80     char *cp = NULL;
  81     debug(49, 5) ("snmp_confFn: Processing request with magic %d!\n", Var->name[8]);
  82     *ErrP = SNMP_ERR_NOERROR;
  83     switch (Var->name[LEN_SQ_CONF]) {
  84     case CONF_ADMIN:
  85         Answer = snmp_var_new(Var->name, Var->name_length);
  86         Answer->type = ASN_OCTET_STR;
  87         Answer->val_len = strlen(Config.adminEmail);
  88         Answer->val.string = (u_char *) xstrdup(Config.adminEmail);
  89         break;
  90     case CONF_VERSION:
  91         Answer = snmp_var_new(Var->name, Var->name_length);
  92         Answer->type = ASN_OCTET_STR;
  93         Answer->val_len = strlen(appname);
  94         Answer->val.string = (u_char *) xstrdup(appname);
  95         break;
  96     case CONF_VERSION_ID:
  97         Answer = snmp_var_new(Var->name, Var->name_length);
  98         Answer->type = ASN_OCTET_STR;
  99         Answer->val_len = strlen(SQUID_VERSION);
 100         Answer->val.string = (u_char *) xstrdup(SQUID_VERSION);
 101         break;
 102     case CONF_STORAGE:
 103         switch (Var->name[LEN_SQ_CONF + 1]) {
 104         case CONF_ST_MMAXSZ:
 105             Answer = snmp_var_new_integer(Var->name, Var->name_length,
 106                 (snint) Config.memMaxSize >> 20,
 107                 ASN_INTEGER);
 108             break;
 109         case CONF_ST_SWMAXSZ:
 110             Answer = snmp_var_new_integer(Var->name, Var->name_length,
 111                 (snint) Config.Swap.maxSize >> 10,
 112                 ASN_INTEGER);
 113             break;
 114         case CONF_ST_SWHIWM:
 115             Answer = snmp_var_new_integer(Var->name, Var->name_length,
 116                 (snint) Config.Swap.highWaterMark,
 117                 ASN_INTEGER);
 118             break;
 119         case CONF_ST_SWLOWM:
 120             Answer = snmp_var_new_integer(Var->name, Var->name_length,
 121                 (snint) Config.Swap.lowWaterMark,
 122                 ASN_INTEGER);
 123             break;
 124         default:
 125             *ErrP = SNMP_ERR_NOSUCHNAME;
 126             break;
 127         }
 128         break;
 129     case CONF_LOG_FAC:
 130         Answer = snmp_var_new(Var->name, Var->name_length);
 131         if (!(cp = Config.debugOptions))
 132             cp = "None";
 133         Answer->type = ASN_OCTET_STR;
 134         Answer->val_len = strlen(cp);
 135         Answer->val.string = (u_char *) xstrdup(cp);
 136         break;
 137     default:
 138         *ErrP = SNMP_ERR_NOSUCHNAME;
 139         break;
 140     }
 141     return Answer;
 142 }
 143
 144 variable_list *
 145 snmp_meshPtblFn(variable_list * Var, snint * ErrP)
 146 {
 147     variable_list *Answer = NULL;
 148     struct in_addr *laddr;
 149     char *cp = NULL;
 150     peer *p = NULL;
 151     int cnt = 0;
 152     debug(49, 5) ("snmp_meshPtblFn: peer %d requested!\n", Var->name[LEN_SQ_MESH + 3]);
 153     *ErrP = SNMP_ERR_NOERROR;
 154     laddr = oid2addr(&Var->name[LEN_SQ_MESH + 3]);
 155     for (p = Config.peers; p != NULL; p = p->next, cnt++)
 156         if (p->in_addr.sin_addr.s_addr == laddr->s_addr)
 157             break;
 158     if (p == NULL) {
 159         *ErrP = SNMP_ERR_NOSUCHNAME;
 160         return NULL;
 161     }
 162     switch (Var->name[LEN_SQ_MESH + 2]) {
 163     case MESH_PTBL_NAME:
 164         cp = p->host;
 165         Answer = snmp_var_new(Var->name, Var->name_length);
 166         Answer->type = ASN_OCTET_STR;
 167         Answer->val_len = strlen(cp);
 168         Answer->val.string = (u_char *) xstrdup(cp);
 169         break;
 170     case MESH_PTBL_IP:
 171         Answer = snmp_var_new_integer(Var->name, Var->name_length,
 172             (snint) p->in_addr.sin_addr.s_addr,
 173             SMI_IPADDRESS);
 174         break;
 175     case MESH_PTBL_HTTP:
 176         Answer = snmp_var_new_integer(Var->name, Var->name_length,
 177             (snint) p->http_port,
 178             ASN_INTEGER);
 179         break;
 180     case MESH_PTBL_ICP:
 181         Answer = snmp_var_new_integer(Var->name, Var->name_length,
 182             (snint) p->icp.port,
 183             ASN_INTEGER);
 184         break;
 185     case MESH_PTBL_TYPE:
 186         Answer = snmp_var_new_integer(Var->name, Var->name_length,
 187             (snint) p->type,
 188             ASN_INTEGER);
 189         break;
 190     case MESH_PTBL_STATE:
 191         Answer = snmp_var_new_integer(Var->name, Var->name_length,
 192             (snint) neighborUp(p),
 193             ASN_INTEGER);
 194         break;
 195     case MESH_PTBL_SENT:
 196         Answer = snmp_var_new_integer(Var->name, Var->name_length,
 197             p->stats.pings_sent,
 198             ASN_INTEGER);
 199         break;
 200     case MESH_PTBL_PACKED:
 201         Answer = snmp_var_new_integer(Var->name, Var->name_length,
 202             p->stats.pings_acked,
 203             ASN_INTEGER);
 204         break;
 205     case MESH_PTBL_FETCHES:
 206         Answer = snmp_var_new_integer(Var->name, Var->name_length,
 207             p->stats.fetches,
 208             SMI_COUNTER32);
 209         break;
 210     case MESH_PTBL_RTT:
 211         Answer = snmp_var_new_integer(Var->name, Var->name_length,
 212             p->stats.rtt,
 213             ASN_INTEGER);
 214         break;
 215     case MESH_PTBL_IGN:
 216         Answer = snmp_var_new_integer(Var->name, Var->name_length,
 217             p->stats.ignored_replies,
 218             SMI_COUNTER32);
 219         break;
 220     case MESH_PTBL_KEEPAL_S:
 221         Answer = snmp_var_new_integer(Var->name, Var->name_length,
 222             p->stats.n_keepalives_sent,
 223             SMI_COUNTER32);
 224         break;
 225     case MESH_PTBL_KEEPAL_R:
 226         Answer = snmp_var_new_integer(Var->name, Var->name_length,
 227             p->stats.n_keepalives_recv,
 228             SMI_COUNTER32);
 229         break;
 230     default:
 231         *ErrP = SNMP_ERR_NOSUCHNAME;
 232         break;
 233     }
 234     return Answer;
 235 }
 236
 237 variable_list *
 238 snmp_prfSysFn(variable_list * Var, snint * ErrP)
 239 {
 240     variable_list *Answer = NULL;
 241     static struct rusage rusage;
 242     debug(49, 5) ("snmp_prfSysFn: Processing request with magic %d!\n", Var->name[LEN_SQ_PRF + 1]);
 243     *ErrP = SNMP_ERR_NOERROR;
 244     switch (Var->name[LEN_SQ_PRF + 1]) {
 245     case PERF_SYS_PF:
 246         squid_getrusage(&rusage);
 247         Answer = snmp_var_new_integer(Var->name, Var->name_length,
 248             rusage_pagefaults(&rusage),
 249             SMI_COUNTER32);
 250         break;
 251     case PERF_SYS_NUMR:
 252         Answer = snmp_var_new_integer(Var->name, Var->name_length,
 253             IOStats.Http.reads,
 254             SMI_COUNTER32);
 255         break;
 256     case PERF_SYS_MEMUSAGE:
 257         Answer = snmp_var_new_integer(Var->name, Var->name_length,
 258             (snint) statMemoryAccounted() >> 10,
 259             ASN_INTEGER);
 260         break;
 261     case PERF_SYS_CPUTIME:
 262         squid_getrusage(&rusage);
 263         Answer = snmp_var_new_integer(Var->name, Var->name_length,
 264             (snint) rusage_cputime(&rusage),
 265             ASN_INTEGER);
 266         break;
 267     case PERF_SYS_CPUUSAGE:
 268         squid_getrusage(&rusage);
 269         Answer = snmp_var_new_integer(Var->name, Var->name_length,
 270             (snint) dpercent(rusage_cputime(&rusage), tvSubDsec(squid_start, current_time)),
 271             ASN_INTEGER);
 272         break;
 273     case PERF_SYS_MAXRESSZ:
 274         squid_getrusage(&rusage);
 275         Answer = snmp_var_new_integer(Var->name, Var->name_length,
 276             (snint) rusage_maxrss(&rusage),
 277             ASN_INTEGER);
 278         break;
 279     case PERF_SYS_CURLRUEXP:
 280         /* No global LRU info anymore */
 281         Answer = snmp_var_new_integer(Var->name, Var->name_length,
 282             0,
 283             SMI_TIMETICKS);
 284         break;
 285     case PERF_SYS_CURUNLREQ:
 286         Answer = snmp_var_new_integer(Var->name, Var->name_length,
 287             (snint) statCounter.unlink.requests,
 288             SMI_COUNTER32);
 289         break;
 290     case PERF_SYS_CURUNUSED_FD:
 291         Answer = snmp_var_new_integer(Var->name, Var->name_length,
 292             (snint) Squid_MaxFD - Number_FD,
 293             SMI_GAUGE32);
 294         break;
 295     case PERF_SYS_CURRESERVED_FD:
 296         Answer = snmp_var_new_integer(Var->name, Var->name_length,
 297             (snint) RESERVED_FD,
 298             SMI_GAUGE32);
 299         break;
 300     case PERF_SYS_NUMOBJCNT:
 301         Answer = snmp_var_new_integer(Var->name, Var->name_length,
 302             (snint) memInUse(MEM_STOREENTRY),
 303             SMI_COUNTER32);
 304         break;
 305     default:
 306         *ErrP = SNMP_ERR_NOSUCHNAME;
 307         break;
 308     }
 309     return Answer;
 310 }
 311
 312 variable_list *
 313 snmp_prfProtoFn(variable_list * Var, snint * ErrP)
 314 {
 315     variable_list *Answer = NULL;
 316     static StatCounters *f = NULL;
 317     static StatCounters *l = NULL;
 318     double x;
 319     int minutes;
 320     debug(49, 5) ("snmp_prfProtoFn: Processing request with magic %d!\n", Var->name[LEN_SQ_PRF]);
 321     *ErrP = SNMP_ERR_NOERROR;
 322     switch (Var->name[LEN_SQ_PRF + 1]) {
 323     case PERF_PROTOSTAT_AGGR:   /* cacheProtoAggregateStats */
 324         switch (Var->name[LEN_SQ_PRF + 2]) {
 325         case PERF_PROTOSTAT_AGGR_HTTP_REQ:
 326             Answer = snmp_var_new_integer(Var->name, Var->name_length,
 327                 (snint) statCounter.client_http.requests,
 328                 SMI_COUNTER32);
 329             break;
 330         case PERF_PROTOSTAT_AGGR_HTTP_HITS:
 331             Answer = snmp_var_new_integer(Var->name, Var->name_length,
 332                 (snint) statCounter.client_http.hits,
 333                 SMI_COUNTER32);
 334             break;
 335         case PERF_PROTOSTAT_AGGR_HTTP_ERRORS:
 336             Answer = snmp_var_new_integer(Var->name, Var->name_length,
 337                 (snint) statCounter.client_http.errors,
 338                 SMI_COUNTER32);
 339             break;
 340         case PERF_PROTOSTAT_AGGR_HTTP_KBYTES_IN:
 341             Answer = snmp_var_new_integer(Var->name, Var->name_length,
 342                 (snint) statCounter.client_http.kbytes_in.kb,
 343                 SMI_COUNTER32);
 344             break;
 345         case PERF_PROTOSTAT_AGGR_HTTP_KBYTES_OUT:
 346             Answer = snmp_var_new_integer(Var->name, Var->name_length,
 347                 (snint) statCounter.client_http.kbytes_out.kb,
 348                 SMI_COUNTER32);
 349             break;
 350         case PERF_PROTOSTAT_AGGR_ICP_S:
 351             Answer = snmp_var_new_integer(Var->name, Var->name_length,
 352                 (snint) statCounter.icp.pkts_sent,
 353                 SMI_COUNTER32);
 354             break;
 355         case PERF_PROTOSTAT_AGGR_ICP_R:
 356             Answer = snmp_var_new_integer(Var->name, Var->name_length,
 357                 (snint) statCounter.icp.pkts_recv,
 358                 SMI_COUNTER32);
 359             break;
 360         case PERF_PROTOSTAT_AGGR_ICP_SKB:
 361             Answer = snmp_var_new_integer(Var->name, Var->name_length,
 362                 (snint) statCounter.icp.kbytes_sent.kb,
 363                 SMI_COUNTER32);
 364             break;
 365         case PERF_PROTOSTAT_AGGR_ICP_RKB:
 366             Answer = snmp_var_new_integer(Var->name, Var->name_length,
 367                 (snint) statCounter.icp.kbytes_recv.kb,
 368                 SMI_COUNTER32);
 369             break;
 370         case PERF_PROTOSTAT_AGGR_REQ:
 371             Answer = snmp_var_new_integer(Var->name, Var->name_length,
 372                 (snint) statCounter.server.all.requests,
 373                 SMI_INTEGER);
 374             break;
 375         case PERF_PROTOSTAT_AGGR_ERRORS:
 376             Answer = snmp_var_new_integer(Var->name, Var->name_length,
 377                 (snint) statCounter.server.all.errors,
 378                 SMI_INTEGER);
 379             break;
 380         case PERF_PROTOSTAT_AGGR_KBYTES_IN:
 381             Answer = snmp_var_new_integer(Var->name, Var->name_length,
 382                 (snint) statCounter.server.all.kbytes_in.kb,
 383                 SMI_COUNTER32);
 384             break;
 385         case PERF_PROTOSTAT_AGGR_KBYTES_OUT:
 386             Answer = snmp_var_new_integer(Var->name, Var->name_length,
 387                 (snint) statCounter.server.all.kbytes_out.kb,
 388                 SMI_COUNTER32);
 389             break;
 390         case PERF_PROTOSTAT_AGGR_CURSWAP:
 391             Answer = snmp_var_new_integer(Var->name, Var->name_length,
 392                 (snint) store_swap_size,
 393                 SMI_COUNTER32);
 394             break;
 395         case PERF_PROTOSTAT_AGGR_CLIENTS:
 396             Answer = snmp_var_new_integer(Var->name, Var->name_length,
 397                 (snint) statCounter.client_http.clients,
 398                 SMI_COUNTER32);
 399             break;
 400         default:
 401             *ErrP = SNMP_ERR_NOSUCHNAME;
 402             break;
 403         }
 404         return Answer;
 405     case PERF_PROTOSTAT_MEDIAN:
 406         if (Var->name_length == LEN_SQ_PRF + 5)
 407             minutes = Var->name[LEN_SQ_PRF + 4];
 408         else
 409             break;
 410         if ((minutes < 1) || (minutes > 60))
 411             break;
 412         f = snmpStatGet(0);
 413         l = snmpStatGet(minutes);
 414         debug(49, 8) ("median: min= %d, %d l= %x , f = %x\n", minutes,
 415             Var->name[LEN_SQ_PRF + 3], l, f);
 416         debug(49, 8) ("median: l= %x , f = %x\n", l, f);
 417         switch (Var->name[LEN_SQ_PRF + 3]) {
 418         case PERF_MEDIAN_TIME:
 419             x = minutes;
 420             break;
 421         case PERF_MEDIAN_HTTP_ALL:
 422             x = statHistDeltaMedian(&l->client_http.all_svc_time,
 423                 &f->client_http.all_svc_time);
 424             break;
 425         case PERF_MEDIAN_HTTP_MISS:
 426             x = statHistDeltaMedian(&l->client_http.miss_svc_time,
 427                 &f->client_http.miss_svc_time);
 428             break;
 429         case PERF_MEDIAN_HTTP_NM:
 430             x = statHistDeltaMedian(&l->client_http.nm_svc_time,
 431                 &f->client_http.nm_svc_time);
 432             break;
 433         case PERF_MEDIAN_HTTP_HIT:
 434             x = statHistDeltaMedian(&l->client_http.hit_svc_time,
 435                 &f->client_http.hit_svc_time);
 436             break;
 437         case PERF_MEDIAN_ICP_QUERY:
 438             x = statHistDeltaMedian(&l->icp.query_svc_time, &f->icp.query_svc_time);
 439             break;
 440         case PERF_MEDIAN_ICP_REPLY:
 441             x = statHistDeltaMedian(&l->icp.reply_svc_time, &f->icp.reply_svc_time);
 442             break;
 443         case PERF_MEDIAN_DNS:
 444             x = statHistDeltaMedian(&l->dns.svc_time, &f->dns.svc_time);
 445             break;
 446         case PERF_MEDIAN_RHR:
 447             x = statRequestHitRatio(minutes);
 448             break;
 449         case PERF_MEDIAN_BHR:
 450             x = statByteHitRatio(minutes);
 451             break;
 452         default:
 453             *ErrP = SNMP_ERR_NOSUCHNAME;
 454             return NULL;
 455         }
 456         return snmp_var_new_integer(Var->name, Var->name_length,
 457             (snint) x,
 458             SMI_INTEGER);
 459     }
 460     *ErrP = SNMP_ERR_NOSUCHNAME;
 461     return NULL;
 462 }