00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035 #include "lwip/opt.h"
00036
00037 #if LWIP_SNMP
00038
00039 #include "lwip/snmp_structs.h"
00040 #include "lwip/memp.h"
00041 #include "lwip/netif.h"
00042
00043
00044 const s32_t prefix[4] = {1, 3, 6, 1};
00045
00046 #define NODE_STACK_SIZE (LWIP_SNMP_OBJ_ID_LEN)
00047
00048 struct nse
00049 {
00050
00051 struct mib_node* r_ptr;
00052
00053 s32_t r_id;
00054
00055 u8_t r_nl;
00056 };
00057 static u8_t node_stack_cnt;
00058 static struct nse node_stack[NODE_STACK_SIZE];
00059
00060
00061
00062
00063 static void
00064 push_node(struct nse* node)
00065 {
00066 LWIP_ASSERT("node_stack_cnt < NODE_STACK_SIZE",node_stack_cnt < NODE_STACK_SIZE);
00067 LWIP_DEBUGF(SNMP_MIB_DEBUG,("push_node() node=%p id=%"S32_F"\n",(void*)(node->r_ptr),node->r_id));
00068 if (node_stack_cnt < NODE_STACK_SIZE)
00069 {
00070 node_stack[node_stack_cnt] = *node;
00071 node_stack_cnt++;
00072 }
00073 }
00074
00075
00076
00077
00078 static void
00079 pop_node(struct nse* node)
00080 {
00081 if (node_stack_cnt > 0)
00082 {
00083 node_stack_cnt--;
00084 *node = node_stack[node_stack_cnt];
00085 }
00086 LWIP_DEBUGF(SNMP_MIB_DEBUG,("pop_node() node=%p id=%"S32_F"\n",(void *)(node->r_ptr),node->r_id));
00087 }
00088
00089
00090
00091
00092
00093
00094 void
00095 snmp_ifindextonetif(s32_t ifindex, struct netif **netif)
00096 {
00097 struct netif *nif = netif_list;
00098 s32_t i, ifidx;
00099
00100 ifidx = ifindex - 1;
00101 i = 0;
00102 while ((nif != NULL) && (i < ifidx))
00103 {
00104 nif = nif->next;
00105 i++;
00106 }
00107 *netif = nif;
00108 }
00109
00110
00111
00112
00113
00114
00115 void
00116 snmp_netiftoifindex(struct netif *netif, s32_t *ifidx)
00117 {
00118 struct netif *nif = netif_list;
00119 u16_t i;
00120
00121 i = 0;
00122 while ((nif != NULL) && (nif != netif))
00123 {
00124 nif = nif->next;
00125 i++;
00126 }
00127 *ifidx = i+1;
00128 }
00129
00130
00131
00132
00133
00134
00135 void
00136 snmp_oidtoip(s32_t *ident, ip_addr_t *ip)
00137 {
00138 IP4_ADDR(ip, ident[0], ident[1], ident[2], ident[3]);
00139 }
00140
00141
00142
00143
00144
00145
00146 void
00147 snmp_iptooid(ip_addr_t *ip, s32_t *ident)
00148 {
00149 ident[0] = ip4_addr1(ip);
00150 ident[1] = ip4_addr2(ip);
00151 ident[2] = ip4_addr3(ip);
00152 ident[3] = ip4_addr4(ip);
00153 }
00154
00155 struct mib_list_node *
00156 snmp_mib_ln_alloc(s32_t id)
00157 {
00158 struct mib_list_node *ln;
00159
00160 ln = (struct mib_list_node *)memp_malloc(MEMP_SNMP_NODE);
00161 if (ln != NULL)
00162 {
00163 ln->prev = NULL;
00164 ln->next = NULL;
00165 ln->objid = id;
00166 ln->nptr = NULL;
00167 }
00168 return ln;
00169 }
00170
00171 void
00172 snmp_mib_ln_free(struct mib_list_node *ln)
00173 {
00174 memp_free(MEMP_SNMP_NODE, ln);
00175 }
00176
00177 struct mib_list_rootnode *
00178 snmp_mib_lrn_alloc(void)
00179 {
00180 struct mib_list_rootnode *lrn;
00181
00182 lrn = (struct mib_list_rootnode*)memp_malloc(MEMP_SNMP_ROOTNODE);
00183 if (lrn != NULL)
00184 {
00185 lrn->get_object_def = noleafs_get_object_def;
00186 lrn->get_value = noleafs_get_value;
00187 lrn->set_test = noleafs_set_test;
00188 lrn->set_value = noleafs_set_value;
00189 lrn->node_type = MIB_NODE_LR;
00190 lrn->maxlength = 0;
00191 lrn->head = NULL;
00192 lrn->tail = NULL;
00193 lrn->count = 0;
00194 }
00195 return lrn;
00196 }
00197
00198 void
00199 snmp_mib_lrn_free(struct mib_list_rootnode *lrn)
00200 {
00201 memp_free(MEMP_SNMP_ROOTNODE, lrn);
00202 }
00203
00204
00205
00206
00207
00208
00209
00210
00211
00212
00213
00214
00215 s8_t
00216 snmp_mib_node_insert(struct mib_list_rootnode *rn, s32_t objid, struct mib_list_node **insn)
00217 {
00218 struct mib_list_node *nn;
00219 s8_t insert;
00220
00221 LWIP_ASSERT("rn != NULL",rn != NULL);
00222
00223
00224 insert = 0;
00225 if (rn->head == NULL)
00226 {
00227
00228 LWIP_DEBUGF(SNMP_MIB_DEBUG,("alloc empty list objid==%"S32_F"\n",objid));
00229 nn = snmp_mib_ln_alloc(objid);
00230 if (nn != NULL)
00231 {
00232 rn->head = nn;
00233 rn->tail = nn;
00234 *insn = nn;
00235 insert = 1;
00236 }
00237 else
00238 {
00239 insert = -1;
00240 }
00241 }
00242 else
00243 {
00244 struct mib_list_node *n;
00245
00246 n = rn->head;
00247 while ((n != NULL) && (insert == 0))
00248 {
00249 if (n->objid == objid)
00250 {
00251
00252 LWIP_DEBUGF(SNMP_MIB_DEBUG,("node already there objid==%"S32_F"\n",objid));
00253 *insn = n;
00254 insert = 2;
00255 }
00256 else if (n->objid < objid)
00257 {
00258 if (n->next == NULL)
00259 {
00260
00261 LWIP_DEBUGF(SNMP_MIB_DEBUG,("alloc ins tail objid==%"S32_F"\n",objid));
00262 nn = snmp_mib_ln_alloc(objid);
00263 if (nn != NULL)
00264 {
00265 nn->next = NULL;
00266 nn->prev = n;
00267 n->next = nn;
00268 rn->tail = nn;
00269 *insn = nn;
00270 insert = 1;
00271 }
00272 else
00273 {
00274
00275 insert = -1;
00276 }
00277 }
00278 else
00279 {
00280
00281 LWIP_DEBUGF(SNMP_MIB_DEBUG,("traverse list\n"));
00282 n = n->next;
00283 }
00284 }
00285 else
00286 {
00287
00288
00289 LWIP_DEBUGF(SNMP_MIB_DEBUG,("alloc ins n->prev, objid==%"S32_F", n\n",objid));
00290 nn = snmp_mib_ln_alloc(objid);
00291 if (nn != NULL)
00292 {
00293 if (n->prev == NULL)
00294 {
00295
00296 nn->next = n;
00297 nn->prev = NULL;
00298 rn->head = nn;
00299 n->prev = nn;
00300 }
00301 else
00302 {
00303
00304 nn->next = n;
00305 nn->prev = n->prev;
00306 n->prev->next = nn;
00307 n->prev = nn;
00308 }
00309 *insn = nn;
00310 insert = 1;
00311 }
00312 else
00313 {
00314
00315 insert = -1;
00316 }
00317 }
00318 }
00319 }
00320 if (insert == 1)
00321 {
00322 rn->count += 1;
00323 }
00324 LWIP_ASSERT("insert != 0",insert != 0);
00325 return insert;
00326 }
00327
00328
00329
00330
00331
00332
00333
00334
00335
00336
00337 s8_t
00338 snmp_mib_node_find(struct mib_list_rootnode *rn, s32_t objid, struct mib_list_node **fn)
00339 {
00340 s8_t fc;
00341 struct mib_list_node *n;
00342
00343 LWIP_ASSERT("rn != NULL",rn != NULL);
00344 n = rn->head;
00345 while ((n != NULL) && (n->objid != objid))
00346 {
00347 n = n->next;
00348 }
00349 if (n == NULL)
00350 {
00351 fc = 0;
00352 }
00353 else if (n->nptr == NULL)
00354 {
00355
00356 fc = 1;
00357 }
00358 else
00359 {
00360 struct mib_list_rootnode *r;
00361
00362 if (n->nptr->node_type == MIB_NODE_LR)
00363 {
00364 r = (struct mib_list_rootnode *)n->nptr;
00365 if (r->count > 1)
00366 {
00367
00368 fc = 2;
00369 }
00370 else
00371 {
00372
00373 fc = 1;
00374 }
00375 }
00376 else
00377 {
00378
00379 fc = 3;
00380 }
00381 }
00382 *fn = n;
00383 return fc;
00384 }
00385
00386
00387
00388
00389
00390
00391
00392
00393
00394 struct mib_list_rootnode *
00395 snmp_mib_node_delete(struct mib_list_rootnode *rn, struct mib_list_node *n)
00396 {
00397 struct mib_list_rootnode *next;
00398
00399 LWIP_ASSERT("rn != NULL",rn != NULL);
00400 LWIP_ASSERT("n != NULL",n != NULL);
00401
00402
00403 next = (struct mib_list_rootnode*)(n->nptr);
00404 rn->count -= 1;
00405
00406 if (n == rn->head)
00407 {
00408 rn->head = n->next;
00409 if (n->next != NULL)
00410 {
00411
00412 n->next->prev = NULL;
00413 }
00414 }
00415 else if (n == rn->tail)
00416 {
00417 rn->tail = n->prev;
00418 if (n->prev != NULL)
00419 {
00420
00421 n->prev->next = NULL;
00422 }
00423 }
00424 else
00425 {
00426
00427 n->prev->next = n->next;
00428 n->next->prev = n->prev;
00429 }
00430 LWIP_DEBUGF(SNMP_MIB_DEBUG,("free list objid==%"S32_F"\n",n->objid));
00431 snmp_mib_ln_free(n);
00432 if (rn->count == 0)
00433 {
00434 rn->head = NULL;
00435 rn->tail = NULL;
00436 }
00437 return next;
00438 }
00439
00440
00441
00442
00443
00444
00445
00446
00447
00448
00449
00450
00451 struct mib_node *
00452 snmp_search_tree(struct mib_node *node, u8_t ident_len, s32_t *ident, struct snmp_name_ptr *np)
00453 {
00454 u8_t node_type, ext_level;
00455
00456 ext_level = 0;
00457 LWIP_DEBUGF(SNMP_MIB_DEBUG,("node==%p *ident==%"S32_F"\n",(void*)node,*ident));
00458 while (node != NULL)
00459 {
00460 node_type = node->node_type;
00461 if ((node_type == MIB_NODE_AR) || (node_type == MIB_NODE_RA))
00462 {
00463 struct mib_array_node *an;
00464 u16_t i;
00465
00466 if (ident_len > 0)
00467 {
00468
00469 an = (struct mib_array_node *)node;
00470 i = 0;
00471 while ((i < an->maxlength) && (an->objid[i] != *ident))
00472 {
00473 i++;
00474 }
00475 if (i < an->maxlength)
00476 {
00477
00478 LWIP_DEBUGF(SNMP_MIB_DEBUG,("an->objid[%"U16_F"]==%"S32_F" *ident==%"S32_F"\n",i,an->objid[i],*ident));
00479 if (an->nptr[i] == NULL)
00480 {
00481
00482
00483 np->ident_len = ident_len;
00484 np->ident = ident;
00485 return (struct mib_node*)an;
00486 }
00487 else
00488 {
00489
00490 ident++;
00491 ident_len--;
00492 node = an->nptr[i];
00493 }
00494 }
00495 else
00496 {
00497
00498 LWIP_DEBUGF(SNMP_MIB_DEBUG,("an search failed *ident==%"S32_F"\n",*ident));
00499 return NULL;
00500 }
00501 }
00502 else
00503 {
00504
00505 LWIP_DEBUGF(SNMP_MIB_DEBUG,("an search failed, short object identifier\n"));
00506 return NULL;
00507 }
00508 }
00509 else if(node_type == MIB_NODE_LR)
00510 {
00511 struct mib_list_rootnode *lrn;
00512 struct mib_list_node *ln;
00513
00514 if (ident_len > 0)
00515 {
00516
00517 lrn = (struct mib_list_rootnode *)node;
00518 ln = lrn->head;
00519
00520 while ((ln != NULL) && (ln->objid != *ident))
00521 {
00522 ln = ln->next;
00523 }
00524 if (ln != NULL)
00525 {
00526 ;
00527 LWIP_DEBUGF(SNMP_MIB_DEBUG,("ln->objid==%"S32_F" *ident==%"S32_F"\n",ln->objid,*ident));
00528 if (ln->nptr == NULL)
00529 {
00530 np->ident_len = ident_len;
00531 np->ident = ident;
00532 return (struct mib_node*)lrn;
00533 }
00534 else
00535 {
00536
00537 ident_len--;
00538 ident++;
00539 node = ln->nptr;
00540 }
00541 }
00542 else
00543 {
00544
00545 LWIP_DEBUGF(SNMP_MIB_DEBUG,("ln search failed *ident==%"S32_F"\n",*ident));
00546 return NULL;
00547 }
00548 }
00549 else
00550 {
00551
00552 LWIP_DEBUGF(SNMP_MIB_DEBUG,("ln search failed, short object identifier\n"));
00553 return NULL;
00554 }
00555 }
00556 else if(node_type == MIB_NODE_EX)
00557 {
00558 struct mib_external_node *en;
00559 u16_t i, len;
00560
00561 if (ident_len > 0)
00562 {
00563
00564 en = (struct mib_external_node *)node;
00565
00566 i = 0;
00567 len = en->level_length(en->addr_inf,ext_level);
00568 while ((i < len) && (en->ident_cmp(en->addr_inf,ext_level,i,*ident) != 0))
00569 {
00570 i++;
00571 }
00572 if (i < len)
00573 {
00574 s32_t debug_id;
00575
00576 en->get_objid(en->addr_inf,ext_level,i,&debug_id);
00577 LWIP_DEBUGF(SNMP_MIB_DEBUG,("en->objid==%"S32_F" *ident==%"S32_F"\n",debug_id,*ident));
00578 if ((ext_level + 1) == en->tree_levels)
00579 {
00580 np->ident_len = ident_len;
00581 np->ident = ident;
00582 return (struct mib_node*)en;
00583 }
00584 else
00585 {
00586
00587 ident_len--;
00588 ident++;
00589 ext_level++;
00590 }
00591 }
00592 else
00593 {
00594
00595 LWIP_DEBUGF(SNMP_MIB_DEBUG,("en search failed *ident==%"S32_F"\n",*ident));
00596 return NULL;
00597 }
00598 }
00599 else
00600 {
00601
00602 LWIP_DEBUGF(SNMP_MIB_DEBUG,("en search failed, short object identifier\n"));
00603 return NULL;
00604 }
00605 }
00606 else if (node_type == MIB_NODE_SC)
00607 {
00608 mib_scalar_node *sn;
00609
00610 sn = (mib_scalar_node *)node;
00611 if ((ident_len == 1) && (*ident == 0))
00612 {
00613 np->ident_len = ident_len;
00614 np->ident = ident;
00615 return (struct mib_node*)sn;
00616 }
00617 else
00618 {
00619
00620 LWIP_DEBUGF(SNMP_MIB_DEBUG,("search failed, invalid object identifier length\n"));
00621 return NULL;
00622 }
00623 }
00624 else
00625 {
00626
00627 LWIP_DEBUGF(SNMP_MIB_DEBUG,("search failed node_type %"U16_F" unkown\n",(u16_t)node_type));
00628 return NULL;
00629 }
00630 }
00631
00632 LWIP_DEBUGF(SNMP_MIB_DEBUG,("search failed node==%p\n",(void*)node));
00633 return NULL;
00634 }
00635
00636
00637
00638
00639 static u8_t
00640 empty_table(struct mib_node *node)
00641 {
00642 u8_t node_type;
00643 u8_t empty = 0;
00644
00645 if (node != NULL)
00646 {
00647 node_type = node->node_type;
00648 if (node_type == MIB_NODE_LR)
00649 {
00650 struct mib_list_rootnode *lrn;
00651 lrn = (struct mib_list_rootnode *)node;
00652 if ((lrn->count == 0) || (lrn->head == NULL))
00653 {
00654 empty = 1;
00655 }
00656 }
00657 else if ((node_type == MIB_NODE_AR) || (node_type == MIB_NODE_RA))
00658 {
00659 struct mib_array_node *an;
00660 an = (struct mib_array_node *)node;
00661 if ((an->maxlength == 0) || (an->nptr == NULL))
00662 {
00663 empty = 1;
00664 }
00665 }
00666 else if (node_type == MIB_NODE_EX)
00667 {
00668 struct mib_external_node *en;
00669 en = (struct mib_external_node *)node;
00670 if (en->tree_levels == 0)
00671 {
00672 empty = 1;
00673 }
00674 }
00675 }
00676 return empty;
00677 }
00678
00679
00680
00681
00682 struct mib_node *
00683 snmp_expand_tree(struct mib_node *node, u8_t ident_len, s32_t *ident, struct snmp_obj_id *oidret)
00684 {
00685 u8_t node_type, ext_level, climb_tree;
00686
00687 ext_level = 0;
00688
00689 node_stack_cnt = 0;
00690 while (node != NULL)
00691 {
00692 climb_tree = 0;
00693 node_type = node->node_type;
00694 if ((node_type == MIB_NODE_AR) || (node_type == MIB_NODE_RA))
00695 {
00696 struct mib_array_node *an;
00697 u16_t i;
00698
00699
00700 an = (struct mib_array_node *)node;
00701 if (ident_len > 0)
00702 {
00703 i = 0;
00704 while ((i < an->maxlength) && (an->objid[i] < *ident))
00705 {
00706 i++;
00707 }
00708 if (i < an->maxlength)
00709 {
00710 LWIP_DEBUGF(SNMP_MIB_DEBUG,("an->objid[%"U16_F"]==%"S32_F" *ident==%"S32_F"\n",i,an->objid[i],*ident));
00711
00712 oidret->id[oidret->len] = an->objid[i];
00713 (oidret->len)++;
00714
00715 if (an->nptr[i] == NULL)
00716 {
00717 LWIP_DEBUGF(SNMP_MIB_DEBUG,("leaf node\n"));
00718
00719 if (an->objid[i] > *ident)
00720 {
00721 return (struct mib_node*)an;
00722 }
00723 else if ((i + 1) < an->maxlength)
00724 {
00725
00726 (oidret->len)--;
00727 oidret->id[oidret->len] = an->objid[i + 1];
00728 (oidret->len)++;
00729 return (struct mib_node*)an;
00730 }
00731 else
00732 {
00733
00734 (oidret->len)--;
00735 climb_tree = 1;
00736 }
00737 }
00738 else
00739 {
00740 u8_t j;
00741 struct nse cur_node;
00742
00743 LWIP_DEBUGF(SNMP_MIB_DEBUG,("non-leaf node\n"));
00744
00745 LWIP_ASSERT("i < 0xff", i < 0xff);
00746 j = (u8_t)i + 1;
00747 while ((j < an->maxlength) && (empty_table(an->nptr[j])))
00748 {
00749 j++;
00750 }
00751 if (j < an->maxlength)
00752 {
00753 cur_node.r_ptr = an->nptr[j];
00754 cur_node.r_id = an->objid[j];
00755 cur_node.r_nl = 0;
00756 }
00757 else
00758 {
00759 cur_node.r_ptr = NULL;
00760 }
00761 push_node(&cur_node);
00762 if (an->objid[i] == *ident)
00763 {
00764 ident_len--;
00765 ident++;
00766 }
00767 else
00768 {
00769
00770 ident_len = 0;
00771 }
00772
00773 node = an->nptr[i];
00774 }
00775 }
00776 else
00777 {
00778
00779 climb_tree = 1;
00780 }
00781 }
00782 else
00783 {
00784 u8_t j;
00785
00786 j = 0;
00787 while ((j < an->maxlength) && empty_table(an->nptr[j]))
00788 {
00789 j++;
00790 }
00791 if (j < an->maxlength)
00792 {
00793 LWIP_DEBUGF(SNMP_MIB_DEBUG,("left an->objid[j]==%"S32_F"\n",an->objid[j]));
00794 oidret->id[oidret->len] = an->objid[j];
00795 (oidret->len)++;
00796 if (an->nptr[j] == NULL)
00797 {
00798
00799 return (struct mib_node*)an;
00800 }
00801 else
00802 {
00803
00804 node = an->nptr[j];
00805 }
00806 }
00807 else
00808 {
00809
00810 climb_tree = 1;
00811 }
00812 }
00813 }
00814 else if(node_type == MIB_NODE_LR)
00815 {
00816 struct mib_list_rootnode *lrn;
00817 struct mib_list_node *ln;
00818
00819
00820 lrn = (struct mib_list_rootnode *)node;
00821 if (ident_len > 0)
00822 {
00823 ln = lrn->head;
00824
00825 while ((ln != NULL) && (ln->objid < *ident))
00826 {
00827 ln = ln->next;
00828 }
00829 if (ln != NULL)
00830 {
00831 LWIP_DEBUGF(SNMP_MIB_DEBUG,("ln->objid==%"S32_F" *ident==%"S32_F"\n",ln->objid,*ident));
00832 oidret->id[oidret->len] = ln->objid;
00833 (oidret->len)++;
00834 if (ln->nptr == NULL)
00835 {
00836
00837 if (ln->objid > *ident)
00838 {
00839 return (struct mib_node*)lrn;
00840 }
00841 else if (ln->next != NULL)
00842 {
00843
00844 (oidret->len)--;
00845 oidret->id[oidret->len] = ln->next->objid;
00846 (oidret->len)++;
00847 return (struct mib_node*)lrn;
00848 }
00849 else
00850 {
00851
00852 (oidret->len)--;
00853 climb_tree = 1;
00854 }
00855 }
00856 else
00857 {
00858 struct mib_list_node *jn;
00859 struct nse cur_node;
00860
00861
00862 jn = ln->next;
00863 while ((jn != NULL) && empty_table(jn->nptr))
00864 {
00865 jn = jn->next;
00866 }
00867 if (jn != NULL)
00868 {
00869 cur_node.r_ptr = jn->nptr;
00870 cur_node.r_id = jn->objid;
00871 cur_node.r_nl = 0;
00872 }
00873 else
00874 {
00875 cur_node.r_ptr = NULL;
00876 }
00877 push_node(&cur_node);
00878 if (ln->objid == *ident)
00879 {
00880 ident_len--;
00881 ident++;
00882 }
00883 else
00884 {
00885
00886 ident_len = 0;
00887 }
00888
00889 node = ln->nptr;
00890 }
00891
00892 }
00893 else
00894 {
00895
00896 climb_tree = 1;
00897 }
00898 }
00899 else
00900 {
00901 struct mib_list_node *jn;
00902
00903 jn = lrn->head;
00904 while ((jn != NULL) && empty_table(jn->nptr))
00905 {
00906 jn = jn->next;
00907 }
00908 if (jn != NULL)
00909 {
00910 LWIP_DEBUGF(SNMP_MIB_DEBUG,("left jn->objid==%"S32_F"\n",jn->objid));
00911 oidret->id[oidret->len] = jn->objid;
00912 (oidret->len)++;
00913 if (jn->nptr == NULL)
00914 {
00915
00916 LWIP_DEBUGF(SNMP_MIB_DEBUG,("jn->nptr == NULL\n"));
00917 return (struct mib_node*)lrn;
00918 }
00919 else
00920 {
00921
00922 node = jn->nptr;
00923 }
00924 }
00925 else
00926 {
00927
00928 climb_tree = 1;
00929 }
00930 }
00931 }
00932 else if(node_type == MIB_NODE_EX)
00933 {
00934 struct mib_external_node *en;
00935 s32_t ex_id;
00936
00937
00938 en = (struct mib_external_node *)node;
00939 if (ident_len > 0)
00940 {
00941 u16_t i, len;
00942
00943 i = 0;
00944 len = en->level_length(en->addr_inf,ext_level);
00945 while ((i < len) && (en->ident_cmp(en->addr_inf,ext_level,i,*ident) < 0))
00946 {
00947 i++;
00948 }
00949 if (i < len)
00950 {
00951
00952 en->get_objid(en->addr_inf,ext_level,i,&ex_id);
00953 LWIP_DEBUGF(SNMP_MIB_DEBUG,("en->objid[%"U16_F"]==%"S32_F" *ident==%"S32_F"\n",i,ex_id,*ident));
00954 oidret->id[oidret->len] = ex_id;
00955 (oidret->len)++;
00956
00957 if ((ext_level + 1) == en->tree_levels)
00958 {
00959 LWIP_DEBUGF(SNMP_MIB_DEBUG,("leaf node\n"));
00960
00961 if (ex_id > *ident)
00962 {
00963 return (struct mib_node*)en;
00964 }
00965 else if ((i + 1) < len)
00966 {
00967
00968 en->get_objid(en->addr_inf,ext_level,i + 1,&ex_id);
00969 (oidret->len)--;
00970 oidret->id[oidret->len] = ex_id;
00971 (oidret->len)++;
00972 return (struct mib_node*)en;
00973 }
00974 else
00975 {
00976
00977 (oidret->len)--;
00978 climb_tree = 1;
00979 }
00980 }
00981 else
00982 {
00983 u8_t j;
00984 struct nse cur_node;
00985
00986 LWIP_DEBUGF(SNMP_MIB_DEBUG,("non-leaf node\n"));
00987
00988 LWIP_ASSERT("i < 0xff", i < 0xff);
00989 j = (u8_t)i + 1;
00990 if (j < len)
00991 {
00992
00993 cur_node.r_ptr = node;
00994 en->get_objid(en->addr_inf,ext_level,j,&cur_node.r_id);
00995 cur_node.r_nl = ext_level + 1;
00996 }
00997 else
00998 {
00999 cur_node.r_ptr = NULL;
01000 }
01001 push_node(&cur_node);
01002 if (en->ident_cmp(en->addr_inf,ext_level,i,*ident) == 0)
01003 {
01004 ident_len--;
01005 ident++;
01006 }
01007 else
01008 {
01009
01010 ident_len = 0;
01011 }
01012
01013 ext_level++;
01014 }
01015 }
01016 else
01017 {
01018
01019 climb_tree = 1;
01020 }
01021 }
01022 else
01023 {
01024
01025 en->get_objid(en->addr_inf,ext_level,0,&ex_id);
01026 LWIP_DEBUGF(SNMP_MIB_DEBUG,("left en->objid==%"S32_F"\n",ex_id));
01027 oidret->id[oidret->len] = ex_id;
01028 (oidret->len)++;
01029 if ((ext_level + 1) == en->tree_levels)
01030 {
01031
01032 LWIP_DEBUGF(SNMP_MIB_DEBUG,("(ext_level + 1) == en->tree_levels\n"));
01033 return (struct mib_node*)en;
01034 }
01035 else
01036 {
01037
01038 ext_level++;
01039 }
01040 }
01041 }
01042 else if(node_type == MIB_NODE_SC)
01043 {
01044 mib_scalar_node *sn;
01045
01046
01047 sn = (mib_scalar_node *)node;
01048 if (ident_len > 0)
01049 {
01050
01051 climb_tree = 1;
01052 }
01053 else
01054 {
01055
01056 oidret->id[oidret->len] = 0;
01057 (oidret->len)++;
01058
01059 LWIP_DEBUGF(SNMP_MIB_DEBUG,("completed scalar leaf\n"));
01060 return (struct mib_node*)sn;
01061 }
01062 }
01063 else
01064 {
01065
01066 LWIP_DEBUGF(SNMP_MIB_DEBUG,("expand failed node_type %"U16_F" unkown\n",(u16_t)node_type));
01067 return NULL;
01068 }
01069
01070 if (climb_tree)
01071 {
01072 struct nse child;
01073
01074
01075 child.r_ptr = NULL;
01076 child.r_id = 0;
01077 child.r_nl = 0;
01078 while ((node_stack_cnt > 0) && (child.r_ptr == NULL))
01079 {
01080 pop_node(&child);
01081
01082 (oidret->len)--;
01083 }
01084 if (child.r_ptr != NULL)
01085 {
01086
01087 ident_len = 0;
01088 oidret->id[oidret->len] = child.r_id;
01089 oidret->len++;
01090 node = child.r_ptr;
01091 ext_level = child.r_nl;
01092 }
01093 else
01094 {
01095
01096 LWIP_DEBUGF(SNMP_MIB_DEBUG,("expand failed, tree ends here\n"));
01097 return NULL;
01098 }
01099 }
01100 }
01101
01102 LWIP_DEBUGF(SNMP_MIB_DEBUG,("expand failed node==%p\n",(void*)node));
01103 return NULL;
01104 }
01105
01106
01107
01108
01109
01110
01111
01112
01113 u8_t
01114 snmp_iso_prefix_tst(u8_t ident_len, s32_t *ident)
01115 {
01116 if ((ident_len > 3) &&
01117 (ident[0] == 1) && (ident[1] == 3) &&
01118 (ident[2] == 6) && (ident[3] == 1))
01119 {
01120 return 1;
01121 }
01122 else
01123 {
01124 return 0;
01125 }
01126 }
01127
01128
01129
01130
01131
01132
01133
01134
01135
01136
01137
01138
01139 u8_t
01140 snmp_iso_prefix_expand(u8_t ident_len, s32_t *ident, struct snmp_obj_id *oidret)
01141 {
01142 const s32_t *prefix_ptr;
01143 s32_t *ret_ptr;
01144 u8_t i;
01145
01146 i = 0;
01147 prefix_ptr = &prefix[0];
01148 ret_ptr = &oidret->id[0];
01149 ident_len = ((ident_len < 4)?ident_len:4);
01150 while ((i < ident_len) && ((*ident) <= (*prefix_ptr)))
01151 {
01152 *ret_ptr++ = *prefix_ptr++;
01153 ident++;
01154 i++;
01155 }
01156 if (i == ident_len)
01157 {
01158
01159 while (i < 4)
01160 {
01161 *ret_ptr++ = *prefix_ptr++;
01162 i++;
01163 }
01164 oidret->len = i;
01165 return 1;
01166 }
01167 else
01168 {
01169
01170 return 0;
01171 }
01172 }
01173
01174 #endif