Port to CMake, get rid of os_int.h.

[stg.git] / libs / smux / BIT_STRING.c

diff --git a/libs/smux/BIT_STRING.c b/libs/smux/BIT_STRING.c
new file mode 100644 (file)
index 0000000..6469d4f
--- /dev/null
+++ b/libs/smux/BIT_STRING.c
@@ -0,0 +1,188 @@
+/*-
+ * 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 <BIT_STRING.h>
+#include <asn_internal.h>
+
+/*
+ * BIT STRING basic type description.
+ */
+static ber_tlv_tag_t asn_DEF_BIT_STRING_tags[] = {
+       (ASN_TAG_CLASS_UNIVERSAL | (3 << 2))
+};
+static asn_OCTET_STRING_specifics_t asn_DEF_BIT_STRING_specs = {
+       sizeof(BIT_STRING_t),
+       offsetof(BIT_STRING_t, _asn_ctx),
+       1,      /* Special indicator that this is a BIT STRING type */
+};
+asn_TYPE_descriptor_t asn_DEF_BIT_STRING = {
+       "BIT STRING",
+       "BIT_STRING",
+       OCTET_STRING_free,         /* Implemented in terms of OCTET STRING */
+       BIT_STRING_print,
+       BIT_STRING_constraint,
+       OCTET_STRING_decode_ber,   /* Implemented in terms of OCTET STRING */
+       OCTET_STRING_encode_der,   /* Implemented in terms of OCTET STRING */
+       OCTET_STRING_decode_xer_binary,
+       BIT_STRING_encode_xer,
+       OCTET_STRING_decode_uper,       /* Unaligned PER decoder */
+       OCTET_STRING_encode_uper,       /* Unaligned PER encoder */
+       0, /* Use generic outmost tag fetcher */
+       asn_DEF_BIT_STRING_tags,
+       sizeof(asn_DEF_BIT_STRING_tags)
+         / sizeof(asn_DEF_BIT_STRING_tags[0]),
+       asn_DEF_BIT_STRING_tags,        /* Same as above */
+       sizeof(asn_DEF_BIT_STRING_tags)
+         / sizeof(asn_DEF_BIT_STRING_tags[0]),
+       0,      /* No PER visible constraints */
+       0, 0,   /* No members */
+       &asn_DEF_BIT_STRING_specs
+};
+
+/*
+ * BIT STRING generic constraint.
+ */
+int
+BIT_STRING_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+               asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+       const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
+
+       if(st && st->buf) {
+               if(st->size == 1 && st->bits_unused) {
+                       _ASN_CTFAIL(app_key, td,
+                               "%s: invalid padding byte (%s:%d)",
+                               td->name, __FILE__, __LINE__);
+                       return -1;
+               }
+       } else {
+               _ASN_CTFAIL(app_key, td,
+                       "%s: value not given (%s:%d)",
+                       td->name, __FILE__, __LINE__);
+               return -1;
+       }
+
+       return 0;
+}
+
+static char *_bit_pattern[16] = {
+       "0000", "0001", "0010", "0011", "0100", "0101", "0110", "0111",
+       "1000", "1001", "1010", "1011", "1100", "1101", "1110", "1111"
+};
+
+asn_enc_rval_t
+BIT_STRING_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
+       int ilevel, enum xer_encoder_flags_e flags,
+               asn_app_consume_bytes_f *cb, void *app_key) {
+       asn_enc_rval_t er;
+       char scratch[128];
+       char *p = scratch;
+       char *scend = scratch + (sizeof(scratch) - 10);
+       const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
+       int xcan = (flags & XER_F_CANONICAL);
+       uint8_t *buf;
+       uint8_t *end;
+
+       if(!st || !st->buf)
+               _ASN_ENCODE_FAILED;
+
+       er.encoded = 0;
+
+       buf = st->buf;
+       end = buf + st->size - 1;       /* Last byte is special */
+
+       /*
+        * Binary dump
+        */
+       for(; buf < end; buf++) {
+               int v = *buf;
+               int nline = xcan?0:(((buf - st->buf) % 8) == 0);
+               if(p >= scend || nline) {
+                       er.encoded += p - scratch;
+                       _ASN_CALLBACK(scratch, p - scratch);
+                       p = scratch;
+                       if(nline) _i_ASN_TEXT_INDENT(1, ilevel);
+               }
+               memcpy(p + 0, _bit_pattern[v >> 4], 4);
+               memcpy(p + 4, _bit_pattern[v & 0x0f], 4);
+               p += 8;
+       }
+
+       if(!xcan && ((buf - st->buf) % 8) == 0)
+               _i_ASN_TEXT_INDENT(1, ilevel);
+       er.encoded += p - scratch;
+       _ASN_CALLBACK(scratch, p - scratch);
+       p = scratch;
+
+       if(buf == end) {
+               int v = *buf;
+               int ubits = st->bits_unused;
+               int i;
+               for(i = 7; i >= ubits; i--)
+                       *p++ = (v & (1 << i)) ? 0x31 : 0x30;
+               er.encoded += p - scratch;
+               _ASN_CALLBACK(scratch, p - scratch);
+       }
+
+       if(!xcan) _i_ASN_TEXT_INDENT(1, ilevel - 1);
+
+       _ASN_ENCODED_OK(er);
+cb_failed:
+       _ASN_ENCODE_FAILED;
+}
+
+
+/*
+ * BIT STRING specific contents printer.
+ */
+int
+BIT_STRING_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
+               asn_app_consume_bytes_f *cb, void *app_key) {
+       static const char *h2c = "0123456789ABCDEF";
+       char scratch[64];
+       const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
+       uint8_t *buf;
+       uint8_t *end;
+       char *p = scratch;
+
+       (void)td;       /* Unused argument */
+
+       if(!st || !st->buf)
+               return (cb("<absent>", 8, app_key) < 0) ? -1 : 0;
+
+       ilevel++;
+       buf = st->buf;
+       end = buf + st->size;
+
+       /*
+        * Hexadecimal dump.
+        */
+       for(; buf < end; buf++) {
+               if((buf - st->buf) % 16 == 0 && (st->size > 16)
+                               && buf != st->buf) {
+                       _i_INDENT(1);
+                       /* Dump the string */
+                       if(cb(scratch, p - scratch, app_key) < 0) return -1;
+                       p = scratch;
+               }
+               *p++ = h2c[*buf >> 4];
+               *p++ = h2c[*buf & 0x0F];
+               *p++ = 0x20;
+       }
+
+       if(p > scratch) {
+               p--;    /* Eat the tailing space */
+
+               if((st->size > 16)) {
+                       _i_INDENT(1);
+               }
+
+               /* Dump the incomplete 16-bytes row */
+               if(cb(scratch, p - scratch, app_key) < 0)
+                       return -1;
+       }
+
+       return 0;
+}
+