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