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