]> git.ipfire.org Git - thirdparty/squid.git/blame_incremental - src/snmp_agent.cc
projects / thirdparty / squid.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Simplify appending SBuf to String (#2108)
[thirdparty/squid.git] / src / snmp_agent.cc
... / ...
CommitLineData
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
43variable_list *
44snmp_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 */
82variable_list *
83snmp_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 */
188variable_list *
189snmp_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
323variable_list *
324snmp_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
431variable_list *
432snmp_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
Mirror of https://github.com/squid-cache/squid.git