/*-

 * 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),

	ASN_OSUBV_BIT

};

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 == 0 && st->bits_unused)

		|| st->bits_unused < 0 || st->bits_unused > 7) {

			_ASN_CTFAIL(app_key, td, sptr,

				"%s: invalid padding byte (%s:%d)",

				td->name, __FILE__, __LINE__);

			return -1;

		}

	} else {

		_ASN_CTFAIL(app_key, td, sptr,

			"%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;

}