aboutsummaryrefslogtreecommitdiffstats
path: root/lib/asn1/c_src/asn1_erl_driver.c
diff options
context:
space:
mode:
Diffstat (limited to 'lib/asn1/c_src/asn1_erl_driver.c')
-rw-r--r--lib/asn1/c_src/asn1_erl_driver.c1667
1 files changed, 1667 insertions, 0 deletions
diff --git a/lib/asn1/c_src/asn1_erl_driver.c b/lib/asn1/c_src/asn1_erl_driver.c
new file mode 100644
index 0000000000..cd2e63a363
--- /dev/null
+++ b/lib/asn1/c_src/asn1_erl_driver.c
@@ -0,0 +1,1667 @@
+/*
+ * %CopyrightBegin%
+ *
+ * Copyright Ericsson AB 2002-2009. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Erlang Public License,
+ * Version 1.1, (the "License"); you may not use this file except in
+ * compliance with the License. You should have received a copy of the
+ * Erlang Public License along with this software. If not, it can be
+ * retrieved online at http://www.erlang.org/.
+ *
+ * Software distributed under the License is distributed on an "AS IS"
+ * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+ * the License for the specific language governing rights and limitations
+ * under the License.
+ *
+ * %CopyrightEnd%
+ *
+ */
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include "erl_driver.h"
+#include "ei.h"
+
+
+/* #define ASN1_DEBUG 1 */
+
+#define ASN1_OK 0
+#define ASN1_ERROR -1
+#define ASN1_COMPL_ERROR 1
+#define ASN1_MEMORY_ERROR 0
+#define ASN1_DECODE_ERROR 2
+#define ASN1_TAG_ERROR -3
+#define ASN1_LEN_ERROR -4
+#define ASN1_INDEF_LEN_ERROR -5
+#define ASN1_VALUE_ERROR -6
+
+
+#define ASN1_CLASS 0xc0
+#define ASN1_FORM 0x20
+#define ASN1_CLASSFORM (ASN1_CLASS | ASN1_FORM)
+#define ASN1_TAG 0x1f
+#define ASN1_LONG_TAG 0x7f
+
+#define ASN1_INDEFINITE_LENGTH 0x80
+#define ASN1_SHORT_DEFINITE_LENGTH 0
+
+#define ASN1_PRIMITIVE 0
+#define ASN1_CONSTRUCTED 0x20
+
+#define ASN1_COMPLETE 1
+#define ASN1_BER_TLV_DECODE 2
+#define ASN1_BER_TLV_PARTIAL_DECODE 3
+
+#define ASN1_NOVALUE 0
+
+#define ASN1_SKIPPED 0
+#define ASN1_OPTIONAL 1
+#define ASN1_CHOOSEN 2
+
+
+#define CEIL(X,Y) ((X-1) / Y + 1)
+
+#define INVMASK(X,M) (X & (M ^ 0xff))
+#define MASK(X,M) (X & M)
+
+typedef struct {
+ ErlDrvPort port;
+ int buffer_size;
+} asn1_data;
+
+/* int min_alloc_bytes; */
+
+
+static ErlDrvData asn1_drv_start(ErlDrvPort, char *);
+
+static void asn1_drv_stop(ErlDrvData);
+
+int asn1_drv_control(ErlDrvData, unsigned int, char *, int, char **, int);
+
+int complete(ErlDrvBinary **,unsigned char *,unsigned char *, int);
+
+int insert_octets(int, unsigned char **, unsigned char **, int *);
+
+int insert_octets_except_unused(int, unsigned char **, unsigned char **,
+ int *, int);
+
+int insert_octets_as_bits_exact_len(int, int, unsigned char **,
+ unsigned char **, int *);
+
+int insert_octets_as_bits(int, unsigned char **, unsigned char **,int *);
+
+int pad_bits(int, unsigned char **, int *);
+
+int insert_least_sign_bits(int, unsigned char, unsigned char **, int *);
+
+int insert_most_sign_bits(int, unsigned char, unsigned char **, int *);
+
+int insert_bits_as_bits(int, int, unsigned char **, unsigned char **, int *);
+
+int insert_octets_unaligned(int, unsigned char **, unsigned char **, int);
+
+int realloc_memory(ErlDrvBinary **,int,unsigned char **,unsigned char **);
+
+int decode_begin(ErlDrvBinary **,unsigned char *, int, unsigned int *);
+
+int decode(ErlDrvBinary **,int *,unsigned char *,int *, int);
+
+int decode_tag(char *,int *,unsigned char *,int,int *);
+
+int decode_value(int *,unsigned char *,int *,ErlDrvBinary **,int ,int);
+
+
+/* declaration of functions used for partial decode of a BER encoded
+ message */
+
+int decode_partial(ErlDrvBinary **,unsigned char *, int);
+
+int skip_tag(unsigned char *,int *,int);
+
+int skip_length_and_value(unsigned char *,int *,int);
+
+int get_tag(unsigned char *,int *,int);
+
+int get_value(char *,unsigned char *,int *,int);
+
+static ErlDrvEntry asn1_drv_entry = {
+ NULL, /* init, always NULL for dynamic drivers */
+ asn1_drv_start, /* start, called when port is opened */
+ asn1_drv_stop, /* stop, called when port is closed */
+ NULL, /* output, called when erlang has sent */
+ NULL, /* ready_input, called when input descriptor ready */
+ NULL, /* ready_output, called when output descriptor ready */
+ "asn1_erl_drv", /* char *driver_name, the argument to open_port */
+ NULL, /* finish, called when unloaded */
+ NULL, /* void * that is not used (BC) */
+ asn1_drv_control, /* control, port_control callback */
+ NULL, /* timeout, called on timeouts */
+ NULL, /* outputv, vector output interface */
+
+ NULL, /* ready_async */
+ NULL, /* flush */
+ NULL, /* call */
+ NULL, /* event */
+ ERL_DRV_EXTENDED_MARKER,
+ ERL_DRV_EXTENDED_MAJOR_VERSION,
+ ERL_DRV_EXTENDED_MINOR_VERSION,
+ ERL_DRV_FLAG_USE_PORT_LOCKING,
+ NULL, /* handle2 */
+ NULL /* process_exit */
+};
+
+
+
+DRIVER_INIT(asn1_erl_drv) /* must match name in driver_entry */
+{
+ return &asn1_drv_entry;
+}
+
+static ErlDrvData asn1_drv_start(ErlDrvPort port, char *buff)
+{
+ /* extern int min_alloc_bytes; */
+ char *ptr;
+ asn1_data* d;
+
+ d = (asn1_data*)driver_alloc(sizeof(asn1_data));
+ set_port_control_flags(port, PORT_CONTROL_FLAG_BINARY);
+ d->port = port;
+
+ if ((ptr = getenv("ASN1_MIN_BUF_SIZE")) == NULL)
+ d->buffer_size = 1024;
+ else
+ d->buffer_size = atoi(ptr);
+ return (ErlDrvData)d;
+}
+
+
+static void asn1_drv_stop(ErlDrvData handle)
+{
+ driver_free((char*)handle);
+}
+
+
+
+int asn1_drv_control(ErlDrvData handle,
+ unsigned int command,
+ char *buf,
+ int buf_len,
+ char **res_buf,
+ int res_buf_len)
+{
+ char *complete_buf;
+ int complete_len, decode_len;
+ ErlDrvBinary *drv_binary;
+ ErlDrvBinary **drv_bin_ptr;
+ asn1_data* a_data;
+ int min_alloc_bytes;
+ unsigned int err_pos = 0; /* in case of error, return last correct position */
+ int ret_err; /* return value in case of error in TLV decode, i.e. length of list in res_buf */
+
+ /* In case previous call to asn1_drv_control resulted in a change of
+ return value from binary to integer list */
+ a_data = (asn1_data *)handle;
+ min_alloc_bytes = a_data->buffer_size;
+ set_port_control_flags(a_data->port, PORT_CONTROL_FLAG_BINARY);
+
+ if (command == ASN1_COMPLETE)
+ { /* Do the PER complete encode step */
+ if ((drv_binary = driver_alloc_binary(buf_len))==NULL) {
+ /* error handling */
+ set_port_control_flags(a_data->port, 0);
+ return ASN1_MEMORY_ERROR;
+ }
+ complete_buf = drv_binary->orig_bytes;
+ if ((complete_len = complete(&drv_binary,complete_buf,buf,buf_len)) == ASN1_ERROR)
+ {
+ /* error handling due to failure in complete */
+ /* printf("error when running complete\n\r"); */
+ driver_free_binary(drv_binary);
+ set_port_control_flags(a_data->port, 0);
+ **res_buf = '1';
+ return ASN1_COMPL_ERROR;
+ }
+ /* printf("complete_len=%dbuf_len=%d,orig_size=%d\n\r",complete_len,buf_len,drv_binary->orig_size); */
+ /* now the message is complete packed, return to Erlang */
+ /* if (complete_len < buf_len) {*/
+ if (complete_len < drv_binary->orig_size) {
+ ErlDrvBinary *tmp;
+ if ((tmp=driver_realloc_binary(drv_binary,complete_len)) == NULL){
+ /*error handling due to memory allocation failure */
+ driver_free_binary(drv_binary);
+ set_port_control_flags(a_data->port, 0);
+ return ASN1_MEMORY_ERROR;
+ }else
+ drv_binary=tmp;
+ }
+ *res_buf = (char *)drv_binary;
+ return complete_len;
+ } else if (command == ASN1_BER_TLV_DECODE) { /* control == 2 */
+ /* Do the tlv decode,
+ return the resulting term encoded on the Erlang
+ external format */
+/* printf("driver: buffer_len = %d, min_alloc_bytes = %d\r\n",buf_len,min_alloc_bytes); */
+ if ((drv_binary = driver_alloc_binary((buf_len*5)+min_alloc_bytes))==NULL) {
+ /* error handling */
+ set_port_control_flags(a_data->port, 0);
+ return ASN1_MEMORY_ERROR;
+ }
+ drv_bin_ptr = &drv_binary;
+ if ((decode_len = decode_begin(drv_bin_ptr,buf,buf_len,&err_pos)) <= ASN1_ERROR)
+ {
+ /* error handling due to failure in decode */
+ char tmp_res_buf[5];
+ driver_free_binary(*drv_bin_ptr);
+ set_port_control_flags(a_data->port, 0);
+
+ if(decode_len==ASN1_ERROR)
+ tmp_res_buf[0]='1';
+ else if(decode_len==ASN1_TAG_ERROR)
+ tmp_res_buf[0]='2';
+ else if(decode_len==ASN1_LEN_ERROR)
+ tmp_res_buf[0]='3';
+ else if(decode_len==ASN1_INDEF_LEN_ERROR)
+ tmp_res_buf[0]='4';
+ else if(decode_len==ASN1_VALUE_ERROR)
+ tmp_res_buf[0]='5';
+/* printf("err_pos=%d\r\n",err_pos); */
+/* printf("decode_len:%d\r\n",decode_len); */
+ ret_err = 1;
+ while(err_pos>0){
+ tmp_res_buf[ret_err] =(char)err_pos;/* c;*/
+ err_pos = err_pos >> 8;
+ ret_err++;
+ }
+ strncpy(*res_buf,tmp_res_buf,ret_err);
+ return ret_err;
+ }
+/* printf("decode_len=%d\r\n",decode_len); */
+ if (decode_len < ((buf_len * 5) + min_alloc_bytes)) {
+ /* not all memory was used => we have to reallocate */
+ ErlDrvBinary *tmp;
+ if ((tmp=driver_realloc_binary(*drv_bin_ptr,decode_len)) == NULL){
+ /*error handling due to memory allocation failure */
+ driver_free_binary(*drv_bin_ptr);
+ set_port_control_flags(a_data->port, 0);
+ return ASN1_MEMORY_ERROR;
+ }else
+ *drv_bin_ptr=tmp;
+ }
+ *res_buf = (char *)(*drv_bin_ptr);
+ return decode_len;
+ } else { /*command == ASN1_BER_TLV_PARTIAL_DECODE */
+ if ((drv_binary = driver_alloc_binary(buf_len))==NULL) {
+ /* error handling */
+ set_port_control_flags(a_data->port, 0);
+ return ASN1_MEMORY_ERROR;
+ }
+ drv_bin_ptr = &drv_binary;
+ if ((decode_len = decode_partial(drv_bin_ptr,buf,buf_len))
+ <= ASN1_ERROR) {
+ /* error handling due to failure in decode */
+ driver_free_binary(*drv_bin_ptr);
+ set_port_control_flags(a_data->port, 0);
+
+/* printf("asn1_drv_control 1: decode_len=%d\r\n",decode_len); */
+
+ if(decode_len==ASN1_ERROR)
+ **res_buf = '1';
+ return ASN1_DECODE_ERROR;
+ }
+ if (decode_len < buf_len) {
+ /* not all memory was used => we have to reallocate */
+ ErlDrvBinary *tmp;
+/* printf("asn1_drv_control 2: decode_len=%d\r\n",decode_len); */
+ if ((tmp=driver_realloc_binary(*drv_bin_ptr,decode_len)) == NULL){
+ /*error handling due to memory allocation failure */
+ driver_free_binary(*drv_bin_ptr);
+ set_port_control_flags(a_data->port, 0);
+ return ASN1_MEMORY_ERROR;
+ }else
+ *drv_bin_ptr=tmp;
+ }
+ *res_buf = (char *)(*drv_bin_ptr);
+ return decode_len;
+ }
+}
+
+
+
+/*
+ *
+ * This section defines functionality for the complete encode of a
+ * PER encoded message
+ *
+ */
+
+int complete(ErlDrvBinary **drv_binary,unsigned char *complete_buf,
+ unsigned char *in_buf, int in_buf_len)
+{
+ int counter = in_buf_len;
+ /* counter keeps track of number of bytes left in the
+ input buffer */
+
+ int buf_space = in_buf_len;
+ /* This is the amount of allocated space left of the complete_buf. It
+ is possible when padding is applied that more space is needed than
+ was originally allocated. */
+
+ int buf_size = in_buf_len;
+ /* Size of the buffer. May become reallocated and thus other than
+ in_buf_len */
+
+ unsigned char *in_ptr, *ptr;
+ /* in_ptr points at the next byte in in_buf to be moved to
+ complete_buf.
+ ptr points into the new completed buffer, complete_buf, at the
+ position of the next byte that will be set */
+ int unused = 8;
+ /* unused = [1,...,8] indicates how many of the rigthmost bits of
+ the byte that ptr points at that are unassigned */
+
+ int no_bits,no_bytes,in_unused,desired_len,ret, saved_mem, needed, pad_bits;
+
+ unsigned char val;
+
+ in_ptr = in_buf;
+ ptr = complete_buf;
+ *ptr = 0x00;
+ while(counter > 0) {
+ counter--;
+/* printf("*in_ptr = %d\n\r",*in_ptr); */
+ switch (*in_ptr) {
+ case 0:
+ /* just one zero-bit should be added to the buffer */
+ if(unused == 1){
+ unused = 8;
+ *++ptr = 0x00;
+ buf_space--;
+ } else
+ unused--;
+ break;
+
+ case 1:
+ /* one one-bit should be added to the buffer */
+ if(unused == 1){
+ *ptr = *ptr | 1;
+ unused = 8;
+ *++ptr = 0x00;
+ buf_space--;
+ } else {
+ *ptr = *ptr | (1 << (unused - 1));
+ unused--;
+ }
+ break;
+
+ case 2:
+ /* align buffer to end of byte */
+ if (unused != 8) {
+ *++ptr = 0x00;
+ buf_space--;
+ unused = 8;
+ }
+ break;
+
+ case 10:
+ /* next byte in in_buf tells how many bits in the second next
+ byte that will be used */
+ /* The leftmost unused bits in the value byte are supposed to be
+ zero bits */
+ no_bits = (int)*(++in_ptr);
+ val = *(++in_ptr);
+ counter -= 2;
+ if ((ret=insert_least_sign_bits(no_bits,val,&ptr,&unused)) == ASN1_ERROR)
+ return ASN1_ERROR;
+ buf_space -= ret;
+ break;
+
+ case 20:
+ /* in this case the next value in_ptr points at holds the number
+ of following bytes that holds the value that will be inserted
+ in the completed buffer */
+ no_bytes = (int)*(++in_ptr);
+ counter -= (no_bytes + 1);
+ if ((counter<0) ||
+ (ret=insert_octets(no_bytes,&in_ptr,&ptr,&unused)) == ASN1_ERROR)
+ return ASN1_ERROR;
+ buf_space -= ret;
+ break;
+
+ case 21:
+ /* in this case the next two bytes in_ptr points at holds the number
+ of following bytes that holds the value that will be inserted
+ in the completed buffer */
+ no_bytes = (int)*(++in_ptr);
+ no_bytes = no_bytes << 8;
+ no_bytes = no_bytes | (int)*(++in_ptr);
+ counter -= (2 + no_bytes);
+ if ((counter<0) ||
+ (ret=insert_octets(no_bytes,&in_ptr,&ptr,&unused)) == ASN1_ERROR)
+ return ASN1_ERROR;
+ buf_space -= ret;
+ break;
+
+ case 30:
+ /* If we call the following bytes, in the buffer in_ptr points at,
+ By1,By2,Rest then Rest is the value that will be transfered to
+ the completed buffer. By1 tells how many of the rightmost bits in
+ Rest that should not be used. By2 is the length of Rest in bytes.*/
+ in_unused = (int)*(++in_ptr);
+ no_bytes = (int)*(++in_ptr);
+ counter -= (2 + no_bytes);
+/* printf("%d: case 30: in_unused=%d, no_bytes=%d,counter=%d\n\r",__LINE__,in_unused,no_bytes,counter); */
+ ret = -4711;
+ if ((counter<0) ||
+ (ret=insert_octets_except_unused(no_bytes,&in_ptr,&ptr,&unused,in_unused)) == ASN1_ERROR)
+ return ASN1_ERROR;
+/* printf("%d: ret=%d\n\r",__LINE__, ret); */
+ buf_space -= ret;
+ break;
+
+ case 31:
+ /* If we call the following bytes, in the buffer in_ptr points at,
+ By1,By2,By3,Rest then Rest is the value that will be transfered to
+ the completed buffer. By1 tells how many of the rightmost bits in
+ Rest that should not be used. By2 and By3 is the length of
+ Rest in bytes.*/
+ in_unused = (int)*(++in_ptr);
+ no_bytes = (int)*(++in_ptr);
+ no_bytes = no_bytes << 8;
+ no_bytes = no_bytes | (int)*(++in_ptr);
+ counter -= (3 + no_bytes);
+ if ((counter<0) ||
+ (ret=insert_octets_except_unused(no_bytes,&in_ptr,&ptr,&unused,in_unused)) == ASN1_ERROR)
+ return ASN1_ERROR;
+ buf_space -= ret;
+ break;
+
+ case 40:
+ /* This case implies that next byte,By1,(..,By1,By2,Bin,...)
+ is the desired length of the completed value, maybe needs
+ padding zero bits or removal of trailing zero bits from Bin.
+ By2 is the length of Bin and Bin is the value that will be
+ put into the completed buffer. Each byte in Bin has the value
+ 1 or 0.*/
+ desired_len = (int)*(++in_ptr);
+ no_bytes=(int)*(++in_ptr);
+
+ /* This is the algorithm for need of memory reallocation:
+ Only when padding (cases 40 - 43,45 - 47) more memory may be
+ used than allocated. Therefore one has to keep track of how
+ much of the allocated memory that has been saved, i.e. the
+ difference between the number of parsed bytes of the input buffer
+ and the number of used bytes of the output buffer.
+ If saved memory is less than needed for the padding then we
+ need more memory. */
+ saved_mem = buf_space - counter;
+ pad_bits = desired_len - no_bytes - unused;
+ needed = (pad_bits > 0) ? CEIL(pad_bits,8) : 0;
+ if (saved_mem < needed) {
+ /* Have to allocate more memory */
+ buf_size += needed;
+ buf_space += needed;
+ if (realloc_memory(drv_binary,buf_size,&ptr,
+ &complete_buf) == ASN1_ERROR)
+ return ASN1_ERROR;
+ }
+
+ counter -= (2 + no_bytes);
+ if ((counter<0) ||
+ (ret=insert_octets_as_bits_exact_len(desired_len,no_bytes,&in_ptr,
+ &ptr,&unused)) == ASN1_ERROR)
+ return ASN1_ERROR;
+ buf_space -= ret;
+ break;
+
+ case 41:
+ /* Same as case 40 apart from By2, the length of Bin, which is in
+ two bytes*/
+ desired_len = (int)*(++in_ptr);
+ no_bytes=(int)*(++in_ptr);
+ no_bytes = no_bytes << 8;
+ no_bytes = no_bytes | (int)*(++in_ptr);
+
+ saved_mem = buf_space - counter;
+ needed = CEIL((desired_len-unused),8) - no_bytes;
+ if (saved_mem < needed) {
+ /* Have to allocate more memory */
+ buf_size += needed;
+ buf_space += needed;
+ if (realloc_memory(drv_binary,buf_size,&ptr,
+ &complete_buf) == ASN1_ERROR)
+ return ASN1_ERROR;
+ }
+
+ counter -= (3 + no_bytes);
+ if ((counter<0) ||
+ (ret=insert_octets_as_bits_exact_len(desired_len,no_bytes,&in_ptr,
+ &ptr,&unused)) == ASN1_ERROR)
+ return ASN1_ERROR;
+ buf_space -= ret;
+ break;
+
+ case 42:
+ /* Same as case 40 apart from By1, the desired length, which is in
+ two bytes*/
+ desired_len = (int)*(++in_ptr);
+ desired_len = desired_len << 8;
+ desired_len = desired_len | (int)*(++in_ptr);
+ no_bytes=(int)*(++in_ptr);
+
+ saved_mem = buf_space - counter;
+ needed = CEIL((desired_len-unused),8) - no_bytes;
+ if (saved_mem < needed) {
+ /* Have to allocate more memory */
+ buf_size += needed;
+ buf_space += needed;
+ if (realloc_memory(drv_binary,buf_size,&ptr,
+ &complete_buf) == ASN1_ERROR)
+ return ASN1_ERROR;
+ }
+
+ counter -= (3 + no_bytes);
+ if ((counter<0) ||
+ (ret=insert_octets_as_bits_exact_len(desired_len,no_bytes,&in_ptr,
+ &ptr,&unused)) == ASN1_ERROR)
+ return ASN1_ERROR;
+ buf_space -= ret;
+ break;
+
+ case 43:
+ /* Same as case 40 apart from By1 and By2, the desired length and
+ the length of Bin, which are in two bytes each. */
+ desired_len = (int)*(++in_ptr);
+ desired_len = desired_len << 8;
+ desired_len = desired_len | (int)*(++in_ptr);
+ no_bytes=(int)*(++in_ptr);
+ no_bytes = no_bytes << 8;
+ no_bytes = no_bytes | (int)*(++in_ptr);
+
+ saved_mem = buf_space - counter;
+ needed = CEIL((desired_len-unused),8) - no_bytes;
+ if (saved_mem < needed) {
+ /* Have to allocate more memory */
+ buf_size += needed;
+ buf_space += needed;
+ if (realloc_memory(drv_binary,buf_size,&ptr,
+ &complete_buf) == ASN1_ERROR)
+ return ASN1_ERROR;
+ }
+
+ counter -= (4 + no_bytes);
+ if ((counter<0) ||
+ (ret=insert_octets_as_bits_exact_len(desired_len,no_bytes,&in_ptr,
+ &ptr,&unused)) == ASN1_ERROR)
+ return ASN1_ERROR;
+ buf_space -= ret;
+ break;
+
+ case 45:
+ /* This case assumes that the following bytes in the incoming buffer
+ (called By1,By2,Bin) is By1, which is the number of bits (n) that
+ will be inserted in the completed buffer. By2 is the number of
+ bytes in Bin. Each bit in the buffer Bin should be inserted from
+ the leftmost until the nth.*/
+ desired_len = (int)*(++in_ptr);
+ no_bytes=(int)*(++in_ptr);
+
+ saved_mem = buf_space - counter;
+ needed = CEIL((desired_len-unused),8) - no_bytes;
+/* printf("buf_space=%d, counter=%d, needed=%d",buf_space,counter,needed); */
+ if (saved_mem < needed) {
+ /* Have to allocate more memory */
+ buf_size += needed;
+ buf_space += needed;
+ if (realloc_memory(drv_binary,buf_size,&ptr,
+ &complete_buf) == ASN1_ERROR)
+ return ASN1_ERROR;
+ }
+
+ counter -= (2 + no_bytes);
+/* printf("calling insert_bits_as_bits: desired_len=%d, no_bytes=%d\n\r",desired_len,no_bytes); */
+/* printf("1in_ptr=%d\n\r",in_ptr); */
+
+ if((counter<0) ||
+ (ret=insert_bits_as_bits(desired_len,no_bytes,&in_ptr,
+ &ptr,&unused)) == ASN1_ERROR)
+ return ASN1_ERROR;
+/* printf("2in_ptr=%d, ptr=%d, complete_buf=%d\n\r",in_ptr,ptr,complete_buf); */
+/* printf("buf_space=%d, ret=%d, counter=%d\n\r",buf_space,ret,counter); */
+ buf_space -= ret;
+ break;
+
+ case 46:
+ /* Same as case 45 apart from By1, the desired length, which is
+ in two bytes. */
+ desired_len = (int)*(++in_ptr);
+ desired_len = desired_len << 8;
+ desired_len = desired_len | (int)*(++in_ptr);
+ no_bytes=(int)*(++in_ptr);
+
+ saved_mem = buf_space - counter;
+ needed = CEIL((desired_len-unused),8) - no_bytes;
+ if (saved_mem < needed) {
+ /* Have to allocate more memory */
+ buf_size += needed;
+ buf_space += needed;
+ if (realloc_memory(drv_binary,buf_size,&ptr,
+ &complete_buf) == ASN1_ERROR)
+ return ASN1_ERROR;
+ }
+
+ counter -= (3 + no_bytes);
+ if((counter<0) ||
+ (ret=insert_bits_as_bits(desired_len,no_bytes,&in_ptr,
+ &ptr,&unused)) == ASN1_ERROR)
+ return ASN1_ERROR;
+ buf_space -= ret;
+ break;
+
+ case 47:
+ /* Same as case 45 apart from By1 and By2, the desired length
+ and the length of Bin, which are in two bytes each. */
+ desired_len = (int)*(++in_ptr);
+ desired_len = desired_len << 8;
+ desired_len = desired_len | (int)*(++in_ptr);
+ no_bytes=(int)*(++in_ptr);
+ no_bytes = no_bytes << 8;
+ no_bytes = no_bytes | (int)*(++in_ptr);
+
+ saved_mem = buf_space - counter;
+ needed = CEIL((desired_len-unused),8) - no_bytes;
+ if (saved_mem < needed) {
+ /* Have to allocate more memory */
+ buf_size += needed;
+ buf_space += needed;
+ if (realloc_memory(drv_binary,buf_size,&ptr,
+ &complete_buf) == ASN1_ERROR)
+ return ASN1_ERROR;
+ }
+
+ counter -= (4 + no_bytes);
+ if((counter<0) ||
+ (ret=insert_bits_as_bits(desired_len,no_bytes,&in_ptr,
+ &ptr,&unused)) == ASN1_ERROR)
+ return ASN1_ERROR;
+ buf_space -= ret;
+ break;
+
+ default:
+ return ASN1_ERROR;
+ }
+ in_ptr++;
+ }
+ /* The returned buffer must be at least one byte and
+ it must be octet aligned */
+ if ((unused == 8) && (ptr != complete_buf))
+ return (ptr - complete_buf);
+ else {
+ ptr++; /* octet align buffer */
+ return (ptr - complete_buf);
+ }
+}
+
+
+int realloc_memory(ErlDrvBinary **drv_binary,
+ int amount,
+ unsigned char **ptr,
+ unsigned char **complete_buf) {
+
+ ErlDrvBinary *tmp_bin;
+ int i;
+
+/* printf("realloc_momory: amount = %d\n",amount); */
+ if ((tmp_bin=driver_realloc_binary(*drv_binary,amount)) == NULL) {
+ /*error handling due to memory allocation failure */
+/* printf("error when allocating memory\n"); */
+ return ASN1_ERROR;
+ }else {
+ i = *ptr - *complete_buf;
+ *drv_binary=tmp_bin;
+ *complete_buf = (*drv_binary)->orig_bytes;
+ *ptr = *complete_buf + i;
+ }
+ return ASN1_OK;
+}
+
+
+int insert_most_sign_bits(int no_bits,
+ unsigned char val,
+ unsigned char **output_ptr,
+ int *unused) {
+ unsigned char *ptr = *output_ptr;
+
+ if (no_bits < *unused){
+ *ptr = *ptr | (val >> (8 - *unused));
+ *unused -= no_bits;
+ } else if (no_bits == *unused) {
+ *ptr = *ptr | (val >> (8 - *unused));
+ *unused = 8;
+ *++ptr = 0x00;
+ } else {
+ *ptr = *ptr | (val >> (8 - *unused));
+ *++ptr = 0x00;
+ *ptr = *ptr | (val << *unused);
+ *unused = 8 - (no_bits - *unused);
+ }
+ *output_ptr = ptr;
+ return ASN1_OK;
+}
+
+
+int insert_least_sign_bits(int no_bits,
+ unsigned char val,
+ unsigned char **output_ptr,
+ int *unused) {
+ unsigned char *ptr = *output_ptr;
+ int ret = 0;
+
+ if (no_bits < *unused){
+ *ptr = *ptr | (val << (*unused - no_bits));
+ *unused -= no_bits;
+ } else if (no_bits == *unused){
+ *ptr = *ptr | val;
+ *unused = 8;
+ *++ptr = 0x00;
+ ret++;
+ } else {
+ /* first in the begun byte in the completed buffer insert
+ so many bits that fit, then insert the rest in next byte.*/
+ *ptr = *ptr | (val >> (no_bits - *unused));
+ *++ptr = 0x00;
+ ret++;
+ *ptr = *ptr | (val << (8 - (no_bits - *unused)));
+ *unused = 8 - (no_bits - *unused);
+ }
+ *output_ptr = ptr;
+ return ret;
+}
+
+/* pad_bits adds no_bits bits in the buffer that output_ptr
+ points at.
+ */
+int pad_bits(int no_bits, unsigned char **output_ptr, int *unused)
+ {
+ unsigned char *ptr = *output_ptr;
+ int ret = 0;
+
+ while (no_bits > 0) {
+ if(*unused == 1){
+ *unused = 8;
+ *++ptr = 0x00;
+ ret++;
+ } else
+ (*unused)--;
+ no_bits--;
+ }
+ *output_ptr = ptr;
+ return ret;
+ }
+
+
+/* insert_bits_as_bits removes no_bytes bytes from the buffer that in_ptr
+ points at and takes the desired_no leftmost bits from those removed
+ bytes and inserts them in the buffer(output buffer) that ptr points at.
+ The unused parameter tells how many bits that are not set in the
+ actual byte in the output buffer. If desired_no is more bits than the
+ input buffer has in no_bytes bytes, then zero bits is padded.*/
+int insert_bits_as_bits(int desired_no,
+ int no_bytes,
+ unsigned char **input_ptr,
+ unsigned char **output_ptr,
+ int *unused)
+{
+ unsigned char *in_ptr = *input_ptr;
+ unsigned char val;
+ int no_bits, ret, ret2;
+
+ if (desired_no == (no_bytes * 8)) {
+ if(insert_octets_unaligned(no_bytes,&in_ptr,output_ptr,*unused)
+ == ASN1_ERROR)
+ return ASN1_ERROR;
+ ret = no_bytes;
+ }
+ else if (desired_no < (no_bytes * 8)) {
+/* printf("insert_bits_as_bits 1\n\r"); */
+ if(insert_octets_unaligned(desired_no/8,&in_ptr,output_ptr,*unused)
+ == ASN1_ERROR)
+ return ASN1_ERROR;
+/* printf("insert_bits_as_bits 2\n\r"); */
+ val = *++in_ptr;
+/* printf("val = %d\n\r",(int)val); */
+ no_bits = desired_no % 8;
+/* printf("no_bits = %d\n\r",no_bits); */
+ insert_most_sign_bits(no_bits,val,output_ptr,unused);
+ ret = CEIL(desired_no,8);
+ }
+ else {
+ if(insert_octets_unaligned(no_bytes,&in_ptr,output_ptr,*unused)
+ == ASN1_ERROR)
+ return ASN1_ERROR;
+ ret2 = pad_bits(desired_no - (no_bytes * 8),output_ptr,unused);
+/* printf("ret2 = %d\n\r",ret2); */
+ ret = CEIL(desired_no,8);
+/* printf("ret = %d\n\r",ret); */
+ }
+/* printf("*unused = %d\n\r",*unused); */
+ *input_ptr = in_ptr;
+ return ret;
+}
+
+
+/* insert_octets_as_bits_exact_len */
+int
+insert_octets_as_bits_exact_len(int desired_len,
+ int in_buff_len,
+ unsigned char **in_ptr,
+ unsigned char **ptr,
+ int *unused)
+{
+ int ret = 0;
+ int ret2 = 0;
+
+ if (desired_len == in_buff_len) {
+ if ((ret = insert_octets_as_bits(in_buff_len,in_ptr,ptr,unused)) == ASN1_ERROR)
+ return ASN1_ERROR;
+ }
+ else if(desired_len > in_buff_len) {
+ if((ret = insert_octets_as_bits(in_buff_len,in_ptr,ptr,unused)) == ASN1_ERROR)
+ return ASN1_ERROR;
+ /* now pad with zero bits */
+/* printf("~npad_bits: called with %d bits padding~n~n~r",desired_len - in_buff_len); */
+ if ((ret2=pad_bits(desired_len - in_buff_len,ptr,unused)) == ASN1_ERROR)
+ return ASN1_ERROR;
+ }
+ else {/* desired_len < no_bits */
+ if ((ret=insert_octets_as_bits(desired_len,in_ptr,ptr,unused)) == ASN1_ERROR)
+ return ASN1_ERROR;
+ /* now remove no_bits - desired_len bytes from in buffer */
+ *in_ptr += (in_buff_len - desired_len);
+ }
+ return (ret+ret2);
+}
+
+
+
+/* insert_octets_as_bits takes no_bytes bytes from the buffer that input_ptr
+ points at and inserts the least significant bit of it in the buffer that
+ output_ptr points at. Each byte in the input buffer must be 1 or 0
+ otherwise the function returns ASN1_ERROR. The output buffer is concatenated
+ without alignment.
+ */
+int insert_octets_as_bits(int no_bytes,
+ unsigned char **input_ptr,
+ unsigned char **output_ptr,
+ int *unused)
+{
+ unsigned char *in_ptr = *input_ptr;
+ unsigned char *ptr = *output_ptr;
+ int used_bits = 8 - *unused;
+
+ while (no_bytes > 0) {
+ switch (*++in_ptr) {
+ case 0:
+ if(*unused == 1){
+ *unused = 8;
+ *++ptr = 0x00;
+ } else
+ (*unused)--;
+ break;
+ case 1:
+ if(*unused == 1){
+ *ptr = *ptr | 1;
+ *unused = 8;
+ *++ptr = 0x00;
+ } else {
+ *ptr = *ptr | (1 << (*unused - 1));
+ (*unused)--;
+ }
+ break;
+ default:
+ return ASN1_ERROR;
+ }
+ no_bytes--;
+ }
+ *input_ptr = in_ptr;
+ *output_ptr = ptr;
+ return ((used_bits+no_bytes) / 8); /*return number of new bytes
+ in completed buffer */
+}
+
+/* insert_octets inserts bytes from the input buffer, *input_ptr,
+ into the output buffer, *output_ptr. Before the first byte is
+ inserted the input buffer is aligned.
+ */
+int insert_octets(int no_bytes,
+ unsigned char **input_ptr,
+ unsigned char **output_ptr,
+ int *unused)
+{
+ unsigned char *in_ptr = *input_ptr;
+ unsigned char *ptr = *output_ptr;
+ int ret = 0;
+
+ if (*unused != 8) {/* must align before octets are added */
+ *++ptr = 0x00;
+ ret++;
+ *unused = 8;
+ }
+ while(no_bytes > 0) {
+ *ptr = *(++in_ptr);
+ *++ptr = 0x00;
+ /* *unused = *unused - 1; */
+ no_bytes--;
+ }
+ *input_ptr = in_ptr;
+ *output_ptr = ptr;
+ return (ret + no_bytes);
+}
+
+/* insert_octets_unaligned inserts bytes from the input buffer, *input_ptr,
+ into the output buffer, *output_ptr.No alignment is done.
+ */
+int insert_octets_unaligned(int no_bytes,
+ unsigned char **input_ptr,
+ unsigned char **output_ptr,
+ int unused)
+{
+ unsigned char *in_ptr = *input_ptr;
+ unsigned char *ptr = *output_ptr;
+ int n = no_bytes;
+ unsigned char val;
+
+ while (n > 0) {
+ if (unused == 8) {
+ *ptr = *++in_ptr;
+ *++ptr = 0x00;
+ }else {
+ val = *++in_ptr;
+ *ptr = *ptr | val >> (8 - unused);
+ *++ptr = 0x00;
+ *ptr = val << unused;
+ }
+ n--;
+ }
+ *input_ptr = in_ptr;
+ *output_ptr = ptr;
+ return no_bytes;
+}
+
+
+int insert_octets_except_unused(int no_bytes,
+ unsigned char **input_ptr,
+ unsigned char **output_ptr,
+ int *unused,
+ int in_unused)
+{
+ unsigned char *in_ptr = *input_ptr;
+ unsigned char *ptr = *output_ptr;
+ int val, no_bits;
+ int ret = 0;
+
+ if (in_unused == 0){
+/* printf("%d: insert_octets_except_unused: if\n\r",__LINE__); */
+ if ((ret = insert_octets_unaligned(no_bytes,&in_ptr,&ptr,
+ *unused)) == ASN1_ERROR)
+ return ASN1_ERROR;
+ }
+ else {
+/* printf("%d: insert_octets_except_unused: else\n\r",__LINE__); */
+ if ((ret=insert_octets_unaligned(no_bytes - 1,&in_ptr,&ptr,*unused)) != ASN1_ERROR) {
+ val = (int) *(++in_ptr);
+ no_bits = 8 - in_unused;
+ /* no_bits is always less than *unused since the buffer is
+ octet aligned after insert:octets call, so the following
+ if clasuse is obsolete I think */
+ if(no_bits < *unused){
+ *ptr = *ptr | (val >> (8 - *unused));
+ *unused = *unused - no_bits;
+ } else if (no_bits == *unused) {
+ *ptr = *ptr | (val >> (8 - *unused));
+ *++ptr = 0x00;
+ ret++;
+ *unused = 8;
+ } else {
+ *ptr = *ptr | (val >> (8 - *unused));
+ *++ptr = 0x00;
+ ret++;
+ *ptr = *ptr | (val << *unused);
+ *unused = 8 - (no_bits - *unused);
+ }
+ } else
+ return ASN1_ERROR;
+ }
+ *input_ptr = in_ptr;
+ *output_ptr = ptr;
+/* printf("%d: insert_octets_except_unused: ret=%d\n\r",__LINE__,ret); */
+ return ret;
+}
+
+
+
+/*
+ *
+ * This section defines functionality for the partial decode of a
+ * BER encoded message
+ *
+ */
+
+/*
+ * int decode(ErlDrvBinary **drv_binary,unsigned char *decode_buf,
+ * unsigned char *in_buf, int in_buf_len)
+ * drv_binary is a pointer to a pointer to an allocated driver binary.
+ * in_buf is a pointer into the buffer of incoming bytes.
+ * in_buf_len is the length of the incoming buffer.
+ * The function reads the bytes in the incoming buffer and structures
+ * it in a nested way as Erlang terms. The buffer contains data in the
+ * order tag - length - value. Tag, length and value has the following
+ * format:
+ * A tag is normally one byte but may be of any length, if the tag number
+ * is greater than 30. +----------+
+ * |CL|C|NNNNN|
+ * +----------+
+ * If NNNNN is 31 then will the 7 l.s.b of each of the following tag number
+ * bytes contain the tag number. Each tag number byte that is not the last one
+ * has the m.s.b. set to 1.
+ * The length can be short definite length (sdl), long definite length (ldl)
+ * or indefinite length (il).
+ * sdl: +---------+ the L bits is the length
+ * |0|LLLLLLL|
+ * +---------+
+ * ldl: +---------+ +---------+ +---------+ +-----------+
+ * |1|lllllll| |first len| | | |the Nth len|
+ * +---------+ +---------+ +---------+ ... +-----------+
+ * The first byte tells how many len octets will follow, max 127
+ * il: +---------+ +----------------------+ +--------+ +--------+
+ * |1|0000000| |content octets (Value)| |00000000| |00000000|
+ * +---------+ +----------------------+ +--------+ +--------+
+ * The value octets are preceded by one octet and followed by two
+ * exactly as above. The value must be some tag-length-value encoding.
+ *
+ * The function returns a value in Erlnag term format:
+ * {{TagNo,Value},Rest}
+ * TagNo is an integer ((CL bsl 16) + tag number) which limits the tag number
+ * to 65535.
+ * Value is a binary if the C bit in tag was unset, otherwise (if tag was
+ * constructed) Value is a list, List.
+ * List is like: [{TagNo,Value},{TagNo,Value},...]
+ * Rest is a binary, i.e. the undecoded part of the buffer. Most often Rest
+ * is the empty binary.
+ * If some error occured during the decoding of the in_buf an error is returned.
+ */
+int decode_begin(ErlDrvBinary **drv_binary,unsigned char *in_buf, int in_buf_len, unsigned int *err_pos)
+{
+ int maybe_ret;
+ char *decode_buf = (*drv_binary)->orig_bytes;
+ int ei_index = 0;
+ int ib_index = 0;
+ /* ei_index is the index used by the ei functions to encode an
+ Erlang term into the buffer decode_buf */
+ /* ib_index is the index were to read the next byte from in_buf */
+
+
+#ifdef ASN1_DEBUG
+ printf("decode_begin1: ei_index=%d, ib_index=%d\n\r",ei_index,ib_index);
+#endif
+ /* the first byte must be a "version magic" */
+ if(ei_encode_version(decode_buf,&ei_index) == ASN1_ERROR)
+ return ASN1_ERROR; /* 1 byte */
+#ifdef ASN1_DEBUG
+ printf("decode_begin2: ei_index=%d, ib_index=%d\n\r",ei_index,ib_index);
+#endif
+ if (ei_encode_tuple_header(decode_buf,&ei_index,2) == ASN1_ERROR)
+ return ASN1_ERROR; /* 2 bytes */
+#ifdef ASN1_DEBUG
+ printf("decode_begin3: ei_index=%d, ib_index=%d\n\r",ei_index,ib_index);
+#endif
+ if((maybe_ret=decode(drv_binary,&ei_index,in_buf,&ib_index,in_buf_len)) <= ASN1_ERROR)
+ {
+ *err_pos = ib_index;
+#ifdef ASN1_DEBUG
+ printf("err_pos=%d,ib_index=%d\r\n",*err_pos,ib_index);
+#endif
+ return maybe_ret;
+ };
+
+ decode_buf = (*drv_binary)->orig_bytes; /* maybe a realloc during decode_value */
+#ifdef ASN1_DEBUG
+ printf("decode_begin4: in_buf_len=%d, ei_index=%d, ib_index=%d\n\r",
+ in_buf_len,ei_index,ib_index);
+#endif
+ /* "{{TagNo,Value},Rest}" */
+ if (ei_encode_binary(decode_buf,&ei_index,&(in_buf[ib_index]),in_buf_len-ib_index)
+ == ASN1_ERROR) /* at least 5 bytes */
+ return ASN1_ERROR;
+#ifdef ASN1_DEBUG
+ printf("decode_begin5: ei_index=%d, ib_index=%d\n\r",ei_index,ib_index);
+#endif
+ return ei_index;
+}
+
+int decode(ErlDrvBinary **drv_binary,int *ei_index,unsigned char *in_buf,
+ int *ib_index, int in_buf_len)
+{
+ int maybe_ret;
+ char *decode_buf = (*drv_binary)->orig_bytes;
+ int form;
+#ifdef ASN1_DEBUG
+ printf("decode 1\n\r");
+#endif
+ if (((*drv_binary)->orig_size - *ei_index) < 19) {/* minimum amount of bytes */
+ /* allocate more memory */
+ if (realloc_decode_buf(drv_binary,(*drv_binary)->orig_size * 2) ==
+ ASN1_ERROR)
+ return ASN1_ERROR;
+ decode_buf = (*drv_binary)->orig_bytes;
+ }
+/* printf("decode 2\n\r"); */
+ /* "{" */
+ if (ei_encode_tuple_header(decode_buf,ei_index,2) == ASN1_ERROR)
+ return ASN1_ERROR; /* 2 bytes */
+#ifdef ASN1_DEBUG
+ printf("decode 3:orig_size=%d, ei_index=%d, ib_index=%d\n\r",(*drv_binary)->orig_size,*ei_index,*ib_index);
+#endif
+
+ /*buffer must hold at least two bytes*/
+ if ((*ib_index +2) > in_buf_len)
+ return ASN1_VALUE_ERROR;
+ /* "{{TagNo," */
+ if ((form = decode_tag(decode_buf,ei_index,in_buf,in_buf_len,ib_index)) <= ASN1_ERROR)
+ return form; /* 5 bytes */
+#ifdef ASN1_DEBUG
+ printf("i_i=%d,in_buf_len=%d\r\n",*ei_index,in_buf_len);
+#endif
+ if (*ib_index >= in_buf_len){
+ return ASN1_TAG_ERROR;
+ }
+#ifdef ASN1_DEBUG
+ printf("decode 5 ib_index=%d\n\r",*ib_index);
+#endif
+ /* buffer must hold at least one byte (0 as length and nothing as
+ value) */
+ /* "{{TagNo,Value}," */
+ if ((maybe_ret=decode_value(ei_index,in_buf,ib_index,drv_binary,form,
+ in_buf_len)) <= ASN1_ERROR)
+ return maybe_ret; /* at least 5 bytes */
+#ifdef ASN1_DEBUG
+ printf("decode 7\n\r");
+#endif
+ return *ei_index;
+}
+
+/*
+ * decode_tag decodes the BER encoded tag in in_buf and puts it in the
+ * decode_buf encoded by the Erlang extern format as an Erlang term.
+ */
+int decode_tag(char *decode_buf,int *db_index,unsigned char *in_buf,
+ int in_buf_len, int *ib_index)
+{
+ int tag_no, tmp_tag, form;
+
+
+ /* first get the class of tag and bit shift left 16*/
+ tag_no = ((MASK(in_buf[*ib_index],ASN1_CLASS)) << 10);
+
+ form = (MASK(in_buf[*ib_index],ASN1_FORM));
+#ifdef ASN1_DEBUG
+ printf("decode_tag0:ii=%d, tag_no=%d, form=%d.\r\n",
+ *ib_index,tag_no,form);
+#endif
+
+ /* then get the tag number */
+ if((tmp_tag = (int) INVMASK(in_buf[*ib_index],ASN1_CLASSFORM)) < 31) {
+ ei_encode_ulong(decode_buf,db_index,tag_no+tmp_tag); /* usual case */
+ (*ib_index)++;
+#ifdef ASN1_DEBUG
+ printf("decode_tag1:ii=%d.\r\n",*ib_index);
+#endif
+ }
+ else
+ {
+ int n = 0; /* n is used to check that the 64K limit is not
+ exceeded*/
+#ifdef ASN1_DEBUG
+ printf("decode_tag1:ii=%d, in_buf_len=%d.\r\n",*ib_index,in_buf_len);
+#endif
+
+ /* should check that at least three bytes are left in
+ in-buffer,at least two tag byte and at least one length byte */
+ if ((*ib_index +3) > in_buf_len)
+ return ASN1_VALUE_ERROR;
+ (*ib_index)++;
+#ifdef ASN1_DEBUG
+ printf("decode_tag2:ii=%d.\r\n",*ib_index);
+#endif
+ /* The tag is in the following bytes in in_buf as
+ 1ttttttt 1ttttttt ... 0ttttttt, where the t-bits
+ is the tag number*/
+ /* In practice is the tag size limited to 64K, i.e. 16 bits. If
+ the tag is greater then 64K return an error */
+ while (((tmp_tag = (int)in_buf[*ib_index]) >= 128) && n < 2){
+ /* m.s.b. = 1 */
+ tag_no = tag_no + (MASK(tmp_tag,ASN1_LONG_TAG) << 7);
+ (*ib_index)++;
+#ifdef ASN1_DEBUG
+ printf("decode_tag3:ii=%d.\r\n",*ib_index);
+#endif
+ n++;
+ };
+ if ((n==2) && in_buf[*ib_index] > 3)
+ return ASN1_TAG_ERROR; /* tag number > 64K */
+ tag_no = tag_no + in_buf[*ib_index];
+ (*ib_index)++;
+#ifdef ASN1_DEBUG
+ printf("decode_tag4:ii=%d.\r\n",*ib_index);
+#endif
+ ei_encode_ulong(decode_buf,db_index,tag_no);
+ }
+ return form;
+}
+
+
+/*
+ * decode_value decodes the BER encoded length and value fields in the
+ * in_buf and puts the value part in the decode_buf as an Erlang term
+ * encoded by the Erlang extern format
+ */
+int decode_value(int *ei_index,unsigned char *in_buf,
+ int *ib_index,ErlDrvBinary **drv_binary,int form,
+ int in_buf_len)
+{
+ int maybe_ret;
+ char *decode_buf = (*drv_binary)->orig_bytes;
+ int len, lenoflen;
+ int indef = 0;
+
+#ifdef ASN1_DEBUG
+ printf("decode_value1:ib_index=%d\n\r",*ib_index);
+#endif
+ if (((in_buf[*ib_index]) & 0x80) == ASN1_SHORT_DEFINITE_LENGTH) {
+ len = in_buf[*ib_index];
+ if (len > (in_buf_len - (*ib_index + 1)))
+ return ASN1_LEN_ERROR;
+ }
+ else if (in_buf[*ib_index] == ASN1_INDEFINITE_LENGTH)
+ indef = 1;
+ else /* long definite length */ {
+ lenoflen = (in_buf[*ib_index] & 0x7f); /*length of length */
+#ifdef ASN1_DEBUG
+ printf("decode_value,lenoflen:%d\r\n",lenoflen);
+#endif
+ len = 0;
+ while (lenoflen-- && (*ib_index <= in_buf_len)) {
+ (*ib_index)++;
+#ifdef ASN1_DEBUG
+ printf("decode_value1:ii=%d.\r\n",*ib_index);
+#endif
+ len = (len << 8) + in_buf[*ib_index];
+ }
+ if (len > (in_buf_len - (*ib_index + 1)))
+ return ASN1_LEN_ERROR;
+ }
+ (*ib_index)++;
+#ifdef ASN1_DEBUG
+ printf("decode_value2:ii=%d.\r\n",*ib_index);
+#endif
+ if (indef == 1)
+ { /* in this case it is desireably to check that indefinite length
+ end bytes exist in inbuffer */
+ while (!(in_buf[*ib_index]==0 && in_buf[*ib_index + 1]==0)) {
+#ifdef ASN1_DEBUG
+ printf("decode_value while:ib_index=%d in_buf_len=%d\n\r",
+ *ib_index,in_buf_len);
+#endif
+ if(*ib_index >= in_buf_len)
+ return ASN1_INDEF_LEN_ERROR;
+ ei_encode_list_header(decode_buf,ei_index,1); /* 5 bytes */
+ if((maybe_ret=decode(drv_binary,ei_index,in_buf,
+ ib_index,in_buf_len)) <= ASN1_ERROR)
+ return maybe_ret;
+ decode_buf = (*drv_binary)->orig_bytes;
+ }
+ (*ib_index) += 2; /* skip the indefinite length end bytes */
+#ifdef ASN1_DEBUG
+ printf("decode_value3:ii=%d.\r\n",*ib_index);
+#endif
+ ei_encode_empty_list(decode_buf,ei_index); /* 1 byte */
+ }
+ else if (form == ASN1_CONSTRUCTED)
+ {
+ int end_index = *ib_index + len;
+ if(end_index > in_buf_len)
+ return ASN1_LEN_ERROR;
+ while (*ib_index < end_index) {
+
+#ifdef ASN1_DEBUG
+ printf("decode_value3:*ib_index=%d, end_index=%d\n\r",*ib_index,end_index);
+#endif
+ ei_encode_list_header(decode_buf,ei_index,1); /* 5 bytes */
+ if((maybe_ret=decode(drv_binary,ei_index,in_buf,
+ ib_index,in_buf_len))<=ASN1_ERROR)
+ return maybe_ret;
+ decode_buf = (*drv_binary)->orig_bytes;
+ }
+ ei_encode_empty_list(decode_buf,ei_index); /* 1 byte */
+ }
+ else
+ {
+ if (((*drv_binary)->orig_size - *ei_index) < 10+len) { /* 5+len for the binary*/
+ if (realloc_decode_buf(drv_binary,(*drv_binary)->orig_size * 2) ==
+ ASN1_ERROR)
+ return ASN1_ERROR;
+ decode_buf = (*drv_binary)->orig_bytes;
+ }
+ if((*ib_index + len) > in_buf_len)
+ return ASN1_LEN_ERROR;
+ ei_encode_binary(decode_buf,ei_index,&in_buf[*ib_index],len);
+ *ib_index = *ib_index + len;
+#ifdef ASN1_DEBUG
+ printf("decode_value4:ii=%d.\r\n",*ib_index);
+#endif
+ }
+ return ASN1_OK;
+}
+
+int realloc_decode_buf(ErlDrvBinary **drv_binary,int amount) {
+ ErlDrvBinary *tmp_bin;
+
+ if ((tmp_bin=driver_realloc_binary(*drv_binary,amount)) == NULL)
+ return ASN1_ERROR;
+ *drv_binary = tmp_bin;
+ return ASN1_OK;
+}
+
+
+
+/*
+ * int decode_partial(drv_binary,in_buf,in_buf_len)
+ */
+/*
+ * The in_buf contains two parts: first information about which value
+ * will be decoded, as a sequence of tags and tag codes, then the
+ * encoded BER value. First of all comes a length field that tells how
+ * many following bytes contains the sequence of tags. Then starts the
+ * BER encoded message. The tag sequence length field is a single
+ * byte. The sequence of tags/tag codes may be one of the codes
+ * ASN1_SKIPPED, ASN1_CHOOSEN and a tag or ASN1_OPTIONAL and a
+ * tag. ASN1_SKIPPED means that the following tag is mandatory and is
+ * skipped. ASN1_CHOOSEN means that the value of this tag shall, if
+ * this was the last tag in tag sequence, be returned or be searched
+ * in for the next tag. ASN1_OPTIONAL means that this tag shall be
+ * skipped but it may be missing. Each tag in the tag sequence
+ * correspond to a tag in the BER encoded message. If the decode
+ * arives to a position where there is no matching tag, an error is
+ * returned (if it wasn't the last tag and it was OPTIONAL). After the
+ * right value has been detected it is returned in the out_buf.
+ *
+ */
+int decode_partial(ErlDrvBinary **drv_binary,unsigned char *in_buf, int in_buf_len)
+{
+ char *out_buf = (*drv_binary)->orig_bytes;
+ int tag_index_val = 1;
+ int msg_index_val;
+ int *msg_index, *tag_index, tmp_index;
+ int tag_seq_length;
+ char tag_code; /* one of ASN1_SKIPPED, ASN1_OPTIONAL, ASN1_CHOOSEN */
+ int wanted_tag, next_tag;
+ int buf_end_index = in_buf_len;
+ int ret = 0, length, old_index;
+
+ tag_index = &tag_index_val;
+ tag_seq_length = in_buf[0];
+ msg_index = &msg_index_val;
+ *msg_index = tag_seq_length + 1;
+
+
+/* printf("decode_partial 1: in_buf_len=%d, tag_index=%d, msg_index=%d\r\n,tag_seq_length=%d\r\n",in_buf_len,*tag_index,*msg_index,tag_seq_length); */
+ while(*tag_index < tag_seq_length) {
+ switch(in_buf[*tag_index]) {
+ case ASN1_SKIPPED:
+/* printf("decode_partial ASN1_SKIPPED: in_buf[*msg_index]=%d\r\n",in_buf[*msg_index]); */
+ (*tag_index)++;
+/* printf("decode_partial ASN1_SKIPPED 2: *msg_index=%d\r\n",*msg_index); */
+ skip_tag(in_buf,msg_index,buf_end_index);
+/* printf("decode_partial ASN1_SKIPPED 3: *msg_index=%d\r\n",*msg_index); */
+ skip_length_and_value(in_buf,msg_index,buf_end_index);
+/* printf("decode_partial ASN1_SKIPPED 4: *msg_index=%d\r\n",*msg_index); */
+ break;
+ case ASN1_OPTIONAL:
+ (*tag_index)++;
+/* printf("decode_partial ASN1_OPTIONAL: in_buf[*tag_index]=%d\r\n",in_buf[*tag_index]); */
+ wanted_tag = in_buf[*tag_index];
+ (*tag_index)++;
+ tmp_index = *msg_index;
+ next_tag = get_tag(in_buf,msg_index,buf_end_index);
+ if (wanted_tag != next_tag) {
+ *msg_index = tmp_index;
+ } else
+ skip_length_and_value(in_buf,msg_index,buf_end_index);
+ break;
+ case ASN1_CHOOSEN:
+/* printf("decode_partial ASN1_CHOOSEN: in_buf[*msg_index]=%d, *msg_index=%d\r\n",in_buf[*msg_index],*msg_index); */
+ (*tag_index)++;
+ wanted_tag = in_buf[*tag_index];
+ (*tag_index)++;
+ old_index = *msg_index;
+/* printf("decode_partial ASN1_CHOOSEN 2: *msg_index=%d\r\n",*msg_index); */
+ next_tag = get_tag(in_buf,msg_index,buf_end_index);
+/* printf("decode_partial ASN1_CHOOSEN 3: *msg_index=%d\r\n,wanted_tag=%d, next_tag=%d\r\n",*msg_index,wanted_tag,next_tag); */
+ if (wanted_tag != next_tag)
+ return ASN1_NOVALUE; /* an empty binary will be returned to Erlang */
+ if (*tag_index == (tag_seq_length + 1)) {
+ /* get the value and return*/
+ if((ret = get_value(out_buf,in_buf,msg_index,buf_end_index)) <= ASN1_ERROR)
+ return ASN1_ERROR;
+ return ret;
+ }
+ else {
+ /* calculate the length of the sub buffer and let *msg_index
+ be at the value part of this BER encoded type*/
+ int indef;
+ indef = 0;
+ length = get_length(in_buf,msg_index,&indef,buf_end_index);
+/* printf("decode_partial ASN1_CHOOSEN 4: length=%d, *msg_index=%d\r\n",length,*msg_index); */
+ if ((length == 0) && (indef == 1)) {
+ /* indefinite length of value */
+ old_index = *msg_index;
+ length = skip_length_and_value(in_buf,msg_index,buf_end_index);
+ *msg_index = old_index;
+ buf_end_index = *msg_index + length - 2;
+ /* remove two bytes due to indefinete length end zeros */
+ } else
+ buf_end_index = (*msg_index + length);
+ }
+ break;
+ default:
+ return ASN1_ERROR;
+ }
+ }
+ return ASN1_ERROR;
+}
+
+
+/*
+ * int skip_tag(unsigned char *in_buf,int *index,int buf_len)
+ * steps past the BER encoded tag in in_buf and updates *index.
+ * Returns the number of skipped bytes.
+ */
+int skip_tag(unsigned char *in_buf,int *index,int buf_len)
+{
+ int start_index = *index;
+ if ((MASK(in_buf[*index],ASN1_TAG)) == 31){
+ do {
+ (*index)++;
+ if (*index >= buf_len)
+ return ASN1_ERROR;
+ }
+ while(in_buf[*index] >=128);
+ }
+ (*index)++;
+ return (*index - start_index);
+}
+
+
+/*
+ * int skip_length_and_value(unsigned char *in_buf,int *index,int buf_len)
+ * steps past the BER encoded length and value in in_buf and updates *index.
+ * returns the length if the skipped "length value".
+ * Returns the number of skipped bytes.
+ */
+int skip_length_and_value(unsigned char *in_buf,int *index,int buf_len)
+{
+ long len;
+ int indef = 0, lenoflen;
+ int start_index = *index;
+
+ if ((MASK(in_buf[*index],0x80)) == ASN1_SHORT_DEFINITE_LENGTH){
+ len = in_buf[*index];
+ if (len > (buf_len - (*index + 1)))
+ return ASN1_LEN_ERROR;
+ } else if (in_buf[*index] == ASN1_INDEFINITE_LENGTH)
+ indef = 1;
+ else /* long definite length */ {
+ lenoflen = (in_buf[*index] & 0x7f); /*length of length */
+ len = 0;
+ while (lenoflen--) {
+ (*index)++;
+ len = (len << 8) + in_buf[*index];
+ }
+ if (len > (buf_len - (*index + 1)))
+ return ASN1_LEN_ERROR;
+ }
+ (*index)++;
+ if (indef == 1)
+ {
+ while(!(in_buf[*index]==0 && in_buf[*index + 1]==0)) {
+ skip_tag(in_buf,index,buf_len);
+ skip_length_and_value(in_buf,index,buf_len);
+ }
+ (*index) += 2;
+ }
+ else
+ (*index) += len;
+ return (*index - start_index);
+}
+
+/* int get_tag(unsigned char *in_buf,int *index)
+ *
+ * assumes next byte/bytes in in_buf is an encoded BER tag. A tag
+ * number has theoretically no upper limit in size. Here the tag
+ * number is assumed to be less than 64K. Returns an integer value
+ * on the format:
+ * xxxxxxxx xxxxxxcc tttttttt tttttttt
+ * the x-bits are 0 (insignificant)
+ * the c-bits are the class of the tag
+ * the t-bits are the tag number. This implies that the tag number
+ * is limited to 64K-1
+ *
+ */
+int get_tag(unsigned char *in_buf,int *index,int buf_len)
+{
+ int tag_no = 0,tmp_tag = 0;
+
+ tag_no = (MASK(in_buf[*index],ASN1_CLASSFORM));
+ if ((MASK(in_buf[*index],ASN1_TAG)) == ASN1_TAG) {
+ /* long form of tag */
+ do {
+ (*index)++;
+ if (*index >= buf_len)
+ return ASN1_TAG_ERROR;
+ tmp_tag = tmp_tag << 7;
+ tmp_tag += (MASK(in_buf[*index],ASN1_LONG_TAG));
+ } while (in_buf[*index] >= 128);
+ (*index)++;
+ tag_no = tag_no + tmp_tag;
+ } else {
+ tag_no += (MASK(in_buf[*index],ASN1_TAG));
+ (*index)++;
+ }
+ if (*index >= buf_len)
+ return ASN1_TAG_ERROR;
+ return tag_no;
+}
+
+
+/*
+ * int get_value(char *out_buf,unsigned char *in_buf,
+ * int *msg_index,int in_buf_len)
+ */
+/* assumes next byte/bytes in in_buf is an encoded BER value preceeded by a BER encoded length. Puts value in out_buf.
+ */
+int get_value(char *out_buf,
+ unsigned char *in_buf,
+ int *msg_index,
+ int in_buf_len)
+{
+ int len, lenoflen, indef=0, skip_len;
+ int ret=0;
+ int start_index, out_index = 0;
+
+/* printf("get_value 1\n\r"); */
+ if (in_buf[*msg_index] < 0x80){ /* short definite length */
+ len = in_buf[*msg_index];
+/* printf("short definite length\r\n"); */
+ } else if (in_buf[*msg_index] > 0x80) { /* long definite length */
+ lenoflen = (in_buf[*msg_index] & 0x7f); /*length of length */
+ len = 0;
+ while (lenoflen--) {
+ (*msg_index)++;
+ len = (len << 8) + in_buf[*msg_index];
+ }
+ if (len > (in_buf_len - (*msg_index + 1)))
+ return ASN1_LEN_ERROR;
+ } else
+ indef = 1;
+ (*msg_index)++;
+/* printf("get_value 2: len = %d, *msg_index = %d\r\n",len,*msg_index); */
+ if (indef == 1) {
+ while(!(in_buf[*msg_index]==0 && in_buf[*msg_index + 1]==0)) {
+ start_index = *msg_index;
+ skip_len = skip_tag(in_buf,msg_index,in_buf_len);
+/* printf("get_value 3: skip_len=%d,start_index=%d,*msg_index=%d\n\r", */
+/* skip_len,start_index,*msg_index); */
+ memcpy(&out_buf[ret],&in_buf[start_index],skip_len);
+ ret += skip_len;
+ start_index = *msg_index;
+ skip_len = skip_length_and_value(in_buf,msg_index,in_buf_len);
+/* printf("get_value 4: skip_len=%d,start_index=%d,*msg_index=%d\n\r", */
+/* skip_len,start_index,*msg_index); */
+ memcpy(&out_buf[ret],&in_buf[start_index],skip_len);
+ ret += skip_len;
+ }
+ return ret;
+ }
+ else
+ memcpy(&out_buf[ret],&in_buf[*msg_index],len);
+ return len;
+}
+
+
+/*
+ * int get_length(unsigned char *in_buf,int *msg_index)
+ * assumes next byte/bytes contain a BER encoded length field,
+ * which is decoded. The value of the length is returned. If it
+ * is an indefinite length the *indef is set to one.
+ */
+int get_length(unsigned char *in_buf,int *msg_index,
+ int *indef,int in_buf_len)
+{
+ int len=0, lenoflen;
+
+ if (in_buf[*msg_index] < 0x80) /* short definite length */
+ len = in_buf[*msg_index];
+ else if (in_buf[*msg_index] > 0x80) { /* long definite length */
+ lenoflen = (in_buf[*msg_index] & 0x7f); /*length of length */
+ len = 0;
+ while (lenoflen--) {
+ (*msg_index)++;
+ len = (len << 8) + in_buf[*msg_index];
+ }
+ if (len > (in_buf_len - (*msg_index + 1)))
+ return ASN1_LEN_ERROR;
+ } else
+ *indef = 1;
+ (*msg_index)++;
+ return len;
+}