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