Skip to Content
Last modified by Frank Fock on 2024/05/25 10:09
From version 3.1
edited by Frank Fock
on 2024/05/25 09:58
Change comment: There is no comment for this version
To version 6.1
edited by Frank Fock
on 2024/05/25 10:06
Change comment: There is no comment for this version

Summary

Details

Page properties
Content
... ... @@ -1,3 +1,5 @@
1 +
2 +
1 1  In AGENT++ prior to 4.3.0, there were many MibEntry relations and the usage of the central Mib instance organised by static class members called "instance". Although this reduces code size and makes initialisation routines easier it makes it impossible to run more than one Mib instance in a process.
2 2  
3 3  In AGENT++ 4.3.0 this has been refactored by lot of internal changes, which had two main goals:
... ... @@ -57,3 +57,668 @@
57 57  + mib.add(new MPDGroup(v3mp));
58 58  {{/code}}
59 59  {{/info}}
62 +
63 +A complete sample agent C++ code with multiple full featured agents in one process is show below.
64 +
65 +It provides per **SNMP agent port** the following features:
66 +
67 +* USM
68 +* MPv3
69 +* Request queue and processing
70 +* MIB counters
71 +* Independent MIB modules including persistency
72 +* SNMPv3 context support
73 +* An agent may contain the same or different MIB modules/objects
74 +
75 +{{info}}
76 +Multi-Agent Sample Code
77 +
78 +{{code}}
79 +/*_############################################################################
80 + _##
81 + _## AGENT++ 4.0 - agent.cpp
82 + _##
83 + _## Copyright (C) 2000-2020 Frank Fock and Jochen Katz (agentpp.com)
84 + _##
85 + _## Licensed under the Apache License, Version 2.0 (the "License");
86 + _## you may not use this file except in compliance with the License.
87 + _## You may obtain a copy of the License at
88 + _##
89 + _## http://www.apache.org/licenses/LICENSE-2.0
90 + _##
91 + _## Unless required by applicable law or agreed to in writing, software
92 + _## distributed under the License is distributed on an "AS IS" BASIS,
93 + _## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
94 + _## See the License for the specific language governing permissions and
95 + _## limitations under the License.
96 + _##
97 + _##########################################################################*/
98 +
99 +#include <stdlib.h>
100 +#include <signal.h>
101 +
102 +#include <agent_pp/agent++.h>
103 +#include <agent_pp/snmp_group.h>
104 +#include <agent_pp/system_group.h>
105 +#include <agent_pp/snmp_target_mib.h>
106 +#include <agent_pp/snmp_notification_mib.h>
107 +#include <agent_pp/snmp_community_mib.h>
108 +#include <agent_pp/notification_originator.h>
109 +#include <agent_pp/notification_log_mib.h>
110 +#include <agent_pp/agentpp_simulation_mib.h>
111 +#include <agent_pp/agentpp_config_mib.h>
112 +#include <agent_pp/v3_mib.h>
113 +#include <agent_pp/mib_policy.h>
114 +#include <agent_pp/vacm.h>
115 +#include <agent_pp/threads.h>
116 +#include <agent_pp/tools.h>
117 +
118 +#include <snmp_pp/oid_def.h>
119 +#include <snmp_pp/mp_v3.h>
120 +#include <snmp_pp/log.h>
121 +
122 +#include "atm_mib.h"
123 +#include "agentpp_notifytest_mib.h"
124 +#include "agentpp_test_mib.h"
125 +
126 +
127 +#ifdef SNMP_PP_NAMESPACE
128 +using namespace Snmp_pp;
129 +#endif
130 +
131 +#ifdef AGENTPP_NAMESPACE
132 +using namespace Agentpp;
133 +#endif
134 +
135 +static const char* loggerModuleName = "agent++.multi.agent";
136 +
137 +// table size policies
138 +
139 +
140 +// globals:
141 +const unsigned int MAX_NUMBER_OF_AGENTS = 10;
142 +
143 +bool go = TRUE;
144 +
145 +unsigned short port[MAX_NUMBER_OF_AGENTS];
146 +#ifdef _SNMPv3
147 +const table_size_def table_sizes[4] =
148 +{ table_size_def(oidUsmUserEntry, 30),
149 + table_size_def(oidVacmSecurityToGroupEntry, 30),
150 + table_size_def(oidVacmAccessEntry, 30),
151 + table_size_def(oidVacmViewTreeFamilyEntry, 30)
152 +};
153 +MibTableSizePolicy policy(table_sizes, 4, 5000);
154 +#endif
155 +
156 +
157 +static void sig(int signo)
158 +{
159 + if ((signo == SIGTERM) || (signo == SIGINT) ||
160 + (signo == SIGSEGV)) {
161 +
162 + printf ("\n");
163 +
164 + switch (signo) {
165 + case SIGSEGV: {
166 + printf ("Segmentation fault, aborting.\n");
167 + exit(1);
168 + }
169 + case SIGTERM:
170 + case SIGINT: {
171 + if (go) {
172 + go = FALSE;
173 + printf ("User abort\n");
174 + }
175 + }
176 + }
177 + }
178 +}
179 +
180 +
181 +void init_signals()
182 +{
183 + signal (SIGTERM, sig);
184 + signal (SIGINT, sig);
185 + signal (SIGSEGV, sig);
186 +}
187 +
188 +
189 +
190 +void init(Mib& mib, const NS_SNMP OctetStr& engineID, const UdpAddress& inaddr)
191 +{
192 + OctetStr sysDescr("AGENT++v");
193 + sysDescr += AGENTPP_VERSION_STRING;
194 + sysDescr += " ATM Simulation Agent (";
195 + sysDescr += inaddr.get_printable();
196 + sysDescr += ")";
197 + mib.add(new sysGroup(sysDescr.get_printable(),
198 + "1.3.6.1.4.1.4976", 10));
199 + mib.add(new snmpGroup());
200 + mib.add(new TestAndIncr(oidSnmpSetSerialNo));
201 + mib.add(new atm_mib());
202 + mib.add(new agentpp_simulation_mib());
203 + mib.add(new agentpp_notifytest_mib(&mib));
204 + mib.add(new agentpp_test_mib());
205 + mib.add(new snmp_target_mib());
206 +#ifdef _SNMPv3
207 + mib.add(new snmp_community_mib(&mib));
208 +#endif
209 + mib.add(new snmp_notification_mib());
210 +#ifdef _SNMPv3
211 +#ifdef _NO_THREADS
212 + mib.add(new agentpp_config_mib(&mib));
213 +#else
214 + mib.add(new agentpp_config_mib(&mib));
215 +#endif
216 + mib.add(new notification_log_mib(&mib));
217 +
218 + OctetStr nonDefaultContext("other");
219 + mib.add(nonDefaultContext, new atm_mib());
220 +
221 + v3MP* v3mp = mib.get_request_list()->get_v3mp();
222 + UsmUserTable *uut = new UsmUserTable(v3mp);
223 +
224 + uut->addNewRow("unsecureUser",
225 + SNMP_AUTHPROTOCOL_NONE,
226 + SNMP_PRIVPROTOCOL_NONE, "", "", engineID, false);
227 +
228 + uut->addNewRow("MD5",
229 + SNMP_AUTHPROTOCOL_HMACMD5,
230 + SNMP_PRIVPROTOCOL_NONE,
231 + "MD5UserAuthPassword", "", engineID, false);
232 +
233 + uut->addNewRow("SHA",
234 + SNMP_AUTHPROTOCOL_HMACSHA,
235 + SNMP_PRIVPROTOCOL_NONE,
236 + "SHAUserAuthPassword", "", engineID, false);
237 +
238 + uut->addNewRow("MD5DES",
239 + SNMP_AUTHPROTOCOL_HMACMD5,
240 + SNMP_PRIVPROTOCOL_DES,
241 + "MD5DESUserAuthPassword",
242 + "MD5DESUserPrivPassword", engineID, false);
243 +
244 + uut->addNewRow("SHADES",
245 + SNMP_AUTHPROTOCOL_HMACSHA,
246 + SNMP_PRIVPROTOCOL_DES,
247 + "SHADESUserAuthPassword",
248 + "SHADESUserPrivPassword", engineID, false);
249 +
250 + uut->addNewRow("MD53DES",
251 + SNMP_AUTHPROTOCOL_HMACMD5,
252 + SNMP_PRIVPROTOCOL_3DESEDE,
253 + "MD53DESUserAuthPassword",
254 + "MD53DESUserPrivPassword", engineID, false);
255 +
256 + uut->addNewRow("SHA3DES",
257 + SNMP_AUTHPROTOCOL_HMACSHA,
258 + SNMP_PRIVPROTOCOL_3DESEDE,
259 + "SHA3DESUserAuthPassword",
260 + "SHA3DESUserPrivPassword", engineID, false);
261 +
262 + uut->addNewRow("MD5IDEA",
263 + SNMP_AUTHPROTOCOL_HMACMD5,
264 + SNMP_PRIVPROTOCOL_IDEA,
265 + "MD5IDEAUserAuthPassword",
266 + "MD5IDEAUserPrivPassword", engineID, false);
267 +
268 + uut->addNewRow("SHAIDEA",
269 + SNMP_AUTHPROTOCOL_HMACSHA,
270 + SNMP_PRIVPROTOCOL_IDEA,
271 + "SHAIDEAUserAuthPassword",
272 + "SHAIDEAUserPrivPassword", engineID, false);
273 +
274 + uut->addNewRow("MD5AES128",
275 + SNMP_AUTHPROTOCOL_HMACMD5,
276 + SNMP_PRIVPROTOCOL_AES128,
277 + "MD5AES128UserAuthPassword",
278 + "MD5AES128UserPrivPassword", engineID, false);
279 +
280 + MibTableRow* r = uut->addNewRow("SHAAES128",
281 + SNMP_AUTHPROTOCOL_HMACSHA,
282 + SNMP_PRIVPROTOCOL_AES128,
283 + "SHAAES128UserAuthPassword",
284 + "SHAAES128UserPrivPassword", engineID, false);
285 + if (r) { uut->set_storage_type(r, storageType_permanent); }
286 +
287 + uut->addNewRow("MD5AES192",
288 + SNMP_AUTHPROTOCOL_HMACMD5,
289 + SNMP_PRIVPROTOCOL_AES192,
290 + "MD5AES192UserAuthPassword",
291 + "MD5AES192UserPrivPassword", engineID, false);
292 +
293 + uut->addNewRow("SHAAES192",
294 + SNMP_AUTHPROTOCOL_HMACSHA,
295 + SNMP_PRIVPROTOCOL_AES192,
296 + "SHAAES192UserAuthPassword",
297 + "SHAAES192UserPrivPassword", engineID, false);
298 +
299 + r = uut->addNewRow("MD5AES256",
300 + SNMP_AUTHPROTOCOL_HMACMD5,
301 + SNMP_PRIVPROTOCOL_AES256,
302 + "MD5AES256UserAuthPassword",
303 + "MD5AES256UserPrivPassword", engineID, false);
304 + if (r) { uut->set_storage_type(r, storageType_readOnly); }
305 +
306 + uut->addNewRow("SHAAES256",
307 + SNMP_AUTHPROTOCOL_HMACSHA,
308 + SNMP_PRIVPROTOCOL_AES256,
309 + "SHAAES256UserAuthPassword",
310 + "SHAAES256UserPrivPassword", engineID, false);
311 +
312 + uut->addNewRow("SHA512AES256",
313 + SNMP_AUTHPROTOCOL_HMAC384SHA512,
314 + SNMP_PRIVPROTOCOL_AES256,
315 + "SHA512AES256UserAuthPassword",
316 + "SHA512AES256UserPrivPassword", engineID, false);
317 +
318 + uut->addNewRow("SHA384AES128",
319 + SNMP_AUTHPROTOCOL_HMAC256SHA384,
320 + SNMP_PRIVPROTOCOL_AES256,
321 + "SHA384AES128UserAuthPassword",
322 + "SHA384AES128UserPrivPassword", engineID, false);
323 +
324 + uut->addNewRow("SHA256AES128",
325 + SNMP_AUTHPROTOCOL_HMAC192SHA256,
326 + SNMP_PRIVPROTOCOL_AES128,
327 + "SHA256AES128UserAuthPassword",
328 + "SHA256AES128UserPrivPassword", engineID, false);
329 +
330 + uut->addNewRow("SHA224AES128",
331 + SNMP_AUTHPROTOCOL_HMAC128SHA224,
332 + SNMP_PRIVPROTOCOL_AES128,
333 + "SHA224AES128UserAuthPassword",
334 + "SHA224AES128UserPrivPassword", engineID, false);
335 +
336 + // add non persistent USM statistics
337 + mib.add(new UsmStats(v3mp));
338 + // add the USM MIB - usm_mib MibGroup is used to
339 + // make user added entries persistent
340 + mib.add(new usm_mib(uut));
341 + // add non persistent SNMPv3 engine object
342 + mib.add(new V3SnmpEngine(v3mp));
343 + mib.add(new MPDGroup(v3mp));
344 +#endif
345 +}
346 +
347 +class SnmpAgent: public Runnable {
348 +
349 +public:
350 + SnmpAgent(const UdpAddress& address): Runnable() {
351 + inaddr = address;
352 + }
353 + virtual ~SnmpAgent() { }
354 + virtual void run();
355 +
356 +protected:
357 + UdpAddress inaddr;
358 +};
359 +
360 +OctetStr& path(OctetStr& path)
361 +{
362 + for (int i=0; i<path.len(); i++) {
363 + if (path[i] == '/') {
364 + path[i] = '_';
365 + }
366 + }
367 + return path;
368 +}
369 +
370 +void SnmpAgent::run() {
371 + Mib* mib;
372 + RequestList* reqList;
373 + int status;
374 + // bind localhost only -> agent will not be reachable from
375 + // outside
376 + // UdpAddress inaddr("127.0.0.1");
377 + Snmpx snmp(status, inaddr);
378 +
379 + if (status == SNMP_CLASS_SUCCESS) {
380 +
381 + LOG_BEGIN(loggerModuleName, EVENT_LOG | 1);
382 + LOG("main: SNMP listen address");
383 + LOG(inaddr.get_printable());
384 + LOG_END;
385 + }
386 + else {
387 + LOG_BEGIN(loggerModuleName, ERROR_LOG | 0);
388 + LOG("main: SNMP port init failed");
389 + LOG(status);
390 + LOG(Snmp::error_msg(status));
391 + LOG_END;
392 + exit(1);
393 + }
394 +
395 + OctetStr persistentObjectsPath(".config/");
396 + OctetStr bootCounterFile(".config_bc_");
397 + persistentObjectsPath += inaddr.get_printable();
398 + bootCounterFile += inaddr.get_printable();
399 + persistentObjectsPath += "/";
400 + // Make sure persistent objects path exists:
401 + if (!AgentTools::make_path(persistentObjectsPath.get_printable())) {
402 + LOG_BEGIN(loggerModuleName, WARNING_LOG | 1);
403 + LOG("Directory for storing persistent data could not be created (dir)");
404 + LOG(persistentObjectsPath.get_printable());
405 + LOG_END;
406 + }
407 + mib = new Mib(persistentObjectsPath, path(bootCounterFile));
408 +
409 +#ifdef _SNMPv3
410 + unsigned int snmpEngineBoots = 0;
411 + OctetStr engineId(SnmpEngineID::create_engine_id(inaddr.get_port()));
412 +
413 + // you may use your own methods to load/store this counter
414 + status = mib->get_boot_counter(engineId, snmpEngineBoots);
415 + if ((status != SNMPv3_OK) && (status < SNMPv3_FILEOPEN_ERROR)) {
416 + LOG_BEGIN(loggerModuleName, ERROR_LOG | 0);
417 + LOG("main: Error loading snmpEngineBoots counter (status)");
418 + LOG(status);
419 + LOG_END;
420 + exit(1);
421 + }
422 +
423 + snmpEngineBoots++;
424 + status = mib->set_boot_counter(engineId, snmpEngineBoots);
425 + if (status != SNMPv3_OK) {
426 + LOG_BEGIN(loggerModuleName, ERROR_LOG | 0);
427 + LOG("main: Error saving snmpEngineBoots counter (status)");
428 + LOG(status);
429 + LOG_END;
430 + exit(1);
431 + }
432 +
433 + int stat;
434 + v3MP *v3mp = new v3MP(engineId, snmpEngineBoots, stat);
435 + snmp.set_mpv3(v3mp);
436 +#endif
437 + reqList = new RequestList(mib);
438 +#ifdef _SNMPv3
439 + // register v3MP
440 + reqList->set_v3mp(v3mp);
441 +#endif
442 + // register requestList for outgoing requests
443 + mib->set_request_list(reqList);
444 +
445 + // add supported objects
446 + init(*mib, engineId, inaddr);
447 +
448 + reqList->set_snmp(&snmp);
449 +
450 +#ifdef _SNMPv3
451 + // register VACM
452 + Vacm* vacm = new Vacm(*mib);
453 + reqList->set_vacm(vacm);
454 +
455 + // initialize security information
456 + vacm->addNewContext("");
457 + vacm->addNewContext("other");
458 +
459 + // Add new entries to the SecurityToGroupTable.
460 + // Used to determine the group a given SecurityName belongs to.
461 + // User "new" of the USM belongs to newGroup
462 +
463 + vacm->addNewGroup(SNMP_SECURITY_MODEL_USM, "new",
464 + "newGroup", storageType_nonVolatile);
465 +
466 + vacm->addNewGroup(SNMP_SECURITY_MODEL_USM, "test",
467 + "testGroup", storageType_nonVolatile);
468 + vacm->addNewGroup(SNMP_SECURITY_MODEL_V2, "public",
469 + "v1v2group", storageType_nonVolatile);
470 + vacm->addNewGroup(SNMP_SECURITY_MODEL_V1, "public",
471 + "v1v2group", storageType_nonVolatile);
472 + vacm->addNewGroup(SNMP_SECURITY_MODEL_USM, "initial",
473 + "initial", storageType_nonVolatile);
474 + vacm->addNewGroup(SNMP_SECURITY_MODEL_USM, "unsecureUser",
475 + "newGroup", storageType_nonVolatile);
476 + vacm->addNewGroup(SNMP_SECURITY_MODEL_USM, "MD5",
477 + "testNoPrivGroup", storageType_nonVolatile);
478 + vacm->addNewGroup(SNMP_SECURITY_MODEL_USM, "SHA",
479 + "testNoPrivGroup", storageType_nonVolatile);
480 + vacm->addNewGroup(SNMP_SECURITY_MODEL_USM, "MD5DES",
481 + "testGroup", storageType_nonVolatile);
482 + vacm->addNewGroup(SNMP_SECURITY_MODEL_USM, "SHADES",
483 + "testGroup", storageType_nonVolatile);
484 + vacm->addNewGroup(SNMP_SECURITY_MODEL_USM, "MD53DES",
485 + "testGroup", storageType_nonVolatile);
486 + vacm->addNewGroup(SNMP_SECURITY_MODEL_USM, "SHA3DES",
487 + "testGroup", storageType_nonVolatile);
488 + vacm->addNewGroup(SNMP_SECURITY_MODEL_USM, "MD5IDEA",
489 + "testGroup", storageType_nonVolatile);
490 + vacm->addNewGroup(SNMP_SECURITY_MODEL_USM, "SHAIDEA",
491 + "testGroup", storageType_nonVolatile);
492 + vacm->addNewGroup(SNMP_SECURITY_MODEL_USM, "MD5AES128",
493 + "testGroup", storageType_nonVolatile);
494 + vacm->addNewGroup(SNMP_SECURITY_MODEL_USM, "SHAAES128",
495 + "testGroup", storageType_nonVolatile);
496 + vacm->addNewGroup(SNMP_SECURITY_MODEL_USM, "MD5AES192",
497 + "testGroup", storageType_nonVolatile);
498 + vacm->addNewGroup(SNMP_SECURITY_MODEL_USM, "SHAAES192",
499 + "testGroup", storageType_nonVolatile);
500 + vacm->addNewGroup(SNMP_SECURITY_MODEL_USM, "MD5AES256",
501 + "testGroup", storageType_nonVolatile);
502 + vacm->addNewGroup(SNMP_SECURITY_MODEL_USM, "SHAAES256",
503 + "testGroup", storageType_nonVolatile);
504 + vacm->addNewGroup(SNMP_SECURITY_MODEL_USM, "SHA512AES256",
505 + "testGroup", storageType_nonVolatile);
506 + vacm->addNewGroup(SNMP_SECURITY_MODEL_USM, "SHA384AES128",
507 + "testGroup", storageType_nonVolatile);
508 + vacm->addNewGroup(SNMP_SECURITY_MODEL_USM, "SHA256AES128",
509 + "testGroup", storageType_nonVolatile);
510 + vacm->addNewGroup(SNMP_SECURITY_MODEL_USM, "SHA224AES128",
511 + "testGroup", storageType_nonVolatile);
512 +
513 + // remove a group with:
514 + //vacm->deleteGroup(SNMP_SECURITY_MODEL_USM, "neu");
515 +
516 + // Set access rights of groups.
517 + // The group "newGroup" (when using the USM with a security
518 + // level >= noAuthNoPriv within context "") would have full access
519 + // (read, write, notify) to all objects in view "newView".
520 + vacm->addNewAccessEntry("newGroup",
521 + "other", // context
522 + SNMP_SECURITY_MODEL_USM,
523 + SNMP_SECURITY_LEVEL_NOAUTH_NOPRIV,
524 + match_exact, // context must mach exactly
525 + // alternatively: match_prefix
526 + "newView", // readView
527 + "newView", // writeView
528 + "newView", // notifyView
529 + storageType_nonVolatile);
530 + vacm->addNewAccessEntry("testGroup", "",
531 + SNMP_SECURITY_MODEL_USM,
532 + SNMP_SECURITY_LEVEL_AUTH_PRIV,
533 + match_prefix,
534 + "testView", "testView",
535 + "testView", storageType_nonVolatile);
536 + vacm->addNewAccessEntry("testNoPrivGroup", "",
537 + SNMP_SECURITY_MODEL_USM,
538 + SNMP_SECURITY_LEVEL_AUTH_NOPRIV,
539 + match_prefix,
540 + "testView", "testView",
541 + "testView", storageType_nonVolatile);
542 + vacm->addNewAccessEntry("testNoPrivGroup", "",
543 + SNMP_SECURITY_MODEL_USM,
544 + SNMP_SECURITY_LEVEL_NOAUTH_NOPRIV,
545 + match_prefix,
546 + "testView", "testView",
547 + "testView", storageType_nonVolatile);
548 + vacm->addNewAccessEntry("testGroup", "",
549 + SNMP_SECURITY_MODEL_USM,
550 + SNMP_SECURITY_LEVEL_NOAUTH_NOPRIV,
551 + match_prefix,
552 + "testView", "testView",
553 + "testView", storageType_nonVolatile);
554 + vacm->addNewAccessEntry("v1v2group", "",
555 + SNMP_SECURITY_MODEL_V2,
556 + SNMP_SECURITY_LEVEL_NOAUTH_NOPRIV,
557 + match_exact,
558 + "v1ReadView", "v1WriteView",
559 + "v1NotifyView", storageType_nonVolatile);
560 + vacm->addNewAccessEntry("v1v2group", "",
561 + SNMP_SECURITY_MODEL_V1,
562 + SNMP_SECURITY_LEVEL_NOAUTH_NOPRIV,
563 + match_exact,
564 + "v1ReadView", "v1WriteView",
565 + "v1NotifyView", storageType_nonVolatile);
566 + vacm->addNewAccessEntry("initial", "",
567 + SNMP_SECURITY_MODEL_USM,
568 + SNMP_SECURITY_LEVEL_NOAUTH_NOPRIV,
569 + match_exact,
570 + "restricted", "",
571 + "restricted", storageType_nonVolatile);
572 + vacm->addNewAccessEntry("initial", "",
573 + SNMP_SECURITY_MODEL_USM,
574 + SNMP_SECURITY_LEVEL_AUTH_NOPRIV,
575 + match_exact,
576 + "internet", "internet",
577 + "internet", storageType_nonVolatile);
578 + vacm->addNewAccessEntry("initial", "",
579 + SNMP_SECURITY_MODEL_USM,
580 + SNMP_SECURITY_LEVEL_AUTH_PRIV,
581 + match_exact,
582 + "internet", "internet",
583 + "internet", storageType_nonVolatile);
584 +
585 + // remove an AccessEntry with:
586 + // vacm->deleteAccessEntry("newGroup",
587 + // "",
588 + // SNMP_SECURITY_MODEL_USM,
589 + // SNMP_SECURITY_LEVEL_NOAUTH_NOPRIV);
590 +
591 +
592 + // Defining Views
593 + // View "v1ReadView" includes all objects starting with "1.3".
594 + // If the ith bit of the mask is not set (0), then also all objects
595 + // which have a different subid at position i are included in the
596 + // view.
597 + // For example: Oid "6.5.4.3.2.1", Mask(binary) 110111
598 + // Then all objects with Oid with "6.5.<?>.3.2.1"
599 + // are included in the view, whereas <?> may be any
600 + // natural number.
601 +
602 + vacm->addNewView("v1ReadView",
603 + "1.3",
604 + "", // Mask "" is same as 0xFFFFFFFFFF...
605 + view_included, // alternatively: view_excluded
606 + storageType_nonVolatile);
607 +
608 + vacm->addNewView("v1WriteView",
609 + "1.3",
610 + "", // Mask "" is same as 0xFFFFFFFFFF...
611 + view_included, // alternatively: view_excluded
612 + storageType_nonVolatile);
613 +
614 + vacm->addNewView("v1NotifyView",
615 + "1.3",
616 + "", // Mask "" is same as 0xFFFFFFFFFF...
617 + view_included, // alternatively: view_excluded
618 + storageType_nonVolatile);
619 +
620 + vacm->addNewView("newView", "1.3", "",
621 + view_included, storageType_nonVolatile);
622 + vacm->addNewView("testView", "1.3.6", "",
623 + view_included, storageType_nonVolatile);
624 + vacm->addNewView("internet", "1.3.6.1","",
625 + view_included, storageType_nonVolatile);
626 + vacm->addNewView("restricted", "1.3.6.1.2.1.1","",
627 + view_included, storageType_nonVolatile);
628 + vacm->addNewView("restricted", "1.3.6.1.2.1.11","",
629 + view_included, storageType_nonVolatile);
630 + vacm->addNewView("restricted", "1.3.6.1.6.3.10.2.1","",
631 + view_included, storageType_nonVolatile);
632 + vacm->addNewView("restricted", "1.3.6.1.6.3.11.2.1","",
633 + view_included, storageType_nonVolatile);
634 + vacm->addNewView("restricted", "1.3.6.1.6.3.15.1.1","",
635 + view_included, storageType_nonVolatile);
636 +
637 + // add SNMPv1/v2c community to v3 security name mapping
638 + snmpCommunityEntry* communityEntry =
639 + snmpCommunityEntry::get_instance(mib);
640 + if (communityEntry) {
641 + OctetStr co("public");
642 + MibTableRow* row = communityEntry->add_row(Oidx::from_string(co, FALSE));
643 + OctetStr tag("v1v2cPermittedManagers");
644 + communityEntry->set_row(row, co, co,
645 + reqList->get_v3mp()->get_local_engine_id(),
646 + "", tag, 3, 1);
647 + }
648 +
649 +#endif
650 +
651 +#ifdef _SNMPv3
652 + // register table size policies
653 + MibTableSizePolicy::register_policy(mib->get_default_context(),
654 + &policy);
655 +#endif
656 + // load persistent objects from disk
657 + mib->init();
658 +
659 +
660 + Vbx* vbs = 0;
661 + coldStartOid coldOid;
662 + NotificationOriginator no(mib);
663 + // add an example destination
664 + UdpAddress dest("127.0.0.1/162");
665 + no.add_v1_trap_destination(dest, "defaultV1Trap", "v1trap", "public");
666 + // send the notification
667 + mib->notify("", coldOid, vbs, 0);
668 +
669 + Request* req;
670 + while (go) {
671 + req = reqList->receive(2);
672 + if (req) {
673 + mib->process_request(req);
674 + }
675 + else {
676 + mib->cleanup();
677 + }
678 + }
679 + delete reqList;
680 + delete mib;
681 +#ifdef _SNMPv3
682 + delete vacm;
683 + delete v3mp;
684 +#endif
685 +}
686 +
687 +int main (int argc, char* argv[])
688 +{
689 + int num_agents = 0;
690 + while (num_agents < MAX_NUMBER_OF_AGENTS && num_agents < argc - 1) {
691 + port[num_agents] = atoi(argv[1+num_agents]);
692 + num_agents++;
693 + }
694 + if (num_agents == 0) {
695 + // minimum of two agents if not specified explicitly:
696 + port[0] = 4700;
697 + port[1] = 4701;
698 + num_agents = 2;
699 + }
700 +
701 +#ifndef _NO_LOGGING
702 + DefaultLog::log()->set_filter(ERROR_LOG, 5);
703 + DefaultLog::log()->set_filter(WARNING_LOG, 5);
704 + DefaultLog::log()->set_filter(EVENT_LOG, 5);
705 + DefaultLog::log()->set_filter(INFO_LOG, 5);
706 + DefaultLog::log()->set_filter(DEBUG_LOG, 1);
707 +#endif
708 + Snmp::socket_startup(); // Initialize socket subsystem
709 +
710 + init_signals();
711 +
712 + ThreadPool agentPool(num_agents);
713 + agentPool.set_one_time_execution(TRUE);
714 + SnmpAgent* agents[num_agents];
715 + for (int i=0; i<num_agents; i++) {
716 + UdpAddress inaddr("0.0.0.0");
717 + inaddr.set_port(port[i]);
718 + agents[i] = new SnmpAgent(inaddr);
719 + agentPool.execute(agents[i]);
720 + }
721 + agentPool.join();
722 + Snmp::socket_cleanup(); // Shut down socket subsystem
723 + return 0;
724 +}
725 +{{/code}}
726 +{{/info}}