← Back to branch summary

~rdoering/ubuntu/karmic/erlang/fix-535090

« back to all changes in this revision

Viewing changes to lib/snmp/test/snmp_test_mgr.erl

  • Committer: Bazaar Package Importer
  • Author(s): Sergei Golovan
  • Date: 2009-02-15 16:42:52 UTC
  • mfrom: (3.1.2 squeeze)
  • Revision ID: james.westby@ubuntu.com-20090215164252-q5x4rcf8a5pbesb1
Tags: 1:12.b.5-dfsg-2
Upload to unstable after lenny is released.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/snmp/test/snmp_test_mgr.erl
68
68
    gen_server:start({local, ?SERVER}, ?MODULE, {Options, self()}, []).
69
69
 
70
70
stop() ->
71
 
    gen_server:call(?SERVER, stop, infinity).
 
71
    call(stop).
72
72
 
73
73
d() ->
74
 
    gen_server:call(?SERVER,discovery,infinity).
 
74
    call(discovery).
75
75
 
76
76
g(Oids) ->
77
 
    ?SERVER ! {get, Oids}, ok.
 
77
    cast({get, Oids}).
78
78
 
79
79
%% VarsAndValues is: {PlainOid, o|s|i, Value} (unknown mibs) | {Oid, Value} 
80
80
s(VarsAndValues) ->
81
 
    ?SERVER ! {set, VarsAndValues}, ok.
 
81
    cast({set, VarsAndValues}).
82
82
 
83
83
gn(Oids) when is_list(Oids) ->
84
 
    ?SERVER ! {get_next, Oids}, ok;
 
84
    cast({get_next, Oids});
85
85
gn(N) when is_integer(N) ->
86
 
    ?SERVER ! {iter_get_next, N}, ok.
 
86
    cast({iter_get_next, N}).
87
87
gn() ->
88
 
    ?SERVER ! iter_get_next, ok.
 
88
    cast(iter_get_next).
89
89
 
90
90
r() ->
91
 
    ?SERVER ! resend_pdu, ok.
 
91
    cast(resend_pdu).
92
92
 
93
93
gb(NonRepeaters, MaxRepetitions, Oids) ->
94
 
    ?SERVER ! {bulk, {NonRepeaters, MaxRepetitions, Oids}}, ok.
 
94
    cast({bulk, {NonRepeaters, MaxRepetitions, Oids}}).
95
95
 
96
96
rpl(RespPdu) ->
97
 
    ?SERVER ! {response, RespPdu}.
 
97
    cast({response, RespPdu}).
98
98
 
99
99
send_bytes(Bytes) ->
100
 
    ?SERVER ! {send_bytes, Bytes}, ok.
 
100
    cast({send_bytes, Bytes}).
101
101
 
102
102
purify_oid(Oid) ->
103
 
    gen_server:call(?SERVER, {purify_oid, Oid}, 5000).
 
103
    call({purify_oid, Oid}, 5000).
104
104
 
105
105
oid_to_name(Oid) ->
106
 
    gen_server:call(?SERVER, {oid_to_name, Oid}, 5000).
 
106
    call({oid_to_name, Oid}, 5000).
107
107
 
108
108
name_to_oid(Name) ->
109
 
    gen_server:call(?SERVER, {name_to_oid, Name}, 5000).
 
109
    call({name_to_oid, Name}, 5000).
110
110
 
111
111
 
112
112
%%----------------------------------------------------------------------
340
340
mk_seclevel(authPriv) -> 3.
341
341
    
342
342
 
343
 
handle_info({get, Oids}, State) ->
344
 
    d("handle_info -> get request for ~p",[Oids]),
345
 
    {noreply, execute_request(get, Oids, State)};
346
 
 
347
 
handle_info({set, VariablesAndValues}, State) ->
348
 
    d("handle_info -> set request for ~p",[VariablesAndValues]),
349
 
    {noreply, execute_request(set, VariablesAndValues, State)};
350
 
 
351
 
handle_info({bulk, Args}, State) ->
352
 
    d("handle_info -> bulk request for ~p",[Args]),
353
 
    {noreply, execute_request(bulk, Args, State)};
354
 
 
355
 
handle_info({response, RespPdu}, State) ->
356
 
    d("handle_info -> response request with ~p",[RespPdu]),
357
 
    ?PACK_SERV:send_pdu(RespPdu, State#state.packet_server),
358
 
    {noreply, State};
359
 
 
360
 
handle_info({snmp_msg, Msg, Ip, Udp}, State) ->
361
 
    io:format("* Got PDU: ~s", [?PACK_SERV:format_hdr(Msg)]),
362
 
    PDU = ?PACK_SERV:get_pdu(Msg),
363
 
    echo_pdu(PDU, State#state.mini_mib),
364
 
    case PDU#pdu.type of
365
 
        'inform-request' ->
366
 
            %% Generate a response...
367
 
            RespPDU = PDU#pdu{type = 'get-response',
368
 
                              error_status = noError,
369
 
                              error_index = 0},
370
 
            RespMsg = ?PACK_SERV:set_pdu(Msg, RespPDU),
371
 
            ?PACK_SERV:send_msg(RespMsg, State#state.packet_server, Ip, Udp);
372
 
        _Else ->
373
 
            ok
374
 
    end,
375
 
    {noreply, State#state{last_received_pdu = PDU}};
376
 
 
377
 
handle_info({get_next, Oids}, State) ->
378
 
    d("handle_info -> get-next request for ~p",[Oids]),
379
 
    {noreply, execute_request(get_next, Oids, State)};
380
 
 
381
 
handle_info(resend_pdu, State) ->
382
 
    PDU = State#state.last_sent_pdu,
383
 
    d("handle_info -> resend_pdu request when last sent pdu: ~n\t~p",[PDU]),
384
 
    send_pdu(PDU#pdu{request_id = make_request_id()},
385
 
             State#state.mini_mib,
386
 
             State#state.packet_server),
387
 
    {noreply, State};
388
 
 
389
 
handle_info(iter_get_next, State)
390
 
  when is_record(State#state.last_received_pdu, pdu) ->
391
 
    d("handle_info -> iter_get_next request",[]),
392
 
    PrevPDU = State#state.last_received_pdu,
393
 
    Oids    = [get_oid_from_varbind(Vb) || Vb <- PrevPDU#pdu.varbinds], 
394
 
    {noreply, execute_request(get_next, Oids, State)};
395
 
 
396
 
handle_info(iter_get_next, State) ->
397
 
    ?PACK_SERV:error("[Iterated get-next] No Response PDU to "
398
 
                        "start iterating from.", []),
399
 
    {noreply, State};
400
 
 
401
 
handle_info({iter_get_next, N}, State) ->
402
 
    d("handle_info -> iter_get_next(~p) request",[N]),
403
 
    if
404
 
        record(State#state.last_received_pdu, pdu) ->
405
 
            PDU = get_next_iter_impl(N, State#state.last_received_pdu,
406
 
                                     State#state.mini_mib,
407
 
                                     State#state.packet_server),
408
 
            {noreply, State#state{last_received_pdu = PDU}};
409
 
        true ->
410
 
            ?PACK_SERV:error("[Iterated get-next] No Response PDU to "
411
 
                                "start iterating from.", []),
412
 
            {noreply, State}
413
 
    end;
414
 
 
415
 
handle_info({send_bytes, Bytes}, State) ->
416
 
    d("handle_info -> send-bytes request for ~p bytes",
417
 
      [sizeOf(Bytes)]),
418
 
    ?PACK_SERV:send_bytes(Bytes, State#state.packet_server),
419
 
    {noreply, State}.
420
 
 
421
 
 
422
343
handle_call({purify_oid, Oid}, _From, #state{mini_mib = MiniMib} = State) ->
423
344
    d("handle_call -> purify_oid for ~p",[Oid]),
424
345
    Reply = (catch purify_oid(Oid, MiniMib)),
460
381
    {Reply, NewState} = execute_discovery(State),
461
382
    {reply, Reply, NewState}.
462
383
    
 
384
 
 
385
handle_cast({get, Oids}, State) ->
 
386
    d("handle_cast -> get request for ~p", [Oids]),
 
387
    {noreply, execute_request(get, Oids, State)};
 
388
 
 
389
handle_cast({set, VariablesAndValues}, State) ->
 
390
    d("handle_cast -> set request for ~p", [VariablesAndValues]),
 
391
    {noreply, execute_request(set, VariablesAndValues, State)};
 
392
 
 
393
handle_cast({get_next, Oids}, State) ->
 
394
    d("handle_cast -> get-next request for ~p", [Oids]),
 
395
    {noreply, execute_request(get_next, Oids, State)};
 
396
 
 
397
handle_cast(iter_get_next, State)
 
398
  when is_record(State#state.last_received_pdu, pdu) ->
 
399
    d("handle_cast -> iter_get_next request", []),
 
400
    PrevPDU = State#state.last_received_pdu,
 
401
    Oids    = [get_oid_from_varbind(Vb) || Vb <- PrevPDU#pdu.varbinds], 
 
402
    {noreply, execute_request(get_next, Oids, State)};
 
403
 
 
404
handle_cast(iter_get_next, State) ->
 
405
    ?PACK_SERV:error("[Iterated get-next] No Response PDU to "
 
406
                     "start iterating from.", []),
 
407
    {noreply, State};
 
408
 
 
409
handle_cast({iter_get_next, N}, State) ->
 
410
    d("handle_cast -> iter_get_next(~p) request",[N]),
 
411
    if
 
412
        is_record(State#state.last_received_pdu, pdu) ->
 
413
            PDU = get_next_iter_impl(N, State#state.last_received_pdu,
 
414
                                     State#state.mini_mib,
 
415
                                     State#state.packet_server),
 
416
            {noreply, State#state{last_received_pdu = PDU}};
 
417
        true ->
 
418
            ?PACK_SERV:error("[Iterated get-next] No Response PDU to "
 
419
                                "start iterating from.", []),
 
420
            {noreply, State}
 
421
    end;
 
422
 
 
423
handle_cast(resend_pdu, #state{last_sent_pdu = PDU} = State) ->
 
424
    d("handle_cast -> resend_pdu request when"
 
425
      "~n   PDU = ~p", [PDU]),
 
426
    send_pdu(PDU#pdu{request_id = make_request_id()},
 
427
             State#state.mini_mib,
 
428
             State#state.packet_server),
 
429
    {noreply, State};
 
430
 
 
431
handle_cast({bulk, Args}, State) ->
 
432
    d("handle_bulk -> bulk request for ~p", [Args]),
 
433
    {noreply, execute_request(bulk, Args, State)};
 
434
 
 
435
handle_cast({response, RespPdu}, State) ->
 
436
    d("handle_cast -> response request with ~p", [RespPdu]),
 
437
    ?PACK_SERV:send_pdu(RespPdu, State#state.packet_server),
 
438
    {noreply, State};
 
439
 
 
440
handle_cast({send_bytes, Bytes}, State) ->
 
441
    d("handle_cast -> send-bytes request for ~p bytes", [sizeOf(Bytes)]),
 
442
    ?PACK_SERV:send_bytes(Bytes, State#state.packet_server),
 
443
    {noreply, State};
 
444
 
463
445
handle_cast(Msg, State) ->
464
 
    d("handle_cast -> unknown message: ~n\t~p",[Msg]),
465
 
    {noreply, State}.
 
446
    d("handle_cast -> unknown message: "
 
447
      "~n   ~p", [Msg]),
 
448
    {noreply, State}.
 
449
 
 
450
 
 
451
handle_info({snmp_msg, Msg, Ip, Udp}, State) ->
 
452
    io:format("* Got PDU: ~s", [?PACK_SERV:format_hdr(Msg)]),
 
453
    PDU = ?PACK_SERV:get_pdu(Msg),
 
454
    echo_pdu(PDU, State#state.mini_mib),
 
455
    case PDU#pdu.type of
 
456
        'inform-request' ->
 
457
            %% Generate a response...
 
458
            RespPDU = PDU#pdu{type = 'get-response',
 
459
                              error_status = noError,
 
460
                              error_index = 0},
 
461
            RespMsg = ?PACK_SERV:set_pdu(Msg, RespPDU),
 
462
            ?PACK_SERV:send_msg(RespMsg, State#state.packet_server, Ip, Udp);
 
463
        _Else ->
 
464
            ok
 
465
    end,
 
466
    {noreply, State#state{last_received_pdu = PDU}};
 
467
 
 
468
handle_info(Info, State) ->
 
469
    d("handle_info -> unknown info: "
 
470
      "~n   ~p", [Info]),
 
471
    {noreply, State}.
 
472
 
466
473
 
467
474
terminate(Reason, State) ->
468
475
    d("terminate -> with Reason: ~n\t~p",[Reason]),
1088
1095
 
1089
1096
 
1090
1097
%%----------------------------------------------------------------------
 
1098
 
 
1099
call(Req) ->
 
1100
    call(Req, infinity).
 
1101
 
 
1102
call(Req, To) ->
 
1103
    gen_server:call(?SERVER, Req, To).
 
1104
 
 
1105
cast(Msg) ->
 
1106
    gen_server:cast(?SERVER, Msg).
 
1107
 
 
1108
 
 
1109
%%----------------------------------------------------------------------
1091
1110
%% Debug
1092
1111
%%----------------------------------------------------------------------
1093
1112