tmk_core/tool/mbed/mbed-sdk/libraries/net/lwip/lwip/core/snmp/msg_out.c

   1 /**
   2  * @file
   3  * SNMP output message processing (RFC1157).
   4  *
   5  * Output responses and traps are build in two passes:
   6  *
   7  * Pass 0: iterate over the output message backwards to determine encoding lengths
   8  * Pass 1: the actual forward encoding of internal form into ASN1
   9  *
  10  * The single-pass encoding method described by Comer & Stevens
  11  * requires extra buffer space and copying for reversal of the packet.
  12  * The buffer requirement can be prohibitively large for big payloads
  13  * (>= 484) therefore we use the two encoding passes.
  14  */
  15
  16 /*
  17  * Copyright (c) 2006 Axon Digital Design B.V., The Netherlands.
  18  * All rights reserved.
  19  *
  20  * Redistribution and use in source and binary forms, with or without modification,
  21  * are permitted provided that the following conditions are met:
  22  *
  23  * 1. Redistributions of source code must retain the above copyright notice,
  24  *    this list of conditions and the following disclaimer.
  25  * 2. Redistributions in binary form must reproduce the above copyright notice,
  26  *    this list of conditions and the following disclaimer in the documentation
  27  *    and/or other materials provided with the distribution.
  28  * 3. The name of the author may not be used to endorse or promote products
  29  *    derived from this software without specific prior written permission.
  30  *
  31  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
  32  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  33  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
  34  * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  35  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
  36  * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  37  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  38  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  39  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  40  * OF SUCH DAMAGE.
  41  *
  42  * Author: Christiaan Simons <christiaan.simons@axon.tv>
  43  */
  44
  45 #include "lwip/opt.h"
  46
  47 #if LWIP_SNMP /* don't build if not configured for use in lwipopts.h */
  48
  49 #include "lwip/udp.h"
  50 #include "lwip/netif.h"
  51 #include "lwip/snmp.h"
  52 #include "lwip/snmp_asn1.h"
  53 #include "lwip/snmp_msg.h"
  54
  55 struct snmp_trap_dst
  56 {
  57   /* destination IP address in network order */
  58   ip_addr_t dip;
  59   /* set to 0 when disabled, >0 when enabled */
  60   u8_t enable;
  61 };
  62 struct snmp_trap_dst trap_dst[SNMP_TRAP_DESTINATIONS];
  63
  64 /** TRAP message structure */
  65 struct snmp_msg_trap trap_msg;
  66
  67 static u16_t snmp_resp_header_sum(struct snmp_msg_pstat *m_stat, u16_t vb_len);
  68 static u16_t snmp_trap_header_sum(struct snmp_msg_trap *m_trap, u16_t vb_len);
  69 static u16_t snmp_varbind_list_sum(struct snmp_varbind_root *root);
  70
  71 static u16_t snmp_resp_header_enc(struct snmp_msg_pstat *m_stat, struct pbuf *p);
  72 static u16_t snmp_trap_header_enc(struct snmp_msg_trap *m_trap, struct pbuf *p);
  73 static u16_t snmp_varbind_list_enc(struct snmp_varbind_root *root, struct pbuf *p, u16_t ofs);
  74
  75 /**
  76  * Sets enable switch for this trap destination.
  77  * @param dst_idx index in 0 .. SNMP_TRAP_DESTINATIONS-1
  78  * @param enable switch if 0 destination is disabled >0 enabled.
  79  */
  80 void
  81 snmp_trap_dst_enable(u8_t dst_idx, u8_t enable)
  82 {
  83   if (dst_idx < SNMP_TRAP_DESTINATIONS)
  84   {
  85     trap_dst[dst_idx].enable = enable;
  86   }
  87 }
  88
  89 /**
  90  * Sets IPv4 address for this trap destination.
  91  * @param dst_idx index in 0 .. SNMP_TRAP_DESTINATIONS-1
  92  * @param dst IPv4 address in host order.
  93  */
  94 void
  95 snmp_trap_dst_ip_set(u8_t dst_idx, ip_addr_t *dst)
  96 {
  97   if (dst_idx < SNMP_TRAP_DESTINATIONS)
  98   {
  99     ip_addr_set(&trap_dst[dst_idx].dip, dst);
 100   }
 101 }
 102
 103 /**
 104  * Sends a 'getresponse' message to the request originator.
 105  *
 106  * @param m_stat points to the current message request state source
 107  * @return ERR_OK when success, ERR_MEM if we're out of memory
 108  *
 109  * @note the caller is responsible for filling in outvb in the m_stat
 110  * and provide error-status and index (except for tooBig errors) ...
 111  */
 112 err_t
 113 snmp_send_response(struct snmp_msg_pstat *m_stat)
 114 {
 115   struct snmp_varbind_root emptyvb = {NULL, NULL, 0, 0, 0};
 116   struct pbuf *p;
 117   u16_t tot_len;
 118   err_t err;
 119
 120   /* pass 0, calculate length fields */
 121   tot_len = snmp_varbind_list_sum(&m_stat->outvb);
 122   tot_len = snmp_resp_header_sum(m_stat, tot_len);
 123
 124   /* try allocating pbuf(s) for complete response */
 125   p = pbuf_alloc(PBUF_TRANSPORT, tot_len, PBUF_POOL);
 126   if (p == NULL)
 127   {
 128     LWIP_DEBUGF(SNMP_MSG_DEBUG, ("snmp_snd_response() tooBig\n"));
 129
 130     /* can't construct reply, return error-status tooBig */
 131     m_stat->error_status = SNMP_ES_TOOBIG;
 132     m_stat->error_index = 0;
 133     /* pass 0, recalculate lengths, for empty varbind-list */
 134     tot_len = snmp_varbind_list_sum(&emptyvb);
 135     tot_len = snmp_resp_header_sum(m_stat, tot_len);
 136     /* retry allocation once for header and empty varbind-list */
 137     p = pbuf_alloc(PBUF_TRANSPORT, tot_len, PBUF_POOL);
 138   }
 139   if (p != NULL)
 140   {
 141     /* first pbuf alloc try or retry alloc success */
 142     u16_t ofs;
 143
 144     LWIP_DEBUGF(SNMP_MSG_DEBUG, ("snmp_snd_response() p != NULL\n"));
 145
 146     /* pass 1, size error, encode packet ino the pbuf(s) */
 147     ofs = snmp_resp_header_enc(m_stat, p);
 148     if (m_stat->error_status == SNMP_ES_TOOBIG)
 149     {
 150       snmp_varbind_list_enc(&emptyvb, p, ofs);
 151     }
 152     else
 153     {
 154       snmp_varbind_list_enc(&m_stat->outvb, p, ofs);
 155     }
 156
 157     switch (m_stat->error_status)
 158     {
 159       case SNMP_ES_TOOBIG:
 160         snmp_inc_snmpouttoobigs();
 161         break;
 162       case SNMP_ES_NOSUCHNAME:
 163         snmp_inc_snmpoutnosuchnames();
 164         break;
 165       case SNMP_ES_BADVALUE:
 166         snmp_inc_snmpoutbadvalues();
 167         break;
 168       case SNMP_ES_GENERROR:
 169         snmp_inc_snmpoutgenerrs();
 170         break;
 171     }
 172     snmp_inc_snmpoutgetresponses();
 173     snmp_inc_snmpoutpkts();
 174
 175     /** @todo do we need separate rx and tx pcbs for threaded case? */
 176     /** connect to the originating source */
 177     udp_connect(m_stat->pcb, &m_stat->sip, m_stat->sp);
 178     err = udp_send(m_stat->pcb, p);
 179     if (err == ERR_MEM)
 180     {
 181       /** @todo release some memory, retry and return tooBig? tooMuchHassle? */
 182       err = ERR_MEM;
 183     }
 184     else
 185     {
 186       err = ERR_OK;
 187     }
 188     /** disassociate remote address and port with this pcb */
 189     udp_disconnect(m_stat->pcb);
 190
 191     pbuf_free(p);
 192     LWIP_DEBUGF(SNMP_MSG_DEBUG, ("snmp_snd_response() done\n"));
 193     return err;
 194   }
 195   else
 196   {
 197     /* first pbuf alloc try or retry alloc failed
 198        very low on memory, couldn't return tooBig */
 199     return ERR_MEM;
 200   }
 201 }
 202
 203
 204 /**
 205  * Sends an generic or enterprise specific trap message.
 206  *
 207  * @param generic_trap is the trap code
 208  * @param eoid points to enterprise object identifier
 209  * @param specific_trap used for enterprise traps when generic_trap == 6
 210  * @return ERR_OK when success, ERR_MEM if we're out of memory
 211  *
 212  * @note the caller is responsible for filling in outvb in the trap_msg
 213  * @note the use of the enterpise identifier field
 214  * is per RFC1215.
 215  * Use .iso.org.dod.internet.mgmt.mib-2.snmp for generic traps
 216  * and .iso.org.dod.internet.private.enterprises.yourenterprise
 217  * (sysObjectID) for specific traps.
 218  */
 219 err_t
 220 snmp_send_trap(s8_t generic_trap, struct snmp_obj_id *eoid, s32_t specific_trap)
 221 {
 222   struct snmp_trap_dst *td;
 223   struct netif *dst_if;
 224   ip_addr_t dst_ip;
 225   struct pbuf *p;
 226   u16_t i,tot_len;
 227
 228   for (i=0, td = &trap_dst[0]; i<SNMP_TRAP_DESTINATIONS; i++, td++)
 229   {
 230     if ((td->enable != 0) && !ip_addr_isany(&td->dip))
 231     {
 232       /* network order trap destination */
 233       ip_addr_copy(trap_msg.dip, td->dip);
 234       /* lookup current source address for this dst */
 235       dst_if = ip_route(&td->dip);
 236       ip_addr_copy(dst_ip, dst_if->ip_addr);
 237       /* @todo: what about IPv6? */
 238       trap_msg.sip_raw[0] = ip4_addr1(&dst_ip);
 239       trap_msg.sip_raw[1] = ip4_addr2(&dst_ip);
 240       trap_msg.sip_raw[2] = ip4_addr3(&dst_ip);
 241       trap_msg.sip_raw[3] = ip4_addr4(&dst_ip);
 242       trap_msg.gen_trap = generic_trap;
 243       trap_msg.spc_trap = specific_trap;
 244       if (generic_trap == SNMP_GENTRAP_ENTERPRISESPC)
 245       {
 246         /* enterprise-Specific trap */
 247         trap_msg.enterprise = eoid;
 248       }
 249       else
 250       {
 251         /* generic (MIB-II) trap */
 252         snmp_get_snmpgrpid_ptr(&trap_msg.enterprise);
 253       }
 254       snmp_get_sysuptime(&trap_msg.ts);
 255
 256       /* pass 0, calculate length fields */
 257       tot_len = snmp_varbind_list_sum(&trap_msg.outvb);
 258       tot_len = snmp_trap_header_sum(&trap_msg, tot_len);
 259
 260       /* allocate pbuf(s) */
 261       p = pbuf_alloc(PBUF_TRANSPORT, tot_len, PBUF_POOL);
 262       if (p != NULL)
 263       {
 264         u16_t ofs;
 265
 266         /* pass 1, encode packet ino the pbuf(s) */
 267         ofs = snmp_trap_header_enc(&trap_msg, p);
 268         snmp_varbind_list_enc(&trap_msg.outvb, p, ofs);
 269
 270         snmp_inc_snmpouttraps();
 271         snmp_inc_snmpoutpkts();
 272
 273         /** send to the TRAP destination */
 274         udp_sendto(trap_msg.pcb, p, &trap_msg.dip, SNMP_TRAP_PORT);
 275
 276         pbuf_free(p);
 277       }
 278       else
 279       {
 280         return ERR_MEM;
 281       }
 282     }
 283   }
 284   return ERR_OK;
 285 }
 286
 287 void
 288 snmp_coldstart_trap(void)
 289 {
 290   trap_msg.outvb.head = NULL;
 291   trap_msg.outvb.tail = NULL;
 292   trap_msg.outvb.count = 0;
 293   snmp_send_trap(SNMP_GENTRAP_COLDSTART, NULL, 0);
 294 }
 295
 296 void
 297 snmp_authfail_trap(void)
 298 {
 299   u8_t enable;
 300   snmp_get_snmpenableauthentraps(&enable);
 301   if (enable == 1)
 302   {
 303     trap_msg.outvb.head = NULL;
 304     trap_msg.outvb.tail = NULL;
 305     trap_msg.outvb.count = 0;
 306     snmp_send_trap(SNMP_GENTRAP_AUTHFAIL, NULL, 0);
 307   }
 308 }
 309
 310 /**
 311  * Sums response header field lengths from tail to head and
 312  * returns resp_header_lengths for second encoding pass.
 313  *
 314  * @param vb_len varbind-list length
 315  * @param rhl points to returned header lengths
 316  * @return the required lenght for encoding the response header
 317  */
 318 static u16_t
 319 snmp_resp_header_sum(struct snmp_msg_pstat *m_stat, u16_t vb_len)
 320 {
 321   u16_t tot_len;
 322   struct snmp_resp_header_lengths *rhl;
 323
 324   rhl = &m_stat->rhl;
 325   tot_len = vb_len;
 326   snmp_asn1_enc_s32t_cnt(m_stat->error_index, &rhl->erridxlen);
 327   snmp_asn1_enc_length_cnt(rhl->erridxlen, &rhl->erridxlenlen);
 328   tot_len += 1 + rhl->erridxlenlen + rhl->erridxlen;
 329
 330   snmp_asn1_enc_s32t_cnt(m_stat->error_status, &rhl->errstatlen);
 331   snmp_asn1_enc_length_cnt(rhl->errstatlen, &rhl->errstatlenlen);
 332   tot_len += 1 + rhl->errstatlenlen + rhl->errstatlen;
 333
 334   snmp_asn1_enc_s32t_cnt(m_stat->rid, &rhl->ridlen);
 335   snmp_asn1_enc_length_cnt(rhl->ridlen, &rhl->ridlenlen);
 336   tot_len += 1 + rhl->ridlenlen + rhl->ridlen;
 337
 338   rhl->pdulen = tot_len;
 339   snmp_asn1_enc_length_cnt(rhl->pdulen, &rhl->pdulenlen);
 340   tot_len += 1 + rhl->pdulenlen;
 341
 342   rhl->comlen = m_stat->com_strlen;
 343   snmp_asn1_enc_length_cnt(rhl->comlen, &rhl->comlenlen);
 344   tot_len += 1 + rhl->comlenlen + rhl->comlen;
 345
 346   snmp_asn1_enc_s32t_cnt(snmp_version, &rhl->verlen);
 347   snmp_asn1_enc_length_cnt(rhl->verlen, &rhl->verlenlen);
 348   tot_len += 1 + rhl->verlen + rhl->verlenlen;
 349
 350   rhl->seqlen = tot_len;
 351   snmp_asn1_enc_length_cnt(rhl->seqlen, &rhl->seqlenlen);
 352   tot_len += 1 + rhl->seqlenlen;
 353
 354   return tot_len;
 355 }
 356
 357 /**
 358  * Sums trap header field lengths from tail to head and
 359  * returns trap_header_lengths for second encoding pass.
 360  *
 361  * @param vb_len varbind-list length
 362  * @param thl points to returned header lengths
 363  * @return the required lenght for encoding the trap header
 364  */
 365 static u16_t
 366 snmp_trap_header_sum(struct snmp_msg_trap *m_trap, u16_t vb_len)
 367 {
 368   u16_t tot_len;
 369   struct snmp_trap_header_lengths *thl;
 370
 371   thl = &m_trap->thl;
 372   tot_len = vb_len;
 373
 374   snmp_asn1_enc_u32t_cnt(m_trap->ts, &thl->tslen);
 375   snmp_asn1_enc_length_cnt(thl->tslen, &thl->tslenlen);
 376   tot_len += 1 + thl->tslen + thl->tslenlen;
 377
 378   snmp_asn1_enc_s32t_cnt(m_trap->spc_trap, &thl->strplen);
 379   snmp_asn1_enc_length_cnt(thl->strplen, &thl->strplenlen);
 380   tot_len += 1 + thl->strplen + thl->strplenlen;
 381
 382   snmp_asn1_enc_s32t_cnt(m_trap->gen_trap, &thl->gtrplen);
 383   snmp_asn1_enc_length_cnt(thl->gtrplen, &thl->gtrplenlen);
 384   tot_len += 1 + thl->gtrplen + thl->gtrplenlen;
 385
 386   thl->aaddrlen = 4;
 387   snmp_asn1_enc_length_cnt(thl->aaddrlen, &thl->aaddrlenlen);
 388   tot_len += 1 + thl->aaddrlen + thl->aaddrlenlen;
 389
 390   snmp_asn1_enc_oid_cnt(m_trap->enterprise->len, &m_trap->enterprise->id[0], &thl->eidlen);
 391   snmp_asn1_enc_length_cnt(thl->eidlen, &thl->eidlenlen);
 392   tot_len += 1 + thl->eidlen + thl->eidlenlen;
 393
 394   thl->pdulen = tot_len;
 395   snmp_asn1_enc_length_cnt(thl->pdulen, &thl->pdulenlen);
 396   tot_len += 1 + thl->pdulenlen;
 397
 398   thl->comlen = sizeof(snmp_publiccommunity) - 1;
 399   snmp_asn1_enc_length_cnt(thl->comlen, &thl->comlenlen);
 400   tot_len += 1 + thl->comlenlen + thl->comlen;
 401
 402   snmp_asn1_enc_s32t_cnt(snmp_version, &thl->verlen);
 403   snmp_asn1_enc_length_cnt(thl->verlen, &thl->verlenlen);
 404   tot_len += 1 + thl->verlen + thl->verlenlen;
 405
 406   thl->seqlen = tot_len;
 407   snmp_asn1_enc_length_cnt(thl->seqlen, &thl->seqlenlen);
 408   tot_len += 1 + thl->seqlenlen;
 409
 410   return tot_len;
 411 }
 412
 413 /**
 414  * Sums varbind lengths from tail to head and
 415  * annotates lengths in varbind for second encoding pass.
 416  *
 417  * @param root points to the root of the variable binding list
 418  * @return the required lenght for encoding the variable bindings
 419  */
 420 static u16_t
 421 snmp_varbind_list_sum(struct snmp_varbind_root *root)
 422 {
 423   struct snmp_varbind *vb;
 424   u32_t *uint_ptr;
 425   s32_t *sint_ptr;
 426   u16_t tot_len;
 427
 428   tot_len = 0;
 429   vb = root->tail;
 430   while ( vb != NULL )
 431   {
 432     /* encoded value lenght depends on type */
 433     switch (vb->value_type)
 434     {
 435       case (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_INTEG):
 436         sint_ptr = (s32_t*)vb->value;
 437         snmp_asn1_enc_s32t_cnt(*sint_ptr, &vb->vlen);
 438         break;
 439       case (SNMP_ASN1_APPLIC | SNMP_ASN1_PRIMIT | SNMP_ASN1_COUNTER):
 440       case (SNMP_ASN1_APPLIC | SNMP_ASN1_PRIMIT | SNMP_ASN1_GAUGE):
 441       case (SNMP_ASN1_APPLIC | SNMP_ASN1_PRIMIT | SNMP_ASN1_TIMETICKS):
 442         uint_ptr = (u32_t*)vb->value;
 443         snmp_asn1_enc_u32t_cnt(*uint_ptr, &vb->vlen);
 444         break;
 445       case (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_OC_STR):
 446       case (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_NUL):
 447       case (SNMP_ASN1_APPLIC | SNMP_ASN1_PRIMIT | SNMP_ASN1_IPADDR):
 448       case (SNMP_ASN1_APPLIC | SNMP_ASN1_PRIMIT | SNMP_ASN1_OPAQUE):
 449         vb->vlen = vb->value_len;
 450         break;
 451       case (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_OBJ_ID):
 452         sint_ptr = (s32_t*)vb->value;
 453         snmp_asn1_enc_oid_cnt(vb->value_len / sizeof(s32_t), sint_ptr, &vb->vlen);
 454         break;
 455       default:
 456         /* unsupported type */
 457         vb->vlen = 0;
 458         break;
 459     };
 460     /* encoding length of value length field */
 461     snmp_asn1_enc_length_cnt(vb->vlen, &vb->vlenlen);
 462     snmp_asn1_enc_oid_cnt(vb->ident_len, vb->ident, &vb->olen);
 463     snmp_asn1_enc_length_cnt(vb->olen, &vb->olenlen);
 464
 465     vb->seqlen = 1 + vb->vlenlen + vb->vlen;
 466     vb->seqlen += 1 + vb->olenlen + vb->olen;
 467     snmp_asn1_enc_length_cnt(vb->seqlen, &vb->seqlenlen);
 468
 469     /* varbind seq */
 470     tot_len += 1 + vb->seqlenlen + vb->seqlen;
 471
 472     vb = vb->prev;
 473   }
 474
 475   /* varbind-list seq */
 476   root->seqlen = tot_len;
 477   snmp_asn1_enc_length_cnt(root->seqlen, &root->seqlenlen);
 478   tot_len += 1 + root->seqlenlen;
 479
 480   return tot_len;
 481 }
 482
 483 /**
 484  * Encodes response header from head to tail.
 485  */
 486 static u16_t
 487 snmp_resp_header_enc(struct snmp_msg_pstat *m_stat, struct pbuf *p)
 488 {
 489   u16_t ofs;
 490
 491   ofs = 0;
 492   snmp_asn1_enc_type(p, ofs, (SNMP_ASN1_UNIV | SNMP_ASN1_CONSTR | SNMP_ASN1_SEQ));
 493   ofs += 1;
 494   snmp_asn1_enc_length(p, ofs, m_stat->rhl.seqlen);
 495   ofs += m_stat->rhl.seqlenlen;
 496
 497   snmp_asn1_enc_type(p, ofs, (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_INTEG));
 498   ofs += 1;
 499   snmp_asn1_enc_length(p, ofs, m_stat->rhl.verlen);
 500   ofs += m_stat->rhl.verlenlen;
 501   snmp_asn1_enc_s32t(p, ofs, m_stat->rhl.verlen, snmp_version);
 502   ofs += m_stat->rhl.verlen;
 503
 504   snmp_asn1_enc_type(p, ofs, (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_OC_STR));
 505   ofs += 1;
 506   snmp_asn1_enc_length(p, ofs, m_stat->rhl.comlen);
 507   ofs += m_stat->rhl.comlenlen;
 508   snmp_asn1_enc_raw(p, ofs, m_stat->rhl.comlen, m_stat->community);
 509   ofs += m_stat->rhl.comlen;
 510
 511   snmp_asn1_enc_type(p, ofs, (SNMP_ASN1_CONTXT | SNMP_ASN1_CONSTR | SNMP_ASN1_PDU_GET_RESP));
 512   ofs += 1;
 513   snmp_asn1_enc_length(p, ofs, m_stat->rhl.pdulen);
 514   ofs += m_stat->rhl.pdulenlen;
 515
 516   snmp_asn1_enc_type(p, ofs, (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_INTEG));
 517   ofs += 1;
 518   snmp_asn1_enc_length(p, ofs, m_stat->rhl.ridlen);
 519   ofs += m_stat->rhl.ridlenlen;
 520   snmp_asn1_enc_s32t(p, ofs, m_stat->rhl.ridlen, m_stat->rid);
 521   ofs += m_stat->rhl.ridlen;
 522
 523   snmp_asn1_enc_type(p, ofs, (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_INTEG));
 524   ofs += 1;
 525   snmp_asn1_enc_length(p, ofs, m_stat->rhl.errstatlen);
 526   ofs += m_stat->rhl.errstatlenlen;
 527   snmp_asn1_enc_s32t(p, ofs, m_stat->rhl.errstatlen, m_stat->error_status);
 528   ofs += m_stat->rhl.errstatlen;
 529
 530   snmp_asn1_enc_type(p, ofs, (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_INTEG));
 531   ofs += 1;
 532   snmp_asn1_enc_length(p, ofs, m_stat->rhl.erridxlen);
 533   ofs += m_stat->rhl.erridxlenlen;
 534   snmp_asn1_enc_s32t(p, ofs, m_stat->rhl.erridxlen, m_stat->error_index);
 535   ofs += m_stat->rhl.erridxlen;
 536
 537   return ofs;
 538 }
 539
 540 /**
 541  * Encodes trap header from head to tail.
 542  */
 543 static u16_t
 544 snmp_trap_header_enc(struct snmp_msg_trap *m_trap, struct pbuf *p)
 545 {
 546   u16_t ofs;
 547
 548   ofs = 0;
 549   snmp_asn1_enc_type(p, ofs, (SNMP_ASN1_UNIV | SNMP_ASN1_CONSTR | SNMP_ASN1_SEQ));
 550   ofs += 1;
 551   snmp_asn1_enc_length(p, ofs, m_trap->thl.seqlen);
 552   ofs += m_trap->thl.seqlenlen;
 553
 554   snmp_asn1_enc_type(p, ofs, (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_INTEG));
 555   ofs += 1;
 556   snmp_asn1_enc_length(p, ofs, m_trap->thl.verlen);
 557   ofs += m_trap->thl.verlenlen;
 558   snmp_asn1_enc_s32t(p, ofs, m_trap->thl.verlen, snmp_version);
 559   ofs += m_trap->thl.verlen;
 560
 561   snmp_asn1_enc_type(p, ofs, (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_OC_STR));
 562   ofs += 1;
 563   snmp_asn1_enc_length(p, ofs, m_trap->thl.comlen);
 564   ofs += m_trap->thl.comlenlen;
 565   snmp_asn1_enc_raw(p, ofs, m_trap->thl.comlen, (u8_t *)&snmp_publiccommunity[0]);
 566   ofs += m_trap->thl.comlen;
 567
 568   snmp_asn1_enc_type(p, ofs, (SNMP_ASN1_CONTXT | SNMP_ASN1_CONSTR | SNMP_ASN1_PDU_TRAP));
 569   ofs += 1;
 570   snmp_asn1_enc_length(p, ofs, m_trap->thl.pdulen);
 571   ofs += m_trap->thl.pdulenlen;
 572
 573   snmp_asn1_enc_type(p, ofs, (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_OBJ_ID));
 574   ofs += 1;
 575   snmp_asn1_enc_length(p, ofs, m_trap->thl.eidlen);
 576   ofs += m_trap->thl.eidlenlen;
 577   snmp_asn1_enc_oid(p, ofs, m_trap->enterprise->len, &m_trap->enterprise->id[0]);
 578   ofs += m_trap->thl.eidlen;
 579
 580   snmp_asn1_enc_type(p, ofs, (SNMP_ASN1_APPLIC | SNMP_ASN1_PRIMIT | SNMP_ASN1_IPADDR));
 581   ofs += 1;
 582   snmp_asn1_enc_length(p, ofs, m_trap->thl.aaddrlen);
 583   ofs += m_trap->thl.aaddrlenlen;
 584   snmp_asn1_enc_raw(p, ofs, m_trap->thl.aaddrlen, &m_trap->sip_raw[0]);
 585   ofs += m_trap->thl.aaddrlen;
 586
 587   snmp_asn1_enc_type(p, ofs, (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_INTEG));
 588   ofs += 1;
 589   snmp_asn1_enc_length(p, ofs, m_trap->thl.gtrplen);
 590   ofs += m_trap->thl.gtrplenlen;
 591   snmp_asn1_enc_u32t(p, ofs, m_trap->thl.gtrplen, m_trap->gen_trap);
 592   ofs += m_trap->thl.gtrplen;
 593
 594   snmp_asn1_enc_type(p, ofs, (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_INTEG));
 595   ofs += 1;
 596   snmp_asn1_enc_length(p, ofs, m_trap->thl.strplen);
 597   ofs += m_trap->thl.strplenlen;
 598   snmp_asn1_enc_u32t(p, ofs, m_trap->thl.strplen, m_trap->spc_trap);
 599   ofs += m_trap->thl.strplen;
 600
 601   snmp_asn1_enc_type(p, ofs, (SNMP_ASN1_APPLIC | SNMP_ASN1_PRIMIT | SNMP_ASN1_TIMETICKS));
 602   ofs += 1;
 603   snmp_asn1_enc_length(p, ofs, m_trap->thl.tslen);
 604   ofs += m_trap->thl.tslenlen;
 605   snmp_asn1_enc_u32t(p, ofs, m_trap->thl.tslen, m_trap->ts);
 606   ofs += m_trap->thl.tslen;
 607
 608   return ofs;
 609 }
 610
 611 /**
 612  * Encodes varbind list from head to tail.
 613  */
 614 static u16_t
 615 snmp_varbind_list_enc(struct snmp_varbind_root *root, struct pbuf *p, u16_t ofs)
 616 {
 617   struct snmp_varbind *vb;
 618   s32_t *sint_ptr;
 619   u32_t *uint_ptr;
 620   u8_t *raw_ptr;
 621
 622   snmp_asn1_enc_type(p, ofs, (SNMP_ASN1_UNIV | SNMP_ASN1_CONSTR | SNMP_ASN1_SEQ));
 623   ofs += 1;
 624   snmp_asn1_enc_length(p, ofs, root->seqlen);
 625   ofs += root->seqlenlen;
 626
 627   vb = root->head;
 628   while ( vb != NULL )
 629   {
 630     snmp_asn1_enc_type(p, ofs, (SNMP_ASN1_UNIV | SNMP_ASN1_CONSTR | SNMP_ASN1_SEQ));
 631     ofs += 1;
 632     snmp_asn1_enc_length(p, ofs, vb->seqlen);
 633     ofs += vb->seqlenlen;
 634
 635     snmp_asn1_enc_type(p, ofs, (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_OBJ_ID));
 636     ofs += 1;
 637     snmp_asn1_enc_length(p, ofs, vb->olen);
 638     ofs += vb->olenlen;
 639     snmp_asn1_enc_oid(p, ofs, vb->ident_len, &vb->ident[0]);
 640     ofs += vb->olen;
 641
 642     snmp_asn1_enc_type(p, ofs, vb->value_type);
 643     ofs += 1;
 644     snmp_asn1_enc_length(p, ofs, vb->vlen);
 645     ofs += vb->vlenlen;
 646
 647     switch (vb->value_type)
 648     {
 649       case (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_INTEG):
 650         sint_ptr = (s32_t*)vb->value;
 651         snmp_asn1_enc_s32t(p, ofs, vb->vlen, *sint_ptr);
 652         break;
 653       case (SNMP_ASN1_APPLIC | SNMP_ASN1_PRIMIT | SNMP_ASN1_COUNTER):
 654       case (SNMP_ASN1_APPLIC | SNMP_ASN1_PRIMIT | SNMP_ASN1_GAUGE):
 655       case (SNMP_ASN1_APPLIC | SNMP_ASN1_PRIMIT | SNMP_ASN1_TIMETICKS):
 656         uint_ptr = (u32_t*)vb->value;
 657         snmp_asn1_enc_u32t(p, ofs, vb->vlen, *uint_ptr);
 658         break;
 659       case (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_OC_STR):
 660       case (SNMP_ASN1_APPLIC | SNMP_ASN1_PRIMIT | SNMP_ASN1_IPADDR):
 661       case (SNMP_ASN1_APPLIC | SNMP_ASN1_PRIMIT | SNMP_ASN1_OPAQUE):
 662         raw_ptr = (u8_t*)vb->value;
 663         snmp_asn1_enc_raw(p, ofs, vb->vlen, raw_ptr);
 664         break;
 665       case (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_NUL):
 666         break;
 667       case (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_OBJ_ID):
 668         sint_ptr = (s32_t*)vb->value;
 669         snmp_asn1_enc_oid(p, ofs, vb->value_len / sizeof(s32_t), sint_ptr);
 670         break;
 671       default:
 672         /* unsupported type */
 673         break;
 674     };
 675     ofs += vb->vlen;
 676     vb = vb->next;
 677   }
 678   return ofs;
 679 }
 680
 681 #endif /* LWIP_SNMP */