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 (at) 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 */ 1175
