- Fix the stupid mess we created when making this from the cmake branch
[reactos.git] / lib / drivers / lwip / src / core / snmp / mib_structs.c
1 /**
2 * @file
3 * MIB tree access/construction functions.
4 */
5
6 /*
7 * Copyright (c) 2006 Axon Digital Design B.V., The Netherlands.
8 * All rights reserved.
9 *
10 * Redistribution and use in source and binary forms, with or without modification,
11 * are permitted provided that the following conditions are met:
12 *
13 * 1. Redistributions of source code must retain the above copyright notice,
14 * this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright notice,
16 * this list of conditions and the following disclaimer in the documentation
17 * and/or other materials provided with the distribution.
18 * 3. The name of the author may not be used to endorse or promote products
19 * derived from this software without specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
22 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
23 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
24 * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
25 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
26 * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
29 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
30 * OF SUCH DAMAGE.
31 *
32 * Author: Christiaan Simons <christiaan.simons@axon.tv>
33 */
34
35 #include "lwip/opt.h"
36
37 #if LWIP_SNMP /* don't build if not configured for use in lwipopts.h */
38
39 #include "lwip/snmp_structs.h"
40 #include "lwip/memp.h"
41 #include "lwip/netif.h"
42
43 /** .iso.org.dod.internet address prefix, @see snmp_iso_*() */
44 const s32_t prefix[4] = {1, 3, 6, 1};
45
46 #define NODE_STACK_SIZE (LWIP_SNMP_OBJ_ID_LEN)
47 /** node stack entry (old news?) */
48 struct nse
49 {
50 /** right child */
51 struct mib_node* r_ptr;
52 /** right child identifier */
53 s32_t r_id;
54 /** right child next level */
55 u8_t r_nl;
56 };
57 static u8_t node_stack_cnt;
58 static struct nse node_stack[NODE_STACK_SIZE];
59
60 /**
61 * Pushes nse struct onto stack.
62 */
63 static void
64 push_node(struct nse* node)
65 {
66 LWIP_ASSERT("node_stack_cnt < NODE_STACK_SIZE",node_stack_cnt < NODE_STACK_SIZE);
67 LWIP_DEBUGF(SNMP_MIB_DEBUG,("push_node() node=%p id=%"S32_F"\n",(void*)(node->r_ptr),node->r_id));
68 if (node_stack_cnt < NODE_STACK_SIZE)
69 {
70 node_stack[node_stack_cnt] = *node;
71 node_stack_cnt++;
72 }
73 }
74
75 /**
76 * Pops nse struct from stack.
77 */
78 static void
79 pop_node(struct nse* node)
80 {
81 if (node_stack_cnt > 0)
82 {
83 node_stack_cnt--;
84 *node = node_stack[node_stack_cnt];
85 }
86 LWIP_DEBUGF(SNMP_MIB_DEBUG,("pop_node() node=%p id=%"S32_F"\n",(void *)(node->r_ptr),node->r_id));
87 }
88
89 /**
90 * Conversion from ifIndex to lwIP netif
91 * @param ifindex is a s32_t object sub-identifier
92 * @param netif points to returned netif struct pointer
93 */
94 void
95 snmp_ifindextonetif(s32_t ifindex, struct netif **netif)
96 {
97 struct netif *nif = netif_list;
98 s32_t i, ifidx;
99
100 ifidx = ifindex - 1;
101 i = 0;
102 while ((nif != NULL) && (i < ifidx))
103 {
104 nif = nif->next;
105 i++;
106 }
107 *netif = nif;
108 }
109
110 /**
111 * Conversion from lwIP netif to ifIndex
112 * @param netif points to a netif struct
113 * @param ifidx points to s32_t object sub-identifier
114 */
115 void
116 snmp_netiftoifindex(struct netif *netif, s32_t *ifidx)
117 {
118 struct netif *nif = netif_list;
119 u16_t i;
120
121 i = 0;
122 while ((nif != NULL) && (nif != netif))
123 {
124 nif = nif->next;
125 i++;
126 }
127 *ifidx = i+1;
128 }
129
130 /**
131 * Conversion from oid to lwIP ip_addr
132 * @param ident points to s32_t ident[4] input
133 * @param ip points to output struct
134 */
135 void
136 snmp_oidtoip(s32_t *ident, ip_addr_t *ip)
137 {
138 IP4_ADDR(ip, ident[0], ident[1], ident[2], ident[3]);
139 }
140
141 /**
142 * Conversion from lwIP ip_addr to oid
143 * @param ip points to input struct
144 * @param ident points to s32_t ident[4] output
145 */
146 void
147 snmp_iptooid(ip_addr_t *ip, s32_t *ident)
148 {
149 ident[0] = ip4_addr1(ip);
150 ident[1] = ip4_addr2(ip);
151 ident[2] = ip4_addr3(ip);
152 ident[3] = ip4_addr4(ip);
153 }
154
155 struct mib_list_node *
156 snmp_mib_ln_alloc(s32_t id)
157 {
158 struct mib_list_node *ln;
159
160 ln = (struct mib_list_node *)memp_malloc(MEMP_SNMP_NODE);
161 if (ln != NULL)
162 {
163 ln->prev = NULL;
164 ln->next = NULL;
165 ln->objid = id;
166 ln->nptr = NULL;
167 }
168 return ln;
169 }
170
171 void
172 snmp_mib_ln_free(struct mib_list_node *ln)
173 {
174 memp_free(MEMP_SNMP_NODE, ln);
175 }
176
177 struct mib_list_rootnode *
178 snmp_mib_lrn_alloc(void)
179 {
180 struct mib_list_rootnode *lrn;
181
182 lrn = (struct mib_list_rootnode*)memp_malloc(MEMP_SNMP_ROOTNODE);
183 if (lrn != NULL)
184 {
185 lrn->get_object_def = noleafs_get_object_def;
186 lrn->get_value = noleafs_get_value;
187 lrn->set_test = noleafs_set_test;
188 lrn->set_value = noleafs_set_value;
189 lrn->node_type = MIB_NODE_LR;
190 lrn->maxlength = 0;
191 lrn->head = NULL;
192 lrn->tail = NULL;
193 lrn->count = 0;
194 }
195 return lrn;
196 }
197
198 void
199 snmp_mib_lrn_free(struct mib_list_rootnode *lrn)
200 {
201 memp_free(MEMP_SNMP_ROOTNODE, lrn);
202 }
203
204 /**
205 * Inserts node in idx list in a sorted
206 * (ascending order) fashion and
207 * allocates the node if needed.
208 *
209 * @param rn points to the root node
210 * @param objid is the object sub identifier
211 * @param insn points to a pointer to the inserted node
212 * used for constructing the tree.
213 * @return -1 if failed, 1 if inserted, 2 if present.
214 */
215 s8_t
216 snmp_mib_node_insert(struct mib_list_rootnode *rn, s32_t objid, struct mib_list_node **insn)
217 {
218 struct mib_list_node *nn;
219 s8_t insert;
220
221 LWIP_ASSERT("rn != NULL",rn != NULL);
222
223 /* -1 = malloc failure, 0 = not inserted, 1 = inserted, 2 = was present */
224 insert = 0;
225 if (rn->head == NULL)
226 {
227 /* empty list, add first node */
228 LWIP_DEBUGF(SNMP_MIB_DEBUG,("alloc empty list objid==%"S32_F"\n",objid));
229 nn = snmp_mib_ln_alloc(objid);
230 if (nn != NULL)
231 {
232 rn->head = nn;
233 rn->tail = nn;
234 *insn = nn;
235 insert = 1;
236 }
237 else
238 {
239 insert = -1;
240 }
241 }
242 else
243 {
244 struct mib_list_node *n;
245 /* at least one node is present */
246 n = rn->head;
247 while ((n != NULL) && (insert == 0))
248 {
249 if (n->objid == objid)
250 {
251 /* node is already there */
252 LWIP_DEBUGF(SNMP_MIB_DEBUG,("node already there objid==%"S32_F"\n",objid));
253 *insn = n;
254 insert = 2;
255 }
256 else if (n->objid < objid)
257 {
258 if (n->next == NULL)
259 {
260 /* alloc and insert at the tail */
261 LWIP_DEBUGF(SNMP_MIB_DEBUG,("alloc ins tail objid==%"S32_F"\n",objid));
262 nn = snmp_mib_ln_alloc(objid);
263 if (nn != NULL)
264 {
265 nn->next = NULL;
266 nn->prev = n;
267 n->next = nn;
268 rn->tail = nn;
269 *insn = nn;
270 insert = 1;
271 }
272 else
273 {
274 /* insertion failure */
275 insert = -1;
276 }
277 }
278 else
279 {
280 /* there's more to explore: traverse list */
281 LWIP_DEBUGF(SNMP_MIB_DEBUG,("traverse list\n"));
282 n = n->next;
283 }
284 }
285 else
286 {
287 /* n->objid > objid */
288 /* alloc and insert between n->prev and n */
289 LWIP_DEBUGF(SNMP_MIB_DEBUG,("alloc ins n->prev, objid==%"S32_F", n\n",objid));
290 nn = snmp_mib_ln_alloc(objid);
291 if (nn != NULL)
292 {
293 if (n->prev == NULL)
294 {
295 /* insert at the head */
296 nn->next = n;
297 nn->prev = NULL;
298 rn->head = nn;
299 n->prev = nn;
300 }
301 else
302 {
303 /* insert in the middle */
304 nn->next = n;
305 nn->prev = n->prev;
306 n->prev->next = nn;
307 n->prev = nn;
308 }
309 *insn = nn;
310 insert = 1;
311 }
312 else
313 {
314 /* insertion failure */
315 insert = -1;
316 }
317 }
318 }
319 }
320 if (insert == 1)
321 {
322 rn->count += 1;
323 }
324 LWIP_ASSERT("insert != 0",insert != 0);
325 return insert;
326 }
327
328 /**
329 * Finds node in idx list and returns deletion mark.
330 *
331 * @param rn points to the root node
332 * @param objid is the object sub identifier
333 * @param fn returns pointer to found node
334 * @return 0 if not found, 1 if deletable,
335 * 2 can't delete (2 or more children), 3 not a list_node
336 */
337 s8_t
338 snmp_mib_node_find(struct mib_list_rootnode *rn, s32_t objid, struct mib_list_node **fn)
339 {
340 s8_t fc;
341 struct mib_list_node *n;
342
343 LWIP_ASSERT("rn != NULL",rn != NULL);
344 n = rn->head;
345 while ((n != NULL) && (n->objid != objid))
346 {
347 n = n->next;
348 }
349 if (n == NULL)
350 {
351 fc = 0;
352 }
353 else if (n->nptr == NULL)
354 {
355 /* leaf, can delete node */
356 fc = 1;
357 }
358 else
359 {
360 struct mib_list_rootnode *r;
361
362 if (n->nptr->node_type == MIB_NODE_LR)
363 {
364 r = (struct mib_list_rootnode *)n->nptr;
365 if (r->count > 1)
366 {
367 /* can't delete node */
368 fc = 2;
369 }
370 else
371 {
372 /* count <= 1, can delete node */
373 fc = 1;
374 }
375 }
376 else
377 {
378 /* other node type */
379 fc = 3;
380 }
381 }
382 *fn = n;
383 return fc;
384 }
385
386 /**
387 * Removes node from idx list
388 * if it has a single child left.
389 *
390 * @param rn points to the root node
391 * @param n points to the node to delete
392 * @return the nptr to be freed by caller
393 */
394 struct mib_list_rootnode *
395 snmp_mib_node_delete(struct mib_list_rootnode *rn, struct mib_list_node *n)
396 {
397 struct mib_list_rootnode *next;
398
399 LWIP_ASSERT("rn != NULL",rn != NULL);
400 LWIP_ASSERT("n != NULL",n != NULL);
401
402 /* caller must remove this sub-tree */
403 next = (struct mib_list_rootnode*)(n->nptr);
404 rn->count -= 1;
405
406 if (n == rn->head)
407 {
408 rn->head = n->next;
409 if (n->next != NULL)
410 {
411 /* not last node, new list begin */
412 n->next->prev = NULL;
413 }
414 }
415 else if (n == rn->tail)
416 {
417 rn->tail = n->prev;
418 if (n->prev != NULL)
419 {
420 /* not last node, new list end */
421 n->prev->next = NULL;
422 }
423 }
424 else
425 {
426 /* node must be in the middle */
427 n->prev->next = n->next;
428 n->next->prev = n->prev;
429 }
430 LWIP_DEBUGF(SNMP_MIB_DEBUG,("free list objid==%"S32_F"\n",n->objid));
431 snmp_mib_ln_free(n);
432 if (rn->count == 0)
433 {
434 rn->head = NULL;
435 rn->tail = NULL;
436 }
437 return next;
438 }
439
440
441
442 /**
443 * Searches tree for the supplied (scalar?) object identifier.
444 *
445 * @param node points to the root of the tree ('.internet')
446 * @param ident_len the length of the supplied object identifier
447 * @param ident points to the array of sub identifiers
448 * @param np points to the found object instance (return)
449 * @return pointer to the requested parent (!) node if success, NULL otherwise
450 */
451 struct mib_node *
452 snmp_search_tree(struct mib_node *node, u8_t ident_len, s32_t *ident, struct snmp_name_ptr *np)
453 {
454 u8_t node_type, ext_level;
455
456 ext_level = 0;
457 LWIP_DEBUGF(SNMP_MIB_DEBUG,("node==%p *ident==%"S32_F"\n",(void*)node,*ident));
458 while (node != NULL)
459 {
460 node_type = node->node_type;
461 if ((node_type == MIB_NODE_AR) || (node_type == MIB_NODE_RA))
462 {
463 struct mib_array_node *an;
464 u16_t i;
465
466 if (ident_len > 0)
467 {
468 /* array node (internal ROM or RAM, fixed length) */
469 an = (struct mib_array_node *)node;
470 i = 0;
471 while ((i < an->maxlength) && (an->objid[i] != *ident))
472 {
473 i++;
474 }
475 if (i < an->maxlength)
476 {
477 /* found it, if available proceed to child, otherwise inspect leaf */
478 LWIP_DEBUGF(SNMP_MIB_DEBUG,("an->objid[%"U16_F"]==%"S32_F" *ident==%"S32_F"\n",i,an->objid[i],*ident));
479 if (an->nptr[i] == NULL)
480 {
481 /* a scalar leaf OR table,
482 inspect remaining instance number / table index */
483 np->ident_len = ident_len;
484 np->ident = ident;
485 return (struct mib_node*)an;
486 }
487 else
488 {
489 /* follow next child pointer */
490 ident++;
491 ident_len--;
492 node = an->nptr[i];
493 }
494 }
495 else
496 {
497 /* search failed, identifier mismatch (nosuchname) */
498 LWIP_DEBUGF(SNMP_MIB_DEBUG,("an search failed *ident==%"S32_F"\n",*ident));
499 return NULL;
500 }
501 }
502 else
503 {
504 /* search failed, short object identifier (nosuchname) */
505 LWIP_DEBUGF(SNMP_MIB_DEBUG,("an search failed, short object identifier\n"));
506 return NULL;
507 }
508 }
509 else if(node_type == MIB_NODE_LR)
510 {
511 struct mib_list_rootnode *lrn;
512 struct mib_list_node *ln;
513
514 if (ident_len > 0)
515 {
516 /* list root node (internal 'RAM', variable length) */
517 lrn = (struct mib_list_rootnode *)node;
518 ln = lrn->head;
519 /* iterate over list, head to tail */
520 while ((ln != NULL) && (ln->objid != *ident))
521 {
522 ln = ln->next;
523 }
524 if (ln != NULL)
525 {
526 /* found it, proceed to child */;
527 LWIP_DEBUGF(SNMP_MIB_DEBUG,("ln->objid==%"S32_F" *ident==%"S32_F"\n",ln->objid,*ident));
528 if (ln->nptr == NULL)
529 {
530 np->ident_len = ident_len;
531 np->ident = ident;
532 return (struct mib_node*)lrn;
533 }
534 else
535 {
536 /* follow next child pointer */
537 ident_len--;
538 ident++;
539 node = ln->nptr;
540 }
541 }
542 else
543 {
544 /* search failed */
545 LWIP_DEBUGF(SNMP_MIB_DEBUG,("ln search failed *ident==%"S32_F"\n",*ident));
546 return NULL;
547 }
548 }
549 else
550 {
551 /* search failed, short object identifier (nosuchname) */
552 LWIP_DEBUGF(SNMP_MIB_DEBUG,("ln search failed, short object identifier\n"));
553 return NULL;
554 }
555 }
556 else if(node_type == MIB_NODE_EX)
557 {
558 struct mib_external_node *en;
559 u16_t i, len;
560
561 if (ident_len > 0)
562 {
563 /* external node (addressing and access via functions) */
564 en = (struct mib_external_node *)node;
565
566 i = 0;
567 len = en->level_length(en->addr_inf,ext_level);
568 while ((i < len) && (en->ident_cmp(en->addr_inf,ext_level,i,*ident) != 0))
569 {
570 i++;
571 }
572 if (i < len)
573 {
574 s32_t debug_id;
575
576 en->get_objid(en->addr_inf,ext_level,i,&debug_id);
577 LWIP_DEBUGF(SNMP_MIB_DEBUG,("en->objid==%"S32_F" *ident==%"S32_F"\n",debug_id,*ident));
578 if ((ext_level + 1) == en->tree_levels)
579 {
580 np->ident_len = ident_len;
581 np->ident = ident;
582 return (struct mib_node*)en;
583 }
584 else
585 {
586 /* found it, proceed to child */
587 ident_len--;
588 ident++;
589 ext_level++;
590 }
591 }
592 else
593 {
594 /* search failed */
595 LWIP_DEBUGF(SNMP_MIB_DEBUG,("en search failed *ident==%"S32_F"\n",*ident));
596 return NULL;
597 }
598 }
599 else
600 {
601 /* search failed, short object identifier (nosuchname) */
602 LWIP_DEBUGF(SNMP_MIB_DEBUG,("en search failed, short object identifier\n"));
603 return NULL;
604 }
605 }
606 else if (node_type == MIB_NODE_SC)
607 {
608 mib_scalar_node *sn;
609
610 sn = (mib_scalar_node *)node;
611 if ((ident_len == 1) && (*ident == 0))
612 {
613 np->ident_len = ident_len;
614 np->ident = ident;
615 return (struct mib_node*)sn;
616 }
617 else
618 {
619 /* search failed, short object identifier (nosuchname) */
620 LWIP_DEBUGF(SNMP_MIB_DEBUG,("search failed, invalid object identifier length\n"));
621 return NULL;
622 }
623 }
624 else
625 {
626 /* unknown node_type */
627 LWIP_DEBUGF(SNMP_MIB_DEBUG,("search failed node_type %"U16_F" unkown\n",(u16_t)node_type));
628 return NULL;
629 }
630 }
631 /* done, found nothing */
632 LWIP_DEBUGF(SNMP_MIB_DEBUG,("search failed node==%p\n",(void*)node));
633 return NULL;
634 }
635
636 /**
637 * Test table for presence of at least one table entry.
638 */
639 static u8_t
640 empty_table(struct mib_node *node)
641 {
642 u8_t node_type;
643 u8_t empty = 0;
644
645 if (node != NULL)
646 {
647 node_type = node->node_type;
648 if (node_type == MIB_NODE_LR)
649 {
650 struct mib_list_rootnode *lrn;
651 lrn = (struct mib_list_rootnode *)node;
652 if ((lrn->count == 0) || (lrn->head == NULL))
653 {
654 empty = 1;
655 }
656 }
657 else if ((node_type == MIB_NODE_AR) || (node_type == MIB_NODE_RA))
658 {
659 struct mib_array_node *an;
660 an = (struct mib_array_node *)node;
661 if ((an->maxlength == 0) || (an->nptr == NULL))
662 {
663 empty = 1;
664 }
665 }
666 else if (node_type == MIB_NODE_EX)
667 {
668 struct mib_external_node *en;
669 en = (struct mib_external_node *)node;
670 if (en->tree_levels == 0)
671 {
672 empty = 1;
673 }
674 }
675 }
676 return empty;
677 }
678
679 /**
680 * Tree expansion.
681 */
682 struct mib_node *
683 snmp_expand_tree(struct mib_node *node, u8_t ident_len, s32_t *ident, struct snmp_obj_id *oidret)
684 {
685 u8_t node_type, ext_level, climb_tree;
686
687 ext_level = 0;
688 /* reset node stack */
689 node_stack_cnt = 0;
690 while (node != NULL)
691 {
692 climb_tree = 0;
693 node_type = node->node_type;
694 if ((node_type == MIB_NODE_AR) || (node_type == MIB_NODE_RA))
695 {
696 struct mib_array_node *an;
697 u16_t i;
698
699 /* array node (internal ROM or RAM, fixed length) */
700 an = (struct mib_array_node *)node;
701 if (ident_len > 0)
702 {
703 i = 0;
704 while ((i < an->maxlength) && (an->objid[i] < *ident))
705 {
706 i++;
707 }
708 if (i < an->maxlength)
709 {
710 LWIP_DEBUGF(SNMP_MIB_DEBUG,("an->objid[%"U16_F"]==%"S32_F" *ident==%"S32_F"\n",i,an->objid[i],*ident));
711 /* add identifier to oidret */
712 oidret->id[oidret->len] = an->objid[i];
713 (oidret->len)++;
714
715 if (an->nptr[i] == NULL)
716 {
717 LWIP_DEBUGF(SNMP_MIB_DEBUG,("leaf node\n"));
718 /* leaf node (e.g. in a fixed size table) */
719 if (an->objid[i] > *ident)
720 {
721 return (struct mib_node*)an;
722 }
723 else if ((i + 1) < an->maxlength)
724 {
725 /* an->objid[i] == *ident */
726 (oidret->len)--;
727 oidret->id[oidret->len] = an->objid[i + 1];
728 (oidret->len)++;
729 return (struct mib_node*)an;
730 }
731 else
732 {
733 /* (i + 1) == an->maxlength */
734 (oidret->len)--;
735 climb_tree = 1;
736 }
737 }
738 else
739 {
740 u8_t j;
741 struct nse cur_node;
742
743 LWIP_DEBUGF(SNMP_MIB_DEBUG,("non-leaf node\n"));
744 /* non-leaf, store right child ptr and id */
745 LWIP_ASSERT("i < 0xff", i < 0xff);
746 j = (u8_t)i + 1;
747 while ((j < an->maxlength) && (empty_table(an->nptr[j])))
748 {
749 j++;
750 }
751 if (j < an->maxlength)
752 {
753 cur_node.r_ptr = an->nptr[j];
754 cur_node.r_id = an->objid[j];
755 cur_node.r_nl = 0;
756 }
757 else
758 {
759 cur_node.r_ptr = NULL;
760 }
761 push_node(&cur_node);
762 if (an->objid[i] == *ident)
763 {
764 ident_len--;
765 ident++;
766 }
767 else
768 {
769 /* an->objid[i] < *ident */
770 ident_len = 0;
771 }
772 /* follow next child pointer */
773 node = an->nptr[i];
774 }
775 }
776 else
777 {
778 /* i == an->maxlength */
779 climb_tree = 1;
780 }
781 }
782 else
783 {
784 u8_t j;
785 /* ident_len == 0, complete with leftmost '.thing' */
786 j = 0;
787 while ((j < an->maxlength) && empty_table(an->nptr[j]))
788 {
789 j++;
790 }
791 if (j < an->maxlength)
792 {
793 LWIP_DEBUGF(SNMP_MIB_DEBUG,("left an->objid[j]==%"S32_F"\n",an->objid[j]));
794 oidret->id[oidret->len] = an->objid[j];
795 (oidret->len)++;
796 if (an->nptr[j] == NULL)
797 {
798 /* leaf node */
799 return (struct mib_node*)an;
800 }
801 else
802 {
803 /* no leaf, continue */
804 node = an->nptr[j];
805 }
806 }
807 else
808 {
809 /* j == an->maxlength */
810 climb_tree = 1;
811 }
812 }
813 }
814 else if(node_type == MIB_NODE_LR)
815 {
816 struct mib_list_rootnode *lrn;
817 struct mib_list_node *ln;
818
819 /* list root node (internal 'RAM', variable length) */
820 lrn = (struct mib_list_rootnode *)node;
821 if (ident_len > 0)
822 {
823 ln = lrn->head;
824 /* iterate over list, head to tail */
825 while ((ln != NULL) && (ln->objid < *ident))
826 {
827 ln = ln->next;
828 }
829 if (ln != NULL)
830 {
831 LWIP_DEBUGF(SNMP_MIB_DEBUG,("ln->objid==%"S32_F" *ident==%"S32_F"\n",ln->objid,*ident));
832 oidret->id[oidret->len] = ln->objid;
833 (oidret->len)++;
834 if (ln->nptr == NULL)
835 {
836 /* leaf node */
837 if (ln->objid > *ident)
838 {
839 return (struct mib_node*)lrn;
840 }
841 else if (ln->next != NULL)
842 {
843 /* ln->objid == *ident */
844 (oidret->len)--;
845 oidret->id[oidret->len] = ln->next->objid;
846 (oidret->len)++;
847 return (struct mib_node*)lrn;
848 }
849 else
850 {
851 /* ln->next == NULL */
852 (oidret->len)--;
853 climb_tree = 1;
854 }
855 }
856 else
857 {
858 struct mib_list_node *jn;
859 struct nse cur_node;
860
861 /* non-leaf, store right child ptr and id */
862 jn = ln->next;
863 while ((jn != NULL) && empty_table(jn->nptr))
864 {
865 jn = jn->next;
866 }
867 if (jn != NULL)
868 {
869 cur_node.r_ptr = jn->nptr;
870 cur_node.r_id = jn->objid;
871 cur_node.r_nl = 0;
872 }
873 else
874 {
875 cur_node.r_ptr = NULL;
876 }
877 push_node(&cur_node);
878 if (ln->objid == *ident)
879 {
880 ident_len--;
881 ident++;
882 }
883 else
884 {
885 /* ln->objid < *ident */
886 ident_len = 0;
887 }
888 /* follow next child pointer */
889 node = ln->nptr;
890 }
891
892 }
893 else
894 {
895 /* ln == NULL */
896 climb_tree = 1;
897 }
898 }
899 else
900 {
901 struct mib_list_node *jn;
902 /* ident_len == 0, complete with leftmost '.thing' */
903 jn = lrn->head;
904 while ((jn != NULL) && empty_table(jn->nptr))
905 {
906 jn = jn->next;
907 }
908 if (jn != NULL)
909 {
910 LWIP_DEBUGF(SNMP_MIB_DEBUG,("left jn->objid==%"S32_F"\n",jn->objid));
911 oidret->id[oidret->len] = jn->objid;
912 (oidret->len)++;
913 if (jn->nptr == NULL)
914 {
915 /* leaf node */
916 LWIP_DEBUGF(SNMP_MIB_DEBUG,("jn->nptr == NULL\n"));
917 return (struct mib_node*)lrn;
918 }
919 else
920 {
921 /* no leaf, continue */
922 node = jn->nptr;
923 }
924 }
925 else
926 {
927 /* jn == NULL */
928 climb_tree = 1;
929 }
930 }
931 }
932 else if(node_type == MIB_NODE_EX)
933 {
934 struct mib_external_node *en;
935 s32_t ex_id;
936
937 /* external node (addressing and access via functions) */
938 en = (struct mib_external_node *)node;
939 if (ident_len > 0)
940 {
941 u16_t i, len;
942
943 i = 0;
944 len = en->level_length(en->addr_inf,ext_level);
945 while ((i < len) && (en->ident_cmp(en->addr_inf,ext_level,i,*ident) < 0))
946 {
947 i++;
948 }
949 if (i < len)
950 {
951 /* add identifier to oidret */
952 en->get_objid(en->addr_inf,ext_level,i,&ex_id);
953 LWIP_DEBUGF(SNMP_MIB_DEBUG,("en->objid[%"U16_F"]==%"S32_F" *ident==%"S32_F"\n",i,ex_id,*ident));
954 oidret->id[oidret->len] = ex_id;
955 (oidret->len)++;
956
957 if ((ext_level + 1) == en->tree_levels)
958 {
959 LWIP_DEBUGF(SNMP_MIB_DEBUG,("leaf node\n"));
960 /* leaf node */
961 if (ex_id > *ident)
962 {
963 return (struct mib_node*)en;
964 }
965 else if ((i + 1) < len)
966 {
967 /* ex_id == *ident */
968 en->get_objid(en->addr_inf,ext_level,i + 1,&ex_id);
969 (oidret->len)--;
970 oidret->id[oidret->len] = ex_id;
971 (oidret->len)++;
972 return (struct mib_node*)en;
973 }
974 else
975 {
976 /* (i + 1) == len */
977 (oidret->len)--;
978 climb_tree = 1;
979 }
980 }
981 else
982 {
983 u8_t j;
984 struct nse cur_node;
985
986 LWIP_DEBUGF(SNMP_MIB_DEBUG,("non-leaf node\n"));
987 /* non-leaf, store right child ptr and id */
988 LWIP_ASSERT("i < 0xff", i < 0xff);
989 j = (u8_t)i + 1;
990 if (j < len)
991 {
992 /* right node is the current external node */
993 cur_node.r_ptr = node;
994 en->get_objid(en->addr_inf,ext_level,j,&cur_node.r_id);
995 cur_node.r_nl = ext_level + 1;
996 }
997 else
998 {
999 cur_node.r_ptr = NULL;
1000 }
1001 push_node(&cur_node);
1002 if (en->ident_cmp(en->addr_inf,ext_level,i,*ident) == 0)
1003 {
1004 ident_len--;
1005 ident++;
1006 }
1007 else
1008 {
1009 /* external id < *ident */
1010 ident_len = 0;
1011 }
1012 /* proceed to child */
1013 ext_level++;
1014 }
1015 }
1016 else
1017 {
1018 /* i == len (en->level_len()) */
1019 climb_tree = 1;
1020 }
1021 }
1022 else
1023 {
1024 /* ident_len == 0, complete with leftmost '.thing' */
1025 en->get_objid(en->addr_inf,ext_level,0,&ex_id);
1026 LWIP_DEBUGF(SNMP_MIB_DEBUG,("left en->objid==%"S32_F"\n",ex_id));
1027 oidret->id[oidret->len] = ex_id;
1028 (oidret->len)++;
1029 if ((ext_level + 1) == en->tree_levels)
1030 {
1031 /* leaf node */
1032 LWIP_DEBUGF(SNMP_MIB_DEBUG,("(ext_level + 1) == en->tree_levels\n"));
1033 return (struct mib_node*)en;
1034 }
1035 else
1036 {
1037 /* no leaf, proceed to child */
1038 ext_level++;
1039 }
1040 }
1041 }
1042 else if(node_type == MIB_NODE_SC)
1043 {
1044 mib_scalar_node *sn;
1045
1046 /* scalar node */
1047 sn = (mib_scalar_node *)node;
1048 if (ident_len > 0)
1049 {
1050 /* at .0 */
1051 climb_tree = 1;
1052 }
1053 else
1054 {
1055 /* ident_len == 0, complete object identifier */
1056 oidret->id[oidret->len] = 0;
1057 (oidret->len)++;
1058 /* leaf node */
1059 LWIP_DEBUGF(SNMP_MIB_DEBUG,("completed scalar leaf\n"));
1060 return (struct mib_node*)sn;
1061 }
1062 }
1063 else
1064 {
1065 /* unknown/unhandled node_type */
1066 LWIP_DEBUGF(SNMP_MIB_DEBUG,("expand failed node_type %"U16_F" unkown\n",(u16_t)node_type));
1067 return NULL;
1068 }
1069
1070 if (climb_tree)
1071 {
1072 struct nse child;
1073
1074 /* find right child ptr */
1075 child.r_ptr = NULL;
1076 child.r_id = 0;
1077 child.r_nl = 0;
1078 while ((node_stack_cnt > 0) && (child.r_ptr == NULL))
1079 {
1080 pop_node(&child);
1081 /* trim returned oid */
1082 (oidret->len)--;
1083 }
1084 if (child.r_ptr != NULL)
1085 {
1086 /* incoming ident is useless beyond this point */
1087 ident_len = 0;
1088 oidret->id[oidret->len] = child.r_id;
1089 oidret->len++;
1090 node = child.r_ptr;
1091 ext_level = child.r_nl;
1092 }
1093 else
1094 {
1095 /* tree ends here ... */
1096 LWIP_DEBUGF(SNMP_MIB_DEBUG,("expand failed, tree ends here\n"));
1097 return NULL;
1098 }
1099 }
1100 }
1101 /* done, found nothing */
1102 LWIP_DEBUGF(SNMP_MIB_DEBUG,("expand failed node==%p\n",(void*)node));
1103 return NULL;
1104 }
1105
1106 /**
1107 * Test object identifier for the iso.org.dod.internet prefix.
1108 *
1109 * @param ident_len the length of the supplied object identifier
1110 * @param ident points to the array of sub identifiers
1111 * @return 1 if it matches, 0 otherwise
1112 */
1113 u8_t
1114 snmp_iso_prefix_tst(u8_t ident_len, s32_t *ident)
1115 {
1116 if ((ident_len > 3) &&
1117 (ident[0] == 1) && (ident[1] == 3) &&
1118 (ident[2] == 6) && (ident[3] == 1))
1119 {
1120 return 1;
1121 }
1122 else
1123 {
1124 return 0;
1125 }
1126 }
1127
1128 /**
1129 * Expands object identifier to the iso.org.dod.internet
1130 * prefix for use in getnext operation.
1131 *
1132 * @param ident_len the length of the supplied object identifier
1133 * @param ident points to the array of sub identifiers
1134 * @param oidret points to returned expanded object identifier
1135 * @return 1 if it matches, 0 otherwise
1136 *
1137 * @note ident_len 0 is allowed, expanding to the first known object id!!
1138 */
1139 u8_t
1140 snmp_iso_prefix_expand(u8_t ident_len, s32_t *ident, struct snmp_obj_id *oidret)
1141 {
1142 const s32_t *prefix_ptr;
1143 s32_t *ret_ptr;
1144 u8_t i;
1145
1146 i = 0;
1147 prefix_ptr = &prefix[0];
1148 ret_ptr = &oidret->id[0];
1149 ident_len = ((ident_len < 4)?ident_len:4);
1150 while ((i < ident_len) && ((*ident) <= (*prefix_ptr)))
1151 {
1152 *ret_ptr++ = *prefix_ptr++;
1153 ident++;
1154 i++;
1155 }
1156 if (i == ident_len)
1157 {
1158 /* match, complete missing bits */
1159 while (i < 4)
1160 {
1161 *ret_ptr++ = *prefix_ptr++;
1162 i++;
1163 }
1164 oidret->len = i;
1165 return 1;
1166 }
1167 else
1168 {
1169 /* i != ident_len */
1170 return 0;
1171 }
1172 }
1173
1174 #endif /* LWIP_SNMP */