3 * MIB tree access/construction functions.
\r
7 * Copyright (c) 2006 Axon Digital Design B.V., The Netherlands.
\r
8 * All rights reserved.
\r
10 * Redistribution and use in source and binary forms, with or without modification,
\r
11 * are permitted provided that the following conditions are met:
\r
13 * 1. Redistributions of source code must retain the above copyright notice,
\r
14 * this list of conditions and the following disclaimer.
\r
15 * 2. Redistributions in binary form must reproduce the above copyright notice,
\r
16 * this list of conditions and the following disclaimer in the documentation
\r
17 * and/or other materials provided with the distribution.
\r
18 * 3. The name of the author may not be used to endorse or promote products
\r
19 * derived from this software without specific prior written permission.
\r
21 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
\r
22 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
\r
23 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
\r
24 * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
\r
25 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
\r
26 * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
\r
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
\r
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
\r
29 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
\r
32 * Author: Christiaan Simons <christiaan.simons@axon.tv>
\r
35 #include "lwip/opt.h"
\r
37 #if LWIP_SNMP /* don't build if not configured for use in lwipopts.h */
\r
39 #include "lwip/snmp_structs.h"
\r
40 #include "lwip/mem.h"
\r
42 /** .iso.org.dod.internet address prefix, @see snmp_iso_*() */
\r
43 const s32_t prefix[4] = {1, 3, 6, 1};
\r
45 #define NODE_STACK_SIZE (LWIP_SNMP_OBJ_ID_LEN)
\r
46 /** node stack entry (old news?) */
\r
50 struct mib_node* r_ptr;
\r
51 /** right child identifier */
\r
53 /** right child next level */
\r
56 static u8_t node_stack_cnt;
\r
57 static struct nse node_stack[NODE_STACK_SIZE];
\r
60 * Pushes nse struct onto stack.
\r
63 push_node(struct nse* node)
\r
65 LWIP_ASSERT("node_stack_cnt < NODE_STACK_SIZE",node_stack_cnt < NODE_STACK_SIZE);
\r
66 LWIP_DEBUGF(SNMP_MIB_DEBUG,("push_node() node=%p id=%"S32_F"\n",(void*)(node->r_ptr),node->r_id));
\r
67 if (node_stack_cnt < NODE_STACK_SIZE)
\r
69 node_stack[node_stack_cnt] = *node;
\r
75 * Pops nse struct from stack.
\r
78 pop_node(struct nse* node)
\r
80 if (node_stack_cnt > 0)
\r
83 *node = node_stack[node_stack_cnt];
\r
85 LWIP_DEBUGF(SNMP_MIB_DEBUG,("pop_node() node=%p id=%"S32_F"\n",(void *)(node->r_ptr),node->r_id));
\r
89 * Conversion from ifIndex to lwIP netif
\r
90 * @param ifindex is a s32_t object sub-identifier
\r
91 * @param netif points to returned netif struct pointer
\r
94 snmp_ifindextonetif(s32_t ifindex, struct netif **netif)
\r
96 struct netif *nif = netif_list;
\r
99 ifidx = ifindex - 1;
\r
101 while ((nif != NULL) && (i < ifidx))
\r
110 * Conversion from lwIP netif to ifIndex
\r
111 * @param netif points to a netif struct
\r
112 * @param ifidx points to s32_t object sub-identifier
\r
115 snmp_netiftoifindex(struct netif *netif, s32_t *ifidx)
\r
117 struct netif *nif = netif_list;
\r
121 while (nif != netif)
\r
130 * Conversion from oid to lwIP ip_addr
\r
131 * @param ident points to s32_t ident[4] input
\r
132 * @param ip points to output struct
\r
135 snmp_oidtoip(s32_t *ident, struct ip_addr *ip)
\r
150 * Conversion from lwIP ip_addr to oid
\r
151 * @param ip points to input struct
\r
152 * @param ident points to s32_t ident[4] output
\r
155 snmp_iptooid(struct ip_addr *ip, s32_t *ident)
\r
160 ident[0] = (ipa >> 24) & 0xff;
\r
161 ident[1] = (ipa >> 16) & 0xff;
\r
162 ident[2] = (ipa >> 8) & 0xff;
\r
163 ident[3] = ipa & 0xff;
\r
166 struct mib_list_node *
\r
167 snmp_mib_ln_alloc(s32_t id)
\r
169 struct mib_list_node *ln;
\r
171 ln = (struct mib_list_node *)mem_malloc(sizeof(struct mib_list_node));
\r
183 snmp_mib_ln_free(struct mib_list_node *ln)
\r
188 struct mib_list_rootnode *
\r
189 snmp_mib_lrn_alloc(void)
\r
191 struct mib_list_rootnode *lrn;
\r
193 lrn = (struct mib_list_rootnode*)mem_malloc(sizeof(struct mib_list_rootnode));
\r
196 lrn->get_object_def = noleafs_get_object_def;
\r
197 lrn->get_value = noleafs_get_value;
\r
198 lrn->set_test = noleafs_set_test;
\r
199 lrn->set_value = noleafs_set_value;
\r
200 lrn->node_type = MIB_NODE_LR;
\r
201 lrn->maxlength = 0;
\r
210 snmp_mib_lrn_free(struct mib_list_rootnode *lrn)
\r
216 * Inserts node in idx list in a sorted
\r
217 * (ascending order) fashion and
\r
218 * allocates the node if needed.
\r
220 * @param rn points to the root node
\r
221 * @param objid is the object sub identifier
\r
222 * @param insn points to a pointer to the inserted node
\r
223 * used for constructing the tree.
\r
224 * @return -1 if failed, 1 if inserted, 2 if present.
\r
227 snmp_mib_node_insert(struct mib_list_rootnode *rn, s32_t objid, struct mib_list_node **insn)
\r
229 struct mib_list_node *nn;
\r
232 LWIP_ASSERT("rn != NULL",rn != NULL);
\r
234 /* -1 = malloc failure, 0 = not inserted, 1 = inserted, 2 = was present */
\r
236 if (rn->head == NULL)
\r
238 /* empty list, add first node */
\r
239 LWIP_DEBUGF(SNMP_MIB_DEBUG,("alloc empty list objid==%"S32_F"\n",objid));
\r
240 nn = snmp_mib_ln_alloc(objid);
\r
255 struct mib_list_node *n;
\r
256 /* at least one node is present */
\r
258 while ((n != NULL) && (insert == 0))
\r
260 if (n->objid == objid)
\r
262 /* node is already there */
\r
263 LWIP_DEBUGF(SNMP_MIB_DEBUG,("node already there objid==%"S32_F"\n",objid));
\r
267 else if (n->objid < objid)
\r
269 if (n->next == NULL)
\r
271 /* alloc and insert at the tail */
\r
272 LWIP_DEBUGF(SNMP_MIB_DEBUG,("alloc ins tail objid==%"S32_F"\n",objid));
\r
273 nn = snmp_mib_ln_alloc(objid);
\r
285 /* insertion failure */
\r
291 /* there's more to explore: traverse list */
\r
292 LWIP_DEBUGF(SNMP_MIB_DEBUG,("traverse list\n"));
\r
298 /* n->objid > objid */
\r
299 /* alloc and insert between n->prev and n */
\r
300 LWIP_DEBUGF(SNMP_MIB_DEBUG,("alloc ins n->prev, objid==%"S32_F", n\n",objid));
\r
301 nn = snmp_mib_ln_alloc(objid);
\r
304 if (n->prev == NULL)
\r
306 /* insert at the head */
\r
314 /* insert in the middle */
\r
316 nn->prev = n->prev;
\r
317 n->prev->next = nn;
\r
325 /* insertion failure */
\r
335 LWIP_ASSERT("insert != 0",insert != 0);
\r
340 * Finds node in idx list and returns deletion mark.
\r
342 * @param rn points to the root node
\r
343 * @param objid is the object sub identifier
\r
344 * @param fn returns pointer to found node
\r
345 * @return 0 if not found, 1 if deletable,
\r
346 * 2 can't delete (2 or more children), 3 not a list_node
\r
349 snmp_mib_node_find(struct mib_list_rootnode *rn, s32_t objid, struct mib_list_node **fn)
\r
352 struct mib_list_node *n;
\r
354 LWIP_ASSERT("rn != NULL",rn != NULL);
\r
356 while ((n != NULL) && (n->objid != objid))
\r
364 else if (n->nptr == NULL)
\r
366 /* leaf, can delete node */
\r
371 struct mib_list_rootnode *r;
\r
373 if (n->nptr->node_type == MIB_NODE_LR)
\r
375 r = (struct mib_list_rootnode *)n->nptr;
\r
378 /* can't delete node */
\r
383 /* count <= 1, can delete node */
\r
389 /* other node type */
\r
398 * Removes node from idx list
\r
399 * if it has a single child left.
\r
401 * @param rn points to the root node
\r
402 * @param n points to the node to delete
\r
403 * @return the nptr to be freed by caller
\r
405 struct mib_list_rootnode *
\r
406 snmp_mib_node_delete(struct mib_list_rootnode *rn, struct mib_list_node *n)
\r
408 struct mib_list_rootnode *next;
\r
410 LWIP_ASSERT("rn != NULL",rn != NULL);
\r
411 LWIP_ASSERT("n != NULL",n != NULL);
\r
413 /* caller must remove this sub-tree */
\r
414 next = (struct mib_list_rootnode*)(n->nptr);
\r
419 rn->head = n->next;
\r
420 if (n->next != NULL)
\r
422 /* not last node, new list begin */
\r
423 n->next->prev = NULL;
\r
426 else if (n == rn->tail)
\r
428 rn->tail = n->prev;
\r
429 if (n->prev != NULL)
\r
431 /* not last node, new list end */
\r
432 n->prev->next = NULL;
\r
437 /* node must be in the middle */
\r
438 n->prev->next = n->next;
\r
439 n->next->prev = n->prev;
\r
441 LWIP_DEBUGF(SNMP_MIB_DEBUG,("free list objid==%"S32_F"\n",n->objid));
\r
442 snmp_mib_ln_free(n);
\r
443 if (rn->count == 0)
\r
454 * Searches tree for the supplied (scalar?) object identifier.
\r
456 * @param node points to the root of the tree ('.internet')
\r
457 * @param ident_len the length of the supplied object identifier
\r
458 * @param ident points to the array of sub identifiers
\r
459 * @param np points to the found object instance (rerurn)
\r
460 * @return pointer to the requested parent (!) node if success, NULL otherwise
\r
463 snmp_search_tree(struct mib_node *node, u8_t ident_len, s32_t *ident, struct snmp_name_ptr *np)
\r
465 u8_t node_type, ext_level;
\r
468 LWIP_DEBUGF(SNMP_MIB_DEBUG,("node==%p *ident==%"S32_F"\n",(void*)node,*ident));
\r
469 while (node != NULL)
\r
471 node_type = node->node_type;
\r
472 if ((node_type == MIB_NODE_AR) || (node_type == MIB_NODE_RA))
\r
474 struct mib_array_node *an;
\r
479 /* array node (internal ROM or RAM, fixed length) */
\r
480 an = (struct mib_array_node *)node;
\r
482 while ((i < an->maxlength) && (an->objid[i] != *ident))
\r
486 if (i < an->maxlength)
\r
488 /* found it, if available proceed to child, otherwise inspect leaf */
\r
489 LWIP_DEBUGF(SNMP_MIB_DEBUG,("an->objid[%"U16_F"]==%"S32_F" *ident==%"S32_F"\n",i,an->objid[i],*ident));
\r
490 if (an->nptr[i] == NULL)
\r
492 /* a scalar leaf OR table,
\r
493 inspect remaining instance number / table index */
\r
494 np->ident_len = ident_len;
\r
496 return (struct mib_node*)an;
\r
500 /* follow next child pointer */
\r
503 node = an->nptr[i];
\r
508 /* search failed, identifier mismatch (nosuchname) */
\r
509 LWIP_DEBUGF(SNMP_MIB_DEBUG,("an search failed *ident==%"S32_F"\n",*ident));
\r
515 /* search failed, short object identifier (nosuchname) */
\r
516 LWIP_DEBUGF(SNMP_MIB_DEBUG,("an search failed, short object identifier\n"));
\r
520 else if(node_type == MIB_NODE_LR)
\r
522 struct mib_list_rootnode *lrn;
\r
523 struct mib_list_node *ln;
\r
527 /* list root node (internal 'RAM', variable length) */
\r
528 lrn = (struct mib_list_rootnode *)node;
\r
530 /* iterate over list, head to tail */
\r
531 while ((ln != NULL) && (ln->objid != *ident))
\r
537 /* found it, proceed to child */;
\r
538 LWIP_DEBUGF(SNMP_MIB_DEBUG,("ln->objid==%"S32_F" *ident==%"S32_F"\n",ln->objid,*ident));
\r
539 if (ln->nptr == NULL)
\r
541 np->ident_len = ident_len;
\r
543 return (struct mib_node*)lrn;
\r
547 /* follow next child pointer */
\r
555 /* search failed */
\r
556 LWIP_DEBUGF(SNMP_MIB_DEBUG,("ln search failed *ident==%"S32_F"\n",*ident));
\r
562 /* search failed, short object identifier (nosuchname) */
\r
563 LWIP_DEBUGF(SNMP_MIB_DEBUG,("ln search failed, short object identifier\n"));
\r
567 else if(node_type == MIB_NODE_EX)
\r
569 struct mib_external_node *en;
\r
574 /* external node (addressing and access via functions) */
\r
575 en = (struct mib_external_node *)node;
\r
578 len = en->level_length(en->addr_inf,ext_level);
\r
579 while ((i < len) && (en->ident_cmp(en->addr_inf,ext_level,i,*ident) != 0))
\r
587 en->get_objid(en->addr_inf,ext_level,i,&debug_id);
\r
588 LWIP_DEBUGF(SNMP_MIB_DEBUG,("en->objid==%"S32_F" *ident==%"S32_F"\n",debug_id,*ident));
\r
589 if ((ext_level + 1) == en->tree_levels)
\r
591 np->ident_len = ident_len;
\r
593 return (struct mib_node*)en;
\r
597 /* found it, proceed to child */
\r
605 /* search failed */
\r
606 LWIP_DEBUGF(SNMP_MIB_DEBUG,("en search failed *ident==%"S32_F"\n",*ident));
\r
612 /* search failed, short object identifier (nosuchname) */
\r
613 LWIP_DEBUGF(SNMP_MIB_DEBUG,("en search failed, short object identifier\n"));
\r
617 else if (node_type == MIB_NODE_SC)
\r
619 mib_scalar_node *sn;
\r
621 sn = (mib_scalar_node *)node;
\r
622 if ((ident_len == 1) && (*ident == 0))
\r
624 np->ident_len = ident_len;
\r
626 return (struct mib_node*)sn;
\r
630 /* search failed, short object identifier (nosuchname) */
\r
631 LWIP_DEBUGF(SNMP_MIB_DEBUG,("search failed, invalid object identifier length\n"));
\r
637 /* unknown node_type */
\r
638 LWIP_DEBUGF(SNMP_MIB_DEBUG,("search failed node_type %"U16_F" unkown\n",(u16_t)node_type));
\r
642 /* done, found nothing */
\r
643 LWIP_DEBUGF(SNMP_MIB_DEBUG,("search failed node==%p\n",(void*)node));
\r
648 * Test table for presence of at least one table entry.
\r
651 empty_table(struct mib_node *node)
\r
658 node_type = node->node_type;
\r
659 if (node_type == MIB_NODE_LR)
\r
661 struct mib_list_rootnode *lrn;
\r
662 lrn = (struct mib_list_rootnode *)node;
\r
663 if ((lrn->count == 0) || (lrn->head == NULL))
\r
668 else if ((node_type == MIB_NODE_AR) || (node_type == MIB_NODE_RA))
\r
670 struct mib_array_node *an;
\r
671 an = (struct mib_array_node *)node;
\r
672 if ((an->maxlength == 0) || (an->nptr == NULL))
\r
677 else if (node_type == MIB_NODE_EX)
\r
679 struct mib_external_node *en;
\r
680 en = (struct mib_external_node *)node;
\r
681 if (en->tree_levels == 0)
\r
694 snmp_expand_tree(struct mib_node *node, u8_t ident_len, s32_t *ident, struct snmp_obj_id *oidret)
\r
696 u8_t node_type, ext_level, climb_tree;
\r
699 /* reset node stack */
\r
700 node_stack_cnt = 0;
\r
701 while (node != NULL)
\r
704 node_type = node->node_type;
\r
705 if ((node_type == MIB_NODE_AR) || (node_type == MIB_NODE_RA))
\r
707 struct mib_array_node *an;
\r
710 /* array node (internal ROM or RAM, fixed length) */
\r
711 an = (struct mib_array_node *)node;
\r
715 while ((i < an->maxlength) && (an->objid[i] < *ident))
\r
719 if (i < an->maxlength)
\r
721 LWIP_DEBUGF(SNMP_MIB_DEBUG,("an->objid[%"U16_F"]==%"S32_F" *ident==%"S32_F"\n",i,an->objid[i],*ident));
\r
722 /* add identifier to oidret */
\r
723 oidret->id[oidret->len] = an->objid[i];
\r
726 if (an->nptr[i] == NULL)
\r
728 LWIP_DEBUGF(SNMP_MIB_DEBUG,("leaf node\n"));
\r
729 /* leaf node (e.g. in a fixed size table) */
\r
730 if (an->objid[i] > *ident)
\r
732 return (struct mib_node*)an;
\r
734 else if ((i + 1) < an->maxlength)
\r
736 /* an->objid[i] == *ident */
\r
738 oidret->id[oidret->len] = an->objid[i + 1];
\r
740 return (struct mib_node*)an;
\r
744 /* (i + 1) == an->maxlength */
\r
752 struct nse cur_node;
\r
754 LWIP_DEBUGF(SNMP_MIB_DEBUG,("non-leaf node\n"));
\r
755 /* non-leaf, store right child ptr and id */
\r
757 while ((j < an->maxlength) && (empty_table(an->nptr[j])))
\r
761 if (j < an->maxlength)
\r
763 cur_node.r_ptr = an->nptr[j];
\r
764 cur_node.r_id = an->objid[j];
\r
769 cur_node.r_ptr = NULL;
\r
771 push_node(&cur_node);
\r
772 if (an->objid[i] == *ident)
\r
779 /* an->objid[i] < *ident */
\r
782 /* follow next child pointer */
\r
783 node = an->nptr[i];
\r
788 /* i == an->maxlength */
\r
795 /* ident_len == 0, complete with leftmost '.thing' */
\r
797 while ((j < an->maxlength) && empty_table(an->nptr[j]))
\r
801 if (j < an->maxlength)
\r
803 LWIP_DEBUGF(SNMP_MIB_DEBUG,("left an->objid[j]==%"S32_F"\n",an->objid[j]));
\r
804 oidret->id[oidret->len] = an->objid[j];
\r
806 if (an->nptr[j] == NULL)
\r
809 return (struct mib_node*)an;
\r
813 /* no leaf, continue */
\r
814 node = an->nptr[j];
\r
819 /* j == an->maxlength */
\r
824 else if(node_type == MIB_NODE_LR)
\r
826 struct mib_list_rootnode *lrn;
\r
827 struct mib_list_node *ln;
\r
829 /* list root node (internal 'RAM', variable length) */
\r
830 lrn = (struct mib_list_rootnode *)node;
\r
834 /* iterate over list, head to tail */
\r
835 while ((ln != NULL) && (ln->objid < *ident))
\r
841 LWIP_DEBUGF(SNMP_MIB_DEBUG,("ln->objid==%"S32_F" *ident==%"S32_F"\n",ln->objid,*ident));
\r
842 oidret->id[oidret->len] = ln->objid;
\r
844 if (ln->nptr == NULL)
\r
847 if (ln->objid > *ident)
\r
849 return (struct mib_node*)lrn;
\r
851 else if (ln->next != NULL)
\r
853 /* ln->objid == *ident */
\r
855 oidret->id[oidret->len] = ln->next->objid;
\r
857 return (struct mib_node*)lrn;
\r
861 /* ln->next == NULL */
\r
868 struct mib_list_node *jn;
\r
869 struct nse cur_node;
\r
871 /* non-leaf, store right child ptr and id */
\r
873 while ((jn != NULL) && empty_table(jn->nptr))
\r
879 cur_node.r_ptr = jn->nptr;
\r
880 cur_node.r_id = jn->objid;
\r
885 cur_node.r_ptr = NULL;
\r
887 push_node(&cur_node);
\r
888 if (ln->objid == *ident)
\r
895 /* ln->objid < *ident */
\r
898 /* follow next child pointer */
\r
911 struct mib_list_node *jn;
\r
912 /* ident_len == 0, complete with leftmost '.thing' */
\r
914 while ((jn != NULL) && empty_table(jn->nptr))
\r
920 LWIP_DEBUGF(SNMP_MIB_DEBUG,("left jn->objid==%"S32_F"\n",jn->objid));
\r
921 oidret->id[oidret->len] = jn->objid;
\r
923 if (jn->nptr == NULL)
\r
926 LWIP_DEBUGF(SNMP_MIB_DEBUG,("jn->nptr == NULL\n"));
\r
927 return (struct mib_node*)lrn;
\r
931 /* no leaf, continue */
\r
942 else if(node_type == MIB_NODE_EX)
\r
944 struct mib_external_node *en;
\r
947 /* external node (addressing and access via functions) */
\r
948 en = (struct mib_external_node *)node;
\r
954 len = en->level_length(en->addr_inf,ext_level);
\r
955 while ((i < len) && (en->ident_cmp(en->addr_inf,ext_level,i,*ident) < 0))
\r
961 /* add identifier to oidret */
\r
962 en->get_objid(en->addr_inf,ext_level,i,&ex_id);
\r
963 LWIP_DEBUGF(SNMP_MIB_DEBUG,("en->objid[%"U16_F"]==%"S32_F" *ident==%"S32_F"\n",i,ex_id,*ident));
\r
964 oidret->id[oidret->len] = ex_id;
\r
967 if ((ext_level + 1) == en->tree_levels)
\r
969 LWIP_DEBUGF(SNMP_MIB_DEBUG,("leaf node\n"));
\r
971 if (ex_id > *ident)
\r
973 return (struct mib_node*)en;
\r
975 else if ((i + 1) < len)
\r
977 /* ex_id == *ident */
\r
978 en->get_objid(en->addr_inf,ext_level,i + 1,&ex_id);
\r
980 oidret->id[oidret->len] = ex_id;
\r
982 return (struct mib_node*)en;
\r
986 /* (i + 1) == len */
\r
994 struct nse cur_node;
\r
996 LWIP_DEBUGF(SNMP_MIB_DEBUG,("non-leaf node\n"));
\r
997 /* non-leaf, store right child ptr and id */
\r
1001 /* right node is the current external node */
\r
1002 cur_node.r_ptr = node;
\r
1003 en->get_objid(en->addr_inf,ext_level,j,&cur_node.r_id);
\r
1004 cur_node.r_nl = ext_level + 1;
\r
1008 cur_node.r_ptr = NULL;
\r
1010 push_node(&cur_node);
\r
1011 if (en->ident_cmp(en->addr_inf,ext_level,i,*ident) == 0)
\r
1018 /* external id < *ident */
\r
1021 /* proceed to child */
\r
1027 /* i == len (en->level_len()) */
\r
1033 /* ident_len == 0, complete with leftmost '.thing' */
\r
1034 en->get_objid(en->addr_inf,ext_level,0,&ex_id);
\r
1035 LWIP_DEBUGF(SNMP_MIB_DEBUG,("left en->objid==%"S32_F"\n",ex_id));
\r
1036 oidret->id[oidret->len] = ex_id;
\r
1038 if ((ext_level + 1) == en->tree_levels)
\r
1041 LWIP_DEBUGF(SNMP_MIB_DEBUG,("(ext_level + 1) == en->tree_levels\n"));
\r
1042 return (struct mib_node*)en;
\r
1046 /* no leaf, proceed to child */
\r
1051 else if(node_type == MIB_NODE_SC)
\r
1053 mib_scalar_node *sn;
\r
1056 sn = (mib_scalar_node *)node;
\r
1057 if (ident_len > 0)
\r
1064 /* ident_len == 0, complete object identifier */
\r
1065 oidret->id[oidret->len] = 0;
\r
1068 LWIP_DEBUGF(SNMP_MIB_DEBUG,("completed scalar leaf\n"));
\r
1069 return (struct mib_node*)sn;
\r
1074 /* unknown/unhandled node_type */
\r
1075 LWIP_DEBUGF(SNMP_MIB_DEBUG,("expand failed node_type %"U16_F" unkown\n",(u16_t)node_type));
\r
1083 /* find right child ptr */
\r
1084 child.r_ptr = NULL;
\r
1087 while ((node_stack_cnt > 0) && (child.r_ptr == NULL))
\r
1090 /* trim returned oid */
\r
1093 if (child.r_ptr != NULL)
\r
1095 /* incoming ident is useless beyond this point */
\r
1097 oidret->id[oidret->len] = child.r_id;
\r
1099 node = child.r_ptr;
\r
1100 ext_level = child.r_nl;
\r
1104 /* tree ends here ... */
\r
1105 LWIP_DEBUGF(SNMP_MIB_DEBUG,("expand failed, tree ends here\n"));
\r
1110 /* done, found nothing */
\r
1111 LWIP_DEBUGF(SNMP_MIB_DEBUG,("expand failed node==%p\n",(void*)node));
\r
1116 * Test object identifier for the iso.org.dod.internet prefix.
\r
1118 * @param ident_len the length of the supplied object identifier
\r
1119 * @param ident points to the array of sub identifiers
\r
1120 * @return 1 if it matches, 0 otherwise
\r
1123 snmp_iso_prefix_tst(u8_t ident_len, s32_t *ident)
\r
1125 if ((ident_len > 3) &&
\r
1126 (ident[0] == 1) && (ident[1] == 3) &&
\r
1127 (ident[2] == 6) && (ident[3] == 1))
\r
1138 * Expands object identifier to the iso.org.dod.internet
\r
1139 * prefix for use in getnext operation.
\r
1141 * @param ident_len the length of the supplied object identifier
\r
1142 * @param ident points to the array of sub identifiers
\r
1143 * @param oidret points to returned expanded object identifier
\r
1144 * @return 1 if it matches, 0 otherwise
\r
1146 * @note ident_len 0 is allowed, expanding to the first known object id!!
\r
1149 snmp_iso_prefix_expand(u8_t ident_len, s32_t *ident, struct snmp_obj_id *oidret)
\r
1151 const s32_t *prefix_ptr;
\r
1156 prefix_ptr = &prefix[0];
\r
1157 ret_ptr = &oidret->id[0];
\r
1158 ident_len = ((ident_len < 4)?ident_len:4);
\r
1159 while ((i < ident_len) && ((*ident) <= (*prefix_ptr)))
\r
1161 *ret_ptr++ = *prefix_ptr++;
\r
1165 if (i == ident_len)
\r
1167 /* match, complete missing bits */
\r
1170 *ret_ptr++ = *prefix_ptr++;
\r
1178 /* i != ident_len */
\r
1183 #endif /* LWIP_SNMP */
\r