l4/pkg/ankh/lib/lwip/lib/contrib/src/core/snmp/msg_in.c

   1 /**
   2  * @file
   3  * SNMP input message processing (RFC1157).
   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.h"
  40 #include "lwip/snmp_asn1.h"
  41 #include "lwip/snmp_msg.h"
  42 #include "lwip/snmp_structs.h"
  43 #include "lwip/ip_addr.h"
  44 #include "lwip/memp.h"
  45 #include "lwip/udp.h"
  46 #include "lwip/stats.h"
  47
  48 #include <string.h>
  49
  50 /* public (non-static) constants */
  51 /** SNMP v1 == 0 */
  52 const s32_t snmp_version = 0;
  53 /** default SNMP community string */
  54 const char snmp_publiccommunity[7] = "public";
  55
  56 /* statically allocated buffers for SNMP_CONCURRENT_REQUESTS */
  57 struct snmp_msg_pstat msg_input_list[SNMP_CONCURRENT_REQUESTS];
  58 /* UDP Protocol Control Block */
  59 struct udp_pcb *snmp1_pcb;
  60
  61 static void snmp_recv(void *arg, struct udp_pcb *pcb, struct pbuf *p, ip_addr_t *addr, u16_t port);
  62 static err_t snmp_pdu_header_check(struct pbuf *p, u16_t ofs, u16_t pdu_len, u16_t *ofs_ret, struct snmp_msg_pstat *m_stat);
  63 static err_t snmp_pdu_dec_varbindlist(struct pbuf *p, u16_t ofs, u16_t *ofs_ret, struct snmp_msg_pstat *m_stat);
  64
  65
  66 /**
  67  * Starts SNMP Agent.
  68  * Allocates UDP pcb and binds it to IP_ADDR_ANY port 161.
  69  */
  70 void
  71 snmp_init(void)
  72 {
  73   struct snmp_msg_pstat *msg_ps;
  74   u8_t i;
  75
  76   snmp1_pcb = udp_new();
  77   if (snmp1_pcb != NULL)
  78   {
  79     udp_recv(snmp1_pcb, snmp_recv, (void *)SNMP_IN_PORT);
  80     udp_bind(snmp1_pcb, IP_ADDR_ANY, SNMP_IN_PORT);
  81   }
  82   msg_ps = &msg_input_list[0];
  83   for (i=0; i<SNMP_CONCURRENT_REQUESTS; i++)
  84   {
  85     msg_ps->state = SNMP_MSG_EMPTY;
  86     msg_ps->error_index = 0;
  87     msg_ps->error_status = SNMP_ES_NOERROR;
  88     msg_ps++;
  89   }
  90   trap_msg.pcb = snmp1_pcb;
  91
  92 #ifdef SNMP_PRIVATE_MIB_INIT
  93   /* If defined, rhis must be a function-like define to initialize the
  94    * private MIB after the stack has been initialized.
  95    * The private MIB can also be initialized in tcpip_callback (or after
  96    * the stack is initialized), this define is only for convenience. */
  97   SNMP_PRIVATE_MIB_INIT();
  98 #endif /* SNMP_PRIVATE_MIB_INIT */
  99
 100   /* The coldstart trap will only be output
 101      if our outgoing interface is up & configured  */
 102   snmp_coldstart_trap();
 103 }
 104
 105 static void
 106 snmp_error_response(struct snmp_msg_pstat *msg_ps, u8_t error)
 107 {
 108   snmp_varbind_list_free(&msg_ps->outvb);
 109   msg_ps->outvb = msg_ps->invb;
 110   msg_ps->invb.head = NULL;
 111   msg_ps->invb.tail = NULL;
 112   msg_ps->invb.count = 0;
 113   msg_ps->error_status = error;
 114   msg_ps->error_index = 1 + msg_ps->vb_idx;
 115   snmp_send_response(msg_ps);
 116   snmp_varbind_list_free(&msg_ps->outvb);
 117   msg_ps->state = SNMP_MSG_EMPTY;
 118 }
 119
 120 static void
 121 snmp_ok_response(struct snmp_msg_pstat *msg_ps)
 122 {
 123   err_t err_ret;
 124
 125   err_ret = snmp_send_response(msg_ps);
 126   if (err_ret == ERR_MEM)
 127   {
 128     /* serious memory problem, can't return tooBig */
 129   }
 130   else
 131   {
 132     LWIP_DEBUGF(SNMP_MSG_DEBUG, ("snmp_msg_event = %"S32_F"\n",msg_ps->error_status));
 133   }
 134   /* free varbinds (if available) */
 135   snmp_varbind_list_free(&msg_ps->invb);
 136   snmp_varbind_list_free(&msg_ps->outvb);
 137   msg_ps->state = SNMP_MSG_EMPTY;
 138 }
 139
 140 /**
 141  * Service an internal or external event for SNMP GET.
 142  *
 143  * @param request_id identifies requests from 0 to (SNMP_CONCURRENT_REQUESTS-1)
 144  * @param msg_ps points to the assosicated message process state
 145  */
 146 static void
 147 snmp_msg_get_event(u8_t request_id, struct snmp_msg_pstat *msg_ps)
 148 {
 149   LWIP_DEBUGF(SNMP_MSG_DEBUG, ("snmp_msg_get_event: msg_ps->state==%"U16_F"\n",(u16_t)msg_ps->state));
 150
 151   if (msg_ps->state == SNMP_MSG_EXTERNAL_GET_OBJDEF)
 152   {
 153     struct mib_external_node *en;
 154     struct snmp_name_ptr np;
 155
 156     /* get_object_def() answer*/
 157     en = msg_ps->ext_mib_node;
 158     np = msg_ps->ext_name_ptr;
 159
 160     /* translate answer into a known lifeform */
 161     en->get_object_def_a(request_id, np.ident_len, np.ident, &msg_ps->ext_object_def);
 162     if ((msg_ps->ext_object_def.instance != MIB_OBJECT_NONE) &&
 163         (msg_ps->ext_object_def.access & MIB_ACCESS_READ))
 164     {
 165       msg_ps->state = SNMP_MSG_EXTERNAL_GET_VALUE;
 166       en->get_value_q(request_id, &msg_ps->ext_object_def);
 167     }
 168     else
 169     {
 170       en->get_object_def_pc(request_id, np.ident_len, np.ident);
 171       /* search failed, object id points to unknown object (nosuchname) */
 172       snmp_error_response(msg_ps,SNMP_ES_NOSUCHNAME);
 173     }
 174   }
 175   else if (msg_ps->state == SNMP_MSG_EXTERNAL_GET_VALUE)
 176   {
 177     struct mib_external_node *en;
 178     struct snmp_varbind *vb;
 179
 180     /* get_value() answer */
 181     en = msg_ps->ext_mib_node;
 182
 183     /* allocate output varbind */
 184     vb = (struct snmp_varbind *)memp_malloc(MEMP_SNMP_VARBIND);
 185     LWIP_ASSERT("vb != NULL",vb != NULL);
 186     if (vb != NULL)
 187     {
 188       vb->next = NULL;
 189       vb->prev = NULL;
 190
 191       /* move name from invb to outvb */
 192       vb->ident = msg_ps->vb_ptr->ident;
 193       vb->ident_len = msg_ps->vb_ptr->ident_len;
 194       /* ensure this memory is refereced once only */
 195       msg_ps->vb_ptr->ident = NULL;
 196       msg_ps->vb_ptr->ident_len = 0;
 197
 198       vb->value_type = msg_ps->ext_object_def.asn_type;
 199       LWIP_ASSERT("invalid length", msg_ps->ext_object_def.v_len <= 0xff);
 200       vb->value_len = (u8_t)msg_ps->ext_object_def.v_len;
 201       if (vb->value_len > 0)
 202       {
 203         LWIP_ASSERT("SNMP_MAX_OCTET_STRING_LEN is configured too low", vb->value_len <= SNMP_MAX_VALUE_SIZE);
 204         vb->value = memp_malloc(MEMP_SNMP_VALUE);
 205         LWIP_ASSERT("vb->value != NULL",vb->value != NULL);
 206         if (vb->value != NULL)
 207         {
 208           en->get_value_a(request_id, &msg_ps->ext_object_def, vb->value_len, vb->value);
 209           snmp_varbind_tail_add(&msg_ps->outvb, vb);
 210           /* search again (if vb_idx < msg_ps->invb.count) */
 211           msg_ps->state = SNMP_MSG_SEARCH_OBJ;
 212           msg_ps->vb_idx += 1;
 213         }
 214         else
 215         {
 216           en->get_value_pc(request_id, &msg_ps->ext_object_def);
 217           LWIP_DEBUGF(SNMP_MSG_DEBUG, ("snmp_msg_event: no variable space\n"));
 218           msg_ps->vb_ptr->ident = vb->ident;
 219           msg_ps->vb_ptr->ident_len = vb->ident_len;
 220           memp_free(MEMP_SNMP_VARBIND, vb);
 221           snmp_error_response(msg_ps,SNMP_ES_TOOBIG);
 222         }
 223       }
 224       else
 225       {
 226         /* vb->value_len == 0, empty value (e.g. empty string) */
 227         en->get_value_a(request_id, &msg_ps->ext_object_def, 0, NULL);
 228         vb->value = NULL;
 229         snmp_varbind_tail_add(&msg_ps->outvb, vb);
 230         /* search again (if vb_idx < msg_ps->invb.count) */
 231         msg_ps->state = SNMP_MSG_SEARCH_OBJ;
 232         msg_ps->vb_idx += 1;
 233       }
 234     }
 235     else
 236     {
 237       en->get_value_pc(request_id, &msg_ps->ext_object_def);
 238       LWIP_DEBUGF(SNMP_MSG_DEBUG, ("snmp_msg_event: no outvb space\n"));
 239       snmp_error_response(msg_ps,SNMP_ES_TOOBIG);
 240     }
 241   }
 242
 243   while ((msg_ps->state == SNMP_MSG_SEARCH_OBJ) &&
 244          (msg_ps->vb_idx < msg_ps->invb.count))
 245   {
 246     struct mib_node *mn;
 247     struct snmp_name_ptr np;
 248
 249     if (msg_ps->vb_idx == 0)
 250     {
 251       msg_ps->vb_ptr = msg_ps->invb.head;
 252     }
 253     else
 254     {
 255       msg_ps->vb_ptr = msg_ps->vb_ptr->next;
 256     }
 257     /** test object identifier for .iso.org.dod.internet prefix */
 258     if (snmp_iso_prefix_tst(msg_ps->vb_ptr->ident_len,  msg_ps->vb_ptr->ident))
 259     {
 260       mn = snmp_search_tree((struct mib_node*)&internet, msg_ps->vb_ptr->ident_len - 4,
 261                              msg_ps->vb_ptr->ident + 4, &np);
 262       if (mn != NULL)
 263       {
 264         if (mn->node_type == MIB_NODE_EX)
 265         {
 266           /* external object */
 267           struct mib_external_node *en = (struct mib_external_node*)mn;
 268
 269           msg_ps->state = SNMP_MSG_EXTERNAL_GET_OBJDEF;
 270           /* save en && args in msg_ps!! */
 271           msg_ps->ext_mib_node = en;
 272           msg_ps->ext_name_ptr = np;
 273
 274           en->get_object_def_q(en->addr_inf, request_id, np.ident_len, np.ident);
 275         }
 276         else
 277         {
 278           /* internal object */
 279           struct obj_def object_def;
 280
 281           msg_ps->state = SNMP_MSG_INTERNAL_GET_OBJDEF;
 282           mn->get_object_def(np.ident_len, np.ident, &object_def);
 283           if ((object_def.instance != MIB_OBJECT_NONE) &&
 284             (object_def.access & MIB_ACCESS_READ))
 285           {
 286             mn = mn;
 287           }
 288           else
 289           {
 290             /* search failed, object id points to unknown object (nosuchname) */
 291             mn =  NULL;
 292           }
 293           if (mn != NULL)
 294           {
 295             struct snmp_varbind *vb;
 296
 297             msg_ps->state = SNMP_MSG_INTERNAL_GET_VALUE;
 298             /* allocate output varbind */
 299             vb = (struct snmp_varbind *)memp_malloc(MEMP_SNMP_VARBIND);
 300             LWIP_ASSERT("vb != NULL",vb != NULL);
 301             if (vb != NULL)
 302             {
 303               vb->next = NULL;
 304               vb->prev = NULL;
 305
 306               /* move name from invb to outvb */
 307               vb->ident = msg_ps->vb_ptr->ident;
 308               vb->ident_len = msg_ps->vb_ptr->ident_len;
 309               /* ensure this memory is refereced once only */
 310               msg_ps->vb_ptr->ident = NULL;
 311               msg_ps->vb_ptr->ident_len = 0;
 312
 313               vb->value_type = object_def.asn_type;
 314               LWIP_ASSERT("invalid length", object_def.v_len <= 0xff);
 315               vb->value_len = (u8_t)object_def.v_len;
 316               if (vb->value_len > 0)
 317               {
 318                 LWIP_ASSERT("SNMP_MAX_OCTET_STRING_LEN is configured too low",
 319                   vb->value_len <= SNMP_MAX_VALUE_SIZE);
 320                 vb->value = memp_malloc(MEMP_SNMP_VALUE);
 321                 LWIP_ASSERT("vb->value != NULL",vb->value != NULL);
 322                 if (vb->value != NULL)
 323                 {
 324                   mn->get_value(&object_def, vb->value_len, vb->value);
 325                   snmp_varbind_tail_add(&msg_ps->outvb, vb);
 326                   msg_ps->state = SNMP_MSG_SEARCH_OBJ;
 327                   msg_ps->vb_idx += 1;
 328                 }
 329                 else
 330                 {
 331                   LWIP_DEBUGF(SNMP_MSG_DEBUG, ("snmp_msg_event: couldn't allocate variable space\n"));
 332                   msg_ps->vb_ptr->ident = vb->ident;
 333                   msg_ps->vb_ptr->ident_len = vb->ident_len;
 334                   memp_free(MEMP_SNMP_VARBIND, vb);
 335                   snmp_error_response(msg_ps,SNMP_ES_TOOBIG);
 336                 }
 337               }
 338               else
 339               {
 340                 /* vb->value_len == 0, empty value (e.g. empty string) */
 341                 vb->value = NULL;
 342                 snmp_varbind_tail_add(&msg_ps->outvb, vb);
 343                 msg_ps->state = SNMP_MSG_SEARCH_OBJ;
 344                 msg_ps->vb_idx += 1;
 345               }
 346             }
 347             else
 348             {
 349               LWIP_DEBUGF(SNMP_MSG_DEBUG, ("snmp_msg_event: couldn't allocate outvb space\n"));
 350               snmp_error_response(msg_ps,SNMP_ES_TOOBIG);
 351             }
 352           }
 353         }
 354       }
 355     }
 356     else
 357     {
 358       mn = NULL;
 359     }
 360     if (mn == NULL)
 361     {
 362       /* mn == NULL, noSuchName */
 363       snmp_error_response(msg_ps,SNMP_ES_NOSUCHNAME);
 364     }
 365   }
 366   if ((msg_ps->state == SNMP_MSG_SEARCH_OBJ) &&
 367       (msg_ps->vb_idx == msg_ps->invb.count))
 368   {
 369     snmp_ok_response(msg_ps);
 370   }
 371 }
 372
 373 /**
 374  * Service an internal or external event for SNMP GETNEXT.
 375  *
 376  * @param request_id identifies requests from 0 to (SNMP_CONCURRENT_REQUESTS-1)
 377  * @param msg_ps points to the assosicated message process state
 378  */
 379 static void
 380 snmp_msg_getnext_event(u8_t request_id, struct snmp_msg_pstat *msg_ps)
 381 {
 382   LWIP_DEBUGF(SNMP_MSG_DEBUG, ("snmp_msg_getnext_event: msg_ps->state==%"U16_F"\n",(u16_t)msg_ps->state));
 383
 384   if (msg_ps->state == SNMP_MSG_EXTERNAL_GET_OBJDEF)
 385   {
 386     struct mib_external_node *en;
 387
 388     /* get_object_def() answer*/
 389     en = msg_ps->ext_mib_node;
 390
 391     /* translate answer into a known lifeform */
 392     en->get_object_def_a(request_id, 1, &msg_ps->ext_oid.id[msg_ps->ext_oid.len - 1], &msg_ps->ext_object_def);
 393     if (msg_ps->ext_object_def.instance != MIB_OBJECT_NONE)
 394     {
 395       msg_ps->state = SNMP_MSG_EXTERNAL_GET_VALUE;
 396       en->get_value_q(request_id, &msg_ps->ext_object_def);
 397     }
 398     else
 399     {
 400       en->get_object_def_pc(request_id, 1, &msg_ps->ext_oid.id[msg_ps->ext_oid.len - 1]);
 401       /* search failed, object id points to unknown object (nosuchname) */
 402       snmp_error_response(msg_ps,SNMP_ES_NOSUCHNAME);
 403     }
 404   }
 405   else if (msg_ps->state == SNMP_MSG_EXTERNAL_GET_VALUE)
 406   {
 407     struct mib_external_node *en;
 408     struct snmp_varbind *vb;
 409
 410     /* get_value() answer */
 411     en = msg_ps->ext_mib_node;
 412
 413     LWIP_ASSERT("invalid length", msg_ps->ext_object_def.v_len <= 0xff);
 414     vb = snmp_varbind_alloc(&msg_ps->ext_oid,
 415                             msg_ps->ext_object_def.asn_type,
 416                             (u8_t)msg_ps->ext_object_def.v_len);
 417     if (vb != NULL)
 418     {
 419       en->get_value_a(request_id, &msg_ps->ext_object_def, vb->value_len, vb->value);
 420       snmp_varbind_tail_add(&msg_ps->outvb, vb);
 421       msg_ps->state = SNMP_MSG_SEARCH_OBJ;
 422       msg_ps->vb_idx += 1;
 423     }
 424     else
 425     {
 426       en->get_value_pc(request_id, &msg_ps->ext_object_def);
 427       LWIP_DEBUGF(SNMP_MSG_DEBUG, ("snmp_msg_getnext_event: couldn't allocate outvb space\n"));
 428       snmp_error_response(msg_ps,SNMP_ES_TOOBIG);
 429     }
 430   }
 431
 432   while ((msg_ps->state == SNMP_MSG_SEARCH_OBJ) &&
 433          (msg_ps->vb_idx < msg_ps->invb.count))
 434   {
 435     struct mib_node *mn;
 436     struct snmp_obj_id oid;
 437
 438     if (msg_ps->vb_idx == 0)
 439     {
 440       msg_ps->vb_ptr = msg_ps->invb.head;
 441     }
 442     else
 443     {
 444       msg_ps->vb_ptr = msg_ps->vb_ptr->next;
 445     }
 446     if (snmp_iso_prefix_expand(msg_ps->vb_ptr->ident_len, msg_ps->vb_ptr->ident, &oid))
 447     {
 448       if (msg_ps->vb_ptr->ident_len > 3)
 449       {
 450         /* can offset ident_len and ident */
 451         mn = snmp_expand_tree((struct mib_node*)&internet,
 452                               msg_ps->vb_ptr->ident_len - 4,
 453                               msg_ps->vb_ptr->ident + 4, &oid);
 454       }
 455       else
 456       {
 457         /* can't offset ident_len -4, ident + 4 */
 458         mn = snmp_expand_tree((struct mib_node*)&internet, 0, NULL, &oid);
 459       }
 460     }
 461     else
 462     {
 463       mn = NULL;
 464     }
 465     if (mn != NULL)
 466     {
 467       if (mn->node_type == MIB_NODE_EX)
 468       {
 469         /* external object */
 470         struct mib_external_node *en = (struct mib_external_node*)mn;
 471
 472         msg_ps->state = SNMP_MSG_EXTERNAL_GET_OBJDEF;
 473         /* save en && args in msg_ps!! */
 474         msg_ps->ext_mib_node = en;
 475         msg_ps->ext_oid = oid;
 476
 477         en->get_object_def_q(en->addr_inf, request_id, 1, &oid.id[oid.len - 1]);
 478       }
 479       else
 480       {
 481         /* internal object */
 482         struct obj_def object_def;
 483         struct snmp_varbind *vb;
 484
 485         msg_ps->state = SNMP_MSG_INTERNAL_GET_OBJDEF;
 486         mn->get_object_def(1, &oid.id[oid.len - 1], &object_def);
 487
 488         LWIP_ASSERT("invalid length", object_def.v_len <= 0xff);
 489         vb = snmp_varbind_alloc(&oid, object_def.asn_type, (u8_t)object_def.v_len);
 490         if (vb != NULL)
 491         {
 492           msg_ps->state = SNMP_MSG_INTERNAL_GET_VALUE;
 493           mn->get_value(&object_def, object_def.v_len, vb->value);
 494           snmp_varbind_tail_add(&msg_ps->outvb, vb);
 495           msg_ps->state = SNMP_MSG_SEARCH_OBJ;
 496           msg_ps->vb_idx += 1;
 497         }
 498         else
 499         {
 500           LWIP_DEBUGF(SNMP_MSG_DEBUG, ("snmp_recv couldn't allocate outvb space\n"));
 501           snmp_error_response(msg_ps,SNMP_ES_TOOBIG);
 502         }
 503       }
 504     }
 505     if (mn == NULL)
 506     {
 507       /* mn == NULL, noSuchName */
 508       snmp_error_response(msg_ps,SNMP_ES_NOSUCHNAME);
 509     }
 510   }
 511   if ((msg_ps->state == SNMP_MSG_SEARCH_OBJ) &&
 512       (msg_ps->vb_idx == msg_ps->invb.count))
 513   {
 514     snmp_ok_response(msg_ps);
 515   }
 516 }
 517
 518 /**
 519  * Service an internal or external event for SNMP SET.
 520  *
 521  * @param request_id identifies requests from 0 to (SNMP_CONCURRENT_REQUESTS-1)
 522  * @param msg_ps points to the assosicated message process state
 523  */
 524 static void
 525 snmp_msg_set_event(u8_t request_id, struct snmp_msg_pstat *msg_ps)
 526 {
 527   LWIP_DEBUGF(SNMP_MSG_DEBUG, ("snmp_msg_set_event: msg_ps->state==%"U16_F"\n",(u16_t)msg_ps->state));
 528
 529   if (msg_ps->state == SNMP_MSG_EXTERNAL_GET_OBJDEF)
 530   {
 531     struct mib_external_node *en;
 532     struct snmp_name_ptr np;
 533
 534     /* get_object_def() answer*/
 535     en = msg_ps->ext_mib_node;
 536     np = msg_ps->ext_name_ptr;
 537
 538     /* translate answer into a known lifeform */
 539     en->get_object_def_a(request_id, np.ident_len, np.ident, &msg_ps->ext_object_def);
 540     if (msg_ps->ext_object_def.instance != MIB_OBJECT_NONE)
 541     {
 542       msg_ps->state = SNMP_MSG_EXTERNAL_SET_TEST;
 543       en->set_test_q(request_id, &msg_ps->ext_object_def);
 544     }
 545     else
 546     {
 547       en->get_object_def_pc(request_id, np.ident_len, np.ident);
 548       /* search failed, object id points to unknown object (nosuchname) */
 549       snmp_error_response(msg_ps,SNMP_ES_NOSUCHNAME);
 550     }
 551   }
 552   else if (msg_ps->state == SNMP_MSG_EXTERNAL_SET_TEST)
 553   {
 554     struct mib_external_node *en;
 555
 556     /* set_test() answer*/
 557     en = msg_ps->ext_mib_node;
 558
 559     if (msg_ps->ext_object_def.access & MIB_ACCESS_WRITE)
 560     {
 561        if ((msg_ps->ext_object_def.asn_type == msg_ps->vb_ptr->value_type) &&
 562            (en->set_test_a(request_id,&msg_ps->ext_object_def,
 563                            msg_ps->vb_ptr->value_len,msg_ps->vb_ptr->value) != 0))
 564       {
 565         msg_ps->state = SNMP_MSG_SEARCH_OBJ;
 566         msg_ps->vb_idx += 1;
 567       }
 568       else
 569       {
 570         en->set_test_pc(request_id,&msg_ps->ext_object_def);
 571         /* bad value */
 572         snmp_error_response(msg_ps,SNMP_ES_BADVALUE);
 573       }
 574     }
 575     else
 576     {
 577       en->set_test_pc(request_id,&msg_ps->ext_object_def);
 578       /* object not available for set */
 579       snmp_error_response(msg_ps,SNMP_ES_NOSUCHNAME);
 580     }
 581   }
 582   else if (msg_ps->state == SNMP_MSG_EXTERNAL_GET_OBJDEF_S)
 583   {
 584     struct mib_external_node *en;
 585     struct snmp_name_ptr np;
 586
 587     /* get_object_def() answer*/
 588     en = msg_ps->ext_mib_node;
 589     np = msg_ps->ext_name_ptr;
 590
 591     /* translate answer into a known lifeform */
 592     en->get_object_def_a(request_id, np.ident_len, np.ident, &msg_ps->ext_object_def);
 593     if (msg_ps->ext_object_def.instance != MIB_OBJECT_NONE)
 594     {
 595       msg_ps->state = SNMP_MSG_EXTERNAL_SET_VALUE;
 596       en->set_value_q(request_id, &msg_ps->ext_object_def,
 597                       msg_ps->vb_ptr->value_len,msg_ps->vb_ptr->value);
 598     }
 599     else
 600     {
 601       en->get_object_def_pc(request_id, np.ident_len, np.ident);
 602       /* set_value failed, object has disappeared for some odd reason?? */
 603       snmp_error_response(msg_ps,SNMP_ES_GENERROR);
 604     }
 605   }
 606   else if (msg_ps->state == SNMP_MSG_EXTERNAL_SET_VALUE)
 607   {
 608     struct mib_external_node *en;
 609
 610     /** set_value_a() */
 611     en = msg_ps->ext_mib_node;
 612     en->set_value_a(request_id, &msg_ps->ext_object_def,
 613       msg_ps->vb_ptr->value_len, msg_ps->vb_ptr->value);
 614
 615     /** @todo use set_value_pc() if toobig */
 616     msg_ps->state = SNMP_MSG_INTERNAL_SET_VALUE;
 617     msg_ps->vb_idx += 1;
 618   }
 619
 620   /* test all values before setting */
 621   while ((msg_ps->state == SNMP_MSG_SEARCH_OBJ) &&
 622          (msg_ps->vb_idx < msg_ps->invb.count))
 623   {
 624     struct mib_node *mn;
 625     struct snmp_name_ptr np;
 626
 627     if (msg_ps->vb_idx == 0)
 628     {
 629       msg_ps->vb_ptr = msg_ps->invb.head;
 630     }
 631     else
 632     {
 633       msg_ps->vb_ptr = msg_ps->vb_ptr->next;
 634     }
 635     /** test object identifier for .iso.org.dod.internet prefix */
 636     if (snmp_iso_prefix_tst(msg_ps->vb_ptr->ident_len,  msg_ps->vb_ptr->ident))
 637     {
 638       mn = snmp_search_tree((struct mib_node*)&internet, msg_ps->vb_ptr->ident_len - 4,
 639                              msg_ps->vb_ptr->ident + 4, &np);
 640       if (mn != NULL)
 641       {
 642         if (mn->node_type == MIB_NODE_EX)
 643         {
 644           /* external object */
 645           struct mib_external_node *en = (struct mib_external_node*)mn;
 646
 647           msg_ps->state = SNMP_MSG_EXTERNAL_GET_OBJDEF;
 648           /* save en && args in msg_ps!! */
 649           msg_ps->ext_mib_node = en;
 650           msg_ps->ext_name_ptr = np;
 651
 652           en->get_object_def_q(en->addr_inf, request_id, np.ident_len, np.ident);
 653         }
 654         else
 655         {
 656           /* internal object */
 657           struct obj_def object_def;
 658
 659           msg_ps->state = SNMP_MSG_INTERNAL_GET_OBJDEF;
 660           mn->get_object_def(np.ident_len, np.ident, &object_def);
 661           if (object_def.instance != MIB_OBJECT_NONE)
 662           {
 663             mn = mn;
 664           }
 665           else
 666           {
 667             /* search failed, object id points to unknown object (nosuchname) */
 668             mn = NULL;
 669           }
 670           if (mn != NULL)
 671           {
 672             msg_ps->state = SNMP_MSG_INTERNAL_SET_TEST;
 673
 674             if (object_def.access & MIB_ACCESS_WRITE)
 675             {
 676               if ((object_def.asn_type == msg_ps->vb_ptr->value_type) &&
 677                   (mn->set_test(&object_def,msg_ps->vb_ptr->value_len,msg_ps->vb_ptr->value) != 0))
 678               {
 679                 msg_ps->state = SNMP_MSG_SEARCH_OBJ;
 680                 msg_ps->vb_idx += 1;
 681               }
 682               else
 683               {
 684                 /* bad value */
 685                 snmp_error_response(msg_ps,SNMP_ES_BADVALUE);
 686               }
 687             }
 688             else
 689             {
 690               /* object not available for set */
 691               snmp_error_response(msg_ps,SNMP_ES_NOSUCHNAME);
 692             }
 693           }
 694         }
 695       }
 696     }
 697     else
 698     {
 699       mn = NULL;
 700     }
 701     if (mn == NULL)
 702     {
 703       /* mn == NULL, noSuchName */
 704       snmp_error_response(msg_ps,SNMP_ES_NOSUCHNAME);
 705     }
 706   }
 707
 708   if ((msg_ps->state == SNMP_MSG_SEARCH_OBJ) &&
 709       (msg_ps->vb_idx == msg_ps->invb.count))
 710   {
 711     msg_ps->vb_idx = 0;
 712     msg_ps->state = SNMP_MSG_INTERNAL_SET_VALUE;
 713   }
 714
 715   /* set all values "atomically" (be as "atomic" as possible) */
 716   while ((msg_ps->state == SNMP_MSG_INTERNAL_SET_VALUE) &&
 717          (msg_ps->vb_idx < msg_ps->invb.count))
 718   {
 719     struct mib_node *mn;
 720     struct snmp_name_ptr np;
 721
 722     if (msg_ps->vb_idx == 0)
 723     {
 724       msg_ps->vb_ptr = msg_ps->invb.head;
 725     }
 726     else
 727     {
 728       msg_ps->vb_ptr = msg_ps->vb_ptr->next;
 729     }
 730     /* skip iso prefix test, was done previously while settesting() */
 731     mn = snmp_search_tree((struct mib_node*)&internet, msg_ps->vb_ptr->ident_len - 4,
 732                            msg_ps->vb_ptr->ident + 4, &np);
 733     /* check if object is still available
 734        (e.g. external hot-plug thingy present?) */
 735     if (mn != NULL)
 736     {
 737       if (mn->node_type == MIB_NODE_EX)
 738       {
 739         /* external object */
 740         struct mib_external_node *en = (struct mib_external_node*)mn;
 741
 742         msg_ps->state = SNMP_MSG_EXTERNAL_GET_OBJDEF_S;
 743         /* save en && args in msg_ps!! */
 744         msg_ps->ext_mib_node = en;
 745         msg_ps->ext_name_ptr = np;
 746
 747         en->get_object_def_q(en->addr_inf, request_id, np.ident_len, np.ident);
 748       }
 749       else
 750       {
 751         /* internal object */
 752         struct obj_def object_def;
 753
 754         msg_ps->state = SNMP_MSG_INTERNAL_GET_OBJDEF_S;
 755         mn->get_object_def(np.ident_len, np.ident, &object_def);
 756         msg_ps->state = SNMP_MSG_INTERNAL_SET_VALUE;
 757         mn->set_value(&object_def,msg_ps->vb_ptr->value_len,msg_ps->vb_ptr->value);
 758         msg_ps->vb_idx += 1;
 759       }
 760     }
 761   }
 762   if ((msg_ps->state == SNMP_MSG_INTERNAL_SET_VALUE) &&
 763       (msg_ps->vb_idx == msg_ps->invb.count))
 764   {
 765     /* simply echo the input if we can set it
 766        @todo do we need to return the actual value?
 767        e.g. if value is silently modified or behaves sticky? */
 768     msg_ps->outvb = msg_ps->invb;
 769     msg_ps->invb.head = NULL;
 770     msg_ps->invb.tail = NULL;
 771     msg_ps->invb.count = 0;
 772     snmp_ok_response(msg_ps);
 773   }
 774 }
 775
 776
 777 /**
 778  * Handle one internal or external event.
 779  * Called for one async event. (recv external/private answer)
 780  *
 781  * @param request_id identifies requests from 0 to (SNMP_CONCURRENT_REQUESTS-1)
 782  */
 783 void
 784 snmp_msg_event(u8_t request_id)
 785 {
 786   struct snmp_msg_pstat *msg_ps;
 787
 788   if (request_id < SNMP_CONCURRENT_REQUESTS)
 789   {
 790     msg_ps = &msg_input_list[request_id];
 791     if (msg_ps->rt == SNMP_ASN1_PDU_GET_NEXT_REQ)
 792     {
 793       snmp_msg_getnext_event(request_id, msg_ps);
 794     }
 795     else if (msg_ps->rt == SNMP_ASN1_PDU_GET_REQ)
 796     {
 797       snmp_msg_get_event(request_id, msg_ps);
 798     }
 799     else if(msg_ps->rt == SNMP_ASN1_PDU_SET_REQ)
 800     {
 801       snmp_msg_set_event(request_id, msg_ps);
 802     }
 803   }
 804 }
 805
 806
 807 /* lwIP UDP receive callback function */
 808 static void
 809 snmp_recv(void *arg, struct udp_pcb *pcb, struct pbuf *p, ip_addr_t *addr, u16_t port)
 810 {
 811   struct snmp_msg_pstat *msg_ps;
 812   u8_t req_idx;
 813   err_t err_ret;
 814   u16_t payload_len = p->tot_len;
 815   u16_t payload_ofs = 0;
 816   u16_t varbind_ofs = 0;
 817
 818   /* suppress unused argument warning */
 819   LWIP_UNUSED_ARG(arg);
 820
 821   /* traverse input message process list, look for SNMP_MSG_EMPTY */
 822   msg_ps = &msg_input_list[0];
 823   req_idx = 0;
 824   while ((req_idx < SNMP_CONCURRENT_REQUESTS) && (msg_ps->state != SNMP_MSG_EMPTY))
 825   {
 826     req_idx++;
 827     msg_ps++;
 828   }
 829   if (req_idx == SNMP_CONCURRENT_REQUESTS)
 830   {
 831     /* exceeding number of concurrent requests */
 832     pbuf_free(p);
 833     return;
 834   }
 835
 836   /* accepting request */
 837   snmp_inc_snmpinpkts();
 838   /* record used 'protocol control block' */
 839   msg_ps->pcb = pcb;
 840   /* source address (network order) */
 841   msg_ps->sip = *addr;
 842   /* source port (host order (lwIP oddity)) */
 843   msg_ps->sp = port;
 844
 845   /* check total length, version, community, pdu type */
 846   err_ret = snmp_pdu_header_check(p, payload_ofs, payload_len, &varbind_ofs, msg_ps);
 847   /* Only accept requests and requests without error (be robust) */
 848   /* Reject response and trap headers or error requests as input! */
 849   if ((err_ret != ERR_OK) ||
 850       ((msg_ps->rt != SNMP_ASN1_PDU_GET_REQ) &&
 851        (msg_ps->rt != SNMP_ASN1_PDU_GET_NEXT_REQ) &&
 852        (msg_ps->rt != SNMP_ASN1_PDU_SET_REQ)) ||
 853       ((msg_ps->error_status != SNMP_ES_NOERROR) ||
 854        (msg_ps->error_index != 0)) )
 855   {
 856     /* header check failed drop request silently, do not return error! */
 857     pbuf_free(p);
 858     LWIP_DEBUGF(SNMP_MSG_DEBUG, ("snmp_pdu_header_check() failed\n"));
 859     return;
 860   }
 861   LWIP_DEBUGF(SNMP_MSG_DEBUG, ("snmp_recv ok, community %s\n", msg_ps->community));
 862
 863   /* Builds a list of variable bindings. Copy the varbinds from the pbuf
 864     chain to glue them when these are divided over two or more pbuf's. */
 865   err_ret = snmp_pdu_dec_varbindlist(p, varbind_ofs, &varbind_ofs, msg_ps);
 866   /* we've decoded the incoming message, release input msg now */
 867   pbuf_free(p);
 868   if ((err_ret != ERR_OK) || (msg_ps->invb.count == 0))
 869   {
 870     /* varbind-list decode failed, or varbind list empty.
 871        drop request silently, do not return error!
 872        (errors are only returned for a specific varbind failure) */
 873     LWIP_DEBUGF(SNMP_MSG_DEBUG, ("snmp_pdu_dec_varbindlist() failed\n"));
 874     return;
 875   }
 876
 877   msg_ps->error_status = SNMP_ES_NOERROR;
 878   msg_ps->error_index = 0;
 879   /* find object for each variable binding */
 880   msg_ps->state = SNMP_MSG_SEARCH_OBJ;
 881   /* first variable binding from list to inspect */
 882   msg_ps->vb_idx = 0;
 883
 884   LWIP_DEBUGF(SNMP_MSG_DEBUG, ("snmp_recv varbind cnt=%"U16_F"\n",(u16_t)msg_ps->invb.count));
 885
 886   /* handle input event and as much objects as possible in one go */
 887   snmp_msg_event(req_idx);
 888 }
 889
 890 /**
 891  * Checks and decodes incoming SNMP message header, logs header errors.
 892  *
 893  * @param p points to pbuf chain of SNMP message (UDP payload)
 894  * @param ofs points to first octet of SNMP message
 895  * @param pdu_len the length of the UDP payload
 896  * @param ofs_ret returns the ofset of the variable bindings
 897  * @param m_stat points to the current message request state return
 898  * @return
 899  * - ERR_OK SNMP header is sane and accepted
 900  * - ERR_ARG SNMP header is either malformed or rejected
 901  */
 902 static err_t
 903 snmp_pdu_header_check(struct pbuf *p, u16_t ofs, u16_t pdu_len, u16_t *ofs_ret, struct snmp_msg_pstat *m_stat)
 904 {
 905   err_t derr;
 906   u16_t len, ofs_base;
 907   u8_t  len_octets;
 908   u8_t  type;
 909   s32_t version;
 910
 911   ofs_base = ofs;
 912   snmp_asn1_dec_type(p, ofs, &type);
 913   derr = snmp_asn1_dec_length(p, ofs+1, &len_octets, &len);
 914   if ((derr != ERR_OK) ||
 915       (pdu_len != (1 + len_octets + len)) ||
 916       (type != (SNMP_ASN1_UNIV | SNMP_ASN1_CONSTR | SNMP_ASN1_SEQ)))
 917   {
 918     snmp_inc_snmpinasnparseerrs();
 919     return ERR_ARG;
 920   }
 921   ofs += (1 + len_octets);
 922   snmp_asn1_dec_type(p, ofs, &type);
 923   derr = snmp_asn1_dec_length(p, ofs+1, &len_octets, &len);
 924   if ((derr != ERR_OK) || (type != (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_INTEG)))
 925   {
 926     /* can't decode or no integer (version) */
 927     snmp_inc_snmpinasnparseerrs();
 928     return ERR_ARG;
 929   }
 930   derr = snmp_asn1_dec_s32t(p, ofs + 1 + len_octets, len, &version);
 931   if (derr != ERR_OK)
 932   {
 933     /* can't decode */
 934     snmp_inc_snmpinasnparseerrs();
 935     return ERR_ARG;
 936   }
 937   if (version != 0)
 938   {
 939     /* not version 1 */
 940     snmp_inc_snmpinbadversions();
 941     return ERR_ARG;
 942   }
 943   ofs += (1 + len_octets + len);
 944   snmp_asn1_dec_type(p, ofs, &type);
 945   derr = snmp_asn1_dec_length(p, ofs+1, &len_octets, &len);
 946   if ((derr != ERR_OK) || (type != (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_OC_STR)))
 947   {
 948     /* can't decode or no octet string (community) */
 949     snmp_inc_snmpinasnparseerrs();
 950     return ERR_ARG;
 951   }
 952   derr = snmp_asn1_dec_raw(p, ofs + 1 + len_octets, len, SNMP_COMMUNITY_STR_LEN, m_stat->community);
 953   if (derr != ERR_OK)
 954   {
 955     snmp_inc_snmpinasnparseerrs();
 956     return ERR_ARG;
 957   }
 958   /* add zero terminator */
 959   len = ((len < (SNMP_COMMUNITY_STR_LEN))?(len):(SNMP_COMMUNITY_STR_LEN));
 960   m_stat->community[len] = 0;
 961   m_stat->com_strlen = (u8_t)len;
 962   if (strncmp(snmp_publiccommunity, (const char*)m_stat->community, SNMP_COMMUNITY_STR_LEN) != 0)
 963   {
 964     /** @todo: move this if we need to check more names */
 965     snmp_inc_snmpinbadcommunitynames();
 966     snmp_authfail_trap();
 967     return ERR_ARG;
 968   }
 969   ofs += (1 + len_octets + len);
 970   snmp_asn1_dec_type(p, ofs, &type);
 971   derr = snmp_asn1_dec_length(p, ofs+1, &len_octets, &len);
 972   if (derr != ERR_OK)
 973   {
 974     snmp_inc_snmpinasnparseerrs();
 975     return ERR_ARG;
 976   }
 977   switch(type)
 978   {
 979     case (SNMP_ASN1_CONTXT | SNMP_ASN1_CONSTR | SNMP_ASN1_PDU_GET_REQ):
 980       /* GetRequest PDU */
 981       snmp_inc_snmpingetrequests();
 982       derr = ERR_OK;
 983       break;
 984     case (SNMP_ASN1_CONTXT | SNMP_ASN1_CONSTR | SNMP_ASN1_PDU_GET_NEXT_REQ):
 985       /* GetNextRequest PDU */
 986       snmp_inc_snmpingetnexts();
 987       derr = ERR_OK;
 988       break;
 989     case (SNMP_ASN1_CONTXT | SNMP_ASN1_CONSTR | SNMP_ASN1_PDU_GET_RESP):
 990       /* GetResponse PDU */
 991       snmp_inc_snmpingetresponses();
 992       derr = ERR_ARG;
 993       break;
 994     case (SNMP_ASN1_CONTXT | SNMP_ASN1_CONSTR | SNMP_ASN1_PDU_SET_REQ):
 995       /* SetRequest PDU */
 996       snmp_inc_snmpinsetrequests();
 997       derr = ERR_OK;
 998       break;
 999     case (SNMP_ASN1_CONTXT | SNMP_ASN1_CONSTR | SNMP_ASN1_PDU_TRAP):
1000       /* Trap PDU */
1001       snmp_inc_snmpintraps();
1002       derr = ERR_ARG;
1003       break;
1004     default:
1005       snmp_inc_snmpinasnparseerrs();
1006       derr = ERR_ARG;
1007       break;
1008   }
1009   if (derr != ERR_OK)
1010   {
1011     /* unsupported input PDU for this agent (no parse error) */
1012     return ERR_ARG;
1013   }
1014   m_stat->rt = type & 0x1F;
1015   ofs += (1 + len_octets);
1016   if (len != (pdu_len - (ofs - ofs_base)))
1017   {
1018     /* decoded PDU length does not equal actual payload length */
1019     snmp_inc_snmpinasnparseerrs();
1020     return ERR_ARG;
1021   }
1022   snmp_asn1_dec_type(p, ofs, &type);
1023   derr = snmp_asn1_dec_length(p, ofs+1, &len_octets, &len);
1024   if ((derr != ERR_OK) || (type != (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_INTEG)))
1025   {
1026     /* can't decode or no integer (request ID) */
1027     snmp_inc_snmpinasnparseerrs();
1028     return ERR_ARG;
1029   }
1030   derr = snmp_asn1_dec_s32t(p, ofs + 1 + len_octets, len, &m_stat->rid);
1031   if (derr != ERR_OK)
1032   {
1033     /* can't decode */
1034     snmp_inc_snmpinasnparseerrs();
1035     return ERR_ARG;
1036   }
1037   ofs += (1 + len_octets + len);
1038   snmp_asn1_dec_type(p, ofs, &type);
1039   derr = snmp_asn1_dec_length(p, ofs+1, &len_octets, &len);
1040   if ((derr != ERR_OK) || (type != (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_INTEG)))
1041   {
1042     /* can't decode or no integer (error-status) */
1043     snmp_inc_snmpinasnparseerrs();
1044     return ERR_ARG;
1045   }
1046   /* must be noError (0) for incoming requests.
1047      log errors for mib-2 completeness and for debug purposes */
1048   derr = snmp_asn1_dec_s32t(p, ofs + 1 + len_octets, len, &m_stat->error_status);
1049   if (derr != ERR_OK)
1050   {
1051     /* can't decode */
1052     snmp_inc_snmpinasnparseerrs();
1053     return ERR_ARG;
1054   }
1055   switch (m_stat->error_status)
1056   {
1057     case SNMP_ES_TOOBIG:
1058       snmp_inc_snmpintoobigs();
1059       break;
1060     case SNMP_ES_NOSUCHNAME:
1061       snmp_inc_snmpinnosuchnames();
1062       break;
1063     case SNMP_ES_BADVALUE:
1064       snmp_inc_snmpinbadvalues();
1065       break;
1066     case SNMP_ES_READONLY:
1067       snmp_inc_snmpinreadonlys();
1068       break;
1069     case SNMP_ES_GENERROR:
1070       snmp_inc_snmpingenerrs();
1071       break;
1072   }
1073   ofs += (1 + len_octets + len);
1074   snmp_asn1_dec_type(p, ofs, &type);
1075   derr = snmp_asn1_dec_length(p, ofs+1, &len_octets, &len);
1076   if ((derr != ERR_OK) || (type != (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_INTEG)))
1077   {
1078     /* can't decode or no integer (error-index) */
1079     snmp_inc_snmpinasnparseerrs();
1080     return ERR_ARG;
1081   }
1082   /* must be 0 for incoming requests.
1083      decode anyway to catch bad integers (and dirty tricks) */
1084   derr = snmp_asn1_dec_s32t(p, ofs + 1 + len_octets, len, &m_stat->error_index);
1085   if (derr != ERR_OK)
1086   {
1087     /* can't decode */
1088     snmp_inc_snmpinasnparseerrs();
1089     return ERR_ARG;
1090   }
1091   ofs += (1 + len_octets + len);
1092   *ofs_ret = ofs;
1093   return ERR_OK;
1094 }
1095
1096 static err_t
1097 snmp_pdu_dec_varbindlist(struct pbuf *p, u16_t ofs, u16_t *ofs_ret, struct snmp_msg_pstat *m_stat)
1098 {
1099   err_t derr;
1100   u16_t len, vb_len;
1101   u8_t  len_octets;
1102   u8_t type;
1103
1104   /* variable binding list */
1105   snmp_asn1_dec_type(p, ofs, &type);
1106   derr = snmp_asn1_dec_length(p, ofs+1, &len_octets, &vb_len);
1107   if ((derr != ERR_OK) ||
1108       (type != (SNMP_ASN1_UNIV | SNMP_ASN1_CONSTR | SNMP_ASN1_SEQ)))
1109   {
1110     snmp_inc_snmpinasnparseerrs();
1111     return ERR_ARG;
1112   }
1113   ofs += (1 + len_octets);
1114
1115   /* start with empty list */
1116   m_stat->invb.count = 0;
1117   m_stat->invb.head = NULL;
1118   m_stat->invb.tail = NULL;
1119
1120   while (vb_len > 0)
1121   {
1122     struct snmp_obj_id oid, oid_value;
1123     struct snmp_varbind *vb;
1124
1125     snmp_asn1_dec_type(p, ofs, &type);
1126     derr = snmp_asn1_dec_length(p, ofs+1, &len_octets, &len);
1127     if ((derr != ERR_OK) ||
1128         (type != (SNMP_ASN1_UNIV | SNMP_ASN1_CONSTR | SNMP_ASN1_SEQ)) ||
1129         (len == 0) || (len > vb_len))
1130     {
1131       snmp_inc_snmpinasnparseerrs();
1132       /* free varbinds (if available) */
1133       snmp_varbind_list_free(&m_stat->invb);
1134       return ERR_ARG;
1135     }
1136     ofs += (1 + len_octets);
1137     vb_len -= (1 + len_octets);
1138
1139     snmp_asn1_dec_type(p, ofs, &type);
1140     derr = snmp_asn1_dec_length(p, ofs+1, &len_octets, &len);
1141     if ((derr != ERR_OK) || (type != (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_OBJ_ID)))
1142     {
1143       /* can't decode object name length */
1144       snmp_inc_snmpinasnparseerrs();
1145       /* free varbinds (if available) */
1146       snmp_varbind_list_free(&m_stat->invb);
1147       return ERR_ARG;
1148     }
1149     derr = snmp_asn1_dec_oid(p, ofs + 1 + len_octets, len, &oid);
1150     if (derr != ERR_OK)
1151     {
1152       /* can't decode object name */
1153       snmp_inc_snmpinasnparseerrs();
1154       /* free varbinds (if available) */
1155       snmp_varbind_list_free(&m_stat->invb);
1156       return ERR_ARG;
1157     }
1158     ofs += (1 + len_octets + len);
1159     vb_len -= (1 + len_octets + len);
1160
1161     snmp_asn1_dec_type(p, ofs, &type);
1162     derr = snmp_asn1_dec_length(p, ofs+1, &len_octets, &len);
1163     if (derr != ERR_OK)
1164     {
1165       /* can't decode object value length */
1166       snmp_inc_snmpinasnparseerrs();
1167       /* free varbinds (if available) */
1168       snmp_varbind_list_free(&m_stat->invb);
1169       return ERR_ARG;
1170     }
1171
1172     switch (type)
1173     {
1174       case (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_INTEG):
1175         vb = snmp_varbind_alloc(&oid, type, sizeof(s32_t));
1176         if (vb != NULL)
1177         {
1178           s32_t *vptr = (s32_t*)vb->value;
1179
1180           derr = snmp_asn1_dec_s32t(p, ofs + 1 + len_octets, len, vptr);
1181           snmp_varbind_tail_add(&m_stat->invb, vb);
1182         }
1183         else
1184         {
1185           derr = ERR_ARG;
1186         }
1187         break;
1188       case (SNMP_ASN1_APPLIC | SNMP_ASN1_PRIMIT | SNMP_ASN1_COUNTER):
1189       case (SNMP_ASN1_APPLIC | SNMP_ASN1_PRIMIT | SNMP_ASN1_GAUGE):
1190       case (SNMP_ASN1_APPLIC | SNMP_ASN1_PRIMIT | SNMP_ASN1_TIMETICKS):
1191         vb = snmp_varbind_alloc(&oid, type, sizeof(u32_t));
1192         if (vb != NULL)
1193         {
1194           u32_t *vptr = (u32_t*)vb->value;
1195
1196           derr = snmp_asn1_dec_u32t(p, ofs + 1 + len_octets, len, vptr);
1197           snmp_varbind_tail_add(&m_stat->invb, vb);
1198         }
1199         else
1200         {
1201           derr = ERR_ARG;
1202         }
1203         break;
1204       case (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_OC_STR):
1205       case (SNMP_ASN1_APPLIC | SNMP_ASN1_PRIMIT | SNMP_ASN1_OPAQUE):
1206         LWIP_ASSERT("invalid length", len <= 0xff);
1207         vb = snmp_varbind_alloc(&oid, type, (u8_t)len);
1208         if (vb != NULL)
1209         {
1210           derr = snmp_asn1_dec_raw(p, ofs + 1 + len_octets, len, vb->value_len, (u8_t*)vb->value);
1211           snmp_varbind_tail_add(&m_stat->invb, vb);
1212         }
1213         else
1214         {
1215           derr = ERR_ARG;
1216         }
1217         break;
1218       case (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_NUL):
1219         vb = snmp_varbind_alloc(&oid, type, 0);
1220         if (vb != NULL)
1221         {
1222           snmp_varbind_tail_add(&m_stat->invb, vb);
1223           derr = ERR_OK;
1224         }
1225         else
1226         {
1227           derr = ERR_ARG;
1228         }
1229         break;
1230       case (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_OBJ_ID):
1231         derr = snmp_asn1_dec_oid(p, ofs + 1 + len_octets, len, &oid_value);
1232         if (derr == ERR_OK)
1233         {
1234           vb = snmp_varbind_alloc(&oid, type, oid_value.len * sizeof(s32_t));
1235           if (vb != NULL)
1236           {
1237             u8_t i = oid_value.len;
1238             s32_t *vptr = (s32_t*)vb->value;
1239
1240             while(i > 0)
1241             {
1242               i--;
1243               vptr[i] = oid_value.id[i];
1244             }
1245             snmp_varbind_tail_add(&m_stat->invb, vb);
1246             derr = ERR_OK;
1247           }
1248           else
1249           {
1250             derr = ERR_ARG;
1251           }
1252         }
1253         break;
1254       case (SNMP_ASN1_APPLIC | SNMP_ASN1_PRIMIT | SNMP_ASN1_IPADDR):
1255         if (len == 4)
1256         {
1257           /* must be exactly 4 octets! */
1258           vb = snmp_varbind_alloc(&oid, type, 4);
1259           if (vb != NULL)
1260           {
1261             derr = snmp_asn1_dec_raw(p, ofs + 1 + len_octets, len, vb->value_len, (u8_t*)vb->value);
1262             snmp_varbind_tail_add(&m_stat->invb, vb);
1263           }
1264           else
1265           {
1266             derr = ERR_ARG;
1267           }
1268         }
1269         else
1270         {
1271           derr = ERR_ARG;
1272         }
1273         break;
1274       default:
1275         derr = ERR_ARG;
1276         break;
1277     }
1278     if (derr != ERR_OK)
1279     {
1280       snmp_inc_snmpinasnparseerrs();
1281       /* free varbinds (if available) */
1282       snmp_varbind_list_free(&m_stat->invb);
1283       return ERR_ARG;
1284     }
1285     ofs += (1 + len_octets + len);
1286     vb_len -= (1 + len_octets + len);
1287   }
1288
1289   if (m_stat->rt == SNMP_ASN1_PDU_SET_REQ)
1290   {
1291     snmp_add_snmpintotalsetvars(m_stat->invb.count);
1292   }
1293   else
1294   {
1295     snmp_add_snmpintotalreqvars(m_stat->invb.count);
1296   }
1297
1298   *ofs_ret = ofs;
1299   return ERR_OK;
1300 }
1301
1302 struct snmp_varbind*
1303 snmp_varbind_alloc(struct snmp_obj_id *oid, u8_t type, u8_t len)
1304 {
1305   struct snmp_varbind *vb;
1306
1307   vb = (struct snmp_varbind *)memp_malloc(MEMP_SNMP_VARBIND);
1308   LWIP_ASSERT("vb != NULL",vb != NULL);
1309   if (vb != NULL)
1310   {
1311     u8_t i;
1312
1313     vb->next = NULL;
1314     vb->prev = NULL;
1315     i = oid->len;
1316     vb->ident_len = i;
1317     if (i > 0)
1318     {
1319       LWIP_ASSERT("SNMP_MAX_TREE_DEPTH is configured too low", i <= SNMP_MAX_TREE_DEPTH);
1320       /* allocate array of s32_t for our object identifier */
1321       vb->ident = (s32_t*)memp_malloc(MEMP_SNMP_VALUE);
1322       LWIP_ASSERT("vb->ident != NULL",vb->ident != NULL);
1323       if (vb->ident == NULL)
1324       {
1325         memp_free(MEMP_SNMP_VARBIND, vb);
1326         return NULL;
1327       }
1328       while(i > 0)
1329       {
1330         i--;
1331         vb->ident[i] = oid->id[i];
1332       }
1333     }
1334     else
1335     {
1336       /* i == 0, pass zero length object identifier */
1337       vb->ident = NULL;
1338     }
1339     vb->value_type = type;
1340     vb->value_len = len;
1341     if (len > 0)
1342     {
1343       LWIP_ASSERT("SNMP_MAX_OCTET_STRING_LEN is configured too low", vb->value_len <= SNMP_MAX_VALUE_SIZE);
1344       /* allocate raw bytes for our object value */
1345       vb->value = memp_malloc(MEMP_SNMP_VALUE);
1346       LWIP_ASSERT("vb->value != NULL",vb->value != NULL);
1347       if (vb->value == NULL)
1348       {
1349         if (vb->ident != NULL)
1350         {
1351           memp_free(MEMP_SNMP_VALUE, vb->ident);
1352         }
1353         memp_free(MEMP_SNMP_VARBIND, vb);
1354         return NULL;
1355       }
1356     }
1357     else
1358     {
1359       /* ASN1_NUL type, or zero length ASN1_OC_STR */
1360       vb->value = NULL;
1361     }
1362   }
1363   return vb;
1364 }
1365
1366 void
1367 snmp_varbind_free(struct snmp_varbind *vb)
1368 {
1369   if (vb->value != NULL )
1370   {
1371     memp_free(MEMP_SNMP_VALUE, vb->value);
1372   }
1373   if (vb->ident != NULL )
1374   {
1375     memp_free(MEMP_SNMP_VALUE, vb->ident);
1376   }
1377   memp_free(MEMP_SNMP_VARBIND, vb);
1378 }
1379
1380 void
1381 snmp_varbind_list_free(struct snmp_varbind_root *root)
1382 {
1383   struct snmp_varbind *vb, *prev;
1384
1385   vb = root->tail;
1386   while ( vb != NULL )
1387   {
1388     prev = vb->prev;
1389     snmp_varbind_free(vb);
1390     vb = prev;
1391   }
1392   root->count = 0;
1393   root->head = NULL;
1394   root->tail = NULL;
1395 }
1396
1397 void
1398 snmp_varbind_tail_add(struct snmp_varbind_root *root, struct snmp_varbind *vb)
1399 {
1400   if (root->count == 0)
1401   {
1402     /* add first varbind to list */
1403     root->head = vb;
1404     root->tail = vb;
1405   }
1406   else
1407   {
1408     /* add nth varbind to list tail */
1409     root->tail->next = vb;
1410     vb->prev = root->tail;
1411     root->tail = vb;
1412   }
1413   root->count += 1;
1414 }
1415
1416 struct snmp_varbind*
1417 snmp_varbind_tail_remove(struct snmp_varbind_root *root)
1418 {
1419   struct snmp_varbind* vb;
1420
1421   if (root->count > 0)
1422   {
1423     /* remove tail varbind */
1424     vb = root->tail;
1425     root->tail = vb->prev;
1426     vb->prev->next = NULL;
1427     root->count -= 1;
1428   }
1429   else
1430   {
1431     /* nothing to remove */
1432     vb = NULL;
1433   }
1434   return vb;
1435 }
1436
1437 #endif /* LWIP_SNMP */