src/snmp_agent.cc

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