src/codec_utils/common/xer_encoder.c

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