asn1c_defs/all-defs/ANY.c

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