Bouncer/e2sm_kpm/lib/UniversalString.c

   1 /*-
   2  * Copyright (c) 2003-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 <UniversalString.h>
   7 #include <UTF8String.h>
   8
   9 /*
  10  * UniversalString basic type description.
  11  */
  12 static const ber_tlv_tag_t asn_DEF_UniversalString_tags[] = {
  13         (ASN_TAG_CLASS_UNIVERSAL | (28 << 2)),  /* [UNIVERSAL 28] IMPLICIT ...*/
  14         (ASN_TAG_CLASS_UNIVERSAL | (4 << 2))    /* ... OCTET STRING */
  15 };
  16 asn_OCTET_STRING_specifics_t asn_SPC_UniversalString_specs = {
  17         sizeof(UniversalString_t),
  18         offsetof(UniversalString_t, _asn_ctx),
  19         ASN_OSUBV_U32   /* 32-bits character */
  20 };
  21 static asn_per_constraints_t asn_DEF_UniversalString_per_constraints = {
  22         { APC_CONSTRAINED, 32, 32, 0, 2147483647 },
  23         { APC_SEMI_CONSTRAINED, -1, -1, 0, 0 },
  24         0, 0
  25 };
  26 asn_TYPE_operation_t asn_OP_UniversalString = {
  27         OCTET_STRING_free,
  28         UniversalString_print,      /* Convert into UTF8 and print */
  29         OCTET_STRING_compare,
  30         OCTET_STRING_decode_ber,
  31         OCTET_STRING_encode_der,
  32         UniversalString_decode_xer,     /* Convert from UTF-8 */
  33         UniversalString_encode_xer,     /* Convert into UTF-8 */
  34 #ifdef  ASN_DISABLE_OER_SUPPORT
  35         0,
  36         0,
  37 #else
  38         OCTET_STRING_decode_oer,
  39         OCTET_STRING_encode_oer,
  40 #endif  /* ASN_DISABLE_OER_SUPPORT */
  41 #ifdef  ASN_DISABLE_PER_SUPPORT
  42         0,
  43         0,
  44         0,
  45         0,
  46 #else
  47         OCTET_STRING_decode_uper,
  48         OCTET_STRING_encode_uper,
  49         OCTET_STRING_decode_aper,
  50         OCTET_STRING_encode_aper,
  51 #endif  /* ASN_DISABLE_PER_SUPPORT */
  52         OCTET_STRING_random_fill,
  53         0       /* Use generic outmost tag fetcher */
  54 };
  55 asn_TYPE_descriptor_t asn_DEF_UniversalString = {
  56         "UniversalString",
  57         "UniversalString",
  58         &asn_OP_UniversalString,
  59         asn_DEF_UniversalString_tags,
  60         sizeof(asn_DEF_UniversalString_tags)
  61           / sizeof(asn_DEF_UniversalString_tags[0]) - 1,
  62         asn_DEF_UniversalString_tags,
  63         sizeof(asn_DEF_UniversalString_tags)
  64           / sizeof(asn_DEF_UniversalString_tags[0]),
  65         { 0, &asn_DEF_UniversalString_per_constraints, UniversalString_constraint },
  66         0, 0,   /* No members */
  67         &asn_SPC_UniversalString_specs
  68 };
  69
  70 int
  71 UniversalString_constraint(const asn_TYPE_descriptor_t *td, const void *sptr,
  72                            asn_app_constraint_failed_f *ctfailcb,
  73                            void *app_key) {
  74     const UniversalString_t *st = (const UniversalString_t *)sptr;
  75
  76     if(st && st->buf) {
  77         if(st->size % 4) {
  78             ASN__CTFAIL(app_key, td, sptr,
  79                         "%s: invalid size %" ASN_PRI_SIZE " not divisible by 4 (%s:%d)",
  80                         td->name, st->size, __FILE__, __LINE__);
  81             return -1;
  82         }
  83     } else {
  84         ASN__CTFAIL(app_key, td, sptr, "%s: value not given (%s:%d)", td->name,
  85                     __FILE__, __LINE__);
  86         return -1;
  87     }
  88
  89     return 0;
  90 }
  91
  92 static ssize_t
  93 UniversalString__dump(const UniversalString_t *st,
  94                 asn_app_consume_bytes_f *cb, void *app_key) {
  95         char scratch[128];                      /* Scratchpad buffer */
  96         char *p = scratch;
  97         ssize_t wrote = 0;
  98         uint8_t *ch;
  99         uint8_t *end;
 100
 101         ch = st->buf;
 102         end = (st->buf + st->size);
 103         for(end -= 3; ch < end; ch += 4) {
 104                 uint32_t wc =     (ch[0] << 24)
 105                                 | (ch[1] << 16)
 106                                 | (ch[2] << 8)
 107                                 |  ch[3];       /* 4 bytes */
 108                 if(sizeof(scratch) - (p - scratch) < 6) {
 109                         wrote += p - scratch;
 110                         if(cb(scratch, p - scratch, app_key) < 0)
 111                                 return -1;
 112                         p = scratch;
 113                 }
 114                 if(wc < 0x80) {
 115                         *p++ = (char)wc;
 116                 } else if(wc < 0x800) {
 117                         *p++ = 0xc0 | ((wc >> 6));
 118                         *p++ = 0x80 | ((wc & 0x3f));
 119                 } else if(wc < 0x10000) {
 120                         *p++ = 0xe0 | ((wc >> 12));
 121                         *p++ = 0x80 | ((wc >> 6) & 0x3f);
 122                         *p++ = 0x80 | ((wc & 0x3f));
 123                 } else if(wc < 0x200000) {
 124                         *p++ = 0xf0 | ((wc >> 18));
 125                         *p++ = 0x80 | ((wc >> 12) & 0x3f);
 126                         *p++ = 0x80 | ((wc >> 6) & 0x3f);
 127                         *p++ = 0x80 | ((wc & 0x3f));
 128                 } else if(wc < 0x4000000) {
 129                         *p++ = 0xf8 | ((wc >> 24));
 130                         *p++ = 0x80 | ((wc >> 18) & 0x3f);
 131                         *p++ = 0x80 | ((wc >> 12) & 0x3f);
 132                         *p++ = 0x80 | ((wc >> 6) & 0x3f);
 133                         *p++ = 0x80 | ((wc & 0x3f));
 134                 } else {
 135                         *p++ = 0xfc | ((wc >> 30) & 0x1);
 136                         *p++ = 0x80 | ((wc >> 24) & 0x3f);
 137                         *p++ = 0x80 | ((wc >> 18) & 0x3f);
 138                         *p++ = 0x80 | ((wc >> 12) & 0x3f);
 139                         *p++ = 0x80 | ((wc >> 6) & 0x3f);
 140                         *p++ = 0x80 | ((wc & 0x3f));
 141                 }
 142         }
 143
 144         wrote += p - scratch;
 145         if(cb(scratch, p - scratch, app_key) < 0)
 146                 return -1;
 147
 148         return wrote;
 149 }
 150
 151 asn_dec_rval_t
 152 UniversalString_decode_xer(const asn_codec_ctx_t *opt_codec_ctx,
 153                            const asn_TYPE_descriptor_t *td, void **sptr,
 154                            const char *opt_mname, const void *buf_ptr,
 155                            size_t size) {
 156     asn_dec_rval_t rc;
 157
 158         rc = OCTET_STRING_decode_xer_utf8(opt_codec_ctx, td, sptr, opt_mname,
 159                 buf_ptr, size);
 160         if(rc.code == RC_OK) {
 161                 /*
 162                  * Now we have a whole string in UTF-8 format.
 163                  * Convert it into UCS-4.
 164                  */
 165                 uint32_t *wcs;
 166                 size_t wcs_len;
 167                 UTF8String_t *st;
 168 #ifndef WORDS_BIGENDIAN
 169                 int little_endian = 1;
 170 #endif
 171
 172                 assert(*sptr);
 173                 st = (UTF8String_t *)*sptr;
 174                 assert(st->buf);
 175                 wcs_len = UTF8String_to_wcs(st, 0, 0);
 176
 177                 wcs = (uint32_t *)MALLOC(4 * (wcs_len + 1));
 178                 if(wcs == 0 || UTF8String_to_wcs(st, wcs, wcs_len) != wcs_len) {
 179                         rc.code = RC_FAIL;
 180                         rc.consumed = 0;
 181                         return rc;
 182                 } else {
 183                         wcs[wcs_len] = 0;       /* nul-terminate */
 184                 }
 185
 186 #ifndef WORDS_BIGENDIAN
 187                 if(*(char *)&little_endian) {
 188                         /* Swap byte order in encoding */
 189                         uint32_t *wc = wcs;
 190                         uint32_t *wc_end = wcs + wcs_len;
 191                         for(; wc < wc_end; wc++) {
 192                                 /* *wc = htonl(*wc); */
 193                                 uint32_t wch = *wc;
 194                                 *((uint8_t *)wc + 0) = wch >> 24;
 195                                 *((uint8_t *)wc + 1) = wch >> 16;
 196                                 *((uint8_t *)wc + 2) = wch >> 8;
 197                                 *((uint8_t *)wc + 3) = wch;
 198                         }
 199                 }
 200 #endif  /* WORDS_BIGENDIAN */
 201
 202                 FREEMEM(st->buf);
 203                 st->buf = (uint8_t *)wcs;
 204                 st->size = 4 * wcs_len;
 205         }
 206         return rc;
 207 }
 208
 209 asn_enc_rval_t
 210 UniversalString_encode_xer(const asn_TYPE_descriptor_t *td, const void *sptr,
 211                            int ilevel, enum xer_encoder_flags_e flags,
 212                            asn_app_consume_bytes_f *cb, void *app_key) {
 213         const UniversalString_t *st = (const UniversalString_t *)sptr;
 214         asn_enc_rval_t er = {0,0,0};
 215
 216         (void)ilevel;
 217         (void)flags;
 218
 219         if(!st || !st->buf)
 220                 ASN__ENCODE_FAILED;
 221
 222         er.encoded = UniversalString__dump(st, cb, app_key);
 223         if(er.encoded < 0) ASN__ENCODE_FAILED;
 224
 225         ASN__ENCODED_OK(er);
 226 }
 227
 228 int
 229 UniversalString_print(const asn_TYPE_descriptor_t *td, const void *sptr,
 230                       int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
 231     const UniversalString_t *st = (const UniversalString_t *)sptr;
 232
 233         (void)td;       /* Unused argument */
 234         (void)ilevel;   /* Unused argument */
 235
 236         if(!st || !st->buf) return (cb("<absent>", 8, app_key) < 0) ? -1 : 0;
 237
 238         if(UniversalString__dump(st, cb, app_key) < 0)
 239                 return -1;
 240
 241         return 0;
 242 }
 243