src/snmp_agent.cc

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