|
0
|
1 %{
|
|
|
2 /*
|
|
|
3 * CDDL HEADER START
|
|
|
4 *
|
|
|
5 * The contents of this file are subject to the terms of the
|
|
|
6 * Common Development and Distribution License, Version 1.0 only
|
|
|
7 * (the "License"). You may not use this file except in compliance
|
|
|
8 * with the License.
|
|
|
9 *
|
|
|
10 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
|
|
|
11 * or http://www.opensolaris.org/os/licensing.
|
|
|
12 * See the License for the specific language governing permissions
|
|
|
13 * and limitations under the License.
|
|
|
14 *
|
|
|
15 * When distributing Covered Code, include this CDDL HEADER in each
|
|
|
16 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
|
|
|
17 * If applicable, add the following below this CDDL HEADER, with the
|
|
|
18 * fields enclosed by brackets "[]" replaced with your own identifying
|
|
|
19 * information: Portions Copyright [yyyy] [name of copyright owner]
|
|
|
20 *
|
|
|
21 * CDDL HEADER END
|
|
|
22 *
|
|
|
23 * Copyright 1998 Sun Microsystems, Inc. All Rights Reserved.
|
|
|
24 * Use is subject to license terms.
|
|
|
25 */
|
|
|
26
|
|
|
27 #pragma ident "@(#)personal.y 1.15 05/06/12 SMI"
|
|
|
28
|
|
|
29 %}
|
|
|
30
|
|
|
31 %start configuration
|
|
|
32
|
|
|
33 %token NUMBER
|
|
|
34 %token MACROS
|
|
|
35 %token EQUAL
|
|
|
36 %token OPENBRACKET
|
|
|
37 %token CLOSEBRACKET
|
|
|
38 %token IDENTIFIER
|
|
|
39 %token MIB2
|
|
|
40 %token SUN
|
|
|
41 %token ENTERPRISE
|
|
|
42 %token DOT
|
|
|
43 %token AGENTS
|
|
|
44 %token NAME
|
|
|
45 %token SUBTREES
|
|
|
46 %token TABLES
|
|
|
47 %token TABLE
|
|
|
48 %token COLUMNS
|
|
|
49 %token INDEXS
|
|
|
50 %token TIMEOUT
|
|
|
51 %token PORT
|
|
|
52 %token QUOTEDSTRING
|
|
|
53 %token COMA
|
|
|
54 %token MINUS
|
|
|
55 %token OPENSQUAREBRACKET
|
|
|
56 %token CLOSESQUAREBRACKET
|
|
|
57 %token WATCHDOGTIME
|
|
|
58
|
|
|
59 /* support SNMP security(5-13-96) */
|
|
|
60 %token COMMUNITIES
|
|
|
61 %token READONLY
|
|
|
62 %token READWRITE
|
|
|
63 %token MANAGERS
|
|
|
64 %token TRAPCOMMUNITY
|
|
|
65 %token TRAPDESTINATORS
|
|
|
66 %token ACL
|
|
|
67 %token ACCESS
|
|
|
68 %token TRAPNUM
|
|
|
69 %token HOSTS
|
|
|
70 %token TRAP
|
|
|
71
|
|
|
72 %{
|
|
|
73 #include <unistd.h>
|
|
|
74 #include <stdio.h>
|
|
|
75 #include <sys/types.h>
|
|
|
76 #include <sys/stat.h>
|
|
|
77 #include <sys/mman.h>
|
|
|
78 #include <sys/socket.h>
|
|
|
79 #include <netinet/in.h>
|
|
|
80 #include <arpa/inet.h>
|
|
|
81 #include <fcntl.h>
|
|
|
82 #include <dirent.h>
|
|
|
83 #include <string.h>
|
|
|
84
|
|
|
85 #include "impl.h"
|
|
|
86 #include "error.h"
|
|
|
87 #include "trace.h"
|
|
|
88 #include "pdu.h"
|
|
|
89
|
|
|
90 #include "pagent.h"
|
|
|
91 #include "subtree.h"
|
|
|
92
|
|
|
93 /** SNMP security (5-13-96) */
|
|
|
94 #include "trap.h"
|
|
|
95 #include "agent_msg.h"
|
|
|
96 #include "access.h"
|
|
|
97 #include "snmpd.h"
|
|
|
98
|
|
|
99
|
|
|
100 /***** DEFINE *****/
|
|
|
101
|
|
|
102 /*
|
|
|
103 #define DEBUG_YACC(string) printf("\t\tYACC: %s: %s at line %d\n", string, yytext, yylineno);
|
|
|
104 */
|
|
|
105 #define DEBUG_YACC(string)
|
|
|
106
|
|
|
107 #define SNMPRELAY_SUFFIX ".snmprelay"
|
|
|
108
|
|
|
109
|
|
|
110 /***** TYPEDEF *****/
|
|
|
111
|
|
|
112 typedef struct _Macro {
|
|
|
113 struct _Macro *next_macro;
|
|
|
114 char *label;
|
|
|
115 Oid name;
|
|
|
116 } Macro;
|
|
|
117
|
|
|
118 #include "table.h"
|
|
|
119 static int table_index=0;
|
|
|
120
|
|
|
121
|
|
|
122 /*
|
|
|
123 typedef struct _Table {
|
|
|
124 struct _Table *next_table;
|
|
|
125 Agent *agent;
|
|
|
126 Oid name;
|
|
|
127 Subid regTblStartColumn;
|
|
|
128 Subid regTblEndColumn;
|
|
|
129 Subid regTblStartRow;
|
|
|
130 Subid regTblEndRow;
|
|
|
131 } Table;
|
|
|
132 */
|
|
|
133
|
|
|
134
|
|
|
135
|
|
|
136 /***** STATIC VARIABLES AND FUNCTIONS *****/
|
|
|
137
|
|
|
138 /* access control(6-20-96) */
|
|
|
139 static AccessServer *static_access_server=NULL;
|
|
|
140 static AccessPolicy *static_access_policy=NULL;
|
|
|
141 static Community *static_community=NULL;
|
|
|
142
|
|
|
143 /* trap filter (6-25-96) */
|
|
|
144 static SubMember *static_sub_member=NULL;
|
|
|
145 static Manager *static_host=NULL;
|
|
|
146 static EFilter *static_filter=NULL;
|
|
|
147 static int static_trap_low=-1;
|
|
|
148 static int static_trap_high=-1;
|
|
|
149
|
|
|
150 /* snmp security(5-13-96) */
|
|
|
151 static int community_type = 0;
|
|
|
152 static char *current_filename = NULL;
|
|
|
153
|
|
|
154 /* lexinput points to the current focus point in the config file */
|
|
|
155 static char *lexinput;
|
|
|
156
|
|
|
157 /* first_macro is the begining of the list */
|
|
|
158 /* of the user defined macros */
|
|
|
159
|
|
|
160 static Macro *first_macro = NULL;
|
|
|
161
|
|
|
162
|
|
|
163 /* first_table is the begining of the list */
|
|
|
164 /* of tables supported by the agents */
|
|
|
165
|
|
|
166 static Table *first_table = NULL;
|
|
|
167 static Table *last_table = NULL;
|
|
|
168
|
|
|
169
|
|
|
170 /* the boolean parsing_oid is used to */
|
|
|
171 /* know if we are parsing an */
|
|
|
172 /* object identifier or not. */
|
|
|
173
|
|
|
174 static int parsing_oid = False;
|
|
|
175
|
|
|
176
|
|
|
177 /* here are the values of the predifined macros */
|
|
|
178 /* that can be used in the configuration file */
|
|
|
179
|
|
|
180 static Subid subids_mib2[] = { 1, 3, 6, 1, 2, 1 };
|
|
|
181 static int mib2_len = 6;
|
|
|
182 static Subid subids_enterprise[] = { 1, 3, 6, 1, 4, 1 };
|
|
|
183 static int enterprise_len = 6;
|
|
|
184 static Subid subids_sun[] = { 1, 3, 6, 1, 4, 1, 42 };
|
|
|
185 static int sun_len = 7;
|
|
|
186
|
|
|
187
|
|
|
188 /* the 2 static variables static_subids and */
|
|
|
189 /* static_len are used when parsing an */
|
|
|
190 /* object identifier. Then the boolean */
|
|
|
191 /* parsing_oid should be true. When a new sub- */
|
|
|
192 /* identifier (or a list of sub-identifiers) */
|
|
|
193 /* is found, we use the function */
|
|
|
194 /* subids_cat to append it to the static_subids.*/
|
|
|
195
|
|
|
196 static Subid *static_subids = NULL;
|
|
|
197 static int static_len = 0;
|
|
|
198 static int subids_cat(Subid *subids, int len);
|
|
|
199
|
|
|
200
|
|
|
201 /* macro_add() is used to append a macro to */
|
|
|
202 /* the macro list. macro_find is used to find */
|
|
|
203 /* a macro in the macro list */
|
|
|
204
|
|
|
205 static Macro *macro_add(char *label, Subid *subids, int len);
|
|
|
206 static Macro *macro_find(char *label);
|
|
|
207 static void macro_free(Macro *mp);
|
|
|
208 static void macro_list_delete();
|
|
|
209
|
|
|
210
|
|
|
211 static void table_free(Table *tp);
|
|
|
212 static void table_list_delete();
|
|
|
213
|
|
|
214 extern int SSARegSubagent(Agent *);
|
|
|
215 extern int SSASubagentOpen(int, char *);
|
|
|
216 extern int SSARegSubtable(SSA_Table *);
|
|
|
217
|
|
|
218 /* static_label is used when parsing a macro */
|
|
|
219 static char *static_label = NULL;
|
|
|
220
|
|
|
221 /* static_agent is used when parsing an agent */
|
|
|
222 static Agent *static_agent = NULL;
|
|
|
223
|
|
|
224 /* static_table is used when parsing n table */
|
|
|
225 static Table *static_table = NULL;
|
|
|
226
|
|
|
227 /* static_inf_value and static_max_value are */
|
|
|
228 /* used when parsing a range */
|
|
|
229 static int static_inf_value = -1;
|
|
|
230 static int static_sup_value = -1;
|
|
|
231
|
|
|
232 static int count;
|
|
|
233 %}
|
|
|
234
|
|
|
235 %%
|
|
|
236
|
|
|
237
|
|
|
238 configuration : agents | macros agents | snmp_security
|
|
|
239 {
|
|
|
240 DEBUG_YACC("configuration")
|
|
|
241 }
|
|
|
242
|
|
|
243 /******************* SNMP security (5-13-96) *********/
|
|
|
244 snmp_security : acls trap_block /*trapcommunity trapdestinators*/
|
|
|
245 {
|
|
|
246 DEBUG_YACC("security configuration")
|
|
|
247 }
|
|
|
248
|
|
|
249 /***************/
|
|
|
250 /* accesscontrol */
|
|
|
251 /***************/
|
|
|
252
|
|
|
253 acls : /*empty */ | t_acls t_equal t_openbracket acls_list t_closebracket
|
|
|
254 {
|
|
|
255 DEBUG_YACC("acls_list")
|
|
|
256 }
|
|
|
257 | t_acls t_equal t_openbracket error t_closebracket
|
|
|
258 {
|
|
|
259 error("BUG: acl stmt parsing error at line %d",yylineno);
|
|
|
260 if(static_access_policy != NULL){
|
|
|
261 access_policy_list_free(static_access_policy);
|
|
|
262 static_access_policy = NULL;
|
|
|
263 }
|
|
|
264 }
|
|
|
265
|
|
|
266 acls_list : /*empty*/ | acls_list acl_item
|
|
|
267 {
|
|
|
268 DEBUG_YACC("acls_list")
|
|
|
269 }
|
|
|
270
|
|
|
271 acl_item : t_openbracket
|
|
|
272 {
|
|
|
273 static_access_policy = calloc(1,sizeof(AccessPolicy));
|
|
|
274 if(static_access_policy == NULL)
|
|
|
275 {
|
|
|
276 error("calloc() failed");
|
|
|
277 YYERROR;
|
|
|
278 }
|
|
|
279 } communities_stmt acl_access
|
|
|
280 {
|
|
|
281 if(static_access_policy!=NULL)
|
|
|
282 static_access_policy->access_type = community_type;
|
|
|
283 } hosts t_closebracket
|
|
|
284 {
|
|
|
285 /* create AccessServer */
|
|
|
286 /* put the AccessPolicy into AccessServer */
|
|
|
287 /* put AccessServer into corresponding manager */
|
|
|
288 static_access_server = NULL;
|
|
|
289 static_access_policy = NULL;
|
|
|
290 static_community = NULL;
|
|
|
291 community_type = 0;
|
|
|
292 }
|
|
|
293
|
|
|
294 communities_stmt : t_communities t_equal communities_set
|
|
|
295 {
|
|
|
296 DEBUG_YACC("communities_stmt");
|
|
|
297 }
|
|
|
298
|
|
|
299 communities_set : communities_set t_coma community_elem | community_elem
|
|
|
300 {
|
|
|
301 DEBUG_YACC("communities_set");
|
|
|
302 }
|
|
|
303
|
|
|
304 community_elem : ct_identifier
|
|
|
305 {
|
|
|
306 if(static_access_policy==NULL){
|
|
|
307 error("acl statement error");
|
|
|
308 YYERROR;
|
|
|
309 }
|
|
|
310 /* add community into AccessPolicy */
|
|
|
311 static_community = calloc(1, sizeof(Community));
|
|
|
312 if(static_community == NULL)
|
|
|
313 {
|
|
|
314 error("calloc() failed");
|
|
|
315 YYERROR;
|
|
|
316 }
|
|
|
317 static_community->name = strdup(yytext);
|
|
|
318 community_attach(static_access_policy,static_community);
|
|
|
319 static_community = NULL;
|
|
|
320 }
|
|
|
321
|
|
|
322 acl_access: t_access t_equal acl_access_type
|
|
|
323 {
|
|
|
324 DEBUG_YACC("acl_access")
|
|
|
325 }
|
|
|
326
|
|
|
327 acl_access_type : t_readonly | t_readwrite
|
|
|
328 {
|
|
|
329 DEBUG_YACC("acl_access_type")
|
|
|
330 }
|
|
|
331
|
|
|
332 hosts : t_managers t_equal hosts_list
|
|
|
333 {
|
|
|
334 DEBUG_YACC("hosts")
|
|
|
335 }
|
|
|
336
|
|
|
337 hosts_list : hosts_list t_coma host_item | host_item
|
|
|
338 {
|
|
|
339 DEBUG_YACC("hosts_list");
|
|
|
340 }
|
|
|
341
|
|
|
342 host_item : ct_identifier
|
|
|
343 {
|
|
|
344 /* add the host item to manager list */
|
|
|
345 /* it should return the pointer if exists */
|
|
|
346 Manager *res;
|
|
|
347
|
|
|
348 DEBUG_YACC("manager_item")
|
|
|
349
|
|
|
350 res = manager_add(yytext, error_label);
|
|
|
351 if(res==NULL){
|
|
|
352 error("error in %s at line %d: %s",
|
|
|
353 current_filename? current_filename:
|
|
|
354 "???",
|
|
|
355 yylineno, error_label);
|
|
|
356 }
|
|
|
357 static_access_server = calloc(1,sizeof(AccessServer));
|
|
|
358 if(static_access_server == NULL)
|
|
|
359 {
|
|
|
360 error("malloc() failed");
|
|
|
361 if(static_access_policy)
|
|
|
362 access_policy_list_free(static_access_policy);
|
|
|
363 YYERROR;
|
|
|
364 }
|
|
|
365 if(static_access_policy!=NULL)
|
|
|
366 static_access_policy->count++;
|
|
|
367 static_access_server->first_acc_policy = static_access_policy;
|
|
|
368 access_server_add_tail(res,static_access_server);
|
|
|
369 static_access_server = NULL;
|
|
|
370 }
|
|
|
371
|
|
|
372
|
|
|
373 /************/
|
|
|
374 /* managers */
|
|
|
375 /************/
|
|
|
376
|
|
|
377 /*
|
|
|
378 managers : t_managers t_equal t_openbracket managers_list t_closebracket
|
|
|
379 {
|
|
|
380 DEBUG_YACC("agents")
|
|
|
381 }
|
|
|
382
|
|
|
383
|
|
|
384 managers_list : | managers_list list_separator manager_item
|
|
|
385 {
|
|
|
386 DEBUG_YACC("managers_list")
|
|
|
387 }
|
|
|
388
|
|
|
389
|
|
|
390 manager_item : ct_identifier
|
|
|
391 {
|
|
|
392 Manager *res;
|
|
|
393
|
|
|
394 DEBUG_YACC("manager_item")
|
|
|
395
|
|
|
396 res = manager_add(yytext, error_label);
|
|
|
397 if(res==NULL){
|
|
|
398 error("error in %s at line %d: %s",
|
|
|
399 current_filename? current_filename:
|
|
|
400 "???",
|
|
|
401 yylineno, error_label);
|
|
|
402 }
|
|
|
403 }
|
|
|
404 */
|
|
|
405
|
|
|
406 /*** trap hanlding (6-25-96) */
|
|
|
407 trap_block : t_trap t_equal t_openbracket trap_list t_closebracket
|
|
|
408 {
|
|
|
409 DEBUG_YACC("trap_block")
|
|
|
410 }
|
|
|
411 | t_trap t_equal t_openbracket error t_closebracket
|
|
|
412 {
|
|
|
413 /* clean up */
|
|
|
414 if(static_sub_member != NULL){
|
|
|
415 sub_member_free(static_sub_member);
|
|
|
416 static_sub_member=NULL;
|
|
|
417 }
|
|
|
418 }
|
|
|
419
|
|
|
420 trap_list : /*empty*/ | trap_list trap_item
|
|
|
421 {
|
|
|
422 DEBUG_YACC("trap_list")
|
|
|
423 }
|
|
|
424
|
|
|
425 trap_item : t_openbracket
|
|
|
426 {
|
|
|
427 /* create submember */
|
|
|
428 static_sub_member = calloc(1,sizeof(SubMember));
|
|
|
429 if(static_sub_member == NULL)
|
|
|
430 {
|
|
|
431 error("malloc() failed");
|
|
|
432 YYERROR;
|
|
|
433 }
|
|
|
434 } trap_community_string trap_interest_hosts
|
|
|
435 {
|
|
|
436 /* attach submember to subgroup */
|
|
|
437 } enterprise_list t_closebracket
|
|
|
438 {
|
|
|
439 static_sub_member = NULL;
|
|
|
440 }
|
|
|
441
|
|
|
442 trap_community_string : t_trapcommunity t_equal ct_identifier
|
|
|
443 {
|
|
|
444 /* set the community field in submember */
|
|
|
445 if(static_sub_member != NULL)
|
|
|
446 {
|
|
|
447 static_sub_member->community_string = strdup(yytext);
|
|
|
448 if(static_sub_member == NULL)
|
|
|
449 {
|
|
|
450 error(ERR_MSG_ALLOC);
|
|
|
451 YYERROR;
|
|
|
452 }
|
|
|
453 }else{
|
|
|
454 error("BUG: missing trap community name");
|
|
|
455 }
|
|
|
456 }
|
|
|
457
|
|
|
458 trap_interest_hosts : t_hosts t_equal trap_interest_hosts_list
|
|
|
459 {
|
|
|
460 DEBUG_YACC("trap_interest_hosts")
|
|
|
461 }
|
|
|
462
|
|
|
463 trap_interest_hosts_list : trap_interest_hosts_list t_coma
|
|
|
464 trap_interest_host_item | trap_interest_host_item
|
|
|
465 {
|
|
|
466 DEBUG_YACC("trap_interest_hosts_list")
|
|
|
467 }
|
|
|
468
|
|
|
469 trap_interest_host_item : ct_identifier
|
|
|
470 {
|
|
|
471 DEBUG_YACC("trap_interest_host_item")
|
|
|
472 /* attach host to the submember */
|
|
|
473 if(static_sub_member==NULL){
|
|
|
474 error("trap statement error");
|
|
|
475 YYERROR;
|
|
|
476 }else{
|
|
|
477 static_host = calloc(1,sizeof(Manager));
|
|
|
478 if(static_host == NULL)
|
|
|
479 {
|
|
|
480 error("malloc() failed");
|
|
|
481 YYERROR;
|
|
|
482 }
|
|
|
483 static_host->name = strdup(yytext);
|
|
|
484 if(name_to_ip_address(static_host->name,
|
|
|
485 &static_host->ip_address,error_label)){
|
|
|
486 error("unknown host %s",static_host->name);
|
|
|
487 free(static_host);
|
|
|
488 static_host=NULL;
|
|
|
489 YYERROR;
|
|
|
490 }
|
|
|
491 static_host->next_manager = static_sub_member->first_manager;
|
|
|
492 static_sub_member->first_manager=static_host;
|
|
|
493 static_host=NULL;
|
|
|
494 }
|
|
|
495 }
|
|
|
496
|
|
|
497 enterprise_list : /* empty */ | enterprise_list enterprise_item
|
|
|
498 {
|
|
|
499 DEBUG_YACC("enterprise_list")
|
|
|
500 }
|
|
|
501
|
|
|
502 enterprise_item : t_openbracket enterprise_stmt trap_number_stmt
|
|
|
503 t_closebracket
|
|
|
504 {
|
|
|
505 DEBUG_YACC("enterprise_item")
|
|
|
506 }
|
|
|
507
|
|
|
508 enterprise_stmt : ENTERPRISE t_equal t_quotedstring
|
|
|
509 {
|
|
|
510 /* currently, it supports single enterprise */
|
|
|
511
|
|
|
512 DEBUG_YACC("enterprise_stmt")
|
|
|
513 /* add or find the enterprise */
|
|
|
514 static_filter = efilter_add(quoted_string,error_label);
|
|
|
515 if(static_filter==NULL){
|
|
|
516 error("error in %s at line %d: %s",
|
|
|
517 current_filename?current_filename:"???",
|
|
|
518 yylineno,error_label);
|
|
|
519 }
|
|
|
520 }
|
|
|
521
|
|
|
522 trap_number_stmt : t_trap_num t_equal trap_number_list
|
|
|
523 {
|
|
|
524 DEBUG_YACC("trap_number_stmt")
|
|
|
525 }
|
|
|
526
|
|
|
527 trap_number_list : trap_number_item
|
|
|
528 {
|
|
|
529 DEBUG_YACC("trap_number_list")
|
|
|
530 }
|
|
|
531 | trap_number_list t_coma trap_number_item
|
|
|
532 {
|
|
|
533 DEBUG_YACC("trap_number_list")
|
|
|
534 }
|
|
|
535
|
|
|
536 trap_number_item : trap_range
|
|
|
537 {
|
|
|
538 DEBUG_YACC("trap_number_item")
|
|
|
539 /* for each trap, find/add to the
|
|
|
540 enterprise, and add_tailthe subgroup
|
|
|
541 to each trap */
|
|
|
542
|
|
|
543 if(static_filter!=NULL){
|
|
|
544 /* expand the trap */
|
|
|
545 mem_filter_join(static_trap_low,
|
|
|
546 static_trap_high,static_sub_member,
|
|
|
547 static_filter);
|
|
|
548 }else{
|
|
|
549 error("error in enterprise statement");
|
|
|
550 YYERROR;
|
|
|
551 }
|
|
|
552 }
|
|
|
553
|
|
|
554 trap_range : NUMBER
|
|
|
555 {
|
|
|
556 /* starting trap num */
|
|
|
557 static_trap_low = token_value;
|
|
|
558 }
|
|
|
559 t_minus NUMBER
|
|
|
560 {
|
|
|
561 /* ending trap num */
|
|
|
562 static_trap_high = token_value;
|
|
|
563 }
|
|
|
564 | NUMBER
|
|
|
565 {
|
|
|
566 /* start & end num the same */
|
|
|
567 DEBUG_YACC("trap_range")
|
|
|
568 static_trap_low=static_trap_high=token_value;
|
|
|
569 }
|
|
|
570
|
|
|
571
|
|
|
572 /*
|
|
|
573 trapcommunity : t_trapcommunity t_equal ct_identifier
|
|
|
574 {
|
|
|
575 DEBUG_YACC("trap_community")
|
|
|
576
|
|
|
577 if(trap_community)
|
|
|
578 {
|
|
|
579 error("BUG: trap_community not NULL in trap_community");
|
|
|
580 }
|
|
|
581
|
|
|
582 trap_community = strdup(yytext);
|
|
|
583 if(trap_community == NULL)
|
|
|
584 {
|
|
|
585 error(ERR_MSG_ALLOC);
|
|
|
586 YYERROR;
|
|
|
587 }
|
|
|
588 }
|
|
|
589 */
|
|
|
590
|
|
|
591 /*******************/
|
|
|
592 /* trapdestinators */
|
|
|
593 /*******************/
|
|
|
594 /*
|
|
|
595
|
|
|
596 trapdestinators : t_trapdestinators t_equal t_openbracket trapdestinators_list t_closebracket
|
|
|
597 {
|
|
|
598 DEBUG_YACC("trapdestinators")
|
|
|
599 }
|
|
|
600
|
|
|
601
|
|
|
602 trapdestinators_list : | trapdestinators_list list_separator trapdestinator_item
|
|
|
603 {
|
|
|
604 DEBUG_YACC("trapdestinators_list")
|
|
|
605 }
|
|
|
606
|
|
|
607
|
|
|
608 trapdestinator_item : ct_identifier
|
|
|
609 {
|
|
|
610 int res;
|
|
|
611
|
|
|
612 DEBUG_YACC("trapdestinator_item")
|
|
|
613
|
|
|
614 res = trap_destinator_add(yytext, error_label);
|
|
|
615 switch(res)
|
|
|
616 {
|
|
|
617 case 0:
|
|
|
618 break;
|
|
|
619
|
|
|
620 case 1:
|
|
|
621 error("error in %s at line %d: %s",
|
|
|
622 current_filename? current_filename:
|
|
|
623 "???",
|
|
|
624 yylineno, error_label);
|
|
|
625 break;
|
|
|
626
|
|
|
627 default:
|
|
|
628 error("fatal error in %s at line %d: %s",
|
|
|
629 current_filename? current_filename:
|
|
|
630 "???",
|
|
|
631 yylineno, error_label);
|
|
|
632 YYERROR;
|
|
|
633 }
|
|
|
634 }
|
|
|
635
|
|
|
636 */
|
|
|
637
|
|
|
638 /******************* SNMP security (5-13-96) *********/
|
|
|
639
|
|
|
640
|
|
|
641
|
|
|
642
|
|
|
643 /**********/
|
|
|
644 /* macros */
|
|
|
645 /**********/
|
|
|
646
|
|
|
647 macros : t_macros t_equal t_openbracket macros_list t_closebracket
|
|
|
648 {
|
|
|
649 DEBUG_YACC("macros")
|
|
|
650 }
|
|
|
651
|
|
|
652
|
|
|
653 macros_list : /* empty */ | macros_list macro_item
|
|
|
654 {
|
|
|
655 DEBUG_YACC("macros_list")
|
|
|
656 }
|
|
|
657
|
|
|
658
|
|
|
659 macro_item : label t_equal
|
|
|
660 {
|
|
|
661 if(parsing_oid != False)
|
|
|
662 {
|
|
|
663 error("BUG at line %d: parsing_oid not False in macro_item", yylineno);
|
|
|
664 }
|
|
|
665 parsing_oid = True;
|
|
|
666
|
|
|
667 if(static_subids != NULL)
|
|
|
668 {
|
|
|
669 error("BUG at line %d: static_subids not NULL in macro_item", yylineno);
|
|
|
670 }
|
|
|
671 if(static_len != 0)
|
|
|
672 {
|
|
|
673 error("BUG at line %d: static_len not 0 in macro_item", yylineno);
|
|
|
674 }
|
|
|
675 }
|
|
|
676 subids_list
|
|
|
677 {
|
|
|
678 DEBUG_YACC("macro_item")
|
|
|
679
|
|
|
680 if(macro_add(static_label, static_subids, static_len) == NULL)
|
|
|
681 {
|
|
|
682 error("error at line %d", yylineno);
|
|
|
683 YYERROR;
|
|
|
684 }
|
|
|
685
|
|
|
686 parsing_oid = False;
|
|
|
687 free(static_label);
|
|
|
688 static_label = NULL;
|
|
|
689 free(static_subids);
|
|
|
690 static_subids = NULL;
|
|
|
691 static_len = 0;
|
|
|
692 }
|
|
|
693
|
|
|
694
|
|
|
695 label : t_identifier
|
|
|
696 {
|
|
|
697 DEBUG_YACC("label")
|
|
|
698
|
|
|
699 if(static_label != NULL)
|
|
|
700 {
|
|
|
701 error("BUG at line %d: static_label not NULL in label", yylineno);
|
|
|
702 }
|
|
|
703 static_label = strdup(yytext);
|
|
|
704 if(static_label == NULL)
|
|
|
705 {
|
|
|
706 error("malloc() failed");
|
|
|
707 YYERROR;
|
|
|
708 }
|
|
|
709 }
|
|
|
710
|
|
|
711
|
|
|
712
|
|
|
713 /**********/
|
|
|
714 /* agents */
|
|
|
715 /**********/
|
|
|
716
|
|
|
717 agents : t_agents t_equal t_openbracket agents_list t_closebracket
|
|
|
718 {
|
|
|
719 DEBUG_YACC("agents")
|
|
|
720 }
|
|
|
721
|
|
|
722
|
|
|
723 agents_list : agent_item | agents_list agent_item
|
|
|
724 {
|
|
|
725 DEBUG_YACC("agents_list")
|
|
|
726 }
|
|
|
727
|
|
|
728
|
|
|
729 agent_item : t_openbracket
|
|
|
730 {
|
|
|
731 if(static_agent != NULL)
|
|
|
732 {
|
|
|
733 error("BUG at line %d: static_agent not NULL in agent", yylineno);
|
|
|
734 }
|
|
|
735 static_agent = malloc(sizeof(Agent));
|
|
|
736 if(static_agent == NULL)
|
|
|
737 {
|
|
|
738 error("malloc() failed");
|
|
|
739 YYERROR;
|
|
|
740 }
|
|
|
741 (void)memset(static_agent, 0, sizeof(Agent));
|
|
|
742 /* LINTED */
|
|
|
743 static_agent->agent_id = (int32_t)getpid();
|
|
|
744 static_agent->agent_status = SSA_OPER_STATUS_NOT_IN_SERVICE;
|
|
|
745 static_agent->personal_file = strdup (current_filename);
|
|
|
746 }
|
|
|
747 name subtrees_tables timeout optional_watch_dog_time optional_port t_closebracket
|
|
|
748 {
|
|
|
749 DEBUG_YACC("agent_item");
|
|
|
750
|
|
|
751 /* add the agent id to agent, currently, agent_id is pid */
|
|
|
752 if(first_agent == NULL)
|
|
|
753 {
|
|
|
754 static_agent->next_agent = NULL;
|
|
|
755 }
|
|
|
756 else
|
|
|
757 {
|
|
|
758 static_agent->next_agent = first_agent;
|
|
|
759 }
|
|
|
760 first_agent = static_agent;
|
|
|
761
|
|
|
762 /* if port is 0, assigned a non-reserved available port */
|
|
|
763 if(static_agent->address.sin_port == 0 && agent_port_number != -1)
|
|
|
764 static_agent->address.sin_port = agent_port_number;
|
|
|
765 else if(static_agent->address.sin_port==0)
|
|
|
766 static_agent->address.sin_port =
|
|
|
767 get_a_non_reserved_port();
|
|
|
768 if (agent_port_number == -1)
|
|
|
769 agent_port_number = static_agent->address.sin_port;
|
|
|
770
|
|
|
771 /* the registration is for confirmation and
|
|
|
772 fill in extra value */
|
|
|
773 static_agent->agent_status = SSA_OPER_STATUS_ACTIVE;
|
|
|
774 if(SSARegSubagent(static_agent) == 0)
|
|
|
775 {
|
|
|
776 error("subagent registration failed");
|
|
|
777 YYERROR;
|
|
|
778 }
|
|
|
779 static_agent = NULL;
|
|
|
780 }
|
|
|
781
|
|
|
782
|
|
|
783 name : t_name t_equal t_quotedstring
|
|
|
784 {
|
|
|
785 DEBUG_YACC("name")
|
|
|
786
|
|
|
787 if(static_agent->name != NULL)
|
|
|
788 {
|
|
|
789 error("BUG at line %d: static_agent->name not NULL in name", yylineno);
|
|
|
790 }
|
|
|
791 static_agent->name = strdup(quoted_string);
|
|
|
792 if(static_agent->name == NULL)
|
|
|
793 {
|
|
|
794 error("malloc() failed");
|
|
|
795 YYERROR;
|
|
|
796 }
|
|
|
797 /*
|
|
|
798 * Increased the num. of retries for SSASubagentOpen in order to insure success
|
|
|
799 * typically for boot time race condition between the master and subagent
|
|
|
800 * Initial sleep is introduced to increase the probability of success the very
|
|
|
801 * first time. This could be removed at a later time, after modifying the timeout
|
|
|
802 * parameters for the subagent
|
|
|
803 */
|
|
|
804 (void)sleep(15);
|
|
|
805 count=1;
|
|
|
806 while(count) {
|
|
|
807 if( (static_agent->agent_id =
|
|
|
808 SSASubagentOpen(max_agent_reg_retry,static_agent->name)) == INVALID_HANDLER )
|
|
|
809 {
|
|
|
810 if (count == 5) {
|
|
|
811 error_exit("subagent registration failed");
|
|
|
812 YYERROR;
|
|
|
813 }
|
|
|
814 }
|
|
|
815 if (static_agent->agent_id ) break;
|
|
|
816 count++;
|
|
|
817 }
|
|
|
818 if(SSARegSubagent(static_agent) == 0)
|
|
|
819 {
|
|
|
820 error("subagent registration failed");
|
|
|
821 YYERROR;
|
|
|
822 }
|
|
|
823 /* LINTED */
|
|
|
824 static_agent->process_id = (int32_t)getpid();
|
|
|
825 }
|
|
|
826
|
|
|
827
|
|
|
828 subtrees_tables : subtrees tables | subtrees | tables
|
|
|
829 {
|
|
|
830 DEBUG_YACC("subtrees_tables")
|
|
|
831 }
|
|
|
832
|
|
|
833
|
|
|
834 subtrees : t_subtrees t_equal t_openbracket
|
|
|
835 {
|
|
|
836 if(parsing_oid != False)
|
|
|
837 {
|
|
|
838 error("BUG at line %d: parsing_oid is not False in subtrees", yylineno);
|
|
|
839 }
|
|
|
840 parsing_oid = True;
|
|
|
841
|
|
|
842 if(static_subids != NULL)
|
|
|
843 {
|
|
|
844 error("BUG at line %d: static_subids not NULL in subtrees", yylineno);
|
|
|
845 }
|
|
|
846 if(static_len != 0)
|
|
|
847 {
|
|
|
848 error("BUG at line %d: static_len not 0 in subtrees", yylineno);
|
|
|
849 }
|
|
|
850 }
|
|
|
851 subtrees_list t_closebracket
|
|
|
852 {
|
|
|
853 DEBUG_YACC("subtrees")
|
|
|
854
|
|
|
855 if(parsing_oid != True)
|
|
|
856 {
|
|
|
857 error("BUG at line %d: parsing_oid is not True in subtrees", yylineno);
|
|
|
858 }
|
|
|
859 parsing_oid = False;
|
|
|
860 }
|
|
|
861
|
|
|
862
|
|
|
863 subtrees_list : /* empty */ | subtrees_list_coma_separated
|
|
|
864 {
|
|
|
865 DEBUG_YACC("subtrees_list")
|
|
|
866 }
|
|
|
867
|
|
|
868
|
|
|
869 subtrees_list_coma_separated : subtree_item | subtrees_list_coma_separated t_coma subtree_item
|
|
|
870 {
|
|
|
871 DEBUG_YACC("subtrees_list_coma_separated")
|
|
|
872 }
|
|
|
873
|
|
|
874
|
|
|
875 subtree_item : subids_list
|
|
|
876 {
|
|
|
877 DEBUG_YACC("subtree_item")
|
|
|
878
|
|
|
879 if(parsing_oid != True)
|
|
|
880 {
|
|
|
881 error("BUG at line %d: parsing_oid is not True in subtree_item", yylineno);
|
|
|
882 }
|
|
|
883
|
|
|
884 if(subtree_add(static_agent, static_subids, static_len) == -1)
|
|
|
885 {
|
|
|
886 error("error at line %d", yylineno);
|
|
|
887 YYERROR;
|
|
|
888 }
|
|
|
889
|
|
|
890 free(static_subids);
|
|
|
891 static_subids = NULL;
|
|
|
892 static_len = 0;
|
|
|
893 }
|
|
|
894
|
|
|
895
|
|
|
896 tables : t_tables t_equal t_openbracket tables_list t_closebracket
|
|
|
897 {
|
|
|
898 DEBUG_YACC("tables")
|
|
|
899 }
|
|
|
900
|
|
|
901
|
|
|
902 tables_list : /* empty */ | tables_list table_item
|
|
|
903 {
|
|
|
904 DEBUG_YACC("tables_list")
|
|
|
905 }
|
|
|
906
|
|
|
907
|
|
|
908 table_item : t_openbracket
|
|
|
909 {
|
|
|
910 if(static_agent == NULL)
|
|
|
911 {
|
|
|
912 error("BUG at line %d: static_agent is NULL in table_item", yylineno);
|
|
|
913 }
|
|
|
914
|
|
|
915 if(static_table)
|
|
|
916 {
|
|
|
917 error("BUG at line %d: static_table not NULL in table_item", yylineno);
|
|
|
918 }
|
|
|
919
|
|
|
920 static_table = calloc(1,sizeof(Table));
|
|
|
921 if(static_table == NULL)
|
|
|
922 {
|
|
|
923 error("malloc() failed");
|
|
|
924 YYERROR;
|
|
|
925 }
|
|
|
926 static_table->regTblStatus =
|
|
|
927 SSA_OPER_STATUS_NOT_IN_SERVICE;
|
|
|
928 static_table->next_table = NULL;
|
|
|
929 static_table->agent = static_agent;
|
|
|
930 if(static_agent!=NULL)
|
|
|
931 static_table->regTblAgentID =
|
|
|
932 static_agent->agent_id;
|
|
|
933 static_table->regTblOID.subids = NULL;
|
|
|
934 static_table->regTblOID.len = 0;
|
|
|
935 static_table->regTblStartColumn = 0;
|
|
|
936 static_table->regTblEndColumn = 0;
|
|
|
937 static_table->regTblIndex = ++table_index;
|
|
|
938 /*
|
|
|
939 static_table->indexs.subids = NULL;
|
|
|
940 static_table->indexs.len = 0;
|
|
|
941 */
|
|
|
942 }
|
|
|
943 table columns indexs t_closebracket
|
|
|
944 {
|
|
|
945 DEBUG_YACC("table_item")
|
|
|
946
|
|
|
947 if(static_table == NULL)
|
|
|
948 {
|
|
|
949 error_exit("BUG at line %d: static_table is NULL in table_item", yylineno);
|
|
|
950 }
|
|
|
951
|
|
|
952 /* register the table, if register fails, delete
|
|
|
953 the table */
|
|
|
954 if(SSARegSubtable(static_table)==0){
|
|
|
955 /* unregister the table */
|
|
|
956
|
|
|
957 error_exit("TABLE CONFIG");
|
|
|
958 }
|
|
|
959
|
|
|
960
|
|
|
961 if(last_table)
|
|
|
962 {
|
|
|
963 last_table->next_table = static_table;
|
|
|
964 }
|
|
|
965 else
|
|
|
966 {
|
|
|
967 first_table = static_table;
|
|
|
968 }
|
|
|
969 last_table = static_table;
|
|
|
970 static_table = NULL;
|
|
|
971 }
|
|
|
972
|
|
|
973
|
|
|
974 table : t_table t_equal
|
|
|
975 {
|
|
|
976 if(parsing_oid != False)
|
|
|
977 {
|
|
|
978 error("BUG at line %d: parsing_oid is not False in tables", yylineno);
|
|
|
979 }
|
|
|
980
|
|
|
981 parsing_oid = True;
|
|
|
982 }
|
|
|
983 subids_list
|
|
|
984 {
|
|
|
985 DEBUG_YACC("table")
|
|
|
986
|
|
|
987 if(parsing_oid != True)
|
|
|
988 {
|
|
|
989 error("BUG at line %d: parsing_oid is not True in tables", yylineno);
|
|
|
990 }
|
|
|
991 parsing_oid = False;
|
|
|
992
|
|
|
993 if(static_table == NULL)
|
|
|
994 {
|
|
|
995 error_exit("BUG at line %d: static_table is NULL in table", yylineno);
|
|
|
996 }
|
|
|
997
|
|
|
998 static_table->regTblOID.subids = static_subids;
|
|
|
999 static_subids = NULL;
|
|
|
1000 static_table->regTblOID.len = static_len;
|
|
|
1001 static_len = 0;
|
|
|
1002 }
|
|
|
1003
|
|
|
1004
|
|
|
1005 columns : t_columns t_equal range
|
|
|
1006 {
|
|
|
1007 DEBUG_YACC("columns")
|
|
|
1008
|
|
|
1009 if(static_table == NULL)
|
|
|
1010 {
|
|
|
1011 error_exit("BUG at line %d: static_table is NULL in columns", yylineno);
|
|
|
1012 }
|
|
|
1013
|
|
|
1014 static_table->regTblStartColumn = static_inf_value;
|
|
|
1015 static_inf_value = -1;
|
|
|
1016 static_table->regTblEndColumn = static_sup_value;
|
|
|
1017 static_sup_value = -1;
|
|
|
1018 }
|
|
|
1019
|
|
|
1020
|
|
|
1021 /*
|
|
|
1022 indexs : t_indexs t_equal
|
|
|
1023 {
|
|
|
1024 if(parsing_oid != False)
|
|
|
1025 {
|
|
|
1026 error("BUG at line %d: parsing_oid is not False in indexs", yylineno);
|
|
|
1027 }
|
|
|
1028
|
|
|
1029 parsing_oid = True;
|
|
|
1030 }
|
|
|
1031 subids_list
|
|
|
1032 {
|
|
|
1033 DEBUG_YACC("indexs")
|
|
|
1034
|
|
|
1035 if(parsing_oid != True)
|
|
|
1036 {
|
|
|
1037 error("BUG at line %d: parsing_oid is not True in indexs", yylineno);
|
|
|
1038 }
|
|
|
1039 parsing_oid = False;
|
|
|
1040
|
|
|
1041 if(static_table == NULL)
|
|
|
1042 {
|
|
|
1043 error_exit("BUG at line %d: static_table is NULL in indexs", yylineno);
|
|
|
1044 }
|
|
|
1045
|
|
|
1046 static_table->indexs.subids = static_subids;
|
|
|
1047 static_subids = NULL;
|
|
|
1048 static_table->indexs.len = static_len;
|
|
|
1049 static_len = 0;
|
|
|
1050 }
|
|
|
1051 */
|
|
|
1052
|
|
|
1053 indexs : t_indexs t_equal range
|
|
|
1054 {
|
|
|
1055 DEBUG_YACC("indexs")
|
|
|
1056
|
|
|
1057 if(static_inf_value == -1)
|
|
|
1058 {
|
|
|
1059 error("BUG at line %d: static_inf_value is -1", yylineno);
|
|
|
1060 }
|
|
|
1061 if(static_sup_value == -1)
|
|
|
1062 {
|
|
|
1063 error("BUG at line %d: static_sup_value is -1", yylineno);
|
|
|
1064 }
|
|
|
1065 static_table->regTblStartRow = static_inf_value;
|
|
|
1066 static_table->regTblEndRow = static_sup_value;
|
|
|
1067 static_inf_value = -1;
|
|
|
1068 static_sup_value = -1;
|
|
|
1069 }
|
|
|
1070
|
|
|
1071
|
|
|
1072 range : t_opensquarebracket t_number
|
|
|
1073 {
|
|
|
1074 if(static_inf_value != -1)
|
|
|
1075 {
|
|
|
1076 error("BUG at line %d: static_inf_value (%d) is not -1 in range",
|
|
|
1077 yylineno,
|
|
|
1078 static_inf_value);
|
|
|
1079 }
|
|
|
1080
|
|
|
1081 static_inf_value = token_value;
|
|
|
1082 }
|
|
|
1083 t_minus t_number
|
|
|
1084 {
|
|
|
1085 if(static_sup_value != -1)
|
|
|
1086 {
|
|
|
1087 error("BUG at line %d: static_sup_value (%d) is not -1 in range",
|
|
|
1088 yylineno,
|
|
|
1089 static_inf_value);
|
|
|
1090 }
|
|
|
1091
|
|
|
1092 static_sup_value = token_value;
|
|
|
1093 }
|
|
|
1094 t_closesquarebracket
|
|
|
1095 {
|
|
|
1096 DEBUG_YACC("range")
|
|
|
1097 }
|
|
|
1098 | t_number
|
|
|
1099 {
|
|
|
1100 if(static_inf_value != -1)
|
|
|
1101 {
|
|
|
1102 error("BUG at line %d: static_inf_value (%d) is not -1 in range",
|
|
|
1103 yylineno,
|
|
|
1104 static_inf_value);
|
|
|
1105 }
|
|
|
1106 if(static_sup_value != -1)
|
|
|
1107 {
|
|
|
1108 error("BUG at line %d: static_sup_value (%d) is not -1 in range",
|
|
|
1109 yylineno,
|
|
|
1110 static_sup_value);
|
|
|
1111 }
|
|
|
1112
|
|
|
1113 static_inf_value = token_value;
|
|
|
1114 static_sup_value = token_value;
|
|
|
1115 }
|
|
|
1116
|
|
|
1117
|
|
|
1118 timeout : t_timeout t_equal t_number
|
|
|
1119 {
|
|
|
1120 DEBUG_YACC("subtree")
|
|
|
1121
|
|
|
1122 static_agent->timeout = token_value;
|
|
|
1123 }
|
|
|
1124
|
|
|
1125 optional_watch_dog_time : /*empty*/ | t_watch_dog_time t_equal NUMBER
|
|
|
1126 {
|
|
|
1127 DEBUG_YACC("optional_watch_dog_time")
|
|
|
1128 static_agent->watch_dog_time = token_value;
|
|
|
1129 }
|
|
|
1130
|
|
|
1131 optional_port: /*empty*/ | port
|
|
|
1132 {
|
|
|
1133 DEBUG_YACC("optional_port")
|
|
|
1134 }
|
|
|
1135
|
|
|
1136 port : t_port t_equal t_number
|
|
|
1137 {
|
|
|
1138 DEBUG_YACC("port")
|
|
|
1139
|
|
|
1140 if(token_value > 0xFFFF)
|
|
|
1141 {
|
|
|
1142 error("error at line %d: the port number (%d) should not be greater than %d", yylineno, token_value, 0xFFFF);
|
|
|
1143 YYERROR;
|
|
|
1144 }
|
|
|
1145
|
|
|
1146 /* LINTED */
|
|
|
1147 static_agent->address.sin_port = (short) token_value;
|
|
|
1148
|
|
|
1149 if(agent_find(&(static_agent->address)))
|
|
|
1150 {
|
|
|
1151 error("error at line %d: the port number %d is already used by another agent", yylineno, token_value);
|
|
|
1152 YYERROR;
|
|
|
1153 }
|
|
|
1154 }
|
|
|
1155
|
|
|
1156
|
|
|
1157
|
|
|
1158 /***************/
|
|
|
1159 /* subids_list */
|
|
|
1160 /***************/
|
|
|
1161
|
|
|
1162 subids_list : subid | subids_list t_dot subid
|
|
|
1163 {
|
|
|
1164 DEBUG_YACC("subids_list")
|
|
|
1165 }
|
|
|
1166
|
|
|
1167
|
|
|
1168 subid : t_mib2 | t_sun | t_enterprise | t_identifier | t_number
|
|
|
1169 {
|
|
|
1170 DEBUG_YACC("subid")
|
|
|
1171 }
|
|
|
1172
|
|
|
1173
|
|
|
1174
|
|
|
1175 /*******************/
|
|
|
1176 /* terminal tokens */
|
|
|
1177 /*******************/
|
|
|
1178
|
|
|
1179 /**************** SNMP security (5-13-96) ***/
|
|
|
1180 ct_identifier : IDENTIFIER
|
|
|
1181 {
|
|
|
1182 DEBUG_YACC("ct_indentifier")
|
|
|
1183 }
|
|
|
1184
|
|
|
1185 t_communities : COMMUNITIES
|
|
|
1186 {
|
|
|
1187 DEBUG_YACC("t_communities")
|
|
|
1188 }
|
|
|
1189
|
|
|
1190 t_hosts : HOSTS
|
|
|
1191 {
|
|
|
1192 DEBUG_YACC("t_hosts")
|
|
|
1193 }
|
|
|
1194
|
|
|
1195 t_acls : ACL
|
|
|
1196 {
|
|
|
1197 DEBUG_YACC("t_acls")
|
|
|
1198 }
|
|
|
1199
|
|
|
1200 t_access : ACCESS
|
|
|
1201 {
|
|
|
1202 DEBUG_YACC("t_access")
|
|
|
1203 }
|
|
|
1204
|
|
|
1205 t_readonly : READONLY
|
|
|
1206 {
|
|
|
1207 DEBUG_YACC("t_readonly")
|
|
|
1208
|
|
|
1209 community_type = READ_ONLY;
|
|
|
1210 }
|
|
|
1211
|
|
|
1212 t_readwrite : READWRITE
|
|
|
1213 {
|
|
|
1214 DEBUG_YACC("t_readwrite")
|
|
|
1215
|
|
|
1216 community_type = READ_WRITE;
|
|
|
1217 }
|
|
|
1218
|
|
|
1219 t_managers : MANAGERS
|
|
|
1220 {
|
|
|
1221 DEBUG_YACC("t_managers")
|
|
|
1222 }
|
|
|
1223
|
|
|
1224
|
|
|
1225 t_trap : TRAP
|
|
|
1226 {
|
|
|
1227 DEBUG_YACC("t_trap")
|
|
|
1228 }
|
|
|
1229
|
|
|
1230 t_trap_num: TRAPNUM
|
|
|
1231 {
|
|
|
1232 DEBUG_YACC("t_trap_num")
|
|
|
1233 }
|
|
|
1234
|
|
|
1235 t_trapcommunity : TRAPCOMMUNITY
|
|
|
1236 {
|
|
|
1237 DEBUG_YACC("t_trapcommunity")
|
|
|
1238 }
|
|
|
1239
|
|
|
1240
|
|
|
1241 /*
|
|
|
1242 t_trapdestinators : TRAPDESTINATORS
|
|
|
1243 {
|
|
|
1244 DEBUG_YACC("t_trapdestinators")
|
|
|
1245 }
|
|
|
1246
|
|
|
1247 list_separator : | t_coma
|
|
|
1248 {
|
|
|
1249 DEBUG_YACC("list_separator")
|
|
|
1250 }
|
|
|
1251 */
|
|
|
1252
|
|
|
1253
|
|
|
1254 /**************** SNMP security (5-13-96) ***/
|
|
|
1255
|
|
|
1256
|
|
|
1257 t_number : NUMBER
|
|
|
1258 {
|
|
|
1259 DEBUG_YACC("t_number")
|
|
|
1260
|
|
|
1261 if(parsing_oid == True)
|
|
|
1262 {
|
|
|
1263 if(subids_cat((Subid *) &token_value, 1) == -1)
|
|
|
1264 {
|
|
|
1265 YYERROR;
|
|
|
1266 }
|
|
|
1267 }
|
|
|
1268 }
|
|
|
1269
|
|
|
1270
|
|
|
1271 t_macros : MACROS
|
|
|
1272 {
|
|
|
1273 DEBUG_YACC("t_macros")
|
|
|
1274 }
|
|
|
1275
|
|
|
1276
|
|
|
1277 t_equal : EQUAL
|
|
|
1278 {
|
|
|
1279 DEBUG_YACC("t_equal")
|
|
|
1280 }
|
|
|
1281
|
|
|
1282
|
|
|
1283 t_minus : MINUS
|
|
|
1284 {
|
|
|
1285 DEBUG_YACC("t_minus")
|
|
|
1286 }
|
|
|
1287
|
|
|
1288
|
|
|
1289 t_openbracket : OPENBRACKET
|
|
|
1290 {
|
|
|
1291 DEBUG_YACC("t_openbracket")
|
|
|
1292 }
|
|
|
1293
|
|
|
1294
|
|
|
1295 t_closebracket : CLOSEBRACKET
|
|
|
1296 {
|
|
|
1297 DEBUG_YACC("t_closebracket")
|
|
|
1298 }
|
|
|
1299
|
|
|
1300
|
|
|
1301 t_opensquarebracket : OPENSQUAREBRACKET
|
|
|
1302 {
|
|
|
1303 DEBUG_YACC("t_opensquarebracket")
|
|
|
1304 }
|
|
|
1305
|
|
|
1306
|
|
|
1307 t_closesquarebracket : CLOSESQUAREBRACKET
|
|
|
1308 {
|
|
|
1309 DEBUG_YACC("t_closesquarebracket")
|
|
|
1310 }
|
|
|
1311
|
|
|
1312
|
|
|
1313 t_identifier : IDENTIFIER
|
|
|
1314 {
|
|
|
1315 DEBUG_YACC("t_identifier")
|
|
|
1316
|
|
|
1317 if(parsing_oid == True)
|
|
|
1318 {
|
|
|
1319 Macro *mp;
|
|
|
1320
|
|
|
1321
|
|
|
1322 mp = macro_find(yytext);
|
|
|
1323 if(mp == NULL)
|
|
|
1324 {
|
|
|
1325 error("error at line %d: %s is not a macro", yylineno, yytext);
|
|
|
1326 YYERROR;
|
|
|
1327 }
|
|
|
1328
|
|
|
1329 if(subids_cat(mp->name.subids, mp->name.len) == -1)
|
|
|
1330 {
|
|
|
1331 YYERROR;
|
|
|
1332 }
|
|
|
1333 }
|
|
|
1334 }
|
|
|
1335
|
|
|
1336
|
|
|
1337 t_mib2 : MIB2
|
|
|
1338 {
|
|
|
1339 DEBUG_YACC("t_mib2")
|
|
|
1340
|
|
|
1341 if(parsing_oid == False)
|
|
|
1342 {
|
|
|
1343 error("BUG at line %d: parsing_oid not True in t_mib2", yylineno);
|
|
|
1344 }
|
|
|
1345 if(subids_cat(subids_mib2, mib2_len) == -1)
|
|
|
1346 {
|
|
|
1347 YYERROR;
|
|
|
1348 }
|
|
|
1349 }
|
|
|
1350
|
|
|
1351
|
|
|
1352 t_sun : SUN
|
|
|
1353 {
|
|
|
1354 DEBUG_YACC("t_sun")
|
|
|
1355
|
|
|
1356 if(parsing_oid == False)
|
|
|
1357 {
|
|
|
1358 error("BUG at line %d: parsing_oid not True in t_sun", yylineno);
|
|
|
1359 }
|
|
|
1360 if(subids_cat(subids_sun, sun_len) == -1)
|
|
|
1361 {
|
|
|
1362 YYERROR;
|
|
|
1363 }
|
|
|
1364 }
|
|
|
1365
|
|
|
1366
|
|
|
1367 t_enterprise : ENTERPRISE
|
|
|
1368 {
|
|
|
1369 DEBUG_YACC("t_enterprise")
|
|
|
1370
|
|
|
1371 if(parsing_oid == False)
|
|
|
1372 {
|
|
|
1373 error("BUG at line %d: parsing_oid not True in t_enterprise", yylineno);
|
|
|
1374 }
|
|
|
1375 if(subids_cat(subids_enterprise, enterprise_len) == -1)
|
|
|
1376 {
|
|
|
1377 YYERROR;
|
|
|
1378 }
|
|
|
1379 }
|
|
|
1380
|
|
|
1381 t_dot : DOT
|
|
|
1382 {
|
|
|
1383 DEBUG_YACC("t_dot")
|
|
|
1384 }
|
|
|
1385
|
|
|
1386
|
|
|
1387 t_agents : AGENTS
|
|
|
1388 {
|
|
|
1389 DEBUG_YACC("t_agents")
|
|
|
1390 }
|
|
|
1391
|
|
|
1392
|
|
|
1393 t_name : NAME
|
|
|
1394 {
|
|
|
1395 DEBUG_YACC("t_name")
|
|
|
1396 }
|
|
|
1397
|
|
|
1398
|
|
|
1399 t_subtrees : SUBTREES
|
|
|
1400 {
|
|
|
1401 DEBUG_YACC("t_subtrees")
|
|
|
1402 }
|
|
|
1403
|
|
|
1404
|
|
|
1405 t_tables : TABLES
|
|
|
1406 {
|
|
|
1407 DEBUG_YACC("t_tables")
|
|
|
1408 }
|
|
|
1409
|
|
|
1410
|
|
|
1411 t_table : TABLE
|
|
|
1412 {
|
|
|
1413 DEBUG_YACC("t_table")
|
|
|
1414 }
|
|
|
1415
|
|
|
1416
|
|
|
1417 t_columns : COLUMNS
|
|
|
1418 {
|
|
|
1419 DEBUG_YACC("t_columns")
|
|
|
1420 }
|
|
|
1421
|
|
|
1422
|
|
|
1423 t_indexs : INDEXS
|
|
|
1424 {
|
|
|
1425 DEBUG_YACC("t_indexs")
|
|
|
1426 }
|
|
|
1427
|
|
|
1428
|
|
|
1429 t_timeout : TIMEOUT
|
|
|
1430 {
|
|
|
1431 DEBUG_YACC("t_timeout")
|
|
|
1432 }
|
|
|
1433
|
|
|
1434 t_watch_dog_time : WATCHDOGTIME
|
|
|
1435 {
|
|
|
1436 DEBUG_YACC("t_watch_dog_time")
|
|
|
1437 }
|
|
|
1438
|
|
|
1439 t_port : PORT
|
|
|
1440 {
|
|
|
1441 DEBUG_YACC("t_port")
|
|
|
1442 }
|
|
|
1443
|
|
|
1444
|
|
|
1445 t_quotedstring : QUOTEDSTRING
|
|
|
1446 {
|
|
|
1447 DEBUG_YACC("t_quotedstring\n")
|
|
|
1448 }
|
|
|
1449
|
|
|
1450
|
|
|
1451 t_coma : COMA
|
|
|
1452 {
|
|
|
1453 DEBUG_YACC("t_coma")
|
|
|
1454 }
|
|
|
1455 %%
|
|
|
1456
|
|
|
1457 #include "personal.lex.c"
|
|
|
1458
|
|
|
1459 /****************************************************************/
|
|
|
1460
|
|
|
1461 static int subids_cat(Subid *subids, int len)
|
|
|
1462 {
|
|
|
1463 Subid *new_subids;
|
|
|
1464 int new_len;
|
|
|
1465
|
|
|
1466
|
|
|
1467 new_len = static_len + len;
|
|
|
1468 /* LINTED */
|
|
|
1469 new_subids = (Subid *) malloc(new_len * (int32_t)sizeof(Subid));
|
|
|
1470 if(new_subids == NULL)
|
|
|
1471 {
|
|
|
1472 error("malloc() failed");
|
|
|
1473 if(static_subids)
|
|
|
1474 {
|
|
|
1475 free(static_subids);
|
|
|
1476 }
|
|
|
1477 static_subids = NULL;
|
|
|
1478 static_len = 0;
|
|
|
1479 return -1;
|
|
|
1480 }
|
|
|
1481 /* LINTED */
|
|
|
1482 (void)memcpy(new_subids, static_subids, static_len * (int32_t)sizeof(Subid));
|
|
|
1483 /* LINTED */
|
|
|
1484 (void)memcpy(&(new_subids[static_len]), subids, len * (int32_t)sizeof(Subid));
|
|
|
1485
|
|
|
1486
|
|
|
1487 if(static_subids)
|
|
|
1488 {
|
|
|
1489 free(static_subids);
|
|
|
1490 }
|
|
|
1491 static_subids = new_subids;
|
|
|
1492 static_len = new_len;
|
|
|
1493
|
|
|
1494 return 0;
|
|
|
1495 }
|
|
|
1496
|
|
|
1497
|
|
|
1498 /****************************************************************/
|
|
|
1499
|
|
|
1500 static Macro *macro_add(char *label, Subid *subids, int len)
|
|
|
1501 {
|
|
|
1502 Macro *new;
|
|
|
1503
|
|
|
1504
|
|
|
1505 if(macro_find(label) != NULL)
|
|
|
1506 {
|
|
|
1507 error("%s is already a macro", label);
|
|
|
1508 return NULL;
|
|
|
1509 }
|
|
|
1510
|
|
|
1511 new = (Macro *) malloc(sizeof(Macro));
|
|
|
1512 if(new == NULL)
|
|
|
1513 {
|
|
|
1514 error("malloc() failed");
|
|
|
1515 return NULL;
|
|
|
1516 }
|
|
|
1517 new->label = NULL;
|
|
|
1518 new->name.subids = NULL;
|
|
|
1519
|
|
|
1520 new->label = strdup(label);
|
|
|
1521 if(new->label == NULL)
|
|
|
1522 {
|
|
|
1523 error("malloc() failed");
|
|
|
1524 macro_free(new);
|
|
|
1525 return NULL;
|
|
|
1526 }
|
|
|
1527 /* LINTED */
|
|
|
1528 new->name.subids = (Subid *) malloc(len * (int32_t)sizeof(Subid));
|
|
|
1529 if(new->name.subids == NULL)
|
|
|
1530 {
|
|
|
1531 error("malloc() failed");
|
|
|
1532 macro_free(new);
|
|
|
1533 return NULL;
|
|
|
1534 }
|
|
|
1535 /* LINTED */
|
|
|
1536 (void)memcpy(new->name.subids, subids, len * (int32_t)sizeof(Subid));
|
|
|
1537 new->name.len = len;
|
|
|
1538 new->next_macro = first_macro;
|
|
|
1539 first_macro = new;
|
|
|
1540
|
|
|
1541 return new;
|
|
|
1542 }
|
|
|
1543
|
|
|
1544
|
|
|
1545 /****************************************************************/
|
|
|
1546
|
|
|
1547 static Macro *macro_find(char *label)
|
|
|
1548 {
|
|
|
1549 Macro *mp;
|
|
|
1550
|
|
|
1551
|
|
|
1552 for(mp = first_macro; mp; mp = mp->next_macro)
|
|
|
1553 {
|
|
|
1554 if(strcmp(mp->label, label) == 0)
|
|
|
1555 {
|
|
|
1556 return mp;
|
|
|
1557 }
|
|
|
1558 }
|
|
|
1559
|
|
|
1560 return NULL;
|
|
|
1561 }
|
|
|
1562
|
|
|
1563
|
|
|
1564 /****************************************************************/
|
|
|
1565
|
|
|
1566 static void macro_free(Macro *mp)
|
|
|
1567 {
|
|
|
1568 if(mp == NULL)
|
|
|
1569 {
|
|
|
1570 return;
|
|
|
1571 }
|
|
|
1572
|
|
|
1573 if(mp->label)
|
|
|
1574 {
|
|
|
1575 free(mp->label);
|
|
|
1576 }
|
|
|
1577
|
|
|
1578 if(mp->name.subids)
|
|
|
1579 {
|
|
|
1580 free(mp->name.subids);
|
|
|
1581 }
|
|
|
1582
|
|
|
1583 free(mp);
|
|
|
1584
|
|
|
1585 return;
|
|
|
1586 }
|
|
|
1587
|
|
|
1588
|
|
|
1589 /****************************************************************/
|
|
|
1590
|
|
|
1591 static void macro_list_delete()
|
|
|
1592 {
|
|
|
1593 Macro *mp = first_macro;
|
|
|
1594 Macro *next;
|
|
|
1595
|
|
|
1596
|
|
|
1597 while(mp)
|
|
|
1598 {
|
|
|
1599 next = mp->next_macro;
|
|
|
1600
|
|
|
1601 macro_free(mp);
|
|
|
1602
|
|
|
1603 mp = next;
|
|
|
1604 }
|
|
|
1605
|
|
|
1606 first_macro = NULL;
|
|
|
1607
|
|
|
1608 return;
|
|
|
1609 }
|
|
|
1610
|
|
|
1611
|
|
|
1612
|
|
|
1613 /****************************************************************/
|
|
|
1614
|
|
|
1615 int yyerror(char *s)
|
|
|
1616 {
|
|
|
1617 error("%s at line %d: %s", s, yylineno, yytext);
|
|
|
1618
|
|
|
1619 return (0);
|
|
|
1620 }
|
|
|
1621
|
|
|
1622
|
|
|
1623 /****************************************************************/
|
|
|
1624
|
|
|
1625 /* If we have a serious problem, this function will */
|
|
|
1626 /* terminate (<==> exit) the program */
|
|
|
1627
|
|
|
1628 void config_init(char *filename)
|
|
|
1629 {
|
|
|
1630 struct stat statb;
|
|
|
1631 char *fileaddr;
|
|
|
1632 int fd;
|
|
|
1633
|
|
|
1634
|
|
|
1635 yylineno = 1;
|
|
|
1636
|
|
|
1637 if((fd = open(filename, O_RDONLY)) < 0)
|
|
|
1638 {
|
|
|
1639 error_exit(ERR_MSG_OPEN,
|
|
|
1640 filename, errno_string());
|
|
|
1641 }
|
|
|
1642
|
|
|
1643 /*
|
|
|
1644 * get the size of the file
|
|
|
1645 */
|
|
|
1646 if(fstat(fd, &statb) < 0)
|
|
|
1647 {
|
|
|
1648 error_exit(ERR_MSG_FSTAT,
|
|
|
1649 filename, errno_string());
|
|
|
1650 }
|
|
|
1651 if(!S_ISREG(statb.st_mode))
|
|
|
1652 {
|
|
|
1653 error_exit("filename: %s is not a file\n",filename);
|
|
|
1654 }
|
|
|
1655
|
|
|
1656 /*
|
|
|
1657 * and map it into my address space
|
|
|
1658 */
|
|
|
1659 if(statb.st_size != 0)
|
|
|
1660 {
|
|
|
1661 /* Purify IPR/IPW error - bug 4124843. yylook wants to
|
|
|
1662 read the last + 1 byte to decide EOF */
|
|
|
1663 /* LINTED */
|
|
|
1664 if((fileaddr = (char *) mmap(0, (int32_t)statb.st_size+1, PROT_READ|PROT_WRITE,
|
|
|
1665 MAP_PRIVATE, fd, 0)) <= (char *) 0)
|
|
|
1666 {
|
|
|
1667 error_exit(ERR_MSG_MMAP,
|
|
|
1668 filename, errno_string());
|
|
|
1669 }
|
|
|
1670
|
|
|
1671 /*
|
|
|
1672 * set current lex focus on the file
|
|
|
1673 */
|
|
|
1674
|
|
|
1675 lexinput = fileaddr;
|
|
|
1676
|
|
|
1677 /*
|
|
|
1678 * and parse the file
|
|
|
1679 */
|
|
|
1680 current_filename = filename;
|
|
|
1681 if(yyparse() == 1)
|
|
|
1682 {
|
|
|
1683 error_exit("parsing %s failed", filename);
|
|
|
1684 }
|
|
|
1685 current_filename = NULL;
|
|
|
1686
|
|
|
1687 /*
|
|
|
1688 * Parsing is finished
|
|
|
1689 *
|
|
|
1690 * unmap the file and close it
|
|
|
1691 */
|
|
|
1692
|
|
|
1693 /* Purify IPR/IPW error - bug 4124843 */
|
|
|
1694 /* LINTED */
|
|
|
1695 if(munmap(fileaddr, (int32_t)statb.st_size+1) == -1)
|
|
|
1696 {
|
|
|
1697 error(ERR_MSG_MUNMAP, errno_string());
|
|
|
1698 }
|
|
|
1699 }
|
|
|
1700 else
|
|
|
1701 {
|
|
|
1702 /* empty file, ignore it */
|
|
|
1703
|
|
|
1704 error_exit("empty configuration file %s", filename);
|
|
|
1705 }
|
|
|
1706
|
|
|
1707 if(close(fd) == -1)
|
|
|
1708 {
|
|
|
1709 error(ERR_MSG_CLOSE, errno_string());
|
|
|
1710 }
|
|
|
1711
|
|
|
1712 macro_list_delete();
|
|
|
1713
|
|
|
1714
|
|
|
1715 table_list_delete();
|
|
|
1716
|
|
|
1717
|
|
|
1718 if(first_agent == NULL)
|
|
|
1719 {
|
|
|
1720 error_exit("No SNMP agent configured");
|
|
|
1721 }
|
|
|
1722
|
|
|
1723 if(trace_level > 0)
|
|
|
1724 {
|
|
|
1725 trace_subtrees();
|
|
|
1726 trace_agents();
|
|
|
1727 }
|
|
|
1728 }
|
|
|
1729
|
|
|
1730
|
|
|
1731 /****************************************************************/
|
|
|
1732
|
|
|
1733 static void table_list_delete()
|
|
|
1734 {
|
|
|
1735 Table *next;
|
|
|
1736
|
|
|
1737 while(first_table)
|
|
|
1738 {
|
|
|
1739 next = first_table->next_table;
|
|
|
1740 table_free(first_table);
|
|
|
1741 first_table = next;
|
|
|
1742 }
|
|
|
1743
|
|
|
1744 first_table = NULL;
|
|
|
1745 last_table = NULL;
|
|
|
1746 }
|
|
|
1747
|
|
|
1748
|
|
|
1749 /****************************************************************/
|
|
|
1750
|
|
|
1751 static void table_free(Table *tp)
|
|
|
1752 {
|
|
|
1753 if(tp == NULL)
|
|
|
1754 {
|
|
|
1755 return;
|
|
|
1756 }
|
|
|
1757
|
|
|
1758 if(tp->regTblOID.subids)
|
|
|
1759 {
|
|
|
1760 free(tp->regTblOID.subids);
|
|
|
1761 }
|
|
|
1762
|
|
|
1763 /*
|
|
|
1764 if(tp->indexs.subids)
|
|
|
1765 {
|
|
|
1766 free(tp->indexs.subids);
|
|
|
1767 }
|
|
|
1768 */
|
|
|
1769
|
|
|
1770 free(tp);
|
|
|
1771 }
|
|
|
1772
|
|
|
1773
|
|
|
1774 /****************************************************************/
|
|
|
1775
|
|
|
1776
|
|
|
1777 /*********** SNMP security (5-13-96) ******/
|
|
|
1778 /* If we have a serious problem, this function will */
|
|
|
1779 /* terminate (<==> exit) the program */
|
|
|
1780
|
|
|
1781 void sec_config_init(char *filename)
|
|
|
1782 {
|
|
|
1783 struct stat statb;
|
|
|
1784 char *fileaddr;
|
|
|
1785 int fd;
|
|
|
1786
|
|
|
1787
|
|
|
1788 delete_manager_list();
|
|
|
1789 delete_community_list();
|
|
|
1790 if(trap_community)
|
|
|
1791 {
|
|
|
1792 free(trap_community);
|
|
|
1793 trap_community = NULL;
|
|
|
1794 }
|
|
|
1795 delete_trap_destinator_list();
|
|
|
1796
|
|
|
1797
|
|
|
1798 yylineno = 1;
|
|
|
1799
|
|
|
1800 if((fd = open(filename, O_RDONLY)) < 0)
|
|
|
1801 {
|
|
|
1802 error_exit(ERR_MSG_OPEN,
|
|
|
1803 filename, errno_string());
|
|
|
1804 }
|
|
|
1805
|
|
|
1806 /*
|
|
|
1807 * get the size of the file
|
|
|
1808 */
|
|
|
1809 if(fstat(fd, &statb) < 0 )
|
|
|
1810 {
|
|
|
1811 error_exit(ERR_MSG_FSTAT,
|
|
|
1812 filename, errno_string());
|
|
|
1813 }
|
|
|
1814 if(!S_ISREG(statb.st_mode))
|
|
|
1815 {
|
|
|
1816 error_exit("filename: %s is not a file\n",filename);
|
|
|
1817 }
|
|
|
1818
|
|
|
1819 /*
|
|
|
1820 * and map it into my address space
|
|
|
1821 */
|
|
|
1822 if(statb.st_size)
|
|
|
1823 {
|
|
|
1824 /* Purify IPR/IPW error - bug 4124843. yylook wants to
|
|
|
1825 read the last + 1 byte to decide EOF */
|
|
|
1826 /* LINTED */
|
|
|
1827 if((fileaddr = (char *) mmap(0, (int32_t)statb.st_size+1, PROT_READ|PROT_WRITE,
|
|
|
1828 MAP_PRIVATE, fd, 0)) <= (char *) 0)
|
|
|
1829 {
|
|
|
1830 error_exit(ERR_MSG_MMAP,
|
|
|
1831 filename, errno_string());
|
|
|
1832 }
|
|
|
1833
|
|
|
1834 /*
|
|
|
1835 * set current lex focus on the file
|
|
|
1836 */
|
|
|
1837
|
|
|
1838 lexinput = fileaddr;
|
|
|
1839
|
|
|
1840 /*
|
|
|
1841 * and parse the file
|
|
|
1842 */
|
|
|
1843
|
|
|
1844 current_filename = filename;
|
|
|
1845 if(yyparse() == 1)
|
|
|
1846 {
|
|
|
1847 error_exit("parsing %s failed", filename);
|
|
|
1848 }
|
|
|
1849 current_filename = NULL;
|
|
|
1850
|
|
|
1851 /*
|
|
|
1852 * Parsing is finished
|
|
|
1853 *
|
|
|
1854 * unmap the file and close it
|
|
|
1855 */
|
|
|
1856
|
|
|
1857 /* Purify IPR/IPW error - bug 4124843 */
|
|
|
1858 /* LINTED */
|
|
|
1859 if(munmap(fileaddr, (int32_t)statb.st_size+1) == -1)
|
|
|
1860 {
|
|
|
1861 error(ERR_MSG_MUNMAP,
|
|
|
1862 errno_string());
|
|
|
1863 }
|
|
|
1864 }
|
|
|
1865 else
|
|
|
1866 {
|
|
|
1867 /* empty file, ignore it */
|
|
|
1868
|
|
|
1869 error_exit("empty configuration file %s", filename);
|
|
|
1870 }
|
|
|
1871
|
|
|
1872 if(close(fd) == -1)
|
|
|
1873 {
|
|
|
1874 error(ERR_MSG_CLOSE, errno_string());
|
|
|
1875 }
|
|
|
1876
|
|
|
1877 if(trace_level > 0)
|
|
|
1878 {
|
|
|
1879 trace("\n");
|
|
|
1880 trace_managers();
|
|
|
1881 trace_filter();
|
|
|
1882 trace_trap_destinators();
|
|
|
1883 }
|
|
|
1884 }
|
|
|
1885 /*********** SNMP security (5-13-96) ******/
|
|
|
1886
|
|
|
1887 int yywrap()
|
|
|
1888 {
|
|
|
1889 return 1;
|
|
|
1890 }
|
|
|
1891
|
|
|
1892 static int get_a_non_reserved_port()
|
|
|
1893 {
|
|
|
1894 struct sockaddr_in me;
|
|
|
1895 socklen_t len;
|
|
|
1896 int cnt=0;
|
|
|
1897 int sd;
|
|
|
1898
|
|
|
1899 sd = socket(AF_INET,SOCK_DGRAM,0);
|
|
|
1900 if(sd<0) return 0;
|
|
|
1901 me.sin_family = AF_INET;
|
|
|
1902 me.sin_addr.s_addr = INADDR_ANY;
|
|
|
1903
|
|
|
1904 for(;cnt<5;cnt++){
|
|
|
1905 me.sin_port = htons(0);
|
|
|
1906 if(bind(sd,(struct sockaddr*)&me,sizeof(me))!=0)continue;
|
|
|
1907 len = (socklen_t) sizeof(me);
|
|
|
1908 if(getsockname(sd,(struct sockaddr*)&me, &len)==-1) continue;
|
|
|
1909 (void)close(sd);
|
|
|
1910 return me.sin_port;
|
|
|
1911 }
|
|
|
1912 (void)close(sd);
|
|
|
1913 return 0;
|
|
|
1914 }
|
