text: /*-
   * Copyright (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
   * Redistribution and modifications are permitted subject to BSD license.
   */
  #include <asn_internal.h>
  #include <ber_tlv_tag.h>
  #include <errno.h>
  
  ssize_t ber_fetch_tag(const void *ptr, size_t size, ber_tlv_tag_t *tag_r)
  {
      ber_tlv_tag_t val;
      ber_tlv_tag_t tclass;
      size_t skipped;
  
      if (size == 0)
          return 0;
  
      val = *(const uint8_t *)ptr;
      tclass = (val >> 6);
      if ((val &= 0x1F) != 0x1F) {
          /*
           * Simple form: everything encoded in a single octet.
           * Tag Class is encoded using two least significant bits.
           */
          *tag_r = (val << 2) | tclass;
          return 1;
      }
  
      /*
       * Each octet contains 7 bits of useful information.
       * The MSB is 0 if it is the last octet of the tag.
       */
      for (val = 0, ptr = ((const char *)ptr) + 1, skipped = 2; skipped <= size;
           ptr = ((const char *)ptr) + 1, skipped++) {
          unsigned int oct = *(const uint8_t *)ptr;
          if (oct & 0x80) {
              val = (val << 7) | (oct & 0x7F);
              /*
               * Make sure there are at least 9 bits spare
               * at the MS side of a value.
               */
              if (val >> ((8 * sizeof(val)) - 9)) {
                  /*
                   * We would not be able to accomodate
                   * any more tag bits.
                   */
                  return -1;
              }
          } else {
              val = (val << 7) | oct;
              *tag_r = (val << 2) | tclass;
              return skipped;
          }
      }
  
      return 0; /* Want more */
  }
  
  ssize_t ber_tlv_tag_fwrite(ber_tlv_tag_t tag, FILE *f)
  {
      char buf[sizeof("[APPLICATION ]") + 32];
      ssize_t ret;
  
      ret = ber_tlv_tag_snprint(tag, buf, sizeof(buf));
      if (ret >= (ssize_t)sizeof(buf) || ret < 2) {
          errno = EPERM;
          return -1;
      }
  
      return fwrite(buf, 1, ret, f);
  }
  
  ssize_t ber_tlv_tag_snprint(ber_tlv_tag_t tag, char *buf, size_t size)
  {
      char *type = 0;
      int ret;
  
      switch (tag & 0x3) {
      case ASN_TAG_CLASS_UNIVERSAL:
          type = "UNIVERSAL ";
          break;
      case ASN_TAG_CLASS_APPLICATION:
          type = "APPLICATION ";
          break;
      case ASN_TAG_CLASS_CONTEXT:
          type = "";
          break;
      case ASN_TAG_CLASS_PRIVATE:
          type = "PRIVATE ";
          break;
      }
  
      ret = snprintf(buf, size, "[%s%u]", type, ((unsigned)tag) >> 2);
      if (ret <= 0 && size)
          buf[0] = '\0'; /* against broken libc's */
  
      return ret;
  }
  
  char *ber_tlv_tag_string(ber_tlv_tag_t tag)
  {
      static char buf[sizeof("[APPLICATION ]") + 32];
  
      (void)ber_tlv_tag_snprint(tag, buf, sizeof(buf));
  
      return buf;
  }
  
  size_t ber_tlv_tag_serialize(ber_tlv_tag_t tag, void *bufp, size_t size)
  {
      int tclass = BER_TAG_CLASS(tag);
      ber_tlv_tag_t tval = BER_TAG_VALUE(tag);
      uint8_t *buf = (uint8_t *)bufp;
      uint8_t *end;
      size_t required_size;
      size_t i;
  
      if (tval <= 30) {
          /* Encoded in 1 octet */
          if (size)
              buf[0] = (tclass << 6) | tval;
          return 1;
      } else if (size) {
          *buf++ = (tclass << 6) | 0x1F;
          size--;
      }
  
      /*
       * Compute the size of the subsequent bytes.
       */
      for (required_size = 1, i = 7; i < 8 * sizeof(tval); i += 7) {
          if (tval >> i)
              required_size++;
          else
              break;
      }
  
      if (size < required_size)
          return required_size + 1;
  
      /*
       * Fill in the buffer, space permitting.
       */
      end = buf + required_size - 1;
      for (i -= 7; buf < end; i -= 7, buf++)
          *buf = 0x80 | ((tval >> i) & 0x7F);
      *buf = (tval & 0x7F); /* Last octet without high bit */
  
      return required_size + 1;
  }
  