tests/tests-c-compiler/check-src/check-60.c

   1 #undef  NDEBUG
   2 #include <stdio.h>
   3 #include <stdlib.h>
   4 #include <sys/types.h>
   5 #include <string.h>
   6 #include <assert.h>
   7 #include <errno.h>
   8
   9 #include <T1.h>
  10 #include <T2.h>
  11
  12 static unsigned char buf[4096];
  13 static int buf_offset;
  14
  15 static int
  16 _buf_writer(const void *buffer, size_t size, void *app_key) {
  17         unsigned char *b, *bend;
  18         (void)app_key;
  19         assert(buf_offset + size < sizeof(buf));
  20         if (buffer) {
  21                 memcpy(buf + buf_offset, buffer, size);
  22         }
  23         b = buf + buf_offset;
  24         bend = b + size;
  25         printf("=> [");
  26         for(; b < bend; b++)
  27                 printf(" %02X", *b);
  28         printf("]:%zd\n", size);
  29         buf_offset += size;
  30         return 0;
  31 }
  32
  33 static int
  34 save_object(void *bs, asn_TYPE_descriptor_t *td) {
  35         asn_enc_rval_t rval; /* Return value */
  36         int i;
  37
  38         buf_offset = 0;
  39
  40         rval = der_encode(td, bs, _buf_writer, 0);
  41         if (rval.encoded == -1) {
  42                 fprintf(stderr,
  43                         "Cannot encode %s: %s\n",
  44                         rval.failed_type->name, strerror(errno));
  45                 assert(rval.encoded != -1);
  46                 return -1;      /* JIC */
  47         }
  48
  49         buf[buf_offset++] = 0xab;       /* Finalize with garbage */
  50
  51         asn_fprint(stderr, td, bs);
  52
  53         printf("OUT: [");
  54         for(i = 0; i < buf_offset; i++)
  55                 printf(" %02x", buf[i]);
  56         printf("]\n");
  57
  58         return 0;
  59 }
  60
  61 static int
  62 load_object(void *bs, asn_TYPE_descriptor_t *td) {
  63         asn_dec_rval_t rval;
  64
  65         fprintf(stderr, "\nLOADING OBJECT OF SIZE %d\n", buf_offset);
  66
  67         rval = ber_decode(0, td, (void **)&bs, buf, buf_offset);
  68         assert(rval.code == RC_OK);
  69
  70         asn_fprint(stderr, td, bs);
  71
  72         return (rval.code == RC_OK)?0:-1;
  73 }
  74
  75 /* [3] IMPLICIT SEQUENCE { b BOOLEAN } */
  76 uint8_t test_any_buf1[] = { 0xa3, 0x80, /* [3], constructed, indefinite */
  77         0x01, 0x01, 0xff,       /* b BOOLEAN ::= TRUE */
  78         0x00, 0x00 /* End of content octets */ };
  79
  80 /* b BOOLEAN */
  81 uint8_t test_any_buf2[] = { 0x01, 0x01, 0x13 };
  82
  83 int
  84 main() {
  85         asn_TYPE_descriptor_t *td1 = &asn_DEF_T1;
  86         asn_TYPE_descriptor_t *td2 = &asn_DEF_T2;
  87         T1_t t1, t1_new;
  88         T2_t t2, t2_new;
  89         int ret;
  90
  91         /*
  92          * Test the T1 with constructed indefinite length ANY encoding.
  93          */
  94         memset(&t1, 0, sizeof(t1));
  95         memset(&t1_new, 0, sizeof(t1_new));
  96
  97         t1.i = 112233;
  98         t1.any.buf = test_any_buf1;
  99         t1.any.size = sizeof(test_any_buf1);
 100
 101         /* Save->Load must succeed */
 102         save_object(&t1, td1);
 103         ret = load_object(&t1_new, td1);
 104
 105         assert(ret == 0);
 106         assert(t1_new.i == 112233);
 107         assert(t1_new.any.size == (ssize_t)sizeof(test_any_buf1));
 108         assert(memcmp(t1_new.any.buf, test_any_buf1, sizeof(test_any_buf1)) == 0);
 109
 110         /*
 111          * Test the T1 with primitive encoding.
 112          */
 113         memset(&t1, 0, sizeof(t1));
 114         ASN_STRUCT_RESET(asn_DEF_T1, &t1_new);
 115
 116         t1.i = -112233;
 117         t1.any.buf = test_any_buf2;
 118         t1.any.size = sizeof(test_any_buf2);
 119
 120         /* Save->Load must succeed */
 121         save_object(&t1, td1);
 122         ret = load_object(&t1_new, td1);
 123
 124         assert(ret == 0);
 125         assert(t1_new.i == -112233);
 126         assert(t1_new.any.size == (ssize_t)sizeof(test_any_buf2));
 127         assert(memcmp(t1_new.any.buf, test_any_buf2, sizeof(test_any_buf2)) == 0);
 128         ASN_STRUCT_RESET(asn_DEF_T1, &t1_new);
 129
 130         /*
 131          * Test the T2 empty sequence.
 132          */
 133         memset(&t2, 0, sizeof(t2));
 134         memset(&t2_new, 0, sizeof(t2_new));
 135
 136         t2.i = 332211;
 137         t2.any = calloc(1, sizeof(*t2.any));
 138         t2.any->buf = 0;
 139         t2.any->size = 0;
 140
 141         /* Save->Load must succeed */
 142         save_object(&t2, td2);
 143         ret = load_object(&t2_new, td2);
 144
 145         assert(ret == 0);
 146         assert(t2_new.i == 332211);
 147         assert(t2_new.any->size == 0);
 148
 149         /*
 150          * Test the T2 sequence.
 151          */
 152         ASN_STRUCT_RESET(asn_DEF_T2, &t2);
 153         ASN_STRUCT_RESET(asn_DEF_T2, &t2_new);
 154
 155         t2.i = 332211;
 156         t2.any = calloc(1, sizeof(*t2.any));
 157         t2.any->buf = test_any_buf1;
 158         t2.any->size = sizeof(test_any_buf1);
 159
 160         /* Save->Load must succeed */
 161         save_object(&t2, td2);
 162         ret = load_object(&t2_new, td2);
 163
 164         assert(ret == 0);
 165         assert(t2_new.i == 332211);
 166         assert(t2_new.any->size == (ssize_t)sizeof(test_any_buf1));
 167         assert(memcmp(t2_new.any->buf, test_any_buf1, sizeof(test_any_buf1)) == 0);
 168
 169         /*
 170          * Test the T2 sequence with primitive encoding.
 171          */
 172         t2.any->buf = NULL;
 173         t2.any->size = 0;
 174         ASN_STRUCT_RESET(asn_DEF_T2, &t2);
 175         ASN_STRUCT_RESET(asn_DEF_T2, &t2_new);
 176
 177         t2.i = 0;
 178         t2.any = calloc(1, sizeof(*t2.any));
 179         t2.any->buf = test_any_buf2;
 180         t2.any->size = sizeof(test_any_buf2);
 181
 182         /* Save->Load must succeed */
 183         save_object(&t2, td2);
 184         ret = load_object(&t2_new, td2);
 185
 186         assert(ret == 0);
 187         assert(t2_new.i == 0);
 188         assert(t2_new.any->size == (ssize_t)sizeof(test_any_buf2));
 189         assert(memcmp(t2_new.any->buf, test_any_buf2, sizeof(test_any_buf2)) == 0);
 190
 191         /*
 192          * Test T2 with ANY element omitted.
 193          */
 194         free(t2.any);
 195         t2.any = 0;
 196         ASN_STRUCT_RESET(asn_DEF_T2, &t2_new);
 197
 198         save_object(&t2, td2);
 199         ret = load_object(&t2_new, td2);
 200
 201         assert(ret == 0);
 202         assert(t2_new.i == 0);
 203         assert(t2_new.any == 0);
 204
 205         printf("OK\n");
 206
 207         return ret;
 208 }