Mercurial > illumos > onarm

comparison usr/src/cmd/agents/snmp/agent/agent.c @ 0:c9caec207d52 b86

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Initial porting based on b86
author Koji Uno <koji.uno@sun.com>
date Tue, 02 Jun 2009 18:56:50 +0900
parents
children 1a15d5aaf794
comparison
equal deleted inserted replaced
-1:000000000000 0:c9caec207d52
1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License, Version 1.0 only
6 * (the "License"). You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22 /*
23 * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 #pragma ident "@(#)agent.c 1.25 05/06/12 SMI"
28
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <string.h>
32 #include <strings.h>
33 #include <sys/types.h>
34 #include <sys/socket.h>
35 #include <netinet/in.h>
36 #include <arpa/inet.h>
37
38
39 #include "impl.h"
40 #include "error.h"
41 #include "trace.h"
42 #include "snmp.h"
43 #include "pdu.h"
44 #include "request.h"
45 #include "trap.h"
46
47 #include "node.h"
48 #include "access.h"
49
50 static int ssa_mem_free = 1; /* on */
51
52 #if defined(_LP64)
53 #define COLUMN_OFFSET(x) (x) * 2
54 #else
55 #define COLUMN_OFFSET(x) (x)
56 #endif
57
58 #define OCTET_STRING 2
59
60 /***** LOCAL VARIABLES *****/
61
62 /*
63 * The idea of these cache variables is to avoid to call
64 * the same *(entry->get) function for variables contained
65 * in a single SNMP PDU.
66 *
67 * There is still a problem in this mechanism.
68 * When you query a whole table row by row and when
69 * you reached the end of the table, the *(entry->get)
70 * will be called several times:
71 * - for the first column, *(entry->get) will be called
72 * once to find that the end of the table is reached
73 * (==> the knowledge that we reached the last row is cached)
74 * and then *(entry->get) will be called on the first row of
75 * the same table (==> the first row is cached).
76 * - Same behaviour for all the remaining columns
77 *
78 * Possible solutions:
79 * - two caches but this implies the copy of the cached
80 * structures + all theis pointers
81 * - only one cache + caching the knowledge that we reached the last
82 * row ???
83 *
84 */
85
86 static Entry *cache_input_entry = NULL;
87 static Subid cache_input_index[MAX_OID_LEN];
88 static void *cache_output_pointer = NULL;
89 static int cache_output_snmp_error = -1;
90 static Subid cache_output_index[MAX_OID_LEN];
91
92
93 /***** LOCAL FUNCTIONS *****/
94
95 static int agent_get_next(SNMP_pdu *pdu, char *error_label);
96 static int agent_get_next_loop(SNMP_variable *variable, Node *node, Oid *suffix);
97 static int agent_get(SNMP_pdu *pdu, char *error_label);
98 static int agent_set(int pass, SNMP_pdu *pdu, char *error_label);
99
100
101 /****************************************************************/
102
103 /* returns: */
104 /* 0 in case of success (the pdu should be sent */
105 /* back to its originator even if an SNMP error */
106 /* was detected) */
107 /* -1 in case of failure (no pdu should be sent */
108 /* back) */
109
110 int agent_process(Address *address, SNMP_pdu *pdu)
111 {
112 int snmpEnableAuthTraps = FALSE;
113 Manager *mngr;
114
115
116 if(pdu == NULL)
117 {
118 error("BUG: agent_process(): pdu is NULL");
119 return -1;
120 }
121
122
123 /* check host */
124 if(is_valid_manager(address,&mngr) == NULL)
125 {
126 error("agent_process(): unauthorized manager (%s)",
127 ip_address_string(&(address->sin_addr)));
128
129 snmpEnableAuthTraps = request_snmpEnableAuthTraps(error_label);
130 switch(snmpEnableAuthTraps)
131 {
132 case TRUE:
133 if(trap_send_to_all_destinators(NULL,
134 SNMP_TRAP_AUTHFAIL, 0,
135 NULL, error_label))
136 {
137 error("trap_send_to_all_destinators() failed: %s\n",
138 error_label);
139 }
140 break;
141
142 case FALSE:
143 default:
144 break;
145 }
146
147 return -1;
148 }
149
150 /* if mngr == NULL -> allow requests from any hosts */
151
152 /* check pdu type */
153 if(pdu->type != GETNEXT_REQ_MSG
154 && (pdu->type != GET_REQ_MSG)
155 && (pdu->type != SET_REQ_MSG) )
156 {
157 error("agent_process(): bad PDU type (0x%x)", pdu->type);
158 return -1;
159 }
160
161
162 /* check host */
163 if(!is_valid_community(pdu->community, pdu->type,mngr))
164 {
165 /*
166 * Earlier, the community name is displayed here
167 * in this error message. But since these error
168 * messages are readable by all users, it is not advisible
169 * to display community names in the error messages.
170 */
171 error("agent_process() : bad community from %s",
172 ip_address_string(&(address->sin_addr)));
173
174 snmpEnableAuthTraps = request_snmpEnableAuthTraps(error_label);
175 switch(snmpEnableAuthTraps)
176 {
177 case TRUE:
178 if(trap_send_to_all_destinators(NULL,
179 SNMP_TRAP_AUTHFAIL, 0,
180 NULL, error_label))
181 {
182 error("trap_send_to_all_destinators() failed: %s\n",
183 error_label);
184 }
185 break;
186
187 case FALSE:
188 default:
189 break;
190 }
191
192 return -1;
193 }
194
195
196 if(cache_input_entry != NULL && cache_output_pointer != NULL)
197 if(ssa_mem_free != 0 && cache_input_entry->dealloc != NULL){
198 (*(cache_input_entry->dealloc))(cache_output_pointer);
199 cache_output_pointer = NULL;
200 }
201
202 cache_input_entry = NULL;
203
204 switch(pdu->type)
205 {
206 case GETNEXT_REQ_MSG:
207 if(agent_get_next(pdu, error_label))
208 {
209 error("agent_get_next() failed: %s", error_label);
210 return -1;
211 }
212 return 0;
213
214 case GET_REQ_MSG:
215 if(agent_get(pdu, error_label))
216 {
217 error("agent_get() failed: %s", error_label);
218 return -1;
219 }
220 return 0;
221
222 case SET_REQ_MSG:
223 switch(agent_set(FIRST_PASS, pdu, error_label))
224 {
225 case 0:
226 switch(agent_set(SECOND_PASS, pdu, error_label))
227 {
228 case 0:
229 case 1:
230 return 0;
231
232 case -1:
233 error("agent_set(SECOND_PASS) failed: %s",
234 error_label);
235 return -1;
236 }
237
238 /* never reached */
239 break;
240
241 case 1:
242 return 0;
243
244 case -1:
245 error("agent_set(FIRST_PASS) failed: %s",
246 error_label);
247 return -1;
248 }
249 }
250
251 /* never reached */
252 return -1;
253 }
254
255
256 /****************************************************************/
257
258 /* returns: */
259 /* 0 in case of success (the pdu should be sent */
260 /* back to its originator even if an SNMP error */
261 /* was detected) */
262 /* -1 in case of failure (no pdu should be sent */
263 /* back) */
264
265 static int agent_get_next(SNMP_pdu *pdu, char *error_label)
266 {
267 SNMP_variable *variable;
268 Node *node;
269 Oid suffix;
270 int index = 1;
271 int snmp_error;
272
273
274 error_label[0] = '\0';
275
276 pdu->type = GET_RSP_MSG;
277
278 for(variable = pdu->first_variable; variable; variable = variable->next_variable)
279 {
280 node = node_find(NEXT_ENTRY, &(variable->name), &suffix);
281 if(node == NULL)
282 {
283 pdu->error_status = SNMP_ERR_NOSUCHNAME;
284 pdu->error_index = index;
285 return 0;
286 }
287 /* we should not forget to free suffix.subids */
288
289 if(trace_level > 0)
290 {
291 trace("!! getnext(): processing the variable %s\n\n",
292 node->label);
293 }
294
295 if(variable->type != NULLOBJ)
296 {
297 error("ASN.1 type (0x%x) is not NULL for node %s",
298 variable->type, node->label);
299 variable->type = NULLOBJ;
300 }
301
302 if(variable->val.string)
303 {
304 error("val is not NULL for node %s",
305 node->label);
306 free(variable->val.string);
307 variable->val.string = NULL;
308 }
309
310 if(variable->val_len)
311 {
312 error("val_len is not 0 for node %s",
313 node->label);
314 variable->val_len = 0;
315 }
316
317 snmp_error = agent_get_next_loop(variable, node, &suffix);
318
319 if(snmp_error != SNMP_ERR_NOERROR)
320 {
321 pdu->error_status = snmp_error;
322 pdu->error_index = index;
323 return 0;
324 }
325
326 index++;
327 }
328
329 return 0;
330 }
331
332
333 /* This function will free suffix->subids */
334 /* It returns a positive snmp_error code. */
335 static int
336 agent_get_next_loop(SNMP_variable *variable, Node *node, Oid *suffix)
337 {
338 Object *object;
339 Column *column;
340 Entry *entry;
341 Integer integer = 0;
342 Integer *integer_ptr;
343 String string = { NULL, 0 };
344 String *string_ptr;
345 Oid oid = { NULL, 0 };
346 Oid *oid_ptr;
347 char *pointer;
348 int snmp_error;
349 Subid index[MAX_OID_LEN];
350 Index *pIndex;
351 int index_len;
352
353 /* create index struct */
354 IndexType index_obj;
355 int index_buffer[256];
356
357 int was_cached ;
358 int i;
359 int get_entry;
360
361 bzero(index, sizeof(Subid) * MAX_OID_LEN);
362 bzero(&index_obj, sizeof(index_obj));
363 bzero(index_buffer, sizeof(index_buffer));
364 index_obj.value = index_buffer;
365
366 if(node == NULL)
367 {
368 if(trace_level > 0)
369 {
370 trace("!! End of MIB\n\n");
371 }
372
373 SSAOidZero(suffix);
374 return SNMP_ERR_NOSUCHNAME;
375 }
376
377 if(trace_level > 0)
378 trace("!! Trying %s with suffix %s\n\n",
379 node->label, SSAOidString(suffix));
380
381 switch(node->type)
382 {
383 case OBJECT:
384 object = node->data.object;
385
386 switch(suffix->len)
387 {
388 case 0:
389 if( !(object->access & READ_FLAG) )
390 return SNMP_ERR_NOSUCHNAME;
391
392 switch(object->asn1_type)
393 {
394 case INTEGER:
395 case COUNTER:
396 case GAUGE:
397 case TIMETICKS:
398 snmp_error = (*(object->get))(&integer);
399 break;
400
401 case OBJID:
402 snmp_error = (*(object->get))(&oid);
403 if(snmp_error != SNMP_ERR_NOERROR &&
404 ssa_mem_free != 0){
405 if(object->dealloc != NULL)
406 (*(object->dealloc))(&oid);
407 }
408 break;
409
410 case STRING:
411 case IPADDRESS:
412 case OPAQUE:
413 snmp_error = (*(object->get))(&string);
414 if(snmp_error != SNMP_ERR_NOERROR &&
415 ssa_mem_free != 0){
416 if(object->dealloc != NULL)
417 (*(object->dealloc))(&string);
418 }
419 break;
420 }
421
422 if(snmp_error != SNMP_ERR_NOERROR)
423 {
424 if(snmp_error < 0)
425 {
426 error("the get() method of %s returned %d",
427 node->label,
428 snmp_error);
429 snmp_error = SNMP_ERR_GENERR;
430 }
431 return snmp_error;
432 }
433
434 /* variable->name */
435 SSAOidZero(&(variable->name));
436 variable->name.subids = (Subid *) malloc((object->name.len + 1) *
437 (int32_t)sizeof(Subid));
438 (void)memcpy(variable->name.subids, object->name.subids,
439 object->name.len * (int32_t)sizeof(Subid));
440 variable->name.subids[object->name.len] = 0;
441 variable->name.len = object->name.len + 1;
442
443 /* variable->type */
444 variable->type = object->asn1_type;
445
446 /* variable->val, variable->val_len */
447 switch(object->asn1_type)
448 {
449 case INTEGER:
450 case COUNTER:
451 case GAUGE:
452 case TIMETICKS:
453 variable->val.integer = (Integer *) malloc(sizeof(Integer));
454 *(variable->val.integer) = integer;
455 variable->val_len = sizeof(Integer);
456 break;
457
458 case OBJID:
459 variable->val.objid = (Subid *) malloc(oid.len *
460 (int32_t)sizeof(Subid));
461 (void)memcpy(variable->val.objid, oid.subids, oid.len *
462 (int32_t)sizeof(Subid));
463 variable->val_len = oid.len *
464 (int32_t)sizeof(Subid);
465 if(ssa_mem_free !=0 && object->dealloc != NULL)
466 (*(object->dealloc))(&oid);
467 break;
468
469 case STRING:
470 case IPADDRESS:
471 case OPAQUE:
472 variable->val.string = (u_char *) malloc(string.len);
473 (void)memcpy(variable->val.string, string.chars, string.len);
474 variable->val_len = string.len;
475 if(ssa_mem_free != 0 && object->dealloc != NULL)
476 (*(object->dealloc))(&string);
477 break;
478
479 }
480
481 return SNMP_ERR_NOERROR;
482
483
484 case 1:
485 if(suffix->subids[0] != 0)
486 {
487 SSAOidZero(suffix);
488 return SNMP_ERR_NOSUCHNAME;
489 }
490 SSAOidZero(suffix);
491
492 return agent_get_next_loop(variable, node->next, suffix);
493
494 default:
495 SSAOidZero(suffix);
496 return SNMP_ERR_NOSUCHNAME;
497 }
498
499
500 case COLUMN:
501 column = node->data.column;
502 entry = column->entry;
503 pIndex = entry->first_index;
504
505 if( !(column->access & READ_FLAG) )
506 {
507 SSAOidZero(suffix);
508 return SNMP_ERR_NOSUCHNAME;
509 }
510
511 if (entry->n_indexs < 0 || entry->n_indexs > MAX_OID_LEN) {
512 SSAOidZero(suffix);
513 return SNMP_ERR_NOSUCHNAME;
514 }
515
516 index_len = 0;
517 for (pIndex=entry->first_index; pIndex; pIndex=pIndex->next_index)
518 {
519 if (pIndex->index_type == OCTET_STRING)
520 index_len = index_len + (pIndex->index_len)+1; /* add extra suffix for str len */
521 else
522 index_len = index_len +1; /* one subid per index */
523 }
524 index_obj.len = index_len;
525
526 for (i=0; i < suffix->len; i++)
527 {
528 index[i] = suffix->subids[i];
529 index_obj.value[i] = suffix->subids[i];
530 }
531
532 for (i = suffix->len; i < index_len; i++) /* Zero out remainder of suffixes */
533 {
534 index[i] = 0;
535 index_obj.value[i] = 0;
536 }
537
538 for (i=0; i < index_len; i++)
539 {
540 if ((cache_input_entry == entry) && (cache_input_index[i] == index[i]))
541 was_cached = 1;
542 else
543 {
544 was_cached = 0;
545 break;
546 }
547
548 }
549
550 if (was_cached)
551 {
552 pointer = cache_output_pointer;
553 snmp_error = cache_output_snmp_error;
554 for (i=0;i < index_len; i++)
555 index[i]= cache_output_index[i];
556 }
557 else
558 {
559 if (cache_input_entry != NULL && cache_output_pointer != NULL)
560 if (ssa_mem_free!=0 && cache_input_entry->dealloc != NULL)
561 {
562 (*(cache_input_entry->dealloc))(cache_output_pointer);
563 cache_output_pointer = NULL;
564 }
565 cache_input_entry= entry;
566 for (i=0; i < index_len; i++)
567 cache_input_index[i] = index[i];
568
569 if (suffix->len == 0)
570 get_entry = FIRST_ENTRY;
571 else
572 get_entry = NEXT_ENTRY;
573
574 snmp_error = (*(entry->get)) (get_entry, &pointer,&index_obj);
575
576 for (i=0; i< index_len; i++)
577 index[i] = index_obj.value[i];
578 cache_output_pointer = pointer;
579 cache_output_snmp_error = snmp_error;
580 for (i=0; i < index_len; i++)
581 cache_output_index[i] = index[i];
582 }
583
584 if (suffix->len !=0)
585 SSAOidZero(suffix);
586
587 if(pointer == NULL)
588 {
589 if(snmp_error == END_OF_TABLE)
590 {
591 if(trace_level > 0)
592 {
593 trace("!! End of table %s\n\n",
594 node->parent->parent->label);
595 }
596 return agent_get_next_loop(variable, node->next, suffix);
597 }
598
599 if(snmp_error < 0)
600 {
601 error("the get() method of %s returned %d",
602 node->parent->label,
603 snmp_error);
604 snmp_error = SNMP_ERR_GENERR;
605 }
606 return snmp_error;
607 }
608
609 /* variable->name */
610 SSAOidZero(&(variable->name));
611 variable->name.subids = (Subid *) malloc((column->name.len + index_len) * sizeof(Subid));
612 memcpy(variable->name.subids, column->name.subids, column->name.len * sizeof(Subid));
613 for (i=0; i < index_len; i++)
614 variable->name.subids[column->name.len + i] = index[i];
615 variable->name.len = column->name.len + index_len;
616
617 /* variable->type */
618 variable->type = column->asn1_type;
619
620 /* variable->val, variable->val_len */
621 switch(column->asn1_type)
622 {
623 case INTEGER:
624 case COUNTER:
625 case GAUGE:
626 case TIMETICKS:
627 integer_ptr = (Integer *) (pointer +
628 COLUMN_OFFSET(column->offset));
629 variable->val.integer = (Integer *) malloc(sizeof(Integer));
630 *(variable->val.integer) = *integer_ptr;
631 variable->val_len = sizeof(Integer);
632 break;
633
634 case OBJID:
635 oid_ptr = (Oid *) (pointer +
636 COLUMN_OFFSET(column->offset));
637 /* fix the null subid */
638 if(oid_ptr->subids == NULL){
639 variable->val.objid = NULL;
640 }else{
641 variable->val.objid = (Subid *) malloc(oid_ptr->len *
642 (int32_t)sizeof(Subid));
643 (void)memcpy(variable->val.objid, oid_ptr->subids, oid_ptr->len *
644 (int32_t)sizeof(Subid));
645 }
646 variable->val_len = oid_ptr->len *
647 (int32_t)sizeof(Subid);
648 break;
649
650 case STRING:
651 case IPADDRESS:
652 case OPAQUE:
653 string_ptr = (String *) (pointer +
654 COLUMN_OFFSET(column->offset));
655 if(string_ptr->chars == NULL){
656 variable->val.string =(u_char*)NULL;
657 }else{
658 variable->val.string = (u_char *) malloc(string_ptr->len);
659 (void)memcpy(variable->val.string, string_ptr->chars, string_ptr->len);
660 }
661 variable->val_len = string_ptr->len;
662 break;
663 }
664
665
666 return SNMP_ERR_NOERROR;
667
668
669 case NODE:
670 return agent_get_next_loop(variable, node->next, suffix);
671 }
672
673 /* never reached */
674 return -1;
675 }
676
677
678 /****************************************************************/
679
680 /* returns: */
681 /* 0 in case of success (the pdu should be sent */
682 /* back to its originator even if an SNMP error */
683 /* was detected) */
684 /* -1 in case of failure (no pdu should be sent */
685 /* back) */
686
687 static int agent_get(SNMP_pdu *pdu, char *error_label)
688 {
689 SNMP_variable *variable;
690 Node *node;
691 Object *object;
692 Column *column;
693 Entry *entry=NULL;
694 Oid suffix;
695 int index_err = 1;
696 Integer integer;
697 Oid oid;
698 String string;
699 Integer *integer_ptr;
700 Oid *oid_ptr;
701 String *string_ptr;
702 int snmp_error;
703 char *pointer=NULL;
704 Subid index[MAX_OID_LEN];
705
706 /* create index struct */
707 IndexType index_obj;
708 int index_buffer[256];
709
710 int was_cached;
711 int i;
712 Index *pIndex;
713 int index_len;
714
715 index_obj.len = 0;
716 index_obj.type = 0;
717 index_obj.value = index_buffer;
718
719
720 error_label[0] = '\0';
721
722 pdu->type = GET_RSP_MSG;
723
724 for(variable = pdu->first_variable; variable; variable = variable->next_variable)
725 {
726 node = node_find(EXACT_ENTRY, &(variable->name), &suffix);
727 if(node == NULL)
728 {
729 pdu->error_status = SNMP_ERR_NOSUCHNAME;
730 pdu->error_index = index_err;
731 return 0;
732 }
733 /* we should not forget to free suffix.subids */
734
735 if(trace_level > 0)
736 {
737 trace("!! get(): processing the variable %s\n\n",
738 node->label);
739 }
740
741 if(variable->type != NULLOBJ)
742 {
743 error("agent_get(): ASN.1 type (0x%x) is not NULL for node %s",
744 variable->type,
745 node->label);
746 variable->type = NULLOBJ;
747 }
748
749 if(variable->val.string)
750 {
751 error("agent_get(): val is not NULL for node %s", node->label);
752 free(variable->val.string);
753 variable->val.string = NULL;
754 }
755
756 if(variable->val_len)
757 {
758 error("agent_get(): val_len is not 0 for node %s", node->label);
759 variable->val_len = 0;
760 }
761
762 switch(node->type)
763 {
764 case OBJECT:
765 object = node->data.object;
766
767 if( (suffix.len != 1)
768 || (suffix.subids[0] != 0) )
769 {
770 pdu->error_status = SNMP_ERR_NOSUCHNAME;
771 pdu->error_index = index_err;
772 SSAOidZero(&suffix);
773 return 0;
774 }
775
776 if( !(object->access & READ_FLAG) )
777 {
778 pdu->error_status = SNMP_ERR_NOSUCHNAME;
779 pdu->error_index = index_err;
780 SSAOidZero(&suffix);
781 return 0;
782 }
783
784 switch(object->asn1_type)
785 {
786 case INTEGER:
787 case COUNTER:
788 case GAUGE:
789 case TIMETICKS:
790 snmp_error = (*(object->get))(&integer);
791 break;
792
793 case OBJID:
794 snmp_error = (*(object->get))(&oid);
795 if(snmp_error != SNMP_ERR_NOERROR &&
796 ssa_mem_free != 0){
797 if(object->dealloc != NULL)
798 (*(object->dealloc))(&oid);
799 }
800 break;
801
802 case STRING:
803 case IPADDRESS:
804 case OPAQUE:
805 snmp_error = (*(object->get))(&string);
806 if(snmp_error != SNMP_ERR_NOERROR &&
807 ssa_mem_free != 0){
808 if(object->dealloc != NULL)
809 (*(object->dealloc))(&string);
810 }
811 break;
812 }
813
814 if(snmp_error != SNMP_ERR_NOERROR)
815 {
816 if(snmp_error < 0)
817 {
818 error("the get() method of %s returned %d",
819 node->label,
820 snmp_error);
821 snmp_error = SNMP_ERR_GENERR;
822 }
823 pdu->error_status = snmp_error;
824 pdu->error_index = index_err;
825 SSAOidZero(&suffix);
826 return 0;
827 }
828
829 /* variable->name */
830
831 /* variable->type */
832 variable->type = object->asn1_type;
833
834 /* variable->val, variable->val_len */
835 switch(object->asn1_type)
836 {
837 case INTEGER:
838 case COUNTER:
839 case GAUGE:
840 case TIMETICKS:
841 variable->val.integer = (Integer *) malloc(sizeof(Integer));
842 *(variable->val.integer) = integer;
843 variable->val_len = sizeof(Integer);
844 break;
845
846 case OBJID:
847 variable->val.objid = (Subid *) malloc(oid.len *
848 (int32_t)sizeof(Subid));
849 (void)memcpy(variable->val.objid, oid.subids, oid.len *
850 (int32_t)sizeof(Subid));
851 variable->val_len = oid.len *
852 (int32_t)sizeof(Subid);
853 if (ssa_mem_free != 0){
854 if(object->dealloc != NULL)
855 (*(object->dealloc))(&oid);
856 }
857 break;
858
859 case STRING:
860 case IPADDRESS:
861 case OPAQUE:
862 variable->val.string = (u_char *) malloc(string.len);
863 (void)memcpy(variable->val.string, string.chars, string.len);
864 variable->val_len = string.len;
865 /*if(snmp_error != SNMP_ERR_NOERROR &&*/
866 if (ssa_mem_free != 0){
867 if(object->dealloc != NULL)
868 (*(object->dealloc))(&string);
869 }
870 break;
871 }
872
873
874 break;
875
876
877 case COLUMN:
878 column = node->data.column;
879 entry = column->entry;
880 pIndex=entry->first_index;
881
882 if( !(column->access & READ_FLAG) )
883 {
884 pdu->error_status = SNMP_ERR_NOSUCHNAME;
885 pdu->error_index = index_err;
886 SSAOidZero(&suffix);
887 return 0;
888 }
889
890 if (suffix.subids == NULL) {
891 pdu->error_status = SNMP_ERR_NOSUCHNAME;
892 pdu->error_index = index_err;
893 SSAOidZero(&suffix);
894 return 0;
895 }
896
897 index_len = 0;
898 for (pIndex=entry->first_index; pIndex; pIndex=pIndex->next_index)
899 {
900 if (pIndex->index_type == OCTET_STRING)
901 index_len = index_len + (pIndex->index_len)+1; /* add extra suffix for str len */
902 else
903 index_len = index_len +1; /* one subid per index */
904 }
905
906
907 for (i=0; i < index_len; i++)
908 {
909 index[i] = suffix.subids[i];
910 index_obj.value[i] = suffix.subids[i];
911 }
912 index_obj.len = index_len;
913 for (i=0; i < index_len; i++)
914 {
915 if( (cache_input_entry == entry) && (cache_input_index[i] == index[i]) )
916 was_cached = 1;
917 else
918 {
919 was_cached = 0;
920 break;
921 }
922 }
923 if (was_cached)
924 {
925 pointer = cache_output_pointer;
926 snmp_error = cache_output_snmp_error;
927 }
928 else
929 {
930 if(cache_input_entry != NULL && cache_output_pointer != NULL)
931 if(ssa_mem_free != 0 && cache_input_entry->dealloc != NULL)
932 {
933 (*(cache_input_entry->dealloc))(cache_output_pointer);
934 cache_output_pointer = NULL;
935 }
936 cache_input_entry = entry;
937 for (i=0; i < index_len; i++)
938 cache_input_index[i] = index[i];
939 snmp_error = (*(entry->get))(EXACT_ENTRY,&pointer,&index_obj);
940 cache_output_pointer = pointer;
941 cache_output_snmp_error = snmp_error;
942 }
943
944
945 if(pointer == NULL)
946 {
947 if(snmp_error < 0)
948 {
949 error("the get() method of %s returned %d",
950 node->parent->label,
951 snmp_error);
952 snmp_error = SNMP_ERR_GENERR;
953 }
954
955 pdu->error_status = snmp_error;
956 pdu->error_index = index_err;
957 SSAOidZero(&suffix);
958 return 0;
959 }
960
961 /* variable->type */
962 variable->type = column->asn1_type;
963
964 /* variable->val, variable->val_len */
965 switch(column->asn1_type)
966 {
967 case INTEGER:
968 case COUNTER:
969 case GAUGE:
970 case TIMETICKS:
971 integer_ptr = (Integer *) (pointer +
972 COLUMN_OFFSET(column->offset));
973 variable->val.integer = (Integer *) malloc(sizeof(Integer));
974 *(variable->val.integer) = *integer_ptr;
975 variable->val_len = sizeof(Integer);
976 break;
977
978 case OBJID:
979 oid_ptr = (Oid *) (pointer +
980 COLUMN_OFFSET(column->offset));
981 variable->val.objid = (Subid *) malloc(oid_ptr->len *
982 (int32_t)sizeof(Subid));
983 (void)memcpy(variable->val.objid, oid_ptr->subids, oid_ptr->len *
984 (int32_t)sizeof(Subid));
985 variable->val_len = oid_ptr->len *
986 (int32_t)sizeof(Subid);
987 break;
988
989 case STRING:
990 case IPADDRESS:
991 case OPAQUE:
992 string_ptr = (String *) (pointer +
993 COLUMN_OFFSET(column->offset));
994 variable->val.string = (u_char *) malloc(string_ptr->len);
995 (void)memcpy(variable->val.string, string_ptr->chars, string_ptr->len);
996 variable->val_len = string_ptr->len;
997 break;
998 }
999
1000 break;
1001
1002
1003 case NODE:
1004 pdu->error_status = SNMP_ERR_NOSUCHNAME;
1005 pdu->error_index = index_err;
1006 SSAOidZero(&suffix);
1007 return 0;
1008 }
1009
1010 SSAOidZero(&suffix);
1011
1012 index_err++;
1013 }
1014 /* Moved this down from the column loop because the cache must be
1015 freed only when the required columns in the row are all read.
1016 - Added pointer check because pointer will point to nothing
1017 if this is a non-column get.
1018 - Added setting cache_output_pointer to NULL because if it is not
1019 NULL, the next iteration of agent_process will try to delete it */
1020 /* Bug fix 4127458 . Added check to see if entry has been initialized */
1021 if(ssa_mem_free != 0 && entry != NULL && entry->dealloc != NULL && pointer != NULL){
1022 /* remember to turn off the caching */
1023 (*(entry->dealloc))(pointer);
1024 pointer = cache_output_pointer = NULL;
1025 }
1026
1027 return 0;
1028 }
1029
1030
1031 /****************************************************************/
1032
1033 /* returns */
1034 /* 0 in case of success. If we are in the */
1035 /* FIRST_PASS, we should go to the second pass. */
1036 /* -1 in case of failure. If we are in the */
1037 /* FIRST_PASS, we should not go to the */
1038 /* second pass and no pdu should be sent back. */
1039 /* 1 If we are in the FIRST_PASS, we should not go */
1040 /* to the second pass but a pdu */
1041 /* with an SNMP error should be sent back to its */
1042 /* originator */
1043
1044 static int agent_set(int pass, SNMP_pdu *pdu, char *error_label)
1045 {
1046 SNMP_variable *variable;
1047 Node *node;
1048 Object *object;
1049 Column *column;
1050 Entry *entry;
1051 Oid suffix;
1052 int index = 1;
1053 Integer integer = 0;
1054 Oid oid = { NULL, 0 };
1055 String string = { NULL, 0 };
1056 int snmp_error;
1057 int i;
1058
1059 /* create index struct */
1060 IndexType index_obj;
1061 int index_buffer[256];
1062
1063 index_obj.len = 0;
1064 index_obj.value = index_buffer;
1065
1066 error_label[0] = '\0';
1067
1068 pdu->type = GET_RSP_MSG;
1069
1070 for(variable = pdu->first_variable; variable; variable = variable->next_variable)
1071 {
1072 node = node_find(EXACT_ENTRY, &(variable->name), &suffix);
1073 if(node == NULL)
1074 {
1075 pdu->error_status = SNMP_ERR_NOSUCHNAME;
1076 pdu->error_index = index;
1077 return 1;
1078 }
1079 /* we should not forget to free suffix.subids */
1080
1081 if(trace_level > 0)
1082 {
1083 trace("!! set(%s): processing the variable %s\n\n",
1084 (pass == FIRST_PASS)? "FIRST_PASS": "SECOND_PASS",
1085 node->label);
1086 }
1087
1088 /*
1089 if(variable->val.string == NULL)
1090 {
1091 (void)sprintf(error_label, "val.string is NULL for node %s",
1092 node->label);
1093 SSAOidZero(&suffix);
1094 return -1;
1095 }
1096
1097 if(variable->val_len == 0)
1098 {
1099 (void)sprintf(error_label, "val_len is 0 for node %s",
1100 node->label);
1101 SSAOidZero(&suffix);
1102 return -1;
1103 }
1104 */
1105
1106 switch(node->type)
1107 {
1108 case OBJECT:
1109 object = node->data.object;
1110
1111 /* check the ASN.1 type */
1112 if(variable->type != object->asn1_type)
1113 {
1114 (void)sprintf(error_label, "wrong ASN.1 type (0x%x) for node %s",
1115 variable->type, node->label);
1116 SSAOidZero(&suffix);
1117 return -1;
1118 }
1119
1120 /* check the suffix */
1121 if( (suffix.len != 1)
1122 || (suffix.subids[0] != 0) )
1123 {
1124 pdu->error_status = SNMP_ERR_NOSUCHNAME;
1125 pdu->error_index = index;
1126 SSAOidZero(&suffix);
1127 return 1;
1128 }
1129
1130 /* check the access */
1131 if( !(object->access & WRITE_FLAG) )
1132 {
1133 pdu->error_status = SNMP_ERR_READONLY;
1134 pdu->error_index = index;
1135 SSAOidZero(&suffix);
1136 return 1;
1137 }
1138
1139 /* check the value length */
1140 switch(object->asn1_type)
1141 {
1142 case INTEGER:
1143 case COUNTER:
1144 case GAUGE:
1145 case TIMETICKS:
1146 case IPADDRESS:
1147 if(variable->val_len != 4)
1148 {
1149 (void)sprintf(error_label, "val_len is not 4 (%d) for node %s",
1150 variable->val_len, node->label);
1151 SSAOidZero(&suffix);
1152 return -1;
1153 }
1154
1155 if(variable->val.integer == NULL)
1156 {
1157 (void)sprintf(error_label, "val.integer is NULL for node %s",
1158 node->label);
1159 SSAOidZero(&suffix);
1160 return -1;
1161 }
1162
1163 break;
1164 }
1165
1166 /* in case of enumerated integer, check the value */
1167 if( (object->asn1_type == INTEGER)
1168 && (object->first_enum != NULL) )
1169 {
1170 Enum *enums;
1171
1172
1173 integer = *(variable->val.integer);
1174
1175 for(enums = object->first_enum; enums; enums = enums->next_enum)
1176 {
1177 if(enums->value == integer)
1178 {
1179 break;
1180 }
1181 }
1182
1183 if(enums == NULL)
1184 {
1185 pdu->error_status = SNMP_ERR_BADVALUE;
1186 pdu->error_index = index;
1187 SSAOidZero(&suffix);
1188 return 1;
1189 }
1190 }
1191
1192 switch(object->asn1_type)
1193 {
1194 case INTEGER:
1195 case COUNTER:
1196 case GAUGE:
1197 case TIMETICKS:
1198 integer = *(variable->val.integer);
1199
1200 snmp_error = (*(object->set))(pass, &integer);
1201 break;
1202
1203 case OBJID:
1204 if(SSAOidInit(&oid, variable->val.objid,
1205 variable->val_len / (int32_t)sizeof(Subid),
1206 error_label)) {
1207 SSAOidZero(&suffix);
1208 return -1;
1209 }
1210
1211 snmp_error = (*(object->set))(pass, &oid);
1212 SSAOidZero(&oid);
1213 break;
1214
1215 case STRING:
1216 case IPADDRESS:
1217 case OPAQUE:
1218 if(SSAStringInit(&string, variable->val.string,
1219 variable->val_len, error_label)) {
1220 SSAOidZero(&suffix);
1221 return -1;
1222 }
1223
1224 snmp_error = (*(object->set))(pass, &string);
1225 SSAStringZero(&string);
1226 break;
1227 }
1228
1229 if(snmp_error != SNMP_ERR_NOERROR)
1230 {
1231 if(snmp_error < 0)
1232 {
1233 error("the set(%s) method of %s returned %d",
1234 (pass == FIRST_PASS)? "FIRST_PASS": "SECOND_PASS",
1235 node->label, snmp_error);
1236 snmp_error = SNMP_ERR_GENERR;
1237 }
1238 pdu->error_status = snmp_error;
1239 pdu->error_index = index;
1240 SSAOidZero(&suffix);
1241 return 1;
1242 }
1243
1244 break;
1245
1246
1247 case COLUMN:
1248 column = node->data.column;
1249 entry = column->entry;
1250
1251 /* check the ASN.1 type */
1252 if(variable->type != column->asn1_type)
1253 {
1254 (void)sprintf(error_label, "wrong ASN.1 type (0x%x) for node %s",
1255 variable->type, node->label);
1256 SSAOidZero(&suffix);
1257 return -1;
1258 }
1259
1260 /* check the suffix */
1261 if (suffix.subids == NULL)
1262 {
1263 pdu->error_status = SNMP_ERR_NOSUCHNAME;
1264 pdu->error_index = index;
1265 SSAOidZero(&suffix);
1266 return 1;
1267 }
1268
1269 /* check the access */
1270 if( !(column->access & WRITE_FLAG) )
1271 {
1272 pdu->error_status = SNMP_ERR_READONLY;
1273 pdu->error_index = index;
1274 SSAOidZero(&suffix);
1275 return 1;
1276 }
1277
1278 /* check the value length */
1279 switch(column->asn1_type)
1280 {
1281 case INTEGER:
1282 case COUNTER:
1283 case GAUGE:
1284 case TIMETICKS:
1285 case IPADDRESS:
1286 if(variable->val_len != 4)
1287 {
1288 (void)sprintf(error_label, "val_len is not 4 (%d) for node %s",
1289 variable->val_len, node->label);
1290 SSAOidZero(&suffix);
1291 return -1;
1292 }
1293
1294 if(variable->val.integer == NULL)
1295 {
1296 (void)sprintf(error_label, "val.integer is NULL for node %s",
1297 node->label);
1298 SSAOidZero(&suffix);
1299 return -1;
1300 }
1301
1302 break;
1303 }
1304
1305 /* in case of enumerated integer, check the value */
1306 if( (column->asn1_type == INTEGER)
1307 && (column->first_enum != NULL) )
1308 {
1309 Enum *enums;
1310
1311
1312 integer = *(variable->val.integer);
1313
1314 for(enums = column->first_enum; enums; enums = enums->next_enum)
1315 {
1316 if(enums->value == integer)
1317 {
1318 break;
1319 }
1320 }
1321
1322 if(enums == NULL)
1323 {
1324 pdu->error_status = SNMP_ERR_BADVALUE;
1325 pdu->error_index = index;
1326 SSAOidZero(&suffix);
1327 return 1;
1328 }
1329 }
1330
1331 switch(column->asn1_type)
1332 {
1333 case INTEGER:
1334 case COUNTER:
1335 case GAUGE:
1336 case TIMETICKS:
1337 integer = *(variable->val.integer);
1338
1339 break;
1340
1341 case OBJID:
1342 if(SSAOidInit(&oid, variable->val.objid,
1343 variable->val_len / (int32_t)sizeof(Subid), error_label)) {
1344 SSAOidZero(&suffix);
1345 return -1;
1346 }
1347
1348 break;
1349
1350 case STRING:
1351 case IPADDRESS:
1352 case OPAQUE:
1353 if(SSAStringInit(&string, variable->val.string, variable->val_len, error_label))
1354 {
1355 SSAOidZero(&suffix);
1356 return -1;
1357 }
1358
1359 break;
1360 }
1361
1362 index_obj.len = suffix.len;
1363 for (i = 0; i < suffix.len; i++)
1364 {
1365 index_obj.value[i] = suffix.subids[i];
1366 }
1367
1368
1369 switch(column->asn1_type)
1370 {
1371 case INTEGER:
1372 case COUNTER:
1373 case GAUGE:
1374 case TIMETICKS:
1375 snmp_error = (*(column->set))(pass, index_obj, &integer);
1376 break;
1377
1378 case OBJID:
1379 snmp_error = (*(column->set))(pass, index_obj, &oid);
1380 break;
1381
1382 case STRING:
1383 case IPADDRESS:
1384 case OPAQUE:
1385 snmp_error = (*(column->set))(pass, index_obj, &string);
1386 break;
1387 }
1388
1389 switch(column->asn1_type)
1390 {
1391 case OBJID:
1392 SSAOidZero(&oid);
1393 break;
1394
1395 case STRING:
1396 case IPADDRESS:
1397 case OPAQUE:
1398 SSAStringZero(&string);
1399 break;
1400 }
1401
1402 if(snmp_error != SNMP_ERR_NOERROR)
1403 {
1404 if(snmp_error < 0)
1405 {
1406 error("the set(%s) method of %s returned %d",
1407 (pass == FIRST_PASS)? "FIRST_PASS": "SECOND_PASS",
1408 node->parent->label,
1409 snmp_error);
1410 snmp_error = SNMP_ERR_GENERR;
1411 }
1412
1413 pdu->error_status = snmp_error;
1414 pdu->error_index = index;
1415 SSAOidZero(&suffix);
1416 return 1;
1417 }
1418
1419 break;
1420
1421
1422 case NODE:
1423 pdu->error_status = SNMP_ERR_NOSUCHNAME;
1424 pdu->error_index = index;
1425 SSAOidZero(&suffix);
1426 return 1;
1427 }
1428
1429 SSAOidZero(&suffix);
1430
1431 index++;
1432 }
1433
1434 return 0;
1435 }
1436
1437
1438 /****************************************************************/
1439
1440 /* flag == 0 means turn off auto mem free */
1441 void SSAAutoMemFree(int flag)
1442 {
1443 ssa_mem_free = flag;
1444 }
1445
1446