src/codec_utils/F1AP/ANY.c

   1 /*
   2  * Copyright (c) 2004-2017 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 asn_OCTET_STRING_specifics_t asn_SPC_ANY_specs = {
  10         sizeof(ANY_t),
  11         offsetof(ANY_t, _asn_ctx),
  12         ASN_OSUBV_ANY
  13 };
  14 asn_TYPE_operation_t asn_OP_ANY = {
  15         OCTET_STRING_free,
  16         OCTET_STRING_print,
  17         OCTET_STRING_compare,
  18         OCTET_STRING_decode_ber,
  19         OCTET_STRING_encode_der,
  20         OCTET_STRING_decode_xer_hex,
  21         ANY_encode_xer,
  22 #ifdef  ASN_DISABLE_OER_SUPPORT
  23         0,
  24         0,
  25 #else
  26         0,
  27         0,
  28 #endif  /* ASN_DISABLE_OER_SUPPORT */
  29 #ifdef  ASN_DISABLE_PER_SUPPORT
  30         0, 0, 0, 0,
  31 #else
  32         ANY_decode_uper,
  33         ANY_encode_uper,
  34         ANY_decode_aper,
  35         ANY_encode_aper,
  36 #endif  /* ASN_DISABLE_PER_SUPPORT */
  37         0,      /* Random fill is not defined for ANY type */
  38         0       /* Use generic outmost tag fetcher */
  39 };
  40 asn_TYPE_descriptor_t asn_DEF_ANY = {
  41         "ANY",
  42         "ANY",
  43         &asn_OP_ANY,
  44         0, 0, 0, 0,
  45         { 0, 0, asn_generic_no_constraint },    /* No constraints */
  46         0, 0,   /* No members */
  47         &asn_SPC_ANY_specs,
  48 };
  49
  50 #undef RETURN
  51 #define RETURN(_code)                       \
  52     do {                                    \
  53         asn_dec_rval_t tmprval;             \
  54         tmprval.code = _code;               \
  55         tmprval.consumed = consumed_myself; \
  56         return tmprval;                     \
  57     } while(0)
  58
  59 asn_enc_rval_t
  60 ANY_encode_xer(const asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
  61                enum xer_encoder_flags_e flags, asn_app_consume_bytes_f *cb,
  62                void *app_key) {
  63     if(flags & XER_F_CANONICAL) {
  64                 /*
  65                  * Canonical XER-encoding of ANY type is not supported.
  66                  */
  67                 ASN__ENCODE_FAILED;
  68         }
  69
  70         /* Dump as binary */
  71         return OCTET_STRING_encode_xer(td, sptr, ilevel, flags, cb, app_key);
  72 }
  73
  74 struct _callback_arg {
  75         uint8_t *buffer;
  76         size_t offset;
  77         size_t size;
  78 };
  79
  80 static int ANY__consume_bytes(const void *buffer, size_t size, void *key);
  81
  82 int
  83 ANY_fromType(ANY_t *st, asn_TYPE_descriptor_t *td, void *sptr) {
  84         struct _callback_arg arg;
  85         asn_enc_rval_t erval = {0,0,0};
  86
  87         if(!st || !td) {
  88                 errno = EINVAL;
  89                 return -1;
  90         }
  91
  92         if(!sptr) {
  93                 if(st->buf) FREEMEM(st->buf);
  94                 st->size = 0;
  95                 return 0;
  96         }
  97
  98         arg.offset = arg.size = 0;
  99         arg.buffer = 0;
 100
 101         erval = der_encode(td, sptr, ANY__consume_bytes, &arg);
 102         if(erval.encoded == -1) {
 103                 if(arg.buffer) FREEMEM(arg.buffer);
 104                 return -1;
 105         }
 106         assert((size_t)erval.encoded == arg.offset);
 107
 108         if(st->buf) FREEMEM(st->buf);
 109         st->buf = arg.buffer;
 110         st->size = arg.offset;
 111
 112         return 0;
 113 }
 114
 115 int
 116 ANY_fromType_aper(ANY_t *st, asn_TYPE_descriptor_t *td, void *sptr) {
 117         uint8_t *buffer = NULL;
 118         ssize_t erval;
 119
 120         if(!st || !td) {
 121                 errno = EINVAL;
 122                 return -1;
 123         }
 124
 125         if(!sptr) {
 126                 if(st->buf) FREEMEM(st->buf);
 127                 st->size = 0;
 128                 return 0;
 129         }
 130
 131         erval = aper_encode_to_new_buffer(td, td->encoding_constraints.per_constraints, sptr, (void**)&buffer);
 132
 133         if(erval == -1) {
 134                 if(buffer) FREEMEM(buffer);
 135                 return -1;
 136         }
 137         assert((size_t)erval > 0);
 138
 139         if(st->buf) FREEMEM(st->buf);
 140         st->buf = buffer;
 141         st->size = erval;
 142
 143         return 0;
 144 }
 145
 146 ANY_t *
 147 ANY_new_fromType(asn_TYPE_descriptor_t *td, void *sptr) {
 148         ANY_t tmp;
 149         ANY_t *st;
 150
 151         if(!td || !sptr) {
 152                 errno = EINVAL;
 153                 return 0;
 154         }
 155
 156         memset(&tmp, 0, sizeof(tmp));
 157
 158         if(ANY_fromType(&tmp, td, sptr)) return 0;
 159
 160         st = (ANY_t *)CALLOC(1, sizeof(ANY_t));
 161         if(st) {
 162                 *st = tmp;
 163                 return st;
 164         } else {
 165                 FREEMEM(tmp.buf);
 166                 return 0;
 167         }
 168 }
 169
 170 ANY_t *
 171 ANY_new_fromType_aper(asn_TYPE_descriptor_t *td, void *sptr) {
 172         ANY_t tmp;
 173         ANY_t *st;
 174
 175         if(!td || !sptr) {
 176                 errno = EINVAL;
 177                 return 0;
 178         }
 179
 180         memset(&tmp, 0, sizeof(tmp));
 181
 182         if(ANY_fromType_aper(&tmp, td, sptr)) return 0;
 183
 184         st = (ANY_t *)CALLOC(1, sizeof(ANY_t));
 185         if(st) {
 186                 *st = tmp;
 187                 return st;
 188         } else {
 189                 FREEMEM(tmp.buf);
 190                 return 0;
 191         }
 192 }
 193
 194 int
 195 ANY_to_type(ANY_t *st, asn_TYPE_descriptor_t *td, void **struct_ptr) {
 196         asn_dec_rval_t rval;
 197         void *newst = 0;
 198
 199         if(!st || !td || !struct_ptr) {
 200                 errno = EINVAL;
 201                 return -1;
 202         }
 203
 204         if(st->buf == 0) {
 205                 /* Nothing to convert, make it empty. */
 206                 *struct_ptr = (void *)0;
 207                 return 0;
 208         }
 209
 210         rval = ber_decode(0, td, (void **)&newst, st->buf, st->size);
 211         if(rval.code == RC_OK) {
 212                 *struct_ptr = newst;
 213                 return 0;
 214         } else {
 215                 /* Remove possibly partially decoded data. */
 216                 ASN_STRUCT_FREE(*td, newst);
 217                 return -1;
 218         }
 219 }
 220
 221 int
 222 ANY_to_type_aper(ANY_t *st, asn_TYPE_descriptor_t *td, void **struct_ptr) {
 223         asn_dec_rval_t rval;
 224         void *newst = 0;
 225
 226         if(!st || !td || !struct_ptr) {
 227                 errno = EINVAL;
 228                 return -1;
 229         }
 230
 231         if(st->buf == 0) {
 232                 /* Nothing to convert, make it empty. */
 233                 *struct_ptr = (void *)0;
 234                 return 0;
 235         }
 236
 237         rval = aper_decode(0, td, (void **)&newst, st->buf, st->size, 0, 0);
 238         if(rval.code == RC_OK) {
 239                 *struct_ptr = newst;
 240                 return 0;
 241         } else {
 242                 /* Remove possibly partially decoded data. */
 243                 ASN_STRUCT_FREE(*td, newst);
 244                 return -1;
 245         }
 246 }
 247
 248 static int ANY__consume_bytes(const void *buffer, size_t size, void *key) {
 249         struct _callback_arg *arg = (struct _callback_arg *)key;
 250
 251         if((arg->offset + size) >= arg->size) {
 252                 size_t nsize = (arg->size ? arg->size << 2 : 16) + size;
 253                 void *p = REALLOC(arg->buffer, nsize);
 254                 if(!p) return -1;
 255                 arg->buffer = (uint8_t *)p;
 256                 arg->size = nsize;
 257         }
 258
 259         memcpy(arg->buffer + arg->offset, buffer, size);
 260         arg->offset += size;
 261         assert(arg->offset < arg->size);
 262
 263         return 0;
 264 }
 265
 266 #ifndef ASN_DISABLE_PER_SUPPORT
 267
 268 asn_dec_rval_t
 269 ANY_decode_uper(const asn_codec_ctx_t *opt_codec_ctx,
 270                 const asn_TYPE_descriptor_t *td,
 271                 const asn_per_constraints_t *constraints, void **sptr,
 272                 asn_per_data_t *pd) {
 273     const asn_OCTET_STRING_specifics_t *specs =
 274         td->specifics ? (const asn_OCTET_STRING_specifics_t *)td->specifics
 275                       : &asn_SPC_ANY_specs;
 276     size_t consumed_myself = 0;
 277     int repeat;
 278     ANY_t *st = (ANY_t *)*sptr;
 279
 280     (void)opt_codec_ctx;
 281     (void)constraints;
 282
 283     /*
 284      * Allocate the structure.
 285      */
 286     if(!st) {
 287         st = (ANY_t *)(*sptr = CALLOC(1, specs->struct_size));
 288         if(!st) RETURN(RC_FAIL);
 289     }
 290
 291     ASN_DEBUG("UPER Decoding ANY type");
 292
 293     st->size = 0;
 294     do {
 295         ssize_t raw_len;
 296         ssize_t len_bytes;
 297         ssize_t len_bits;
 298         void *p;
 299         int ret;
 300
 301         /* Get the PER length */
 302         raw_len = uper_get_length(pd, -1, 0, &repeat);
 303         if(raw_len < 0) RETURN(RC_WMORE);
 304         if(raw_len == 0 && st->buf) break;
 305
 306         ASN_DEBUG("Got PER length len %" ASN_PRI_SIZE ", %s (%s)", raw_len,
 307                   repeat ? "repeat" : "once", td->name);
 308         len_bytes = raw_len;
 309         len_bits = len_bytes * 8;
 310
 311         p = REALLOC(st->buf, st->size + len_bytes + 1);
 312         if(!p) RETURN(RC_FAIL);
 313         st->buf = (uint8_t *)p;
 314
 315         ret = per_get_many_bits(pd, &st->buf[st->size], 0, len_bits);
 316         if(ret < 0) RETURN(RC_WMORE);
 317         consumed_myself += len_bits;
 318         st->size += len_bytes;
 319     } while(repeat);
 320     st->buf[st->size] = 0; /* nul-terminate */
 321
 322     RETURN(RC_OK);
 323 }
 324
 325 asn_enc_rval_t
 326 ANY_encode_uper(const asn_TYPE_descriptor_t *td,
 327                 const asn_per_constraints_t *constraints, const void *sptr,
 328                 asn_per_outp_t *po) {
 329     const ANY_t *st = (const ANY_t *)sptr;
 330     asn_enc_rval_t er = {0, 0, 0};
 331     const uint8_t *buf;
 332     size_t size;
 333     int ret;
 334
 335     (void)constraints;
 336
 337     if(!st || (!st->buf && st->size)) ASN__ENCODE_FAILED;
 338
 339     buf = st->buf;
 340     size = st->size;
 341     do {
 342         int need_eom = 0;
 343         ssize_t may_save = uper_put_length(po, size, &need_eom);
 344         if(may_save < 0) ASN__ENCODE_FAILED;
 345
 346         ret = per_put_many_bits(po, buf, may_save * 8);
 347         if(ret) ASN__ENCODE_FAILED;
 348
 349         buf += may_save;
 350         size -= may_save;
 351         assert(!(may_save & 0x07) || !size);
 352         if(need_eom && uper_put_length(po, 0, 0))
 353             ASN__ENCODE_FAILED; /* End of Message length */
 354     } while(size);
 355
 356     ASN__ENCODED_OK(er);
 357 }
 358
 359 asn_dec_rval_t
 360 ANY_decode_aper(const asn_codec_ctx_t *opt_codec_ctx,
 361                 const asn_TYPE_descriptor_t *td,
 362                 const asn_per_constraints_t *constraints, void **sptr,
 363                 asn_per_data_t *pd) {
 364     const asn_OCTET_STRING_specifics_t *specs =
 365         td->specifics ? (const asn_OCTET_STRING_specifics_t *)td->specifics
 366                       : &asn_SPC_ANY_specs;
 367     size_t consumed_myself = 0;
 368     int repeat;
 369     ANY_t *st = (ANY_t *)*sptr;
 370
 371     (void)opt_codec_ctx;
 372     (void)constraints;
 373
 374     /*
 375      * Allocate the structure.
 376      */
 377     if(!st) {
 378         st = (ANY_t *)(*sptr = CALLOC(1, specs->struct_size));
 379         if(!st) RETURN(RC_FAIL);
 380     }
 381
 382     ASN_DEBUG("APER Decoding ANY type");
 383
 384     st->size = 0;
 385     do {
 386         ssize_t raw_len;
 387         ssize_t len_bytes;
 388         ssize_t len_bits;
 389         void *p;
 390         int ret;
 391
 392         /* Get the PER length */
 393         raw_len = aper_get_length(pd, -1, 0, &repeat);
 394         if(raw_len < 0) RETURN(RC_WMORE);
 395         if(raw_len == 0 && st->buf) break;
 396
 397         ASN_DEBUG("Got PER length len %" ASN_PRI_SIZE ", %s (%s)", raw_len,
 398                   repeat ? "repeat" : "once", td->name);
 399         len_bytes = raw_len;
 400         len_bits = len_bytes * 8;
 401
 402         p = REALLOC(st->buf, st->size + len_bytes + 1);
 403         if(!p) RETURN(RC_FAIL);
 404         st->buf = (uint8_t *)p;
 405
 406         ret = per_get_many_bits(pd, &st->buf[st->size], 0, len_bits);
 407         if(ret < 0) RETURN(RC_WMORE);
 408         consumed_myself += len_bits;
 409         st->size += len_bytes;
 410     } while(repeat);
 411     st->buf[st->size] = 0; /* nul-terminate */
 412
 413     RETURN(RC_OK);
 414 }
 415
 416 asn_enc_rval_t
 417 ANY_encode_aper(const asn_TYPE_descriptor_t *td,
 418                 const asn_per_constraints_t *constraints, const void *sptr,
 419                 asn_per_outp_t *po) {
 420     const ANY_t *st = (const ANY_t *)sptr;
 421     asn_enc_rval_t er = {0, 0, 0};
 422     const uint8_t *buf;
 423     size_t size;
 424     int ret;
 425
 426     (void)constraints;
 427
 428     if(!st || (!st->buf && st->size)) ASN__ENCODE_FAILED;
 429
 430     buf = st->buf;
 431     size = st->size;
 432     do {
 433         int need_eom = 0;
 434         ssize_t may_save = uper_put_length(po, size, &need_eom);
 435         if(may_save < 0) ASN__ENCODE_FAILED;
 436
 437         ret = per_put_many_bits(po, buf, may_save * 8);
 438         if(ret) ASN__ENCODE_FAILED;
 439
 440         buf += may_save;
 441         size -= may_save;
 442         assert(!(may_save & 0x07) || !size);
 443         if(need_eom && uper_put_length(po, 0, 0))
 444             ASN__ENCODE_FAILED; /* End of Message length */
 445     } while(size);
 446
 447     ASN__ENCODED_OK(er);
 448 }
 449 #endif /* ASN_DISABLE_PER_SUPPORT */
 450