1%% 2%% %CopyrightBegin% 3%% 4%% Copyright Ericsson AB 2005-2016. All Rights Reserved. 5%% 6%% Licensed under the Apache License, Version 2.0 (the "License"); 7%% you may not use this file except in compliance with the License. 8%% You may obtain a copy of the License at 9%% 10%% http://www.apache.org/licenses/LICENSE-2.0 11%% 12%% Unless required by applicable law or agreed to in writing, software 13%% distributed under the License is distributed on an "AS IS" BASIS, 14%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 15%% See the License for the specific language governing permissions and 16%% limitations under the License. 17%% 18%% %CopyrightEnd% 19%% 20 21%%---------------------------------------------------------------------- 22%% Purpose: Utility functions for the (snmp manager) user test(s). 23%%---------------------------------------------------------------------- 24 25-module(snmp_manager_user). 26 27-behaviour(snmpm_user). 28%% -behaviour(snmpm_user_old). 29 30 31%%---------------------------------------------------------------------- 32%% Include files 33%%---------------------------------------------------------------------- 34-include_lib("common_test/include/ct.hrl"). 35-include("snmp_test_lib.hrl"). 36 37 38%%---------------------------------------------------------------------- 39%% External exports 40%%---------------------------------------------------------------------- 41-export([ 42 start_link/0, start_link/1, start_link/2, 43 start/0, start/1, start/2, 44 stop/0, 45 info/0, 46 system_info/0, 47 simulate_crash/1, 48 register_agent/2, 49 unregister_agent/1, 50 agent_info/2, 51 update_agent_info/3, 52 which_all_agents/0, which_own_agents/0, 53 load_mib/1, unload_mib/1, 54 sync_get/1, sync_get/2, sync_get2/3, 55 async_get/1, async_get/2, async_get2/3, 56 sync_get_next/1, sync_get_next/2, sync_get_next2/3, 57 async_get_next/1, async_get_next/2, async_get_next2/3, 58 sync_set/1, sync_set/2, sync_set2/3, 59 async_set/1, async_set/2, async_set2/3, 60 sync_get_bulk/3, sync_get_bulk/4, sync_get_bulk2/5, 61 async_get_bulk/3, async_get_bulk/4, async_get_bulk2/5, 62 name_to_oid/1, oid_to_name/1, 63 purify_oid/1 64 ]). 65 66 67%%---------------------------------------------------------------------- 68%% Internal exports 69%%---------------------------------------------------------------------- 70 71-export([ 72 main/4 73 ]). 74 75-export([ 76 handle_error/3, 77 handle_agent/5, 78 handle_pdu/4, 79 handle_trap/3, 80 handle_inform/3, 81 handle_report/3 82 ]). 83 84 85-define(SERVER, ?MODULE). 86 87-record(state, {parent, id, reqs = []}). 88%% -record(request, {from, ref, tmr, req_id, type}). 89 90 91%%---------------------------------------------------------------------- 92%% The user API 93%%---------------------------------------------------------------------- 94 95start() -> 96 start(self()). 97 98start(Parent) -> 99 start(Parent, test_user). 100 101start(Parent, Id) -> 102 proc_lib:start(?MODULE, main, [true, Parent, self(), Id]). 103 104start_link() -> 105 start_link(self()). 106start_link(Parent) -> 107 start_link(Parent, test_user). 108 109start_link(Parent, Id) -> 110 proc_lib:start_link(?MODULE, main, [true, Parent, self(), Id]). 111 112stop() -> 113 MRef = erlang:monitor(process, ?SERVER), 114 cast(stop), 115 receive {'DOWN', MRef, _, _, Info} -> 116 case Info of 117 noproc -> 118 ok; 119 noconnection -> 120 ok; 121 normal -> 122 ok 123 end 124 end. 125 126info() -> 127 call(info). 128 129system_info() -> 130 call(system_info). 131 132simulate_crash(Reason) -> 133 call({simulate_crash, Reason}). 134 135register_agent(TargetName, Config) 136 when is_list(TargetName) andalso is_list(Config) -> 137 call({register_agent, TargetName, Config}). 138 139unregister_agent(TargetName) -> 140 call({unregister_agent, TargetName}). 141 142agent_info(TargetName, Item) -> 143 call({agent_info, TargetName, Item}). 144 145update_agent_info(TargetName, Item, Val) -> 146 call({update_agent_info, TargetName, Item, Val}). 147 148which_all_agents() -> 149 call(which_all_agents). 150 151which_own_agents() -> 152 call(which_own_agents). 153 154load_mib(Mib) -> 155 call({load_mib, Mib}). 156 157unload_mib(Mib) -> 158 call({unload_mib, Mib}). 159 160%% -- 161 162sync_get(Oids) -> 163 call({sync_get, Oids}). 164 165sync_get(TargetName, Oids) -> 166 call({sync_get, TargetName, Oids}). 167 168sync_get2(TargetName, Oids, SendOpts) -> 169 call({sync_get2, TargetName, Oids, SendOpts}). 170 171 172%% -- 173 174async_get(Oids) -> 175 call({async_get, Oids}). 176 177async_get(TargetName, Oids) -> 178 call({async_get, TargetName, Oids}). 179 180async_get2(TargetName, Oids, SendOpts) -> 181 call({async_get2, TargetName, Oids, SendOpts}). 182 183%% -- 184 185sync_get_next(Oids) -> 186 call({sync_get_next, Oids}). 187 188sync_get_next(TargetName, Oids) -> 189 call({sync_get_next, TargetName, Oids}). 190 191sync_get_next2(TargetName, Oids, SendOpts) -> 192 call({sync_get_next2, TargetName, Oids, SendOpts}). 193 194%% -- 195 196async_get_next(Oids) -> 197 call({async_get_next, Oids}). 198 199async_get_next(TargetName, Oids) -> 200 call({async_get_next, TargetName, Oids}). 201 202async_get_next2(TargetName, Oids, SendOpts) -> 203 call({async_get_next2, TargetName, Oids, SendOpts}). 204 205%% -- 206 207sync_set(VAV) -> 208 call({sync_set, VAV}). 209 210sync_set(TargetName, VAV) -> 211 call({sync_set, TargetName, VAV}). 212 213sync_set2(TargetName, VAV, SendOpts) -> 214 call({sync_set2, TargetName, VAV, SendOpts}). 215 216%% -- 217 218async_set(VAV) -> 219 call({async_set, VAV}). 220 221async_set(TargetName, VAV) -> 222 call({async_set, TargetName, VAV}). 223 224async_set2(TargetName, VAV, SendOpts) -> 225 call({async_set2, TargetName, VAV, SendOpts}). 226 227%% -- 228 229sync_get_bulk(NonRep, MaxRep, Oids) -> 230 call({sync_get_bulk, NonRep, MaxRep, Oids}). 231 232sync_get_bulk(TargetName, NonRep, MaxRep, Oids) -> 233 call({sync_get_bulk, TargetName, NonRep, MaxRep, Oids}). 234 235sync_get_bulk2(TargetName, NonRep, MaxRep, Oids, SendOpts) -> 236 call({sync_get_bulk2, TargetName, NonRep, MaxRep, Oids, SendOpts}). 237 238%% -- 239 240async_get_bulk(NonRep, MaxRep, Oids) -> 241 call({async_get_bulk, NonRep, MaxRep, Oids}). 242 243async_get_bulk(TargetName, NonRep, MaxRep, Oids) -> 244 call({async_get_bulk, TargetName, NonRep, MaxRep, Oids}). 245 246async_get_bulk2(TargetName, NonRep, MaxRep, Oids, SendOpts) -> 247 call({async_get_bulk2, TargetName, NonRep, MaxRep, Oids, SendOpts}). 248 249%% -- 250 251name_to_oid(Name) -> 252 call({name_to_oid, Name}). 253 254oid_to_name(Oid) -> 255 call({oid_to_name, Oid}). 256 257purify_oid(Oid) -> 258 call({purify_oid, Oid}). 259 260 261%%---------------------------------------------------------------------- 262 263main(Debug, Parent, Starter, Id) -> 264 put(debug, Debug), 265 d("main -> entry with" 266 "~n Parent: ~p" 267 "~n Starter: ~p" 268 "~n Id: ~p", [Parent, Starter, Id]), 269 case (catch do_init(Id)) of 270 ok -> 271 proc_lib:init_ack(Starter, {ok, self()}), 272 loop(#state{parent = Parent, id = Id}); 273 Error -> 274 d("main -> error: " 275 "~p", [Error]), 276 proc_lib:init_ack(Starter, Error) 277 end. 278 279do_init(Id) -> 280 erlang:register(?SERVER, self()), 281 snmpm:register_user(Id, ?MODULE, self()). 282 283 284%%---------------------------------------------------------------------- 285 286loop(#state{parent = Parent, id = Id} = S) -> 287 d("loop -> entry"), 288 receive 289 {stop, _From} -> 290 d("loop -> received stop request"), 291 exit(normal); 292 293 {{simulate_crash, Reason}, From, Ref} -> 294 d("loop -> received simulate_crash request"), 295 reply(From, ok, Ref), 296 exit(Reason); 297 298 {info, From, Ref} -> 299 d("loop -> received info request"), 300 Res = snmpm:info(), 301 reply(From, Res, Ref), 302 loop(S); 303 304 {system_info, From, Ref} -> 305 d("loop -> received system_info request"), 306 Res = snmpm_config:system_info(), 307 reply(From, Res, Ref), 308 loop(S); 309 310 {{register_agent, TargetName, Conf}, From, Ref} -> 311 d("loop -> received register_agent request"), 312 Res = snmpm:register_agent(Id, TargetName, Conf), 313 reply(From, Res, Ref), 314 loop(S); 315 316 {{unregister_agent, TargetName}, From, Ref} -> 317 d("loop -> received unregister_agent request"), 318 Res = snmpm:unregister_agent(Id, TargetName), 319 reply(From, Res, Ref), 320 loop(S); 321 322 {{agent_info, TargetName, Item}, From, Ref} -> 323 d("loop -> received agent_info request with" 324 "~n TargetName: ~p" 325 "~n Item: ~p", [TargetName, Item]), 326 Res = snmpm:agent_info(TargetName, Item), 327 d("loop -> agent_info for ~p" 328 "~n Res: ~p", [Item, Res]), 329 reply(From, Res, Ref), 330 loop(S); 331 332 {{update_agent_info, TargetName, Item, Val}, From, Ref} -> 333 d("loop -> received update_agent_info request with" 334 "~n TargetName: ~p" 335 "~n Item: ~p" 336 "~n Val: ~p", [TargetName, Item, Val]), 337 Res = snmpm:update_agent_info(Id, TargetName, Item, Val), 338 reply(From, Res, Ref), 339 loop(S); 340 341 {which_all_agents, From, Ref} -> 342 d("loop -> received which_all_agents request"), 343 Res = snmpm:which_agents(), 344 reply(From, Res, Ref), 345 loop(S); 346 347 {which_own_agents, From, Ref} -> 348 d("loop -> received which_own_agents request"), 349 Res = snmpm:which_agents(Id), 350 reply(From, Res, Ref), 351 loop(S); 352 353 {{load_mib, Mib}, From, Ref} -> 354 d("loop -> received load_mib request"), 355 Res = snmpm:load_mib(Mib), 356 reply(From, Res, Ref), 357 loop(S); 358 359 {{unload_mib, Mib}, From, Ref} -> 360 d("loop -> received unload_mib request"), 361 Res = snmpm:unload_mib(Mib), 362 reply(From, Res, Ref), 363 loop(S); 364 365 366 %% 367 %% -- (sync) get-request -- 368 %% 369 370 {{sync_get2, TargetName, Oids, SendOpts}, From, Ref} 371 when is_list(TargetName) -> 372 d("loop -> received sync_get2 request with" 373 "~n TargetName: ~p" 374 "~n Oids: ~p" 375 "~n SendOpts: ~p", [TargetName, Oids, SendOpts]), 376 Res = snmpm:sync_get2(Id, TargetName, Oids, SendOpts), 377 reply(From, Res, Ref), 378 loop(S); 379 380 %% No agent specified, so send it to all of them 381 {{sync_get, Oids}, From, Ref} -> 382 d("loop -> received sync_get request " 383 "(for every agent of this user)"), 384 Res = [snmpm:sync_get(Id, TargetName, Oids) || 385 TargetName <- snmpm:which_agents(Id)], 386 reply(From, Res, Ref), 387 loop(S); 388 389 {{sync_get, TargetName, Oids}, From, Ref} when is_list(TargetName) -> 390 d("loop -> received sync_get request with" 391 "~n TargetName: ~p" 392 "~n Oids: ~p", [TargetName, Oids]), 393 Res = snmpm:sync_get(Id, TargetName, Oids), 394 reply(From, Res, Ref), 395 loop(S); 396 397 398 %% 399 %% -- (async) get-request -- 400 %% 401 402 {{async_get2, TargetName, Oids, SendOpts}, From, Ref} 403 when is_list(TargetName) -> 404 d("loop -> received async_get2 request with" 405 "~n TargetName: ~p" 406 "~n Oids: ~p" 407 "~n SendOpts: ~p", [TargetName, Oids, SendOpts]), 408 Res = snmpm:async_get2(Id, TargetName, Oids, SendOpts), 409 reply(From, Res, Ref), 410 loop(S); 411 412 %% No agent specified, so send it to all of them 413 {{async_get, Oids}, From, Ref} -> 414 d("loop -> received async_get request"), 415 Res = [snmpm:async_get(Id, TargetName, Oids) || 416 TargetName <- snmpm:which_agents(Id)], 417 reply(From, Res, Ref), 418 loop(S); 419 420 {{async_get, TargetName, Oids}, From, Ref} when is_list(TargetName) -> 421 d("loop -> received async_get request with" 422 "~n TargetName: ~p" 423 "~n Oids: ~p", [TargetName, Oids]), 424 Res = snmpm:async_get(Id, TargetName, Oids), 425 reply(From, Res, Ref), 426 loop(S); 427 428 429 %% 430 %% -- (sync) get_next-request -- 431 %% 432 433 {{sync_get_next2, TargetName, Oids, SendOpts}, From, Ref} 434 when is_list(TargetName) -> 435 d("loop -> received sync_get_next2 request with" 436 "~n TargetName: ~p" 437 "~n Oids: ~p" 438 "~n SendOpts: ~p", [TargetName, Oids, SendOpts]), 439 Res = snmpm:sync_get_next2(Id, TargetName, Oids, SendOpts), 440 reply(From, Res, Ref), 441 loop(S); 442 443 %% No agent specified, so send it to all of them 444 {{sync_get_next, Oids}, From, Ref} -> 445 d("loop -> received sync_get_next request"), 446 Res = [snmpm:sync_get_next(Id, TargetName, Oids) || 447 TargetName <- snmpm:which_agents(Id)], 448 reply(From, Res, Ref), 449 loop(S); 450 451 {{sync_get_next, TargetName, Oids}, From, Ref} when is_list(TargetName) -> 452 d("loop -> received sync_get_next request with" 453 "~n TargetName: ~p" 454 "~n Oids: ~p", [TargetName, Oids]), 455 Res = snmpm:sync_get_next(Id, TargetName, Oids), 456 reply(From, Res, Ref), 457 loop(S); 458 459 460 %% 461 %% -- (async) get_next-request -- 462 %% 463 464 {{async_get_next2, TargetName, Oids, SendOpts}, From, Ref} 465 when is_list(TargetName) -> 466 d("loop -> received async_get_next2 request with" 467 "~n TargetName: ~p" 468 "~n Oids: ~p" 469 "~n SendOpts: ~p", [TargetName, Oids, SendOpts]), 470 Res = snmpm:async_get_next2(Id, TargetName, Oids, SendOpts), 471 reply(From, Res, Ref), 472 loop(S); 473 474 %% No agent specified, so send it to all of them 475 {{async_get_next, Oids}, From, Ref} -> 476 d("loop -> received async_get_next request"), 477 Res = [snmpm:async_get_next(Id, TargetName, Oids) || 478 TargetName <- snmpm:which_agents(Id)], 479 reply(From, Res, Ref), 480 loop(S); 481 482 {{async_get_next, TargetName, Oids}, From, Ref} when is_list(TargetName) -> 483 d("loop -> received async_get_next request with" 484 "~n TargetName: ~p" 485 "~n Oids: ~p", [TargetName, Oids]), 486 Res = snmpm:async_get_next(Id, TargetName, Oids), 487 reply(From, Res, Ref), 488 loop(S); 489 490 491 %% 492 %% -- (sync) set-request -- 493 %% 494 495 {{sync_set2, TargetName, VAV, SendOpts}, From, Ref} 496 when is_list(TargetName) -> 497 d("loop -> received sync_set2 request with" 498 "~n TargetName: ~p" 499 "~n VAV: ~p" 500 "~n SendOpts: ~p", [TargetName, VAV, SendOpts]), 501 Res = snmpm:sync_set2(Id, TargetName, VAV, SendOpts), 502 reply(From, Res, Ref), 503 loop(S); 504 505 {{sync_set, VAV}, From, Ref} -> 506 d("loop -> received sync_set request"), 507 Res = [snmpm:sync_set(Id, TargetName, VAV) || 508 TargetName <- snmpm:which_agents(Id)], 509 reply(From, Res, Ref), 510 loop(S); 511 512 {{sync_set, TargetName, VAV}, From, Ref} when is_list(TargetName) -> 513 d("loop -> received sync_set request"), 514 Res = snmpm:sync_set(Id, TargetName, VAV), 515 reply(From, Res, Ref), 516 loop(S); 517 518 519 %% 520 %% -- (async) set-request -- 521 %% 522 523 {{async_set2, TargetName, VAV, SendOpts}, From, Ref} 524 when is_list(TargetName) -> 525 d("loop -> received async_set2 request with" 526 "~n TargetName: ~p" 527 "~n VAV: ~p" 528 "~n SendOpts: ~p", [TargetName, VAV, SendOpts]), 529 Res = snmpm:async_set2(Id, TargetName, VAV, SendOpts), 530 reply(From, Res, Ref), 531 loop(S); 532 533 {{async_set, VAV}, From, Ref} -> 534 d("loop -> received async_set request"), 535 Res = [snmpm:async_set(Id, TargetName, VAV) || 536 TargetName <- snmpm:which_agents(Id)], 537 reply(From, Res, Ref), 538 loop(S); 539 540 {{async_set, TargetName, VAV}, From, Ref} when is_list(TargetName) -> 541 d("loop -> received async_set request"), 542 Res = snmpm:async_set(Id, TargetName, VAV), 543 reply(From, Res, Ref), 544 loop(S); 545 546 547 %% 548 %% -- (sync) get-bulk-request -- 549 %% 550 551 {{sync_get_bulk2, TargetName, NonRep, MaxRep, Oids, SendOpts}, From, Ref} 552 when is_list(TargetName) -> 553 d("loop -> received sync_get_bulk request with" 554 "~n TargetName: ~p" 555 "~n NonRep: ~w" 556 "~n MaxRep: ~w" 557 "~n Oids: ~p" 558 "~n SendOpts: ~p", 559 [TargetName, NonRep, MaxRep, Oids, SendOpts]), 560 Res = snmpm:sync_get_bulk2(Id, TargetName, 561 NonRep, MaxRep, Oids, SendOpts), 562 reply(From, Res, Ref), 563 loop(S); 564 565 %% No agent specified, so send it to all of them 566 {{sync_get_bulk, NonRep, MaxRep, Oids}, From, Ref} -> 567 d("loop -> received sync_get_bulk request with" 568 "~n NonRep: ~w" 569 "~n MaxRep: ~w" 570 "~n Oids: ~p", [NonRep, MaxRep, Oids]), 571 Res = [snmpm:sync_get_bulk(Id, TargetName, NonRep, MaxRep, Oids) || 572 TargetName <- snmpm:which_agents(Id)], 573 reply(From, Res, Ref), 574 loop(S); 575 576 {{sync_get_bulk, TargetName, NonRep, MaxRep, Oids}, From, Ref} when is_list(TargetName) -> 577 d("loop -> received sync_get_bulk request with" 578 "~n TargetName: ~p" 579 "~n NonRep: ~w" 580 "~n MaxRep: ~w" 581 "~n Oids: ~p", [TargetName, NonRep, MaxRep, Oids]), 582 Res = snmpm:sync_get_bulk(Id, TargetName, NonRep, MaxRep, Oids), 583 reply(From, Res, Ref), 584 loop(S); 585 586 587 %% 588 %% -- (async) get-bulk-request -- 589 %% 590 591 {{async_get_bulk2, TargetName, NonRep, MaxRep, Oids, SendOpts}, 592 From, Ref} when is_list(TargetName) -> 593 d("loop -> received async_get_bulk2 request with" 594 "~n TargetName: ~p" 595 "~n NonRep: ~w" 596 "~n MaxRep: ~w" 597 "~n Oids: ~p" 598 "~n SendOpts: ~p", 599 [TargetName, NonRep, MaxRep, Oids, SendOpts]), 600 Res = snmpm:async_get_bulk2(Id, TargetName, 601 NonRep, MaxRep, Oids, SendOpts), 602 reply(From, Res, Ref), 603 loop(S); 604 605 %% No agent specified, so send it to all of them 606 {{async_get_bulk, NonRep, MaxRep, Oids}, From, Ref} -> 607 d("loop -> received async_get_bulk request with" 608 "~n NonRep: ~w" 609 "~n MaxRep: ~w" 610 "~n Oids: ~p", [NonRep, MaxRep, Oids]), 611 Res = [snmpm:async_get_bulk(Id, TargetName, NonRep, MaxRep, Oids) || 612 TargetName <- snmpm:which_agents(Id)], 613 reply(From, Res, Ref), 614 loop(S); 615 616 {{async_get_bulk, TargetName, NonRep, MaxRep, Oids}, From, Ref} when is_list(TargetName) -> 617 d("loop -> received async_get_bulk request with" 618 "~n TargetName: ~p" 619 "~n NonRep: ~w" 620 "~n MaxRep: ~w" 621 "~n Oids: ~p", [TargetName, NonRep, MaxRep, Oids]), 622 Res = snmpm:async_get_bulk(Id, TargetName, NonRep, MaxRep, Oids), 623 reply(From, Res, Ref), 624 loop(S); 625 626 627 %% 628 %% -- logical name translation -- 629 %% 630 631 {{name_to_oid, Name}, From, Ref} -> 632 d("loop -> received name_to_oid request for" 633 "~n Name: ~p", [Name]), 634 Res = snmpm:name_to_oid(Name), 635 reply(From, Res, Ref), 636 loop(S); 637 638 {{oid_to_name, Oid}, From, Ref} -> 639 d("loop -> received oid_to_name request for" 640 "~n Oid: ~p", [Oid]), 641 Res = snmpm:oid_to_name(Oid), 642 reply(From, Res, Ref), 643 loop(S); 644 645 {{purify_oid, Oid}, From, Ref} -> 646 d("loop -> received purify_oid request for" 647 "~n Oid: ~p", [Oid]), 648 Res = do_purify_oid(Oid), 649 reply(From, Res, Ref), 650 loop(S); 651 652 653 %% SNMP manager callback messages (from our callback API): 654 655 {handle_error, _Pid, ReqId, Reason} -> 656 d("loop -> received error callback from manager for ~w:" 657 "~n ~p", [ReqId, Reason]), 658 Parent ! {async_event, ReqId, {error, Reason}}, 659 loop(S); 660 661 {handle_agent, _Pid, Addr, Port, SnmpInfo} -> 662 d("loop -> received agent callback from manager for ~n ~p:~w", 663 [Addr, Port]), 664 Parent ! {async_event, {Addr, Port}, {agent, SnmpInfo}}, 665 loop(S); 666 667 {handle_pdu, _Pid, _TargetName, ReqId, SnmpResponse} -> 668 d("loop -> received pdu callback from manager for ~w", [ReqId]), 669 Parent ! {async_event, ReqId, {pdu, SnmpResponse}}, 670 loop(S); 671 672 {handle_trap, _Pid, TargetName, SnmpTrap} -> 673 d("loop -> received trap callback from manager for " 674 "~n ~p", 675 "~n ~p", 676 [TargetName, SnmpTrap]), 677 Parent ! {async_event, TargetName, {trap, SnmpTrap}}, 678 loop(S); 679 680 {handle_inform, Pid, TargetName, SnmpInform} -> 681 d("loop -> received inform callback from manager for " 682 "~n ~p", 683 "~n ~p", 684 [TargetName, SnmpInform]), 685 Parent ! {async_event, TargetName, {inform, Pid, SnmpInform}}, 686 loop(S); 687 688 {handle_report, _Pid, TargetName, SnmpReport} -> 689 d("loop -> received report callback from manager for " 690 "~n ~p", 691 "~n ~p", 692 [TargetName, SnmpReport]), 693 Parent ! {async_event, TargetName, {report, SnmpReport}}, 694 loop(S); 695 696 {handle_invalid_result, _Pid, In, Out} -> 697 d("loop -> received invalid result callback from manager for " 698 "~n In: ~p", 699 "~n Out: ~p", [In, Out]), 700 info("received invalid result message: " 701 "~n In: ~p" 702 "~n Out: ~p", [In, Out]), 703 loop(S); 704 705 {'EXIT', Parent, Reason} -> 706 d("received exit signal from parent: ~n~p", [Reason]), 707 info("received exit signal from parent: ~n~p", [Reason]), 708 exit(Reason); 709 710 Unknown -> 711 d("received unknown message: ~n~p", [Unknown]), 712 info("received unknown message: ~n~p", [Unknown]), 713 loop(S) 714 end. 715 716 717%% ------------- 718 719do_purify_oid([A|T]) when is_atom(A) -> 720 case snmpm:name_to_oid(A) of 721 {ok, [Oid|_]} -> 722 verify_pure_oid(lists:flatten([Oid|T])); 723 {error, not_found} -> 724 {error, {not_found, A}}; 725 {error, _} = Error -> 726 Error 727 end; 728do_purify_oid(L) when is_list(L) -> 729 verify_pure_oid(lists:flatten(L)); 730do_purify_oid(X) -> 731 {error, {unpure_oid, X}}. 732 733verify_pure_oid([]) -> 734 []; 735verify_pure_oid([H | T]) when is_integer(H) andalso (H >= 0) -> 736 [H | verify_pure_oid(T)]; 737verify_pure_oid([H | _]) -> 738 throw({error, {not_pure_oid, H}}). 739 740 741%% ------------- 742 743info(F, A) -> 744 error_logger:info_msg("TEST MGR USER " ++ F ++ "~n", A). 745 746 747%% ------------- 748 749call(Req) -> 750 call(Req, 5000). 751 752call(Req, To) when is_integer(To) -> 753 Ref = make_ref(), 754 ?SERVER ! {Req, self(), Ref}, 755 receive 756 {Reply, Ref} -> 757 Reply 758 after To -> 759 {error, timeout} 760 end. 761 762reply(Pid, Reply, Ref) -> 763 d("reply -> entry with" 764 "~n Pid: ~p" 765 "~n Reply: ~p" 766 "~n Ref: ~p", [Pid, Reply, Ref]), 767 Pid ! {Reply, Ref}. 768 769cast(Msg) -> 770 ?SERVER ! {Msg, self()}, 771 ok. 772 773 774%%---------------------------------------------------------------------- 775%% User callback functions: 776%%---------------------------------------------------------------------- 777 778handle_error(ReqId, Reason, UserPid) -> 779 UserPid ! {handle_error, self(), ReqId, Reason}, 780 ignore. 781 782 783handle_agent(Addr, Port, SnmpInfo, UserPid, UserData) -> 784 UserPid ! {handle_agent, self(), Addr, Port, SnmpInfo, UserData}, 785 ignore. 786 787 788handle_pdu(TargetName, ReqId, SnmpResponse, UserPid) -> 789 UserPid ! {handle_pdu, self(), TargetName, ReqId, SnmpResponse}, 790 ignore. 791 792handle_trap(TargetName, SnmpTrap, UserPid) -> 793 UserPid ! {handle_trap, self(), TargetName, SnmpTrap}, 794 ignore. 795 796handle_inform(TargetName, SnmpInform, UserPid) -> 797 UserPid ! {handle_inform, self(), TargetName, SnmpInform}, 798 receive 799 {handle_inform_no_response, TargetName} -> 800 no_reply; 801 {handle_inform_response, TargetName} -> 802 ignore 803 end. 804 805handle_report(TargetName, SnmpReport, UserPid) -> 806 UserPid ! {handle_report, self(), TargetName, SnmpReport}, 807 ignore. 808 809 810%%---------------------------------------------------------------------- 811%% Debug 812%%---------------------------------------------------------------------- 813 814d(F) -> 815 d(F, []). 816 817d(F, A) -> 818 d(get(debug), F, A). 819 820d(true, F, A) -> 821 io:format("~w:" ++ F ++ "~n", [?SERVER|A]); 822d(_, _, _) -> 823 ok. 824