libs/smux/ANY.c

   1 /*-
   2  * Copyright (c) 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 <ANY.h>
   7 #include <errno.h>
   8
   9 static asn_OCTET_STRING_specifics_t asn_DEF_ANY_specs = {
  10         sizeof(ANY_t),
  11         offsetof(ANY_t, _asn_ctx),
  12         ASN_OSUBV_ANY
  13 };
  14 asn_TYPE_descriptor_t asn_DEF_ANY = {
  15         "ANY",
  16         "ANY",
  17         OCTET_STRING_free,
  18         OCTET_STRING_print,
  19         asn_generic_no_constraint,
  20         OCTET_STRING_decode_ber,
  21         OCTET_STRING_encode_der,
  22         OCTET_STRING_decode_xer_hex,
  23         ANY_encode_xer,
  24         0, 0,
  25         0, /* Use generic outmost tag fetcher */
  26         0, 0, 0, 0,
  27         0,      /* No PER visible constraints */
  28         0, 0,   /* No members */
  29         &asn_DEF_ANY_specs,
  30 };
  31
  32
  33 asn_enc_rval_t
  34 ANY_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
  35         int ilevel, enum xer_encoder_flags_e flags,
  36                 asn_app_consume_bytes_f *cb, void *app_key) {
  37
  38         if(flags & XER_F_CANONICAL) {
  39                 /*
  40                  * Canonical XER-encoding of ANY type is not supported.
  41                  */
  42                 ASN__ENCODE_FAILED;
  43         }
  44
  45         /* Dump as binary */
  46         return OCTET_STRING_encode_xer(td, sptr, ilevel, flags, cb, app_key);
  47 }
  48
  49 struct _callback_arg {
  50         uint8_t *buffer;
  51         size_t offset;
  52         size_t size;
  53 };
  54
  55 static int ANY__consume_bytes(const void *buffer, size_t size, void *key);
  56
  57 int
  58 ANY_fromType(ANY_t *st, asn_TYPE_descriptor_t *td, void *sptr) {
  59         struct _callback_arg arg;
  60         asn_enc_rval_t erval;
  61
  62         if(!st || !td) {
  63                 errno = EINVAL;
  64                 return -1;
  65         }
  66
  67         if(!sptr) {
  68                 if(st->buf) FREEMEM(st->buf);
  69                 st->size = 0;
  70                 return 0;
  71         }
  72
  73         arg.offset = arg.size = 0;
  74         arg.buffer = 0;
  75
  76         erval = der_encode(td, sptr, ANY__consume_bytes, &arg);
  77         if(erval.encoded == -1) {
  78                 if(arg.buffer) FREEMEM(arg.buffer);
  79                 return -1;
  80         }
  81         assert((size_t)erval.encoded == arg.offset);
  82
  83         if(st->buf) FREEMEM(st->buf);
  84         st->buf = arg.buffer;
  85         st->size = arg.offset;
  86
  87         return 0;
  88 }
  89
  90 ANY_t *
  91 ANY_new_fromType(asn_TYPE_descriptor_t *td, void *sptr) {
  92         ANY_t tmp;
  93         ANY_t *st;
  94
  95         if(!td || !sptr) {
  96                 errno = EINVAL;
  97                 return 0;
  98         }
  99
 100         memset(&tmp, 0, sizeof(tmp));
 101
 102         if(ANY_fromType(&tmp, td, sptr)) return 0;
 103
 104         st = (ANY_t *)CALLOC(1, sizeof(ANY_t));
 105         if(st) {
 106                 *st = tmp;
 107                 return st;
 108         } else {
 109                 FREEMEM(tmp.buf);
 110                 return 0;
 111         }
 112 }
 113
 114 int
 115 ANY_to_type(ANY_t *st, asn_TYPE_descriptor_t *td, void **struct_ptr) {
 116         asn_dec_rval_t rval;
 117         void *newst = 0;
 118
 119         if(!st || !td || !struct_ptr) {
 120                 errno = EINVAL;
 121                 return -1;
 122         }
 123
 124         if(st->buf == 0) {
 125                 /* Nothing to convert, make it empty. */
 126                 *struct_ptr = (void *)0;
 127                 return 0;
 128         }
 129
 130         rval = ber_decode(0, td, (void **)&newst, st->buf, st->size);
 131         if(rval.code == RC_OK) {
 132                 *struct_ptr = newst;
 133                 return 0;
 134         } else {
 135                 /* Remove possibly partially decoded data. */
 136                 ASN_STRUCT_FREE(*td, newst);
 137                 return -1;
 138         }
 139 }
 140
 141 static int ANY__consume_bytes(const void *buffer, size_t size, void *key) {
 142         struct _callback_arg *arg = (struct _callback_arg *)key;
 143
 144         if((arg->offset + size) >= arg->size) {
 145                 size_t nsize = (arg->size ? arg->size << 2 : 16) + size;
 146                 void *p = REALLOC(arg->buffer, nsize);
 147                 if(!p) return -1;
 148                 arg->buffer = (uint8_t *)p;
 149                 arg->size = nsize;
 150         }
 151
 152         memcpy(arg->buffer + arg->offset, buffer, size);
 153         arg->offset += size;
 154         assert(arg->offset < arg->size);
 155
 156         return 0;
 157 }
 158