src/snmp_agent.cc

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