stglibs/smux.lib/ber_tlv_length.c

   1 /*-
   2  * Copyright (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
   3  * Redistribution and modifications are permitted subject to BSD license.
   4  */
   5 #include <asn_internal.h>
   6 #include <ber_tlv_length.h>
   7 #include <ber_tlv_tag.h>
   8
   9 ssize_t
  10 ber_fetch_length(int _is_constructed, const void *bufptr, size_t size,
  11                 ber_tlv_len_t *len_r) {
  12         const uint8_t *buf = (const uint8_t *)bufptr;
  13         unsigned oct;
  14
  15         if(size == 0)
  16                 return 0;       /* Want more */
  17
  18         oct = *(const uint8_t *)buf;
  19         if((oct & 0x80) == 0) {
  20                 /*
  21                  * Short definite length.
  22                  */
  23                 *len_r = oct;   /* & 0x7F */
  24                 return 1;
  25         } else {
  26                 ber_tlv_len_t len;
  27                 size_t skipped;
  28
  29                 if(_is_constructed && oct == 0x80) {
  30                         *len_r = -1;    /* Indefinite length */
  31                         return 1;
  32                 }
  33
  34                 if(oct == 0xff) {
  35                         /* Reserved in standard for future use. */
  36                         return -1;
  37                 }
  38
  39                 oct &= 0x7F;    /* Leave only the 7 LS bits */
  40                 for(len = 0, buf++, skipped = 1;
  41                         oct && (++skipped <= size); buf++, oct--) {
  42
  43                         len = (len << 8) | *buf;
  44                         if(len < 0
  45                         || (len >> ((8 * sizeof(len)) - 8) && oct > 1)) {
  46                                 /*
  47                                  * Too large length value.
  48                                  */
  49                                 return -1;
  50                         }
  51                 }
  52
  53                 if(oct == 0) {
  54                         ber_tlv_len_t lenplusepsilon = (size_t)len + 1024;
  55                         /*
  56                          * Here length may be very close or equal to 2G.
  57                          * However, the arithmetics used in some decoders
  58                          * may add some (small) quantities to the length,
  59                          * to check the resulting value against some limits.
  60                          * This may result in integer wrap-around, which
  61                          * we try to avoid by checking it earlier here.
  62                          */
  63                         if(lenplusepsilon < 0) {
  64                                 /* Too large length value */
  65                                 return -1;
  66                         }
  67
  68                         *len_r = len;
  69                         return skipped;
  70                 }
  71
  72                 return 0;       /* Want more */
  73         }
  74
  75 }
  76
  77 ssize_t
  78 ber_skip_length(asn_codec_ctx_t *opt_codec_ctx,
  79                 int _is_constructed, const void *ptr, size_t size) {
  80         ber_tlv_len_t vlen;     /* Length of V in TLV */
  81         ssize_t tl;             /* Length of L in TLV */
  82         ssize_t ll;             /* Length of L in TLV */
  83         size_t skip;
  84
  85         /*
  86          * Make sure we didn't exceed the maximum stack size.
  87          */
  88         if(_ASN_STACK_OVERFLOW_CHECK(opt_codec_ctx))
  89                 return -1;
  90
  91         /*
  92          * Determine the size of L in TLV.
  93          */
  94         ll = ber_fetch_length(_is_constructed, ptr, size, &vlen);
  95         if(ll <= 0) return ll;
  96
  97         /*
  98          * Definite length.
  99          */
 100         if(vlen >= 0) {
 101                 skip = ll + vlen;
 102                 if(skip > size)
 103                         return 0;       /* Want more */
 104                 return skip;
 105         }
 106
 107         /*
 108          * Indefinite length!
 109          */
 110         ASN_DEBUG("Skipping indefinite length");
 111         for(skip = ll, ptr = ((const char *)ptr) + ll, size -= ll;;) {
 112                 ber_tlv_tag_t tag;
 113
 114                 /* Fetch the tag */
 115                 tl = ber_fetch_tag(ptr, size, &tag);
 116                 if(tl <= 0) return tl;
 117
 118                 ll = ber_skip_length(opt_codec_ctx,
 119                         BER_TLV_CONSTRUCTED(ptr),
 120                         ((const char *)ptr) + tl, size - tl);
 121                 if(ll <= 0) return ll;
 122
 123                 skip += tl + ll;
 124
 125                 /*
 126                  * This may be the end of the indefinite length structure,
 127                  * two consecutive 0 octets.
 128                  * Check if it is true.
 129                  */
 130                 if(((const uint8_t *)ptr)[0] == 0
 131                 && ((const uint8_t *)ptr)[1] == 0)
 132                         return skip;
 133
 134                 ptr = ((const char *)ptr) + tl + ll;
 135                 size -= tl + ll;
 136         }
 137
 138         /* UNREACHABLE */
 139 }
 140
 141 size_t
 142 der_tlv_length_serialize(ber_tlv_len_t len, void *bufp, size_t size) {
 143         size_t required_size;   /* Size of len encoding */
 144         uint8_t *buf = (uint8_t *)bufp;
 145         uint8_t *end;
 146         size_t i;
 147
 148         if(len <= 127) {
 149                 /* Encoded in 1 octet */
 150                 if(size) *buf = (uint8_t)len;
 151                 return 1;
 152         }
 153
 154         /*
 155          * Compute the size of the subsequent bytes.
 156          */
 157         for(required_size = 1, i = 8; i < 8 * sizeof(len); i += 8) {
 158                 if(len >> i)
 159                         required_size++;
 160                 else
 161                         break;
 162         }
 163
 164         if(size <= required_size)
 165                 return required_size + 1;
 166
 167         *buf++ = (uint8_t)(0x80 | required_size);  /* Length of the encoding */
 168
 169         /*
 170          * Produce the len encoding, space permitting.
 171          */
 172         end = buf + required_size;
 173         for(i -= 8; buf < end; i -= 8, buf++)
 174                 *buf = (uint8_t)(len >> i);
 175
 176         return required_size + 1;
 177 }
 178