lwip/src/core/snmp/asn1_dec.c

/**
 * @file
 * Abstract Syntax Notation One (ISO 8824, 8825) decoding
 *
 * @todo not optimised (yet), favor correctness over speed, favor speed over size
 */

/*
 * Copyright (c) 2006 Axon Digital Design B.V., The Netherlands.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 * 3. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
 * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
 * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
 * OF SUCH DAMAGE.
 *
 * Author: Christiaan Simons <christiaan.simons@axon.tv>
 */

#include "lwip/opt.h"

#if LWIP_SNMP /* don't build if not configured for use in lwipopts.h */

#include "lwip/snmp_asn1.h"

/**
 * Retrieves type field from incoming pbuf chain.
 *
 * @param p points to a pbuf holding an ASN1 coded type field
 * @param ofs points to the offset within the pbuf chain of the ASN1 coded type field
 * @param type return ASN1 type
 * @return ERR_OK if successfull, ERR_ARG if we can't (or won't) decode
 */
err_t
snmp_asn1_dec_type(struct pbuf *p, u16_t ofs, u8_t *type)
{
  u16_t plen, base;
  u8_t *msg_ptr;

  plen = 0;
  while (p != NULL)
  {
    base = plen;
    plen += p->len;
    if (ofs < plen)
    {
      msg_ptr = p->payload;
      msg_ptr += ofs - base;
      *type = *msg_ptr;
      return ERR_OK;
    }
    p = p->next;
  }
  /* p == NULL, ofs >= plen */
  return ERR_ARG;
}

/**
 * Decodes length field from incoming pbuf chain into host length.
 *
 * @param p points to a pbuf holding an ASN1 coded length
 * @param ofs points to the offset within the pbuf chain of the ASN1 coded length
 * @param octets_used returns number of octets used by the length code
 * @param length return host order length, upto 64k
 * @return ERR_OK if successfull, ERR_ARG if we can't (or won't) decode
 */
err_t
snmp_asn1_dec_length(struct pbuf *p, u16_t ofs, u8_t *octets_used, u16_t *length)
{
  u16_t plen, base;
  u8_t *msg_ptr;

  plen = 0;
  while (p != NULL)
  {
    base = plen;
    plen += p->len;
    if (ofs < plen)
    {
      msg_ptr = p->payload;
      msg_ptr += ofs - base;

      if (*msg_ptr < 0x80)
      {
        /* primitive definite length format */
        *octets_used = 1;
        *length = *msg_ptr;
        return ERR_OK;
      }
      else if (*msg_ptr == 0x80)
      {
        /* constructed indefinite length format, termination with two zero octets */
        u8_t zeros;
        u8_t i;

        *length = 0;
        zeros = 0;
        while (zeros != 2)
        {
          i = 2;
          while (i > 0)
          {
            i--;
            (*length) += 1;
            ofs += 1;
            if (ofs >= plen)
            {
              /* next octet in next pbuf */
              p = p->next;
              if (p == NULL) { return ERR_ARG; }
              msg_ptr = p->payload;
              plen += p->len;
            }
            else
            {
              /* next octet in same pbuf */
              msg_ptr++;
            }
            if (*msg_ptr == 0)
            {
              zeros++;
              if (zeros == 2)
              {
                /* stop while (i > 0) */
                i = 0;
              }
            }
            else
            {
              zeros = 0;
            }
          }
        }
        *octets_used = 1;
        return ERR_OK;
      }
      else if (*msg_ptr == 0x81)
      {
        /* constructed definite length format, one octet */
        ofs += 1;
        if (ofs >= plen)
        {
          /* next octet in next pbuf */
          p = p->next;
          if (p == NULL) { return ERR_ARG; }
          msg_ptr = p->payload;
        }
        else
        {
          /* next octet in same pbuf */
          msg_ptr++;
        }
        *length = *msg_ptr;
        *octets_used = 2;
        return ERR_OK;
      }
      else if (*msg_ptr == 0x82)
      {
        u8_t i;

        /* constructed definite length format, two octets */
        i = 2;
        while (i > 0)
        {
          i--;
          ofs += 1;
          if (ofs >= plen)
          {
            /* next octet in next pbuf */
            p = p->next;
            if (p == NULL) { return ERR_ARG; }
            msg_ptr = p->payload;
            plen += p->len;
          }
          else
          {
            /* next octet in same pbuf */
            msg_ptr++;
          }
          if (i == 0)
          {
            /* least significant length octet */
            *length |= *msg_ptr;
          }
          else
          {
            /* most significant length octet */
            *length = (*msg_ptr) << 8;
          }
        }
        *octets_used = 3;
        return ERR_OK;
      }
      else
      {
        /* constructed definite length format 3..127 octets, this is too big (>64k) */
        /**  @todo: do we need to accept inefficient codings with many leading zero's? */
        *octets_used = 1 + ((*msg_ptr) & 0x7f);
        return ERR_ARG;
      }
    }
    p = p->next;
  }

  /* p == NULL, ofs >= plen */
  return ERR_ARG;
}

/**
 * Decodes positive integer (counter, gauge, timeticks) into u32_t.
 *
 * @param p points to a pbuf holding an ASN1 coded integer
 * @param ofs points to the offset within the pbuf chain of the ASN1 coded integer
 * @param len length of the coded integer field
 * @param value return host order integer
 * @return ERR_OK if successfull, ERR_ARG if we can't (or won't) decode
 *
 * @note ASN coded integers are _always_ signed. E.g. +0xFFFF is coded
 * as 0x00,0xFF,0xFF. Note the leading sign octet. A positive value
 * of 0xFFFFFFFF is preceded with 0x00 and the length is 5 octets!!
 */
err_t
snmp_asn1_dec_u32t(struct pbuf *p, u16_t ofs, u16_t len, u32_t *value)
{
  u16_t plen, base;
  u8_t *msg_ptr;

  plen = 0;
  while (p != NULL)
  {
    base = plen;
    plen += p->len;
    if (ofs < plen)
    {
      msg_ptr = p->payload;
      msg_ptr += ofs - base;
      if ((len > 0) && (len < 6))
      {
        /* start from zero */
        *value = 0;
        if (*msg_ptr & 0x80)
        {
          /* negative, expecting zero sign bit! */
          return ERR_ARG;
        }
        else
        {
          /* positive */
          if ((len > 1) && (*msg_ptr == 0))
          {
            /* skip leading "sign byte" octet 0x00 */
            len--;
            ofs += 1;
            if (ofs >= plen)
            {
              /* next octet in next pbuf */
              p = p->next;
              if (p == NULL) { return ERR_ARG; }
              msg_ptr = p->payload;
              plen += p->len;
            }
            else
            {
              /* next octet in same pbuf */
              msg_ptr++;
            }
          }
        }
        /* OR octets with value */
        while (len > 1)
        {
          len--;
          *value |= *msg_ptr;
          *value <<= 8;
          ofs += 1;
          if (ofs >= plen)
          {
            /* next octet in next pbuf */
            p = p->next;
            if (p == NULL) { return ERR_ARG; }
            msg_ptr = p->payload;
            plen += p->len;
          }
          else
          {
            /* next octet in same pbuf */
            msg_ptr++;
          }
        }
        *value |= *msg_ptr;
        return ERR_OK;
      }
      else
      {
        return ERR_ARG;
      }
    }
    p = p->next;
  }
  /* p == NULL, ofs >= plen */
  return ERR_ARG;
}

/**
 * Decodes integer into s32_t.
 *
 * @param p points to a pbuf holding an ASN1 coded integer
 * @param ofs points to the offset within the pbuf chain of the ASN1 coded integer
 * @param len length of the coded integer field
 * @param value return host order integer
 * @return ERR_OK if successfull, ERR_ARG if we can't (or won't) decode
 *
 * @note ASN coded integers are _always_ signed!
 */
err_t
snmp_asn1_dec_s32t(struct pbuf *p, u16_t ofs, u16_t len, s32_t *value)
{
  u16_t plen, base;
  u8_t *msg_ptr;
#if BYTE_ORDER == LITTLE_ENDIAN
  u8_t *lsb_ptr = (u8_t*)value;
#endif
#if BYTE_ORDER == BIG_ENDIAN
  u8_t *lsb_ptr = (u8_t*)value + sizeof(s32_t) - 1;
#endif
  u8_t sign;

  plen = 0;
  while (p != NULL)
  {
    base = plen;
    plen += p->len;
    if (ofs < plen)
    {
      msg_ptr = p->payload;
      msg_ptr += ofs - base;
      if ((len > 0) && (len < 5))
      {
        if (*msg_ptr & 0x80)
        {
          /* negative, start from -1 */
          *value = -1;
          sign = 1;
        }
        else
        {
          /* positive, start from 0 */
          *value = 0;
          sign = 0;
        }
        /* OR/AND octets with value */
        while (len > 1)
        {
          len--;
          if (sign)
          {
            *lsb_ptr &= *msg_ptr;
            *value <<= 8;
            *lsb_ptr |= 255;
          }
          else
          {
            *lsb_ptr |= *msg_ptr;
            *value <<= 8;
          }
          ofs += 1;
          if (ofs >= plen)
          {
            /* next octet in next pbuf */
            p = p->next;
            if (p == NULL) { return ERR_ARG; }
            msg_ptr = p->payload;
            plen += p->len;
          }
          else
          {
            /* next octet in same pbuf */
            msg_ptr++;
          }
        }
        if (sign)
        {
          *lsb_ptr &= *msg_ptr;
        }
        else
        {
          *lsb_ptr |= *msg_ptr;
        }
        return ERR_OK;
      }
      else
      {
        return ERR_ARG;
      }
    }
    p = p->next;
  }
  /* p == NULL, ofs >= plen */
  return ERR_ARG;
}

/**
 * Decodes object identifier from incoming message into array of s32_t.
 *
 * @param p points to a pbuf holding an ASN1 coded object identifier
 * @param ofs points to the offset within the pbuf chain of the ASN1 coded object identifier
 * @param len length of the coded object identifier
 * @param oid return object identifier struct
 * @return ERR_OK if successfull, ERR_ARG if we can't (or won't) decode
 */
err_t
snmp_asn1_dec_oid(struct pbuf *p, u16_t ofs, u16_t len, struct snmp_obj_id *oid)
{
  u16_t plen, base;
  u8_t *msg_ptr;
  s32_t *oid_ptr;

  plen = 0;
  while (p != NULL)
  {
    base = plen;
    plen += p->len;
    if (ofs < plen)
    {
      msg_ptr = p->payload;
      msg_ptr += ofs - base;

      oid->len = 0;
      oid_ptr = &oid->id[0];
      if (len > 0)
      {
        /* first compressed octet */
        if (*msg_ptr == 0x2B)
        {
          /* (most) common case 1.3 (iso.org) */
          *oid_ptr = 1;
          oid_ptr++;
          *oid_ptr = 3;
          oid_ptr++;
        }
        else if (*msg_ptr < 40)
        {
          *oid_ptr = 0;
          oid_ptr++;
          *oid_ptr = *msg_ptr;
          oid_ptr++;
        }
        else if (*msg_ptr < 80)
        {
          *oid_ptr = 1;
          oid_ptr++;
          *oid_ptr = (*msg_ptr) - 40;
          oid_ptr++;
        }
        else
        {
          *oid_ptr = 2;
          oid_ptr++;
          *oid_ptr = (*msg_ptr) - 80;
          oid_ptr++;
        }
        oid->len = 2;
      }
      else
      {
        /* accepting zero length identifiers e.g. for
           getnext operation. uncommon but valid */
        return ERR_OK;
      }
      len--;
      if (len > 0)
      {
        ofs += 1;
        if (ofs >= plen)
        {
          /* next octet in next pbuf */
          p = p->next;
          if (p == NULL) { return ERR_ARG; }
          msg_ptr = p->payload;
          plen += p->len;
        }
        else
        {
          /* next octet in same pbuf */
          msg_ptr++;
        }
      }
      while ((len > 0) && (oid->len < LWIP_SNMP_OBJ_ID_LEN))
      {
        /* sub-identifier uses multiple octets */
        if (*msg_ptr & 0x80)
        {
          s32_t sub_id = 0;

          while ((*msg_ptr & 0x80) && (len > 1))
          {
            len--;
            sub_id = (sub_id << 7) + (*msg_ptr & ~0x80);
            ofs += 1;
            if (ofs >= plen)
            {
              /* next octet in next pbuf */
              p = p->next;
              if (p == NULL) { return ERR_ARG; }
              msg_ptr = p->payload;
              plen += p->len;
            }
            else
            {
              /* next octet in same pbuf */
              msg_ptr++;
            }
          }
          if (!(*msg_ptr & 0x80) && (len > 0))
          {
            /* last octet sub-identifier */
            len--;
            sub_id = (sub_id << 7) + *msg_ptr;
            *oid_ptr = sub_id;
          }
        }
        else
        {
          /* !(*msg_ptr & 0x80) sub-identifier uses single octet */
          len--;
          *oid_ptr = *msg_ptr;
        }
        if (len > 0)
        {
          /* remaining oid bytes available ... */
          ofs += 1;
          if (ofs >= plen)
          {
            /* next octet in next pbuf */
            p = p->next;
            if (p == NULL) { return ERR_ARG; }
            msg_ptr = p->payload;
            plen += p->len;
          }
          else
          {
            /* next octet in same pbuf */
            msg_ptr++;
          }
        }
        oid_ptr++;
        oid->len++;
      }
      if (len == 0)
      {
        /* len == 0, end of oid */
        return ERR_OK;
      }
      else
      {
        /* len > 0, oid->len == LWIP_SNMP_OBJ_ID_LEN or malformed encoding */
        return ERR_ARG;
      }

    }
    p = p->next;
  }
  /* p == NULL, ofs >= plen */
  return ERR_ARG;
}

/**
 * Decodes (copies) raw data (ip-addresses, octet strings, opaque encoding)
 * from incoming message into array.
 *
 * @param p points to a pbuf holding an ASN1 coded raw data
 * @param ofs points to the offset within the pbuf chain of the ASN1 coded raw data
 * @param len length of the coded raw data (zero is valid, e.g. empty string!)
 * @param raw_len length of the raw return value
 * @param raw return raw bytes
 * @return ERR_OK if successfull, ERR_ARG if we can't (or won't) decode
 */
err_t
snmp_asn1_dec_raw(struct pbuf *p, u16_t ofs, u16_t len, u16_t raw_len, u8_t *raw)
{
  u16_t plen, base;
  u8_t *msg_ptr;

  if (len > 0)
  {
    plen = 0;
    while (p != NULL)
    {
      base = plen;
      plen += p->len;
      if (ofs < plen)
      {
        msg_ptr = p->payload;
        msg_ptr += ofs - base;
        if (raw_len >= len)
        {
          while (len > 1)
          {
            /* copy len - 1 octets */
            len--;
            *raw = *msg_ptr;
            raw++;
            ofs += 1;
            if (ofs >= plen)
            {
              /* next octet in next pbuf */
              p = p->next;
              if (p == NULL) { return ERR_ARG; }
              msg_ptr = p->payload;
              plen += p->len;
            }
            else
            {
              /* next octet in same pbuf */
              msg_ptr++;
            }
          }
          /* copy last octet */
          *raw = *msg_ptr;
          return ERR_OK;
        }
        else
        {
          /* raw_len < len, not enough dst space */
          return ERR_ARG;
        }
      }
      p = p->next;
    }
    /* p == NULL, ofs >= plen */
    return ERR_ARG;
  }
  else
  {
    /* len == 0, empty string */
    return ERR_OK;
  }
}

#endif /* LWIP_SNMP */
Commit	Line	Data
	1	/**
	2	* @file
	3	* Abstract Syntax Notation One (ISO 8824, 8825) decoding
	4	*
	5	* @todo not optimised (yet), favor correctness over speed, favor speed over size
	6	*/
	7
	8	/*
	9	* Copyright (c) 2006 Axon Digital Design B.V., The Netherlands.
	10	* All rights reserved.
	11	*
	12	* Redistribution and use in source and binary forms, with or without modification,
	13	* are permitted provided that the following conditions are met:
	14	*
	15	* 1. Redistributions of source code must retain the above copyright notice,
	16	* this list of conditions and the following disclaimer.
	17	* 2. Redistributions in binary form must reproduce the above copyright notice,
	18	* this list of conditions and the following disclaimer in the documentation
	19	* and/or other materials provided with the distribution.
	20	* 3. The name of the author may not be used to endorse or promote products
	21	* derived from this software without specific prior written permission.
	22	*
	23	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
	24	* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
	25	* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
	26	* SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
	27	* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
	28	* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	29	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	30	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
	31	* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
	32	* OF SUCH DAMAGE.
	33	*
	34	* Author: Christiaan Simons <christiaan.simons@axon.tv>
	35	*/
	36
	37	#include "lwip/opt.h"
	38
	39	#if LWIP_SNMP /* don't build if not configured for use in lwipopts.h */
	40
	41	#include "lwip/snmp_asn1.h"
	42
	43	/**
	44	* Retrieves type field from incoming pbuf chain.
	45	*
	46	* @param p points to a pbuf holding an ASN1 coded type field
	47	* @param ofs points to the offset within the pbuf chain of the ASN1 coded type field
	48	* @param type return ASN1 type
	49	* @return ERR_OK if successfull, ERR_ARG if we can't (or won't) decode
	50	*/
	51	err_t
	52	snmp_asn1_dec_type(struct pbuf p, u16_t ofs, u8_t type)
	53	{
	54	u16_t plen, base;
	55	u8_t *msg_ptr;
	56
	57	plen = 0;
	58	while (p != NULL)
	59	{
	60	base = plen;
	61	plen += p->len;
	62	if (ofs < plen)
	63	{
	64	msg_ptr = p->payload;
	65	msg_ptr += ofs - base;
	66	type = msg_ptr;
	67	return ERR_OK;
	68	}
	69	p = p->next;
	70	}
	71	/* p == NULL, ofs >= plen */
	72	return ERR_ARG;
	73	}
	74
	75	/**
	76	* Decodes length field from incoming pbuf chain into host length.
	77	*
	78	* @param p points to a pbuf holding an ASN1 coded length
	79	* @param ofs points to the offset within the pbuf chain of the ASN1 coded length
	80	* @param octets_used returns number of octets used by the length code
	81	* @param length return host order length, upto 64k
	82	* @return ERR_OK if successfull, ERR_ARG if we can't (or won't) decode
	83	*/
	84	err_t
	85	snmp_asn1_dec_length(struct pbuf p, u16_t ofs, u8_t octets_used, u16_t *length)
	86	{
	87	u16_t plen, base;
	88	u8_t *msg_ptr;
	89
	90	plen = 0;
	91	while (p != NULL)
	92	{
	93	base = plen;
	94	plen += p->len;
	95	if (ofs < plen)
	96	{
	97	msg_ptr = p->payload;
	98	msg_ptr += ofs - base;
	99
	100	if (*msg_ptr < 0x80)
	101	{
	102	/* primitive definite length format */
	103	*octets_used = 1;
	104	length = msg_ptr;
	105	return ERR_OK;
	106	}
	107	else if (*msg_ptr == 0x80)
	108	{
	109	/* constructed indefinite length format, termination with two zero octets */
	110	u8_t zeros;
	111	u8_t i;
	112
	113	*length = 0;
	114	zeros = 0;
	115	while (zeros != 2)
	116	{
	117	i = 2;
	118	while (i > 0)
	119	{
	120	i--;
	121	(*length) += 1;
	122	ofs += 1;
	123	if (ofs >= plen)
	124	{
	125	/* next octet in next pbuf */
	126	p = p->next;
	127	if (p == NULL) { return ERR_ARG; }
	128	msg_ptr = p->payload;
	129	plen += p->len;
	130	}
	131	else
	132	{
	133	/* next octet in same pbuf */
	134	msg_ptr++;
	135	}
	136	if (*msg_ptr == 0)
	137	{
	138	zeros++;
	139	if (zeros == 2)
	140	{
	141	/* stop while (i > 0) */
	142	i = 0;
	143	}
	144	}
	145	else
	146	{
	147	zeros = 0;
	148	}
	149	}
	150	}
	151	*octets_used = 1;
	152	return ERR_OK;
	153	}
	154	else if (*msg_ptr == 0x81)
	155	{
	156	/* constructed definite length format, one octet */
	157	ofs += 1;
	158	if (ofs >= plen)
	159	{
	160	/* next octet in next pbuf */
	161	p = p->next;
	162	if (p == NULL) { return ERR_ARG; }
	163	msg_ptr = p->payload;
	164	}
	165	else
	166	{
	167	/* next octet in same pbuf */
	168	msg_ptr++;
	169	}
	170	length = msg_ptr;
	171	*octets_used = 2;
	172	return ERR_OK;
	173	}
	174	else if (*msg_ptr == 0x82)
	175	{
	176	u8_t i;
	177
	178	/* constructed definite length format, two octets */
	179	i = 2;
	180	while (i > 0)
	181	{
	182	i--;
	183	ofs += 1;
	184	if (ofs >= plen)
	185	{
	186	/* next octet in next pbuf */
	187	p = p->next;
	188	if (p == NULL) { return ERR_ARG; }
	189	msg_ptr = p->payload;
	190	plen += p->len;
	191	}
	192	else
	193	{
	194	/* next octet in same pbuf */
	195	msg_ptr++;
	196	}
	197	if (i == 0)
	198	{
	199	/* least significant length octet */
	200	length \|= msg_ptr;
	201	}
	202	else
	203	{
	204	/* most significant length octet */
	205	length = (msg_ptr) << 8;
	206	}
	207	}
	208	*octets_used = 3;
	209	return ERR_OK;
	210	}
	211	else
	212	{
	213	/* constructed definite length format 3..127 octets, this is too big (>64k) */
	214	/** @todo: do we need to accept inefficient codings with many leading zero's? */
	215	octets_used = 1 + ((msg_ptr) & 0x7f);
	216	return ERR_ARG;
	217	}
	218	}
	219	p = p->next;
	220	}
	221
	222	/* p == NULL, ofs >= plen */
	223	return ERR_ARG;
	224	}
	225
	226	/**
	227	* Decodes positive integer (counter, gauge, timeticks) into u32_t.
	228	*
	229	* @param p points to a pbuf holding an ASN1 coded integer
	230	* @param ofs points to the offset within the pbuf chain of the ASN1 coded integer
	231	* @param len length of the coded integer field
	232	* @param value return host order integer
	233	* @return ERR_OK if successfull, ERR_ARG if we can't (or won't) decode
	234	*
	235	* @note ASN coded integers are _always_ signed. E.g. +0xFFFF is coded
	236	* as 0x00,0xFF,0xFF. Note the leading sign octet. A positive value
	237	* of 0xFFFFFFFF is preceded with 0x00 and the length is 5 octets!!
	238	*/
	239	err_t
	240	snmp_asn1_dec_u32t(struct pbuf p, u16_t ofs, u16_t len, u32_t value)
	241	{
	242	u16_t plen, base;
	243	u8_t *msg_ptr;
	244
	245	plen = 0;
	246	while (p != NULL)
	247	{
	248	base = plen;
	249	plen += p->len;
	250	if (ofs < plen)
	251	{
	252	msg_ptr = p->payload;
	253	msg_ptr += ofs - base;
	254	if ((len > 0) && (len < 6))
	255	{
	256	/* start from zero */
	257	*value = 0;
	258	if (*msg_ptr & 0x80)
	259	{
	260	/* negative, expecting zero sign bit! */
	261	return ERR_ARG;
	262	}
	263	else
	264	{
	265	/* positive */
	266	if ((len > 1) && (*msg_ptr == 0))
	267	{
	268	/* skip leading "sign byte" octet 0x00 */
	269	len--;
	270	ofs += 1;
	271	if (ofs >= plen)
	272	{
	273	/* next octet in next pbuf */
	274	p = p->next;
	275	if (p == NULL) { return ERR_ARG; }
	276	msg_ptr = p->payload;
	277	plen += p->len;
	278	}
	279	else
	280	{
	281	/* next octet in same pbuf */
	282	msg_ptr++;
	283	}
	284	}
	285	}
	286	/* OR octets with value */
	287	while (len > 1)
	288	{
	289	len--;
	290	value \|= msg_ptr;
	291	*value <<= 8;
	292	ofs += 1;
	293	if (ofs >= plen)
	294	{
	295	/* next octet in next pbuf */
	296	p = p->next;
	297	if (p == NULL) { return ERR_ARG; }
	298	msg_ptr = p->payload;
	299	plen += p->len;
	300	}
	301	else
	302	{
	303	/* next octet in same pbuf */
	304	msg_ptr++;
	305	}
	306	}
	307	value \|= msg_ptr;
	308	return ERR_OK;
	309	}
	310	else
	311	{
	312	return ERR_ARG;
	313	}
	314	}
	315	p = p->next;
	316	}
	317	/* p == NULL, ofs >= plen */
	318	return ERR_ARG;
	319	}
	320
	321	/**
	322	* Decodes integer into s32_t.
	323	*
	324	* @param p points to a pbuf holding an ASN1 coded integer
	325	* @param ofs points to the offset within the pbuf chain of the ASN1 coded integer
	326	* @param len length of the coded integer field
	327	* @param value return host order integer
	328	* @return ERR_OK if successfull, ERR_ARG if we can't (or won't) decode
	329	*
	330	* @note ASN coded integers are _always_ signed!
	331	*/
	332	err_t
	333	snmp_asn1_dec_s32t(struct pbuf p, u16_t ofs, u16_t len, s32_t value)
	334	{
	335	u16_t plen, base;
	336	u8_t *msg_ptr;
	337	#if BYTE_ORDER == LITTLE_ENDIAN
	338	u8_t lsb_ptr = (u8_t)value;
	339	#endif
	340	#if BYTE_ORDER == BIG_ENDIAN
	341	u8_t lsb_ptr = (u8_t)value + sizeof(s32_t) - 1;
	342	#endif
	343	u8_t sign;
	344
	345	plen = 0;
	346	while (p != NULL)
	347	{
	348	base = plen;
	349	plen += p->len;
	350	if (ofs < plen)
	351	{
	352	msg_ptr = p->payload;
	353	msg_ptr += ofs - base;
	354	if ((len > 0) && (len < 5))
	355	{
	356	if (*msg_ptr & 0x80)
	357	{
	358	/* negative, start from -1 */
	359	*value = -1;
	360	sign = 1;
	361	}
	362	else
	363	{
	364	/* positive, start from 0 */
	365	*value = 0;
	366	sign = 0;
	367	}
	368	/* OR/AND octets with value */
	369	while (len > 1)
	370	{
	371	len--;
	372	if (sign)
	373	{
	374	lsb_ptr &= msg_ptr;
	375	*value <<= 8;
	376	*lsb_ptr \|= 255;
	377	}
	378	else
	379	{
	380	lsb_ptr \|= msg_ptr;
	381	*value <<= 8;
	382	}
	383	ofs += 1;
	384	if (ofs >= plen)
	385	{
	386	/* next octet in next pbuf */
	387	p = p->next;
	388	if (p == NULL) { return ERR_ARG; }
	389	msg_ptr = p->payload;
	390	plen += p->len;
	391	}
	392	else
	393	{
	394	/* next octet in same pbuf */
	395	msg_ptr++;
	396	}
	397	}
	398	if (sign)
	399	{
	400	lsb_ptr &= msg_ptr;
	401	}
	402	else
	403	{
	404	lsb_ptr \|= msg_ptr;
	405	}
	406	return ERR_OK;
	407	}
	408	else
	409	{
	410	return ERR_ARG;
	411	}
	412	}
	413	p = p->next;
	414	}
	415	/* p == NULL, ofs >= plen */
	416	return ERR_ARG;
	417	}
	418
	419	/**
	420	* Decodes object identifier from incoming message into array of s32_t.
	421	*
	422	* @param p points to a pbuf holding an ASN1 coded object identifier
	423	* @param ofs points to the offset within the pbuf chain of the ASN1 coded object identifier
	424	* @param len length of the coded object identifier
	425	* @param oid return object identifier struct
	426	* @return ERR_OK if successfull, ERR_ARG if we can't (or won't) decode
	427	*/
	428	err_t
	429	snmp_asn1_dec_oid(struct pbuf p, u16_t ofs, u16_t len, struct snmp_obj_id oid)
	430	{
	431	u16_t plen, base;
	432	u8_t *msg_ptr;
	433	s32_t *oid_ptr;
	434
	435	plen = 0;
	436	while (p != NULL)
	437	{
	438	base = plen;
	439	plen += p->len;
	440	if (ofs < plen)
	441	{
	442	msg_ptr = p->payload;
	443	msg_ptr += ofs - base;
	444
	445	oid->len = 0;
	446	oid_ptr = &oid->id[0];
	447	if (len > 0)
	448	{
	449	/* first compressed octet */
	450	if (*msg_ptr == 0x2B)
	451	{
	452	/* (most) common case 1.3 (iso.org) */
	453	*oid_ptr = 1;
	454	oid_ptr++;
	455	*oid_ptr = 3;
	456	oid_ptr++;
	457	}
	458	else if (*msg_ptr < 40)
	459	{
	460	*oid_ptr = 0;
	461	oid_ptr++;
	462	oid_ptr = msg_ptr;
	463	oid_ptr++;
	464	}
	465	else if (*msg_ptr < 80)
	466	{
	467	*oid_ptr = 1;
	468	oid_ptr++;
	469	oid_ptr = (msg_ptr) - 40;
	470	oid_ptr++;
	471	}
	472	else
	473	{
	474	*oid_ptr = 2;
	475	oid_ptr++;
	476	oid_ptr = (msg_ptr) - 80;
	477	oid_ptr++;
	478	}
	479	oid->len = 2;
	480	}
	481	else
	482	{
	483	/* accepting zero length identifiers e.g. for
	484	getnext operation. uncommon but valid */
	485	return ERR_OK;
	486	}
	487	len--;
	488	if (len > 0)
	489	{
	490	ofs += 1;
	491	if (ofs >= plen)
	492	{
	493	/* next octet in next pbuf */
	494	p = p->next;
	495	if (p == NULL) { return ERR_ARG; }
	496	msg_ptr = p->payload;
	497	plen += p->len;
	498	}
	499	else
	500	{
	501	/* next octet in same pbuf */
	502	msg_ptr++;
	503	}
	504	}
	505	while ((len > 0) && (oid->len < LWIP_SNMP_OBJ_ID_LEN))
	506	{
	507	/* sub-identifier uses multiple octets */
	508	if (*msg_ptr & 0x80)
	509	{
	510	s32_t sub_id = 0;
	511
	512	while ((*msg_ptr & 0x80) && (len > 1))
	513	{
	514	len--;
	515	sub_id = (sub_id << 7) + (*msg_ptr & ~0x80);
	516	ofs += 1;
	517	if (ofs >= plen)
	518	{
	519	/* next octet in next pbuf */
	520	p = p->next;
	521	if (p == NULL) { return ERR_ARG; }
	522	msg_ptr = p->payload;
	523	plen += p->len;
	524	}
	525	else
	526	{
	527	/* next octet in same pbuf */
	528	msg_ptr++;
	529	}
	530	}
	531	if (!(*msg_ptr & 0x80) && (len > 0))
	532	{
	533	/* last octet sub-identifier */
	534	len--;
	535	sub_id = (sub_id << 7) + *msg_ptr;
	536	*oid_ptr = sub_id;
	537	}
	538	}
	539	else
	540	{
	541	/* !(msg_ptr & 0x80) sub-identifier uses single octet /
	542	len--;
	543	oid_ptr = msg_ptr;
	544	}
	545	if (len > 0)
	546	{
	547	/* remaining oid bytes available ... */
	548	ofs += 1;
	549	if (ofs >= plen)
	550	{
	551	/* next octet in next pbuf */
	552	p = p->next;
	553	if (p == NULL) { return ERR_ARG; }
	554	msg_ptr = p->payload;
	555	plen += p->len;
	556	}
	557	else
	558	{
	559	/* next octet in same pbuf */
	560	msg_ptr++;
	561	}
	562	}
	563	oid_ptr++;
	564	oid->len++;
	565	}
	566	if (len == 0)
	567	{
	568	/* len == 0, end of oid */
	569	return ERR_OK;
	570	}
	571	else
	572	{
	573	/* len > 0, oid->len == LWIP_SNMP_OBJ_ID_LEN or malformed encoding */
	574	return ERR_ARG;
	575	}
	576
	577	}
	578	p = p->next;
	579	}
	580	/* p == NULL, ofs >= plen */
	581	return ERR_ARG;
	582	}
	583
	584	/**
	585	* Decodes (copies) raw data (ip-addresses, octet strings, opaque encoding)
	586	* from incoming message into array.
	587	*
	588	* @param p points to a pbuf holding an ASN1 coded raw data
	589	* @param ofs points to the offset within the pbuf chain of the ASN1 coded raw data
	590	* @param len length of the coded raw data (zero is valid, e.g. empty string!)
	591	* @param raw_len length of the raw return value
	592	* @param raw return raw bytes
	593	* @return ERR_OK if successfull, ERR_ARG if we can't (or won't) decode
	594	*/
	595	err_t
	596	snmp_asn1_dec_raw(struct pbuf p, u16_t ofs, u16_t len, u16_t raw_len, u8_t raw)
	597	{
	598	u16_t plen, base;
	599	u8_t *msg_ptr;
	600
	601	if (len > 0)
	602	{
	603	plen = 0;
	604	while (p != NULL)
	605	{
	606	base = plen;
	607	plen += p->len;
	608	if (ofs < plen)
	609	{
	610	msg_ptr = p->payload;
	611	msg_ptr += ofs - base;
	612	if (raw_len >= len)
	613	{
	614	while (len > 1)
	615	{
	616	/* copy len - 1 octets */
	617	len--;
	618	raw = msg_ptr;
	619	raw++;
	620	ofs += 1;
	621	if (ofs >= plen)
	622	{
	623	/* next octet in next pbuf */
	624	p = p->next;
	625	if (p == NULL) { return ERR_ARG; }
	626	msg_ptr = p->payload;
	627	plen += p->len;
	628	}
	629	else
	630	{
	631	/* next octet in same pbuf */
	632	msg_ptr++;
	633	}
	634	}
	635	/* copy last octet */
	636	raw = msg_ptr;
	637	return ERR_OK;
	638	}
	639	else
	640	{
	641	/* raw_len < len, not enough dst space */
	642	return ERR_ARG;
	643	}
	644	}
	645	p = p->next;
	646	}
	647	/* p == NULL, ofs >= plen */
	648	return ERR_ARG;
	649	}
	650	else
	651	{
	652	/* len == 0, empty string */
	653	return ERR_OK;
	654	}
	655	}
	656
	657	#endif /* LWIP_SNMP */