Skip to Content
Version 4.1 by Frank Fock on 2024/05/25 10:00
Show last authors
1
2
3 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.
4
5 In AGENT++ 4.3.0 this has been refactored by lot of internal changes, which had two main goals:
6
7 1. Remove any Mib::instance usages that are not optional to the API user (i.e. backward compatibility can/should be provided)
8 1. Remove any v3MP::I usages that are not optional to the API user.
9
10 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:
11
12 {{info}}
13 **AGENT++ agent intialisation (+new/-old)**
14
15 {{code language="none" title=" "}}
16 Snmpx snmp(status, inaddr);
17 - mib = new Mib(persistentObjectsPath);
18 + mib = new Mib(persistentObjectsPath, path(bootCounterFile));
19 - reqList = new RequestList();
20 + reqList = new RequestList(mib);
21 reqList->set_snmp(&snmp);
22 mib->set_request_list(reqList);
23
24 v3MP *v3mp = new v3MP(engineId, snmpEngineBoots, stat);
25 + snmp.set_mpv3(v3mp);
26
27 - mib.add(new snmp_community_mib());
28 + mib.add(new snmp_community_mib(&mib));
29
30 - mib.add(new agentpp_config_mib());
31 + mib.add(new agentpp_config_mib(&mib));
32
33 - mib.add(new notification_log_mib());
34 + mib.add(new notification_log_mib(&mib));
35
36 + snmpCommunityEntry* communityEntry = snmpCommunityEntry::get_instance(mib);
37 + if (communityEntry) {
38 OctetStr co("public");
39 - MibTableRow* row = snmpCommunityEntry::instance->add_row(Oidx::from_string(co, FALSE));
40 + MibTableRow* row = communityEntry->add_row(Oidx::from_string(co, FALSE));
41 OctetStr tag("v1v2cPermittedManagers");
42 - snmpCommunityEntry::instance->set_row(row, co, co,
43 + communityEntry->set_row(row, co, co, reqList->get_v3mp()->get_local_engine_id(),"", tag, 3, 1);
44 + }
45
46 - UsmUserTable *uut = new UsmUserTable();
47 + v3MP* v3mp = mib.get_request_list()->get_v3mp();
48 + UsmUserTable *uut = new UsmUserTable(v3mp);
49 // add non persistent USM statistics
50 - mib.add(new UsmStats());
51 + mib.add(new UsmStats(v3mp));
52 // add the USM MIB - usm_mib MibGroup is used to
53 // make user added entries persistent
54 mib.add(new usm_mib(uut));
55 // add non persistent SNMPv3 engine object
56 - mib.add(new V3SnmpEngine());
57 - mib.add(new MPDGroup());
58 + mib.add(new V3SnmpEngine(v3mp));
59 + mib.add(new MPDGroup(v3mp));
60 {{/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}}/*_############################################################################
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