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