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 /*
 199  * cacheMesh group
 200  *   - cachePeerTable
 201  */
 202 variable_list *
 203 snmp_meshPtblFn(variable_list * Var, snint * ErrP)
 204 {
 205     variable_list *Answer = NULL;
 206
 207     Ip::Address laddr;
 208     char *cp = NULL;
 209     peer *p = NULL;
 210     int cnt = 0;
 211     debugs(49, 5, "snmp_meshPtblFn: peer " << Var->name[LEN_SQ_MESH + 3] << " requested!");
 212     *ErrP = SNMP_ERR_NOERROR;
 213
 214     u_int index = Var->name[LEN_SQ_MESH + 3] ;
 215     for (p = Config.peers; p != NULL; p = p->next, ++cnt) {
 216         if (p->index == index) {
 217             laddr = p->in_addr ;
 218             break;
 219         }
 220     }
 221
 222     if (p == NULL) {
 223         *ErrP = SNMP_ERR_NOSUCHNAME;
 224         return NULL;
 225     }
 226
 227
 228     switch (Var->name[LEN_SQ_MESH + 2]) {
 229     case MESH_PTBL_INDEX: { // FIXME INET6: Should be visible?
 230         Answer = snmp_var_new_integer(Var->name, Var->name_length,
 231                                       (snint)p->index, SMI_INTEGER);
 232     }
 233     break;
 234
 235
 236     case MESH_PTBL_NAME:
 237         cp = p->host;
 238         Answer = snmp_var_new(Var->name, Var->name_length);
 239         Answer->type = ASN_OCTET_STR;
 240         Answer->val_len = strlen(cp);
 241         Answer->val.string = (u_char *) xstrdup(cp);
 242
 243         break;
 244
 245     case MESH_PTBL_ADDR_TYPE: {
 246         int ival;
 247         ival = laddr.IsIPv4() ? INETADDRESSTYPE_IPV4 : INETADDRESSTYPE_IPV6 ;
 248         Answer = snmp_var_new_integer(Var->name, Var->name_length,
 249                                       ival, SMI_INTEGER);
 250     }
 251     break;
 252     case MESH_PTBL_ADDR: {
 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     }
 263     break;
 264
 265     case MESH_PTBL_HTTP:
 266         Answer = snmp_var_new_integer(Var->name, Var->name_length,
 267                                       (snint) p->http_port,
 268                                       ASN_INTEGER);
 269         break;
 270
 271     case MESH_PTBL_ICP:
 272         Answer = snmp_var_new_integer(Var->name, Var->name_length,
 273                                       (snint) p->icp.port,
 274                                       ASN_INTEGER);
 275         break;
 276
 277     case MESH_PTBL_TYPE:
 278         Answer = snmp_var_new_integer(Var->name, Var->name_length,
 279                                       (snint) p->type,
 280                                       ASN_INTEGER);
 281         break;
 282
 283     case MESH_PTBL_STATE:
 284         Answer = snmp_var_new_integer(Var->name, Var->name_length,
 285                                       (snint) neighborUp(p),
 286                                       ASN_INTEGER);
 287         break;
 288
 289     case MESH_PTBL_SENT:
 290         Answer = snmp_var_new_integer(Var->name, Var->name_length,
 291                                       p->stats.pings_sent,
 292                                       SMI_COUNTER32);
 293         break;
 294
 295     case MESH_PTBL_PACKED:
 296         Answer = snmp_var_new_integer(Var->name, Var->name_length,
 297                                       p->stats.pings_acked,
 298                                       SMI_COUNTER32);
 299         break;
 300
 301     case MESH_PTBL_FETCHES:
 302         Answer = snmp_var_new_integer(Var->name, Var->name_length,
 303                                       p->stats.fetches,
 304                                       SMI_COUNTER32);
 305         break;
 306
 307     case MESH_PTBL_RTT:
 308         Answer = snmp_var_new_integer(Var->name, Var->name_length,
 309                                       p->stats.rtt,
 310                                       ASN_INTEGER);
 311         break;
 312
 313     case MESH_PTBL_IGN:
 314         Answer = snmp_var_new_integer(Var->name, Var->name_length,
 315                                       p->stats.ignored_replies,
 316                                       SMI_COUNTER32);
 317         break;
 318
 319     case MESH_PTBL_KEEPAL_S:
 320         Answer = snmp_var_new_integer(Var->name, Var->name_length,
 321                                       p->stats.n_keepalives_sent,
 322                                       SMI_COUNTER32);
 323         break;
 324
 325     case MESH_PTBL_KEEPAL_R:
 326         Answer = snmp_var_new_integer(Var->name, Var->name_length,
 327                                       p->stats.n_keepalives_recv,
 328                                       SMI_COUNTER32);
 329         break;
 330
 331     default:
 332         *ErrP = SNMP_ERR_NOSUCHNAME;
 333         break;
 334     }
 335
 336     return Answer;
 337 }
 338
 339 variable_list *
 340 snmp_prfSysFn(variable_list * Var, snint * ErrP)
 341 {
 342     variable_list *Answer = NULL;
 343
 344     static struct rusage rusage;
 345     debugs(49, 5, "snmp_prfSysFn: Processing request with magic " << Var->name[LEN_SQ_PRF + 1] << "!");
 346     *ErrP = SNMP_ERR_NOERROR;
 347
 348     switch (Var->name[LEN_SQ_PRF + 1]) {
 349
 350     case PERF_SYS_PF:
 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
 357     case PERF_SYS_NUMR:
 358         Answer = snmp_var_new_integer(Var->name, Var->name_length,
 359                                       IOStats.Http.reads,
 360                                       SMI_COUNTER32);
 361         break;
 362
 363     case PERF_SYS_MEMUSAGE:
 364         Answer = snmp_var_new_integer(Var->name, Var->name_length,
 365                                       (snint) statMemoryAccounted() >> 10,
 366                                       ASN_INTEGER);
 367         break;
 368
 369     case PERF_SYS_CPUTIME:
 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
 376     case PERF_SYS_CPUUSAGE:
 377         squid_getrusage(&rusage);
 378         Answer = snmp_var_new_integer(Var->name, Var->name_length,
 379                                       (snint) Math::doublePercent(rusage_cputime(&rusage), tvSubDsec(squid_start, current_time)),
 380                                       ASN_INTEGER);
 381         break;
 382
 383     case PERF_SYS_MAXRESSZ:
 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
 390     case PERF_SYS_CURLRUEXP:
 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
 397     case PERF_SYS_CURUNLREQ:
 398         Answer = snmp_var_new_integer(Var->name, Var->name_length,
 399                                       (snint) statCounter.unlink.requests,
 400                                       SMI_GAUGE32);
 401         break;
 402
 403     case PERF_SYS_CURUNUSED_FD:
 404         Answer = snmp_var_new_integer(Var->name, Var->name_length,
 405                                       (snint) Squid_MaxFD - Number_FD,
 406                                       SMI_GAUGE32);
 407         break;
 408
 409     case PERF_SYS_CURRESERVED_FD:
 410         Answer = snmp_var_new_integer(Var->name, Var->name_length,
 411                                       (snint) RESERVED_FD,
 412                                       SMI_GAUGE32);
 413         break;
 414
 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
 427     case PERF_SYS_NUMOBJCNT:
 428         Answer = snmp_var_new_integer(Var->name, Var->name_length,
 429                                       (snint) StoreEntry::inUseCount(),
 430                                       SMI_GAUGE32);
 431         break;
 432
 433     default:
 434         *ErrP = SNMP_ERR_NOSUCHNAME;
 435         break;
 436     }
 437
 438     return Answer;
 439 }
 440
 441 variable_list *
 442 snmp_prfProtoFn(variable_list * Var, snint * ErrP)
 443 {
 444     variable_list *Answer = NULL;
 445     static StatCounters *f = NULL;
 446     static StatCounters *l = NULL;
 447     double x;
 448     int minutes;
 449     debugs(49, 5, "snmp_prfProtoFn: Processing request with magic " << Var->name[LEN_SQ_PRF] << "!");
 450     *ErrP = SNMP_ERR_NOERROR;
 451
 452     switch (Var->name[LEN_SQ_PRF + 1]) {
 453
 454     case PERF_PROTOSTAT_AGGR:   /* cacheProtoAggregateStats */
 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::Root().currentSize() >> 10,
 539                                           SMI_GAUGE32);
 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,
 545                                           SMI_GAUGE32);
 546             break;
 547
 548         default:
 549             *ErrP = SNMP_ERR_NOSUCHNAME;
 550             break;
 551         }
 552
 553         return Answer;
 554
 555     case PERF_PROTOSTAT_MEDIAN:
 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
 569         debugs(49, 8, "median: min= " << minutes << ", " << Var->name[LEN_SQ_PRF + 3] << " l= " << l << " , f = " << f);
 570         debugs(49, 8, "median: l= " << l << " , f = " << f);
 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.allSvcTime,
 580                                     f->client_http.allSvcTime);
 581             break;
 582
 583         case PERF_MEDIAN_HTTP_MISS:
 584             x = statHistDeltaMedian(l->client_http.missSvcTime,
 585                                     f->client_http.missSvcTime);
 586             break;
 587
 588         case PERF_MEDIAN_HTTP_NM:
 589             x = statHistDeltaMedian(l->client_http.nearMissSvcTime,
 590                                     f->client_http.nearMissSvcTime);
 591             break;
 592
 593         case PERF_MEDIAN_HTTP_HIT:
 594             x = statHistDeltaMedian(l->client_http.hitSvcTime,
 595                                     f->client_http.hitSvcTime);
 596             break;
 597
 598         case PERF_MEDIAN_ICP_QUERY:
 599             x = statHistDeltaMedian(l->icp.querySvcTime, f->icp.querySvcTime);
 600             break;
 601
 602         case PERF_MEDIAN_ICP_REPLY:
 603             x = statHistDeltaMedian(l->icp.replySvcTime, f->icp.replySvcTime);
 604             break;
 605
 606         case PERF_MEDIAN_DNS:
 607             x = statHistDeltaMedian(l->dns.svcTime, f->dns.svcTime);
 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
 618         case PERF_MEDIAN_HTTP_NH:
 619             x = statHistDeltaMedian(l->client_http.nearHitSvcTime,
 620                                     f->client_http.nearHitSvcTime);
 621             break;
 622
 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);
 631     }
 632
 633     *ErrP = SNMP_ERR_NOSUCHNAME;
 634     return NULL;
 635 }