← Back to branch summary

~statik/ubuntu/maverick/erlang/erlang-merge-testing

« back to all changes in this revision

Viewing changes to lib/snmp/src/manager/snmpm_config.erl

  • Committer: Bazaar Package Importer
  • Author(s): Sergei Golovan
  • Date: 2009-05-01 10:14:38 UTC
  • mfrom: (3.1.4 sid)
  • Revision ID: james.westby@ubuntu.com-20090501101438-6qlr6rsdxgyzrg2z
Tags: 1:13.b-dfsg-2
* Cleaned up patches: removed unneeded patch which helped to support
  different SCTP library versions, made sure that changes for m68k
  architecture applied only when building on this architecture.
* Removed duplicated information from binary packages descriptions.
* Don't require libsctp-dev build-dependency on solaris-i386 architecture
  which allows to build Erlang on Nexenta (thanks to Tim Spriggs for
  the suggestion).

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/snmp/src/manager/snmpm_config.erl
1
 
%%<copyright>
2
 
%% <year>2004-2008</year>
3
 
%% <holder>Ericsson AB, All Rights Reserved</holder>
4
 
%%</copyright>
5
 
%%<legalnotice>
 
1
%% 
 
2
%% %CopyrightBegin%
 
3
%% 
 
4
%% Copyright Ericsson AB 2004-2009. All Rights Reserved.
 
5
%% 
6
6
%% The contents of this file are subject to the Erlang Public License,
7
7
%% Version 1.1, (the "License"); you may not use this file except in
8
8
%% compliance with the License. You should have received a copy of the
9
9
%% Erlang Public License along with this software. If not, it can be
10
10
%% retrieved online at http://www.erlang.org/.
11
 
%%
 
11
%% 
12
12
%% Software distributed under the License is distributed on an "AS IS"
13
13
%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
14
14
%% the License for the specific language governing rights and limitations
15
15
%% under the License.
16
 
%%
17
 
%% The Initial Developer of the Original Code is Ericsson AB.
18
 
%%</legalnotice>
19
 
%%
 
16
%% 
 
17
%% %CopyrightEnd%
 
18
%% 
20
19
%% -------------------------------------------------------------------------
21
20
%%
22
21
%% Some of the stuff stored here should really be persistent!!
30
29
 
31
30
%% External exports
32
31
-export([start_link/1, stop/0, is_started/0]).
33
 
-export([register_user/3, unregister_user/1, 
 
32
-export([register_user/4, unregister_user/1, 
34
33
         which_users/0, 
35
 
         user_info/0, user_info/1, 
 
34
         user_info/0, user_info/1, user_info/2, 
36
35
 
37
 
         register_agent/4, unregister_agent/3, 
38
 
         agent_info/3, update_agent_info/5, 
 
36
         register_agent/3, unregister_agent/2, 
 
37
         agent_info/0, agent_info/2, agent_info/3, update_agent_info/4, 
39
38
         which_agents/0, which_agents/1, 
40
39
 
41
 
         get_agent_engine_id/1, get_agent_engine_id/2, is_known_engine_id/3, 
42
 
         get_agent_engine_max_message_size/2, 
43
 
         get_agent_version/2, 
44
 
         get_agent_mp_model/2, 
45
 
         get_agent_user_id/2, 
 
40
         is_known_engine_id/2, 
 
41
         get_agent_engine_id/1, 
 
42
         get_agent_engine_max_message_size/1, 
 
43
         get_agent_version/1, 
 
44
         get_agent_mp_model/1, 
 
45
         get_agent_user_id/1, get_agent_user_id/2, 
 
46
         get_agent_user_info/2, 
46
47
         
47
48
         system_info/0, system_info/1, 
48
49
         %% update_system_info/2, 
78
79
         info/0, 
79
80
         verbosity/1,
80
81
 
81
 
         backup/1
82
 
 
 
82
         backup/1,
 
83
 
 
84
         mk_target_name/3
 
85
 
 
86
        ]).
 
87
 
 
88
%% Backward compatibillity exports
 
89
-export([
 
90
         register_user/3,
 
91
         unregister_agent/3, 
 
92
         update_agent_info/5,
 
93
         is_known_engine_id/3, 
 
94
         get_agent_engine_id/2, 
 
95
         get_agent_engine_max_message_size/2, 
 
96
         get_agent_version/2, 
 
97
         get_agent_mp_model/2
83
98
        ]).
84
99
 
85
100
-export([check_manager_config/1, 
103
118
 
104
119
 
105
120
%% Types:
106
 
-record(user, {id, mod, data}).
 
121
-record(user, {id, mod, data, default_agent_config}).
107
122
 
108
123
-record(state, {backup}).
109
124
 
113
128
-define(BACKUP_DB, snmpm_config_backup).
114
129
-define(CONFIG_DB, snmpm_config_db).
115
130
 
 
131
-define(DEFAULT_USER,       default_user).
 
132
 
 
133
-define(DEFAULT_AGENT_PORT, 161).
116
134
 
117
135
-define(IRB_DEFAULT, auto).
118
136
%% -define(IRB_DEFAULT, {user, timer:seconds(15)}).
120
138
-define(USER_MOD_DEFAULT,  snmpm_user_default).
121
139
-define(USER_DATA_DEFAULT, undefined).
122
140
 
123
 
-define(DEF_ADDR_TAG, default_addr_tag).
 
141
%% -define(DEF_ADDR_TAG, default_addr_tag).
 
142
-define(DEFAULT_TARGETNAME, default_agent).
124
143
-define(DEF_PORT_TAG, default_port_tag).
125
144
 
126
145
-ifdef(snmp_debug).
151
170
backup(BackupDir) when is_list(BackupDir) ->
152
171
    call({backup, BackupDir}).
153
172
 
154
 
register_user(UserId, UserMod, UserData) when UserId =/= default_user ->
 
173
%% Backward compatibillity
 
174
register_user(UserId, UserMod, UserData) ->
 
175
    register_user(UserId, UserMod, UserData, []).
 
176
 
 
177
register_user(UserId, UserMod, UserData, DefaultAgentConfig) 
 
178
  when (UserId =/= ?DEFAULT_USER) andalso is_list(DefaultAgentConfig) ->
155
179
    case (catch verify_user_behaviour(UserMod)) of
156
180
        ok ->
157
 
            call({register_user, UserId, UserMod, UserData});
 
181
            Config = default_agent_config(DefaultAgentConfig),
 
182
            call({register_user, UserId, UserMod, UserData, Config});
158
183
        Error ->
159
184
            Error
160
185
    end;
161
 
register_user(UserId, _, _) ->
 
186
register_user(UserId, _UserMod, _UserData, DefaultAgentConfig) 
 
187
  when (UserId =/= ?DEFAULT_USER) ->
 
188
    {error, {bad_default_agent_config, DefaultAgentConfig}};
 
189
register_user(UserId, _, _, _) ->
162
190
    {error, {bad_user_id, UserId}}.
163
191
 
 
192
default_agent_config(DefaultAgentConfig) ->
 
193
    {ok, SystemDefaultAgentConfig} = agent_info(),
 
194
    default_agent_config(SystemDefaultAgentConfig, DefaultAgentConfig).
 
195
 
 
196
default_agent_config([], DefaultAgentConfig) ->
 
197
    DefaultAgentConfig;
 
198
default_agent_config([{Key, _} = Entry|T], DefaultAgentConfig) ->
 
199
    case lists:keysearch(Key, 1, DefaultAgentConfig) of
 
200
        {value, _} ->
 
201
            default_agent_config(T, DefaultAgentConfig);
 
202
        false ->
 
203
            default_agent_config(T, [Entry|DefaultAgentConfig])
 
204
    end.
 
205
 
 
206
 
164
207
verify_user_behaviour(UserMod) ->
165
208
    case snmp_misc:verify_behaviour(snmpm_user, UserMod) of
166
209
        ok ->
167
210
            ok;
168
211
        Error ->
169
 
            throw(Error)
 
212
            %% This user may implement the old behaviour, check it
 
213
            case snmp_misc:verify_behaviour(snmpm_user_old, UserMod) of
 
214
                ok ->
 
215
                    ok;
 
216
                _ ->
 
217
                    throw(Error)
 
218
            end
170
219
    end.
171
220
 
172
221
 
173
 
unregister_user(UserId) when UserId =/= default_user ->
 
222
unregister_user(UserId) when UserId =/= ?DEFAULT_USER ->
174
223
    call({unregister_user, UserId});
175
224
unregister_user(BadUserId) ->
176
225
    {error, {bad_user_id, BadUserId}}.
177
226
 
 
227
 
178
228
which_users() ->
179
229
    Pattern = #user{id = '$1', _ = '_'},
180
230
    Match   = ets:match(snmpm_user_table, Pattern),
181
 
    [UserId || [UserId] <- Match, UserId =/= default_user].
 
231
    [UserId || [UserId] <- Match, UserId =/= ?DEFAULT_USER].
182
232
 
183
233
 
184
234
user_info() ->
185
 
    UserId = default_user,
 
235
    UserId = ?DEFAULT_USER,
186
236
    case user_info(UserId) of
187
237
        {ok, Mod, Data} ->
188
238
            {ok, UserId, Mod, Data};
198
248
            {error, not_found}
199
249
    end.
200
250
 
201
 
 
202
 
register_agent(_UserId, ?DEF_ADDR_TAG = Addr, _Port, _Config) ->
203
 
    {error, {invalid_address, Addr}};
204
 
register_agent(UserId, Addr0, Port, Config) ->
 
251
user_info(UserId, Item) ->
 
252
    case (catch do_user_info(UserId, Item)) of
 
253
        {'EXIT', _} ->
 
254
            {error, {not_found, Item}};
 
255
        Val ->
 
256
            {ok, Val}
 
257
    end.
 
258
 
 
259
do_user_info(UserId, module) ->
 
260
    ets:lookup_element(snmpm_user_table, UserId, #user.mod);
 
261
do_user_info(UserId, data) ->
 
262
    ets:lookup_element(snmpm_user_table, UserId, #user.data);
 
263
do_user_info(UserId, default_agent_config) ->
 
264
    ets:lookup_element(snmpm_user_table, UserId, #user.default_agent_config);
 
265
do_user_info(_UserId, BadItem) ->
 
266
    error({not_found, BadItem}).
 
267
 
 
268
 
 
269
%% A target-name constructed in this way is a string with the following 
 
270
%% <IP-address>:<Port>-<Version>
 
271
%% 
 
272
mk_target_name(Addr0, Port, Config) when is_list(Config) ->
 
273
    Version = 
 
274
        case lists:keysearch(version, 1, Config) of
 
275
            {value, {_, V}} ->
 
276
                V;
 
277
            false ->
 
278
                select_lowest_supported_version()
 
279
        end,
 
280
%%     p("mk_target_name -> Version: ~p", [Version]),
 
281
    case normalize_address(Addr0) of
 
282
        {A, B, C, D} ->
 
283
            lists:flatten(
 
284
              io_lib:format("~w.~w.~w.~w:~w-~w", [A, B, C, D, Port, Version]));
 
285
        [A, B, C, D] ->
 
286
            lists:flatten(
 
287
              io_lib:format("~w.~w.~w.~w:~w-~w", [A, B, C, D, Port, Version]));
 
288
        _ -> 
 
289
            lists:flatten(
 
290
              io_lib:format("~p:~w-~w", [Addr0, Port, Version]))
 
291
    end.
 
292
        
 
293
select_lowest_supported_version() ->
 
294
    {ok, Versions} = system_info(versions),
 
295
    select_lowest_supported_version([v1, v2, v3], Versions).
 
296
 
 
297
select_lowest_supported_version([], Versions) ->
 
298
    error({bad_versions, Versions});
 
299
select_lowest_supported_version([H|T], Versions) ->
 
300
    case lists:member(H, Versions) of
 
301
        true ->
 
302
            H;
 
303
        false ->
 
304
            select_lowest_supported_version(T, Versions)
 
305
    end.
 
306
 
 
307
 
 
308
register_agent(UserId, _TargetName, _Config) when (UserId =:= user_id) ->
 
309
    {error, {bad_user_id, UserId}};
 
310
register_agent(UserId, TargetName, Config) 
 
311
  when (is_list(TargetName) andalso 
 
312
        (length(TargetName) > 0) andalso 
 
313
        is_list(Config)) ->
 
314
 
 
315
%%     p("register_agent -> entry with"
 
316
%%       "~n   UserId:     ~p"
 
317
%%       "~n   TargetName: ~p"
 
318
%%       "~n   Config:     ~p", [UserId, TargetName, Config]),
 
319
 
205
320
    %% Check: 
206
 
    %%   1) That the mandatory configs (none at the moment) are present
207
 
    %%   2) That the illegal configs user_id (used internally) is 
 
321
    %%   1) That the mandatory configs are present
 
322
    %%   2) That the illegal config user_id (used internally) is 
208
323
    %%      not present
209
324
    %%   3) Check that there are no invalid or erroneous configs
210
325
    %%   4) Chack that the manager is capable to use the selected version
211
326
    case verify_agent_config(Config) of
212
327
        ok ->
213
 
            Addr = normalize_address(Addr0),
214
 
            call({register_agent, UserId, Addr, Port, Config});
 
328
            call({register_agent, UserId, TargetName, Config});
215
329
        Error ->
216
330
            Error
217
331
    end.
218
332
 
 
333
 
219
334
verify_agent_config(Conf) ->
220
 
    %%     case verify_mandatory(Conf, []) of
221
 
    %%  ok ->
222
 
    %%      case verify_invalid(Conf, [user_id]) of
223
 
    %%          ok ->
224
 
    %%              case verify_agent_config2(Conf) of
225
 
    %%                  ok ->
226
 
    %%                      {ok, Vsns} = system_info(versions),
227
 
    %%                      Vsn = 
228
 
    %%                          case lists:keysearch(version, 1, Conf) of
229
 
    %%                              {value, {version, V}} ->
230
 
    %%                                  V;
231
 
    %%                              false ->
232
 
    %%                                  v1
233
 
    %%                          end,
234
 
    %%                      case lists:member(Vsn, Vsns) of
235
 
    %%                          true ->
236
 
    %%                              ok;
237
 
    %%                          false ->
238
 
    %%                              {error, {version_not_supported_by_manager, Vsn, Vsns}}
239
 
    %%                      end
240
 
    %%              end;
241
 
    %%          Error ->
242
 
    %%              Error
243
 
    %%      end;
244
 
    %%  Error ->
245
 
    %%      Error
246
 
    %%     end.
247
 
    ok = verify_mandatory(Conf, []),
 
335
    ok = verify_mandatory(Conf, [engine_id, address, reg_type]),
248
336
    case verify_invalid(Conf, [user_id]) of
249
337
        ok ->
250
338
            case verify_agent_config2(Conf) of
272
360
    verify_agent2(Conf).
273
361
 
274
362
 
 
363
unregister_agent(UserId, TargetName) ->
 
364
    call({unregister_agent, UserId, TargetName}).
 
365
 
275
366
unregister_agent(UserId, Addr0, Port) ->
276
367
    Addr = normalize_address(Addr0),
277
 
    call({unregister_agent, UserId, Addr, Port}).
278
 
 
279
 
agent_info(?DEF_ADDR_TAG = Addr, Port, Item) ->
280
 
    do_agent_info(Addr, Port, Item);
 
368
    case do_agent_info(Addr, Port, target_name) of
 
369
        {ok, TargetName} ->
 
370
            unregister_agent(UserId, TargetName);
 
371
        Error ->
 
372
            Error
 
373
    end.
 
374
 
 
375
agent_info() ->
 
376
    agent_info(?DEFAULT_TARGETNAME, all).
 
377
 
 
378
agent_info(TargetName, all) ->
 
379
    case ets:match_object(snmpm_agent_table, {{TargetName, '_'}, '_'}) of
 
380
        [] ->
 
381
            {error, not_found};
 
382
        All ->
 
383
            {ok, [{Item, Val} || {{_, Item}, Val} <- All]}
 
384
    end;
 
385
agent_info(TargetName, Item) ->
 
386
    case ets:lookup(snmpm_agent_table, {TargetName, Item}) of
 
387
        [{_, Val}] ->
 
388
            {ok, Val};
 
389
        [] ->
 
390
            {error, not_found}
 
391
    end.
 
392
    
281
393
agent_info(Addr0, Port, Item) ->
282
394
    Addr = normalize_address(Addr0),
283
395
    do_agent_info(Addr, Port, Item).
284
396
 
285
 
do_agent_info(Addr, Port, all) ->
286
 
    case ets:match_object(snmpm_agent_table, {{Addr, Port, '_'}, '_'}) of
 
397
do_agent_info(Addr, Port, target_name = Item) ->
 
398
    case ets:lookup(snmpm_agent_table, {Addr, Port, Item}) of
 
399
        [{_, Val}] ->
 
400
            {ok, Val};
287
401
        [] ->
288
 
            {error, not_found};
289
 
        All ->
290
 
            {ok, [{Item, Val} || {{_, _, Item}, Val} <- All,
291
 
                                Item /= address, Item /= port]}
 
402
            {error, not_found}
292
403
    end;
293
404
do_agent_info(Addr, Port, Item) ->
294
 
    case ets:lookup(snmpm_agent_table, {Addr, Port, Item}) of
295
 
        [{_, Val}] ->
296
 
            {ok, Val};
297
 
        [] ->
298
 
            {error, not_found}
 
405
    case do_agent_info(Addr, Port, target_name) of
 
406
        {ok, TargetName} ->
 
407
            agent_info(TargetName, Item);
 
408
        Error ->
 
409
            Error
299
410
    end.
300
411
 
301
412
 
303
414
    which_agents('_').
304
415
 
305
416
which_agents(UserId) ->
306
 
    Pat = {{'$1', '$2', user_id}, UserId},
 
417
    Pat = {{'$1', user_id}, UserId},
307
418
    Agents = ets:match(snmpm_agent_table, Pat),
308
 
    [{Addr, Port} || [Addr, Port] <- Agents].
 
419
    [TargetName || [TargetName] <- Agents].
309
420
 
310
421
    
311
 
update_agent_info(UserId, Addr0, Port, Item, Val0)  
312
 
  when Item /= address, Item /= port, Item /= user_id ->
 
422
update_agent_info(UserId, TargetName, Item, Val0) 
 
423
  when (Item =/= user_id) ->
313
424
    case (catch verify_val(Item, Val0)) of
314
425
        {ok, Val} ->
315
 
            Addr = normalize_address(Addr0),
316
 
            call({update_agent_info, UserId, Addr, Port, Item, Val});
317
 
        Error ->
318
 
            Error
319
 
    end.
320
 
 
321
 
is_known_engine_id(EngineID, Addr, Port) ->
322
 
    case agent_info(Addr, Port, engine_id) of
 
426
            call({update_agent_info, UserId, TargetName, Item, Val});
 
427
        Error ->
 
428
            Error
 
429
    end.
 
430
 
 
431
%% Backward compatibillity
 
432
update_agent_info(UserId, Addr, Port, Item, Val)  ->
 
433
    case agent_info(Addr, Port, target_name) of
 
434
        {ok, TargetName} ->
 
435
            update_agent_info(UserId, TargetName, Item, Val);
 
436
        Error ->
 
437
            Error
 
438
    end.
 
439
 
 
440
is_known_engine_id(EngineID, TargetName) ->
 
441
    case agent_info(TargetName, engine_id) of
323
442
        {ok, EngineID} ->
324
443
            true;
325
444
        {ok, _OtherEngineID} ->
327
446
        _ ->
328
447
            false
329
448
    end.
330
 
            
331
 
                                     
332
449
    
333
 
get_agent_engine_id(Name) ->
334
 
    Pat = {{'$1', '$2', target_name}, Name},
335
 
    case ets:match(snmpm_agent_table, Pat) of
336
 
        [[Addr, Port]|_] ->
337
 
            %% If the user has given several agents
338
 
            %% the same name, we pick the first we find...
339
 
            agent_info(Addr, Port, engine_id);
 
450
%% Backward compatibillity
 
451
is_known_engine_id(EngineID, Addr, Port) ->
 
452
    case agent_info(Addr, Port, target_name) of
 
453
        {ok, TargetName} ->
 
454
            is_known_engine_id(EngineID, TargetName);
340
455
        _ ->
341
 
            {error, not_found}
 
456
            false
342
457
    end.
343
458
 
 
459
get_agent_engine_id(TargetName) ->
 
460
    agent_info(TargetName, engine_id).
 
461
 
 
462
%% Backward compatibillity
344
463
get_agent_engine_id(Addr, Port) ->
345
464
    agent_info(Addr, Port, engine_id).
346
465
 
 
466
get_agent_engine_max_message_size(TargetName) ->
 
467
    agent_info(TargetName, max_message_size).
 
468
 
 
469
%% Backward compatibillity
347
470
get_agent_engine_max_message_size(Addr, Port) ->
348
471
    agent_info(Addr, Port, max_message_size).
349
472
 
 
473
get_agent_version(TargetName) ->
 
474
    agent_info(TargetName, version). 
 
475
 
 
476
%% Backward compatibillity
350
477
get_agent_version(Addr, Port) ->
351
 
    agent_info(Addr, Port, version). %% MP-model
 
478
    agent_info(Addr, Port, version). 
352
479
 
353
 
get_agent_mp_model(Addr, Port) ->
354
 
    case agent_info(Addr, Port, version) of
 
480
get_agent_mp_model(TargetName) ->
 
481
    case agent_info(TargetName, version) of
355
482
        {ok, v2} ->
356
483
            {ok, v2c};
357
484
        {ok, V} ->
360
487
            Err
361
488
    end.
362
489
 
 
490
%% Backward compatibillity
 
491
get_agent_mp_model(Addr, Port) ->
 
492
    case agent_info(Addr, Port, target_name) of
 
493
        {ok, TargetName} ->
 
494
            get_agent_mp_model(TargetName);
 
495
        Error ->
 
496
            Error
 
497
    end.
 
498
 
 
499
get_agent_user_id(TargetName) ->
 
500
    agent_info(TargetName, user_id).
 
501
 
363
502
get_agent_user_id(Addr, Port) ->
364
503
    agent_info(Addr, Port, user_id).
365
504
 
 
505
get_agent_user_info(Addr, Port) ->
 
506
    case agent_info(Addr, Port, target_name) of
 
507
        {ok, Target} ->
 
508
            case agent_info(Target, reg_type) of
 
509
                {ok, RegType} ->
 
510
                    case agent_info(Target, user_id) of
 
511
                        {ok, UserId} ->
 
512
                            {ok, UserId, Target, RegType};
 
513
                        {error, not_found} ->
 
514
                            {error, {user_id_not_found, Target}}
 
515
                    end;
 
516
                {error, not_found} ->
 
517
                    {error, {reg_type_not_found, Target}}
 
518
            end;
 
519
        {error, not_found} ->
 
520
            {error, {target_name_not_found, Addr, Port}}
 
521
    end.
 
522
            
 
523
 
366
524
 
367
525
system_info() ->
368
526
    system_info(all).
398
556
    end.
399
557
 
400
558
set_engine_boots(Boots) ->
401
 
    case (whereis(?SERVER) == self()) of
 
559
    case (whereis(?SERVER) =:= self()) of
402
560
        false ->
403
561
            call({set_engine_boots, Boots});
404
562
        true ->
463
621
    call({set_usm_cache, Key, Val}).
464
622
 
465
623
reset_usm_cache(SnmpEngineID) ->
466
 
    case (whereis(?SERVER) == self()) of
 
624
    case (whereis(?SERVER) =:= self()) of
467
625
        false ->
468
626
            call({reset_usm_cache, SnmpEngineID});
469
627
        true ->
847
1005
            ets:insert(snmpm_config_table, {audit_trail_log_repair, LogRep})
848
1006
    end,
849
1007
 
 
1008
    %% -- System default agent config --
 
1009
    ?vdebug("system default agent config", []),
 
1010
    init_agent_default(),
 
1011
 
850
1012
    %% -- User (optional) --
851
1013
    ?vdebug("default user", []),
852
1014
    DefUserMod  = get_opt(def_user_mod,  Opts, ?USER_MOD_DEFAULT),
853
1015
    DefUserData = get_opt(def_user_data, Opts, ?USER_DATA_DEFAULT),
854
1016
    ets:insert(snmpm_config_table, {def_user_mod,  DefUserMod}),
855
1017
    ets:insert(snmpm_config_table, {def_user_data, DefUserData}),
856
 
    DefUser = #user{id = default_user, mod = DefUserMod, data = DefUserData},
 
1018
    
 
1019
    {ok, SystemDefaultAgentConfig}       = agent_info(),
 
1020
    DefUser = #user{id                   = ?DEFAULT_USER, 
 
1021
                    mod                  = DefUserMod, 
 
1022
                    data                 = DefUserData,
 
1023
                    default_agent_config = SystemDefaultAgentConfig},
857
1024
    ok = handle_register_user(DefUser),
858
1025
    
859
1026
    %% -- Note store --
876
1043
 
877
1044
    %% -- Agents config --
878
1045
    ?vdebug("agents config", []),
879
 
    init_agent_default(),
880
1046
    Agents = read_agents_config_file(ConfDir),
881
1047
    init_agents_config(Agents),
882
1048
 
1295
1461
    init_manager_config(Confs).
1296
1462
 
1297
1463
 
 
1464
 
1298
1465
init_agent_default() ->
1299
 
    %% Name
1300
 
    init_agent_default(target_name, "agent-default"),
 
1466
    %% The purpose of the default_agent is only to have a place
 
1467
    %% to store system wide default values related to agents.
 
1468
    %% 
1301
1469
 
1302
 
    %% EngineId
1303
 
    init_agent_default(engine_id, "agentEngine-default"),
 
1470
    %% Port
 
1471
    init_agent_default(port, ?DEFAULT_AGENT_PORT),
1304
1472
 
1305
1473
    %% Timeout
1306
1474
    init_agent_default(timeout, 10000),
1322
1490
 
1323
1491
    %% Community
1324
1492
    init_agent_default(community, "all-rights"),
1325
 
 
1326
1493
    ok.
1327
1494
 
1328
 
init_agent_default(Item, Val) 
1329
 
  when Item /= address; Item /= port; Item /= user_id ->
1330
 
    case do_update_agent_info(?DEF_ADDR_TAG, ?DEF_PORT_TAG, Item, Val) of
 
1495
 
 
1496
init_agent_default(Item, Val) when Item =/= user_id ->
 
1497
    case do_update_agent_info(default_agent, Item, Val) of
1331
1498
        ok ->
1332
1499
            ok;
1333
1500
        {error, Reason} ->
1347
1514
 
1348
1515
check_agent_config2(Agent) ->
1349
1516
    case (catch check_agent_config(Agent)) of
1350
 
        {ok, {UserId, Addr, Port, Conf, Version}} ->
 
1517
        {ok, {UserId, TargetName, Conf, Version}} ->
1351
1518
            {ok, Vsns} = system_info(versions),
1352
1519
            case lists:member(Version, Vsns) of
1353
1520
                true ->
1354
 
                    {ok, {UserId, Addr, Port, Conf}};
 
1521
                    {ok, {UserId, TargetName, Conf}};
1355
1522
                false ->
1356
1523
                    error({version_not_supported_by_manager, 
1357
1524
                           Version, Vsns})
1403
1570
    init_agent_config(Agent),
1404
1571
    init_agents_config(Agents).
1405
1572
 
1406
 
init_agent_config({_UserId, ?DEF_ADDR_TAG = Addr, _Port, _Config}) ->
1407
 
    throw({error, {invalid_address, Addr}});
1408
 
init_agent_config({UserId, Addr, Port, Config}) ->
1409
 
    case handle_register_agent(UserId, Addr, Port, Config) of
 
1573
init_agent_config({_UserId, ?DEFAULT_TARGETNAME = TargetName, _Config}) ->
 
1574
    throw({error, {invalid_target_name, TargetName}});
 
1575
init_agent_config({UserId, TargetName, Config}) ->
 
1576
    case handle_register_agent(UserId, TargetName, Config) of
1410
1577
        ok ->
1411
1578
            ok;
1412
1579
        Error ->
1424
1591
    ?vtrace("verify_agent -> entry with"
1425
1592
            "~n   UserId:     ~p"
1426
1593
            "~n   TargetName: ~p", [UserId, TargetName]),
 
1594
    snmp_conf:check_string(TargetName, {gt, 0}),
1427
1595
    case verify_val(address, Ip) of
1428
1596
        {ok, Addr} ->
1429
1597
            snmp_conf:check_integer(Port, {gt, 0}),
1430
1598
            Conf = 
1431
 
                [{target_name,      TargetName},
 
1599
                [{address,          Addr},
 
1600
                 {port,             Port},
1432
1601
                 {community,        Comm}, 
1433
1602
                 {engine_id,        EngineId},
1434
1603
                 {timeout,          Timeout},
1440
1609
                ],
1441
1610
            case verify_agent2(Conf) of
1442
1611
                ok ->
1443
 
                    {UserId, Addr, Port, Conf, Version};
 
1612
                    {UserId, TargetName, Conf, Version};
1444
1613
                Err ->
1445
1614
                    throw(Err)
1446
1615
            end;
1458
1627
            verify_agent2(Items);
1459
1628
        Err ->
1460
1629
            Err
1461
 
    end.
 
1630
    end;
 
1631
verify_agent2([Bad|_]) ->
 
1632
    {error, {bad_agent_config, Bad}}.
1462
1633
 
1463
1634
 
1464
1635
read_users_config_file(Dir) ->
1471
1642
            throw(Error)
1472
1643
    end.
1473
1644
 
1474
 
check_user_config({Id, Mod, _Data} = User) when Id =/= default_user ->
 
1645
 
 
1646
check_user_config({Id, Mod, Data}) ->
 
1647
    check_user_config({Id, Mod, Data, []});
 
1648
check_user_config({Id, Mod, _Data, DefaultAgentConfig} = User) 
 
1649
  when (Id =/= ?DEFAULT_USER) andalso is_list(DefaultAgentConfig) ->
1475
1650
    case (catch verify_user_behaviour(Mod)) of
1476
1651
        ok ->
1477
 
            {ok, User};
 
1652
            case verify_user_agent_config(DefaultAgentConfig) of
 
1653
                ok ->
 
1654
                    {ok, User};
 
1655
                {error, Reason} ->
 
1656
                    error({bad_default_agent_config, Reason})
 
1657
            end;
1478
1658
        Error ->
1479
1659
            throw(Error)
1480
1660
    end;
1481
 
check_user_config({Id, _Mod, _Data}) ->
 
1661
check_user_config({Id, _Mod, _Data, DefaultAgentConfig}) 
 
1662
  when (Id =/= ?DEFAULT_USER) ->
 
1663
    {error, {bad_default_agent_config, DefaultAgentConfig}};
 
1664
check_user_config({Id, _Mod, _Data, _DefaultAgentConfig}) ->
1482
1665
    error({bad_user_id, Id});
1483
1666
check_user_config(User) ->
1484
1667
    error({bad_user_config, User}).
1505
1688
    end.
1506
1689
   
1507
1690
verify_user({Id, UserMod, UserData}) ->
 
1691
    verify_user({Id, UserMod, UserData, []});
 
1692
verify_user({Id, UserMod, UserData, DefaultAgentConfig}) 
 
1693
  when (Id =/= ?DEFAULT_USER) andalso is_list(DefaultAgentConfig) ->
1508
1694
    ?d("verify_user -> entry with"
1509
1695
       "~n   Id:       ~p"
1510
1696
       "~n   UserMod:  ~p"
1511
 
       "~n   UserData: ~p", [Id, UserMod, UserData]),
 
1697
       "~n   UserData: ~p"
 
1698
       "~n   DefaultAgentConfig: ~p", 
 
1699
       [Id, UserMod, UserData, DefaultAgentConfig]),
1512
1700
    case (catch verify_user_behaviour(UserMod)) of
1513
1701
        ok ->
1514
 
            {ok, #user{id = Id, mod = UserMod, data = UserData}};
 
1702
            case verify_user_agent_config(DefaultAgentConfig) of
 
1703
                ok ->
 
1704
                    Config = default_agent_config(DefaultAgentConfig),
 
1705
                    {ok, #user{id                   = Id, 
 
1706
                               mod                  = UserMod, 
 
1707
                               data                 = UserData, 
 
1708
                               default_agent_config = Config}};
 
1709
                {error, Reason} ->
 
1710
                    error({bad_default_agent_config, Reason})
 
1711
            end;
1515
1712
        Error ->
1516
1713
            throw(Error)
 
1714
    end;
 
1715
verify_user({Id, _UserMod, _UserData, DefaultAgentConfig}) 
 
1716
  when (Id =/= ?DEFAULT_USER) ->
 
1717
    {error, {bad_default_agent_config, DefaultAgentConfig}};
 
1718
verify_user({Id, _, _, _}) ->
 
1719
    {error, {bad_user_id, Id}}.
 
1720
 
 
1721
verify_user_agent_config(Conf) ->
 
1722
    case verify_invalid(Conf, [user_id, engine_id, address]) of
 
1723
        ok ->
 
1724
            verify_agent_config2(Conf);
 
1725
        Error ->
 
1726
            Error
1517
1727
    end.
1518
1728
 
1519
 
 
1520
1729
read_usm_config_file(Dir) ->
1521
1730
    Check = fun(C) -> check_usm_user_config(C) end,
1522
1731
    case read_file(Dir, "usm.conf", Check, []) of
1838
2047
%%          {stop, Reason, Reply, State}   | (terminate/2 is called)
1839
2048
%%          {stop, Reason, State}            (terminate/2 is called)
1840
2049
%%--------------------------------------------------------------------
1841
 
handle_call({register_user, UserId, UserMod, UserData}, _From, State) ->
 
2050
handle_call({register_user, UserId, UserMod, UserData, DefaultAgentConfig}, 
 
2051
            _From, State) ->
1842
2052
    ?vlog("received register_user request: "
1843
 
          "~n   UserId:   ~p"
1844
 
          "~n   UserMod:  ~p"
1845
 
          "~n   UserData: ~p", [UserId, UserMod, UserData]),
1846
 
    User  = #user{id = UserId, mod = UserMod, data = UserData},
 
2053
          "~n   UserId:             ~p"
 
2054
          "~n   UserMod:            ~p"
 
2055
          "~n   UserData:           ~p"
 
2056
          "~n   DefaultAgentConfig: ~p", 
 
2057
          [UserId, UserMod, UserData, DefaultAgentConfig]),
 
2058
    User  = #user{id                   = UserId, 
 
2059
                  mod                  = UserMod, 
 
2060
                  data                 = UserData,
 
2061
                  default_agent_config = DefaultAgentConfig},
1847
2062
    Reply = handle_register_user(User),
1848
2063
    {reply, Reply, State};
1849
2064
 
1853
2068
    Reply = handle_unregister_user(UserId),
1854
2069
    {reply, Reply, State};
1855
2070
 
1856
 
handle_call({register_agent, UserId, Addr, Port, Config}, _From, State) ->
 
2071
handle_call({register_agent, UserId, TargetName, Config}, _From, State) ->
1857
2072
    ?vlog("received register_agent request: "
1858
 
          "~n   UserId: ~p"
1859
 
          "~n   Addr:   ~p"
1860
 
          "~n   Port:   ~p"
1861
 
          "~n   Config: ~p", [UserId, Addr, Port, Config]),
1862
 
    Reply = handle_register_agent(UserId, Addr, Port, Config),
 
2073
          "~n   UserId:     ~p"
 
2074
          "~n   TargetName: ~p"
 
2075
          "~n   Config:     ~p", [UserId, TargetName, Config]),
 
2076
    Reply = handle_register_agent(UserId, TargetName, Config),
1863
2077
    {reply, Reply, State};
1864
2078
 
1865
 
handle_call({unregister_agent, UserId, Addr, Port}, _From, State) ->
 
2079
handle_call({unregister_agent, UserId, TargetName}, _From, State) ->
1866
2080
    ?vlog("received unregister_agent request: "
1867
 
          "~n   UserId: ~p"
1868
 
          "~n   Addr:   ~p"
1869
 
          "~n   Port:   ~p", [UserId, Addr, Port]),
1870
 
    Reply = handle_unregister_agent(UserId, Addr, Port),
 
2081
          "~n   UserId:     ~p"
 
2082
          "~n   TargetName: ~p", [UserId, TargetName]),
 
2083
    Reply = handle_unregister_agent(UserId, TargetName),
1871
2084
    {reply, Reply, State};
1872
2085
 
1873
 
handle_call({update_agent_info, UserId, Addr, Port, Item, Val}, 
 
2086
handle_call({update_agent_info, UserId, TargetName, Item, Val}, 
1874
2087
            _From, State) ->
1875
2088
    ?vlog("received update_agent_info request: "
1876
 
          "~n   UserId: ~p"
1877
 
          "~n   Addr:   ~p"
1878
 
          "~n   Port:   ~p"
1879
 
          "~n   Item:   ~p"
1880
 
          "~n   Val:    ~p", [UserId, Addr, Port, Item, Val]),
1881
 
    Reply = handle_update_agent_info(UserId, Addr, Port, Item, Val),
 
2089
          "~n   UserId:     ~p"
 
2090
          "~n   TargetName: ~p"
 
2091
          "~n   Item:       ~p"
 
2092
          "~n   Val:        ~p", [UserId, TargetName, Item, Val]),
 
2093
    Reply = handle_update_agent_info(UserId, TargetName, Item, Val),
1882
2094
    {reply, Reply, State};
1883
2095
 
1884
2096
handle_call({register_usm_user, User}, _From, State) ->
2234
2446
    ok.
2235
2447
 
2236
2448
 
2237
 
handle_register_agent(UserId, Addr, Port, Config) ->
 
2449
handle_register_agent(UserId, TargetName, Config) ->
2238
2450
    ?vdebug("handle_register_agent -> entry with"
2239
 
            "~n   UserId: ~p"
2240
 
            "~n   Addr:   ~p"
2241
 
            "~n   Port:   ~p"
2242
 
            "~n   Config: ~p", [UserId, Addr, Port, Config]),
2243
 
    case (catch agent_info(Addr, Port, address)) of
 
2451
            "~n   UserId:     ~p"
 
2452
            "~n   TargetName: ~p"
 
2453
            "~n   Config:     ~p", [UserId, TargetName, Config]),
 
2454
    case (catch agent_info(TargetName, user_id)) of
2244
2455
        {error, _} ->
2245
 
            {ok, DefConfig} = agent_info(?DEF_ADDR_TAG, ?DEF_PORT_TAG, all),
2246
 
            do_handle_register_agent(Addr, Port, DefConfig),
2247
 
            do_handle_register_agent(Addr, Port, [{user_id, UserId}|Config]);
2248
 
        Error ->
2249
 
            ?vinfo("[~w] Agent (~w:~w) already registered:"
2250
 
                   "~n   Error: ~p"
2251
 
                   "~nwhen"
2252
 
                   "~n   Agents: ~p", 
2253
 
                   [UserId, Addr, Port, Error, which_agents()]),
2254
 
            {error, {already_registered, Addr, Port}}
 
2456
            case ets:lookup(snmpm_user_table, UserId) of
 
2457
                [#user{default_agent_config = DefConfig}] ->
 
2458
                    do_handle_register_agent(TargetName, DefConfig),
 
2459
                    do_handle_register_agent(TargetName, 
 
2460
                                             [{user_id, UserId}|Config]),
 
2461
                    %% <DIRTY-BACKWARD-COMPATIBILLITY>
 
2462
                    %% And now for some (backward compatibillity) 
 
2463
                    %% dirty crossref stuff
 
2464
                    {ok, Addr} = agent_info(TargetName, address),
 
2465
                    {ok, Port} = agent_info(TargetName, port),
 
2466
                    ets:insert(snmpm_agent_table, 
 
2467
                               {{Addr, Port, target_name}, TargetName}),
 
2468
                    %% </DIRTY-BACKWARD-COMPATIBILLITY>
 
2469
                    ok;
 
2470
                _ ->
 
2471
                    {error, {not_found, UserId}}
 
2472
            end;
 
2473
        {ok, UserId} ->
 
2474
            ?vinfo("[~w] Agent (~p) already registered"
 
2475
                   "~nwhen"
 
2476
                   "~n   Agents: ~p", 
 
2477
                   [UserId, TargetName, which_agents()]),
 
2478
            {error, {already_registered, TargetName}};
 
2479
        {ok, OtherUserId} ->
 
2480
            ?vinfo("[~w] Agent (~p) already registered to ~p"
 
2481
                   "~nwhen"
 
2482
                   "~n   Agents: ~p", 
 
2483
                   [UserId, TargetName, OtherUserId, which_agents()]),
 
2484
            {error, {already_registered, TargetName, OtherUserId}}
2255
2485
    end.
2256
2486
 
2257
 
do_handle_register_agent(Addr, Port, []) ->
2258
 
    do_update_agent_info(Addr, Port, address, Addr),
2259
 
    do_update_agent_info(Addr, Port, port,    Port),
 
2487
do_handle_register_agent(_TargetName, []) ->
2260
2488
    ok;
2261
 
do_handle_register_agent(Addr, Port, [{Item, Val}|Rest]) ->
2262
 
    case (catch do_update_agent_info(Addr, Port, Item, Val)) of
 
2489
do_handle_register_agent(TargetName, [{Item, Val}|Rest]) ->
 
2490
    case (catch do_update_agent_info(TargetName, Item, Val)) of
2263
2491
        ok ->
2264
 
            do_handle_register_agent(Addr, Port, Rest);
 
2492
            do_handle_register_agent(TargetName, Rest);
2265
2493
        {error, Reason} ->
2266
 
            ets:match_delete(snmpm_agent_table, {Addr, Port, '_'}),
 
2494
            ets:match_delete(snmpm_agent_table, {TargetName, '_'}),
2267
2495
            {error, Reason}
2268
2496
    end;
2269
 
do_handle_register_agent(Addr, Port, BadConfig) ->
2270
 
    error_msg("error during agent registration - bab config: ~n~p", 
 
2497
do_handle_register_agent(TargetName, BadConfig) ->
 
2498
    error_msg("error during agent registration - bad config: ~n~p", 
2271
2499
              [BadConfig]),
2272
 
    ets:match_delete(snmpm_agent_table, {Addr, Port, '_'}),
2273
 
    {error, {bad_agent_config, Addr, Port, BadConfig}}.
2274
 
 
2275
 
 
2276
 
handle_unregister_agent(UserId, Addr, Port) ->
 
2500
    ets:match_delete(snmpm_agent_table, {TargetName, '_'}),
 
2501
    {error, {bad_agent_config, TargetName, BadConfig}}.
 
2502
 
 
2503
 
 
2504
handle_unregister_agent(UserId, TargetName) ->
2277
2505
    ?vdebug("handle_unregister_agent -> entry with"
2278
 
            "~n   UserId: ~p"
2279
 
            "~n   Addr:   ~p"
2280
 
            "~n   Port:   ~p", [UserId, Addr, Port]),
2281
 
    case (catch agent_info(Addr, Port, user_id)) of
 
2506
            "~n   UserId:     ~p"
 
2507
            "~n   TargetName: ~p", [UserId, TargetName]),
 
2508
    case (catch agent_info(TargetName, user_id)) of
2282
2509
        {ok, UserId} ->
2283
 
            {ok, EngineID} = agent_info(Addr, Port, engine_id),
 
2510
            {ok, EngineID} = agent_info(TargetName, engine_id),
2284
2511
            reset_usm_cache(EngineID),
2285
 
            ets:match_delete(snmpm_agent_table, {{Addr, Port, '_'}, '_'}),
 
2512
            %% <DIRTY-BACKWARD-COMPATIBILLITY>
 
2513
            %% And now for some (backward compatibillity) 
 
2514
            %% dirty crossref stuff
 
2515
            {ok, Addr} = agent_info(TargetName, address),
 
2516
            {ok, Port} = agent_info(TargetName, port),
 
2517
            ets:delete(snmpm_agent_table, {Addr, Port, target_name}),
 
2518
            %% </DIRTY-BACKWARD-COMPATIBILLITY>
 
2519
            ets:match_delete(snmpm_agent_table, {{TargetName, '_'}, '_'}),
2286
2520
            ok;
2287
2521
        {ok, OtherUserId} ->
2288
2522
            {error, {not_owner, OtherUserId}};
2291
2525
    end.
2292
2526
 
2293
2527
 
2294
 
handle_update_agent_info(UserId, Addr, Port, Item, Val) ->
 
2528
handle_update_agent_info(UserId, TargetName, Item, Val) ->
2295
2529
    ?vdebug("handle_update_agent_info -> entry with"
2296
 
            "~n   UserId: ~p"
2297
 
            "~n   Addr:   ~p"
2298
 
            "~n   Port:   ~p"
2299
 
            "~n   Item:   ~p"
2300
 
            "~n   Val:    ~p", [UserId, Addr, Port, Item, Val]),
2301
 
    case (catch agent_info(Addr, Port, user_id)) of
 
2530
            "~n   UserId:     ~p"
 
2531
            "~n   TargetName: ~p"
 
2532
            "~n   Item:       ~p"
 
2533
            "~n   Val:        ~p", [UserId, TargetName, Item, Val]),
 
2534
    case (catch agent_info(TargetName, user_id)) of
2302
2535
        {ok, UserId} ->
2303
 
            do_update_agent_info(Addr, Port, Item, Val);
 
2536
            do_update_agent_info(TargetName, Item, Val);
2304
2537
        {ok, OtherUserId} ->
2305
2538
            {error, {not_owner, OtherUserId}};
2306
2539
        Error ->
2307
2540
            Error
2308
2541
    end.
2309
2542
 
2310
 
do_update_agent_info(Addr, Port, Item, Val0) ->
 
2543
do_update_agent_info(TargetName, Item, Val0) ->
 
2544
%%     p("do_update_agent_info -> entry with"
 
2545
%%       "~n   TargetName: ~p"
 
2546
%%       "~n   Item:       ~p"
 
2547
%%       "~n   Val0:       ~p", [TargetName, Item, Val0]),
2311
2548
    case verify_val(Item, Val0) of
2312
2549
        {ok, Val} ->
2313
 
            ets:insert(snmpm_agent_table, {{Addr, Port, Item}, Val}),
 
2550
%%          p("do_update_agent_info -> verified value"
 
2551
%%            "~n   Val: ~p", [Val]),
 
2552
            ets:insert(snmpm_agent_table, {{TargetName, Item}, Val}),
2314
2553
            ok;
2315
2554
        Error ->
2316
2555
            ?vlog("do_update_agent_info -> verify value failed: "
2317
 
                  "~n   Addr:  ~p"
2318
 
                  "~n   Port:  ~p"
2319
 
                  "~n   Item:  ~p"
2320
 
                  "~n   Val0:  ~p"
2321
 
                  "~n   Error: ~p", [Addr, Port, Item, Val0, Error]),
2322
 
            {error, {bad_agent_val, Addr, Port, Item, Val0}}
 
2556
                  "~n   TargetName: ~p"
 
2557
                  "~n   Item:       ~p"
 
2558
                  "~n   Val0:       ~p"
 
2559
                  "~n   Error:      ~p", [TargetName, Item, Val0, Error]),
 
2560
            {error, {bad_agent_val, TargetName, Item, Val0}}
2323
2561
    end.
2324
2562
 
2325
2563
 
2370
2608
    ok = verify_usm_user_sec_name(Val),
2371
2609
    do_update_usm_user_info(Key, User#usm_user{sec_name = Val});
2372
2610
do_update_usm_user_info(Key, User, auth, Val) 
2373
 
  when Val == usmNoAuthProtocol; 
2374
 
       Val == usmHMACMD5AuthProtocol;
2375
 
       Val == usmHMACSHAAuthProtocol ->
 
2611
  when (Val =:= usmNoAuthProtocol) orelse 
 
2612
       (Val =:= usmHMACMD5AuthProtocol) orelse
 
2613
       (Val =:= usmHMACSHAAuthProtocol) ->
2376
2614
    do_update_usm_user_info(Key, User#usm_user{auth = Val});
2377
2615
do_update_usm_user_info(_Key, _User, auth, Val) ->
2378
2616
    {error, {invalid_auth_protocol, Val}};
2388
2626
do_update_usm_user_info(Key, 
2389
2627
                        #usm_user{auth = usmHMACMD5AuthProtocol} = User, 
2390
2628
                        auth_key, Val) 
2391
 
  when length(Val) == 16 ->
 
2629
  when length(Val) =:= 16 ->
2392
2630
    case is_crypto_supported(md5_mac_96) of
2393
2631
        true -> 
2394
2632
            do_update_usm_user_info(Key, User#usm_user{auth_key = Val});
2483
2721
%% ---------------------------------------------------------------------
2484
2722
 
2485
2723
verify_mandatory(_, []) ->
2486
 
    ok.
2487
 
%% verify_mandatory(Conf, [Mand|Mands]) ->
2488
 
%%     case lists:member(Mand, Conf) of
2489
 
%%      true ->
2490
 
%%          verify_mandatory(Conf, Mands);
2491
 
%%      false ->
2492
 
%%          {error, {missing_mandatory_config, Mand}}
2493
 
%%     end.
 
2724
    ok;
 
2725
verify_mandatory(Conf, [Mand|Mands]) ->
 
2726
    case lists:keymember(Mand, 1, Conf) of
 
2727
        true ->
 
2728
            verify_mandatory(Conf, Mands);
 
2729
        false ->
 
2730
            {error, {missing_mandatory_config, Mand}}
 
2731
    end.
2494
2732
 
2495
2733
verify_invalid(_, []) ->
2496
2734
    ok;
2505
2743
 
2506
2744
verify_val(user_id, UserId) ->
2507
2745
    {ok, UserId};
2508
 
verify_val(address, Ip) when list(Ip) ->
2509
 
    case (catch snmp_conf:check_ip(Ip)) of
2510
 
        ok ->
2511
 
            {ok, list_to_tuple(Ip)};
2512
 
        Err ->
2513
 
            Err
 
2746
verify_val(reg_type, RegType) 
 
2747
  when (RegType =:= addr_port) orelse (RegType =:= target_name) ->
 
2748
    {ok, RegType};
 
2749
verify_val(address, Addr0) ->
 
2750
    case normalize_address(Addr0) of
 
2751
        {_A1, _A2, _A3, _A4} = Addr ->
 
2752
            {ok, Addr};
 
2753
        _ when is_list(Addr0) ->
 
2754
            case (catch snmp_conf:check_ip(Addr0)) of
 
2755
                ok ->
 
2756
                    {ok, list_to_tuple(Addr0)};
 
2757
                Err ->
 
2758
                    Err
 
2759
            end;
 
2760
        _ ->
 
2761
            error({bad_address, Addr0})
2514
2762
    end;
2515
 
verify_val(address, {A1, A2, A3, A4} = Addr) 
2516
 
  when integer(A1), integer(A2), integer(A3), integer(A4) ->
2517
 
    {ok, Addr};
2518
 
verify_val(address, InvalidAddr) ->
2519
 
    error({bad_address, InvalidAddr});
2520
2763
verify_val(port, Port) ->
2521
2764
    case (catch snmp_conf:check_integer(Port, {gt, 0})) of
2522
2765
        ok ->
2524
2767
        Err ->
2525
2768
            Err
2526
2769
    end;
2527
 
verify_val(target_name, Name) ->
2528
 
    case (catch snmp_conf:check_string(Name,{gt, 0})) of
2529
 
        ok ->
2530
 
            {ok, Name};
2531
 
        Err ->
2532
 
            Err
2533
 
    end;
2534
2770
verify_val(community, Comm) ->
2535
2771
    case (catch snmp_conf:check_string(Comm)) of
2536
2772
        ok ->
2538
2774
        Err ->
2539
2775
            Err
2540
2776
    end;
 
2777
verify_val(engine_id, discovery = EngineId) ->
 
2778
    {ok, EngineId};
2541
2779
verify_val(engine_id, EngineId) ->
2542
2780
    case (catch snmp_conf:check_string(EngineId)) of
2543
2781
        ok ->
2555
2793
            Err
2556
2794
    end;
2557
2795
verify_val(version, V) 
2558
 
  when V == v1; V == v2; V == v3 ->
 
2796
  when (V =:= v1) orelse (V =:= v2) orelse (V =:= v3) ->
2559
2797
    {ok, V};
2560
2798
verify_val(version, BadVersion) ->
2561
2799
    error({bad_version, BadVersion});
2562
2800
verify_val(sec_model, Model) ->
2563
2801
    (catch snmp_conf:check_sec_model(Model));
2564
 
verify_val(sec_name, Name) when list(Name) ->
 
2802
verify_val(sec_name, Name) when is_list(Name) ->
2565
2803
    case (catch snmp_conf:check_string(Name)) of
2566
2804
        ok ->
2567
2805
            {ok, Name};
2733
2971
    case inet:getaddr(Addr, inet) of
2734
2972
        {ok, Addr2} ->
2735
2973
            Addr2;
2736
 
        _ when list(Addr) ->
 
2974
        _ when is_list(Addr) ->
2737
2975
            case (catch snmp_conf:check_ip(Addr)) of
2738
2976
                ok ->
2739
2977
                    list_to_tuple(Addr);
2845
3083
 
2846
3084
error_msg(F, A) ->
2847
3085
    ?snmpm_error("Config server: " ++ F, A).
 
3086
 
 
3087
%% p(F) ->
 
3088
%%     p(F, []).
 
3089
 
 
3090
%% p(F, A) ->
 
3091
%%     io:format("~w:" ++ F ++ "~n", [?MODULE | A]).
 
3092