OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [rtos/] [freertos-6.1.1/] [Demo/] [Common/] [ethernet/] [lwIP_130/] [src/] [core/] [snmp/] [msg_in.c] - Blame information for rev 606

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.