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