RSM/3rdparty/asn1codec/e2ap_engine/xer_encoder.c

   1
   2 /*-
   3  * Copyright (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
   4  * Redistribution and modifications are permitted subject to BSD license.
   5  */
   6 #include <asn_internal.h>
   7 #include <stdio.h>
   8 #include <errno.h>
   9
  10 /*
  11  * The XER encoder of any type. May be invoked by the application.
  12  */
  13 asn_enc_rval_t
  14 xer_encode(const asn_TYPE_descriptor_t *td, const void *sptr,
  15            enum xer_encoder_flags_e xer_flags, asn_app_consume_bytes_f *cb,
  16            void *app_key) {
  17     asn_enc_rval_t er = {0, 0, 0};
  18         asn_enc_rval_t tmper;
  19         const char *mname;
  20         size_t mlen;
  21         int xcan = (xer_flags & XER_F_CANONICAL) ? 1 : 2;
  22
  23         if(!td || !sptr) goto cb_failed;
  24
  25         mname = td->xml_tag;
  26         mlen = strlen(mname);
  27
  28         ASN__CALLBACK3("<", 1, mname, mlen, ">", 1);
  29
  30         tmper = td->op->xer_encoder(td, sptr, 1, xer_flags, cb, app_key);
  31         if(tmper.encoded == -1) return tmper;
  32         er.encoded += tmper.encoded;
  33
  34         ASN__CALLBACK3("</", 2, mname, mlen, ">\n", xcan);
  35
  36         ASN__ENCODED_OK(er);
  37 cb_failed:
  38         ASN__ENCODE_FAILED;
  39 }
  40
  41 /*
  42  * This is a helper function for xer_fprint, which directs all incoming data
  43  * into the provided file descriptor.
  44  */
  45 static int
  46 xer__print2fp(const void *buffer, size_t size, void *app_key) {
  47         FILE *stream = (FILE *)app_key;
  48
  49         if(fwrite(buffer, 1, size, stream) != size)
  50                 return -1;
  51
  52         return 0;
  53 }
  54
  55 int
  56 xer_fprint(FILE *stream, const asn_TYPE_descriptor_t *td, const void *sptr) {
  57         asn_enc_rval_t er = {0,0,0};
  58
  59         if(!stream) stream = stdout;
  60         if(!td || !sptr)
  61                 return -1;
  62
  63         er = xer_encode(td, sptr, XER_F_BASIC, xer__print2fp, stream);
  64         if(er.encoded == -1)
  65                 return -1;
  66
  67         return fflush(stream);
  68 }
  69
  70 struct xer_buffer {
  71     char *buffer;
  72     size_t buffer_size;
  73     size_t allocated_size;
  74 };
  75
  76 static int
  77 xer__buffer_append(const void *buffer, size_t size, void *app_key) {
  78     struct xer_buffer *xb = app_key;
  79
  80     while(xb->buffer_size + size + 1 > xb->allocated_size) {
  81         size_t new_size = 2 * (xb->allocated_size ? xb->allocated_size : 64);
  82         char *new_buf = MALLOC(new_size);
  83         if(!new_buf) return -1;
  84         if (xb->buffer) {
  85             memcpy(new_buf, xb->buffer, xb->buffer_size);
  86         }
  87         FREEMEM(xb->buffer);
  88         xb->buffer = new_buf;
  89         xb->allocated_size = new_size;
  90     }
  91
  92     memcpy(xb->buffer + xb->buffer_size, buffer, size);
  93     xb->buffer_size += size;
  94     xb->buffer[xb->buffer_size] = '\0';
  95     return 0;
  96 }
  97
  98 enum xer_equivalence_e
  99 xer_equivalent(const struct asn_TYPE_descriptor_s *td, const void *struct1,
 100                const void *struct2, FILE *opt_debug_stream) {
 101     struct xer_buffer xb1 = {0, 0, 0};
 102     struct xer_buffer xb2 = {0, 0, 0};
 103     asn_enc_rval_t e1, e2;
 104     asn_dec_rval_t rval;
 105     void *sptr = NULL;
 106
 107     if(!td || !struct1 || !struct2) {
 108         if(opt_debug_stream) {
 109             if(!td) fprintf(opt_debug_stream, "Type descriptor missing\n");
 110             if(!struct1) fprintf(opt_debug_stream, "Structure 1 missing\n");
 111             if(!struct2) fprintf(opt_debug_stream, "Structure 2 missing\n");
 112         }
 113         return XEQ_FAILURE;
 114     }
 115
 116     e1 = xer_encode(td, struct1, XER_F_BASIC, xer__buffer_append, &xb1);
 117     if(e1.encoded == -1) {
 118         if(opt_debug_stream) {
 119             fprintf(stderr, "XER Encoding of %s failed\n", td->name);
 120         }
 121         FREEMEM(xb1.buffer);
 122         return XEQ_ENCODE1_FAILED;
 123     }
 124
 125     e2 = xer_encode(td, struct2, XER_F_BASIC, xer__buffer_append, &xb2);
 126     if(e2.encoded == -1) {
 127         if(opt_debug_stream) {
 128             fprintf(stderr, "XER Encoding of %s failed\n", td->name);
 129         }
 130         FREEMEM(xb1.buffer);
 131         FREEMEM(xb2.buffer);
 132         return XEQ_ENCODE1_FAILED;
 133     }
 134
 135     if(xb1.buffer_size != xb2.buffer_size
 136        || memcmp(xb1.buffer, xb2.buffer, xb1.buffer_size) != 0) {
 137         if(opt_debug_stream) {
 138             fprintf(opt_debug_stream,
 139                     "Structures XER-encoded into different byte streams:\n=== "
 140                     "Structure 1 ===\n%s\n=== Structure 2 ===\n%s\n",
 141                     xb1.buffer, xb2.buffer);
 142         }
 143         FREEMEM(xb1.buffer);
 144         FREEMEM(xb2.buffer);
 145         return XEQ_DIFFERENT;
 146     } else {
 147         if(opt_debug_stream) {
 148             fprintf(opt_debug_stream,
 149                     "Both structures encoded into the same XER byte stream "
 150                     "of size %" ASN_PRI_SIZE ":\n%s",
 151                     xb1.buffer_size, xb1.buffer);
 152         }
 153     }
 154
 155     rval = xer_decode(NULL, td, (void **)&sptr, xb1.buffer,
 156                xb1.buffer_size);
 157     switch(rval.code) {
 158     case RC_OK:
 159         break;
 160     case RC_WMORE:
 161         if(opt_debug_stream) {
 162             fprintf(opt_debug_stream,
 163                     "Structure %s XER decode unexpectedly requires "
 164                     "more data:\n%s\n",
 165                     td->name, xb1.buffer);
 166         }
 167         /* Fall through */
 168     case RC_FAIL:
 169     default:
 170         if(opt_debug_stream) {
 171             fprintf(opt_debug_stream,
 172                     "Structure %s XER decoding resulted in failure.\n",
 173                     td->name);
 174         }
 175         ASN_STRUCT_FREE(*td, sptr);
 176         FREEMEM(xb1.buffer);
 177         FREEMEM(xb2.buffer);
 178         return XEQ_DECODE_FAILED;
 179     }
 180
 181     if(rval.consumed != xb1.buffer_size
 182        && ((rval.consumed > xb1.buffer_size)
 183            || xer_whitespace_span(xb1.buffer + rval.consumed,
 184                                   xb1.buffer_size - rval.consumed)
 185                   != (xb1.buffer_size - rval.consumed))) {
 186         if(opt_debug_stream) {
 187             fprintf(opt_debug_stream,
 188                     "Round-trip decode of %s required less bytes (%" ASN_PRI_SIZE ") than "
 189                     "encoded (%" ASN_PRI_SIZE ")\n",
 190                     td->name, rval.consumed, xb1.buffer_size);
 191         }
 192         ASN_STRUCT_FREE(*td, sptr);
 193         FREEMEM(xb1.buffer);
 194         FREEMEM(xb2.buffer);
 195         return XEQ_ROUND_TRIP_FAILED;
 196     }
 197
 198     /*
 199      * Reuse xb2 to encode newly decoded structure.
 200      */
 201     FREEMEM(xb2.buffer);
 202     memset(&xb2, 0, sizeof(xb2));
 203
 204     e2 = xer_encode(td, sptr, XER_F_BASIC, xer__buffer_append, &xb2);
 205     if(e2.encoded == -1) {
 206         if(opt_debug_stream) {
 207             fprintf(stderr, "XER Encoding of round-trip decode of %s failed\n",
 208                     td->name);
 209         }
 210         ASN_STRUCT_FREE(*td, sptr);
 211         FREEMEM(xb1.buffer);
 212         FREEMEM(xb2.buffer);
 213         return XEQ_ROUND_TRIP_FAILED;
 214     }
 215
 216     ASN_STRUCT_FREE(*td, sptr);
 217     sptr = 0;
 218
 219     if(xb1.buffer_size != xb2.buffer_size
 220        || memcmp(xb1.buffer, xb2.buffer, xb1.buffer_size) != 0) {
 221         if(opt_debug_stream) {
 222             fprintf(opt_debug_stream,
 223                     "XER Encoding of round-trip decode of %s resulted in "
 224                     "different byte stream:\n"
 225                     "=== Original ===\n%s\n"
 226                     "=== Round-tripped ===\n%s\n",
 227                     xb1.buffer, xb2.buffer, td->name);
 228         }
 229         FREEMEM(xb1.buffer);
 230         FREEMEM(xb2.buffer);
 231         return XEQ_ROUND_TRIP_FAILED;
 232     }
 233
 234         FREEMEM(xb1.buffer);
 235         FREEMEM(xb2.buffer);
 236         return XEQ_SUCCESS;
 237 }
 238