tests/tests-c-compiler/check-src/check-41.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
   8 #include <T.h>
   9
  10
  11 uint8_t buf1[] = {
  12         32 | (2 << 6),          /* [0], constructed */
  13         25,     /* L */
  14
  15         /* string   [0] IMPLICIT UTF8String, */
  16         (2 << 6),                       /* [0] */
  17         16,     /* L */
  18  'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z',
  19
  20         /* beta    [2] IMPLICIT INTEGER OPTIONAL */
  21         (2 << 6) + 2,                   /* [2] */
  22         5,      /* L */
  23   0,
  24   75,
  25   0x4b,
  26   75,
  27   75,
  28 };
  29
  30 uint8_t buf1_reconstr[] = {
  31         32 | (2 << 6),          /* [0], constructed */
  32         24,     /* L */
  33
  34         /* string   [0] IMPLICIT UTF8String, */
  35         (2 << 6),                       /* [0] */
  36         16,     /* L */
  37  'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z',
  38
  39         /* beta    [2] IMPLICIT INTEGER OPTIONAL */
  40         (2 << 6) + 2,                   /* [2] */
  41         4,      /* L */
  42   75,
  43   75,
  44   75,
  45   0x4b,
  46 };
  47
  48
  49 static void
  50 check(T_t *tp, uint8_t *buf, size_t size, size_t consumed) {
  51         asn_dec_rval_t rval;
  52
  53         tp = memset(tp, 0, sizeof(*tp));
  54
  55         fprintf(stderr, "Buf %p (%zd)\n", buf, size);
  56         rval = ber_decode(0, &asn_DEF_T, (void **)&tp, buf, size);
  57         fprintf(stderr, "Returned code %d, consumed %zd\n",
  58                 (int)rval.code, rval.consumed);
  59
  60         assert(rval.code == RC_OK);
  61         assert(rval.consumed == consumed);
  62
  63         assert(tp->choice.seq.string.size == 16);
  64         assert(strcmp((char *)tp->choice.seq.string.buf, "zzzzzzzzzzzzzzzz") == 0);
  65         assert(tp->choice.seq.alpha == NULL);
  66         assert(tp->choice.seq.beta);
  67         assert(*tp->choice.seq.beta == 0x4b4b4b4b);
  68 }
  69
  70 size_t buf_pos;
  71 size_t buf_size;
  72 uint8_t *buf;
  73
  74 static int
  75 buf_fill(const void *buffer, size_t size, void *app_key) {
  76
  77         (void)app_key;  /* Unused argument */
  78
  79         if(buf_pos + size > buf_size) {
  80                 fprintf(stderr, "%zd + %zd > %zd\n",
  81                         buf_pos, size, buf_size);
  82                 return -1;
  83         }
  84
  85         memcpy(buf + buf_pos, buffer, size);
  86         buf_pos += size;
  87         fprintf(stderr, "   written %zd (%zd)\n", size, buf_pos);
  88
  89         return 0;
  90 }
  91
  92 static void
  93 compare(T_t *tp, uint8_t *cmp_buf, size_t cmp_buf_size) {
  94         asn_enc_rval_t erval;
  95
  96         buf_size = cmp_buf_size + 100;
  97     uint8_t scratch[buf_size];
  98         buf = scratch;
  99         buf_pos = 0;
 100
 101         /*
 102          * Try to re-create using DER encoding.
 103          */
 104         erval = der_encode(&asn_DEF_T, tp, buf_fill, 0);
 105         assert(erval.encoded != -1);
 106         if((size_t)erval.encoded != cmp_buf_size) {
 107                 printf("%zd != %zd\n", erval.encoded, cmp_buf_size);
 108         assert((size_t)erval.encoded == cmp_buf_size);
 109     }
 110         for(size_t i = 0; i < cmp_buf_size; i++) {
 111                 if(buf[i] != cmp_buf[i]) {
 112                         fprintf(stderr, "Recreated buffer content mismatch:\n");
 113                         fprintf(stderr, "Byte %zd, %x != %x (%d != %d)\n",
 114                                 i,
 115                                 buf[i], cmp_buf[i],
 116                                 buf[i], cmp_buf[i]
 117                         );
 118                 }
 119                 assert(buf[i] == cmp_buf[i]);
 120         }
 121
 122     buf = 0;
 123 }
 124
 125 static void
 126 partial_read(uint8_t *buf_0, size_t size) {
 127         T_t t, *tp;
 128         asn_dec_rval_t rval;
 129         uint8_t buf_1[size];
 130         uint8_t buf_2[size];
 131         uint8_t buf_3[size];
 132
 133         fprintf(stderr, "\nPartial read sequence...\n");
 134
 135         /*
 136          * Divide the space (size) into three blocks in various combinations:
 137          *   |<----->i1<----->i2<----->|
 138          *   ^ buf_0                    ^ buf_0+size
 139          * Try to read block by block.
 140          */
 141         for(size_t i1 = 0; i1 < size; i1++) {
 142                 for(size_t i2 = i1; i2 < size; i2++) {
 143                         uint8_t *chunk1 = buf_0;
 144                         size_t size1 = i1;
 145                         uint8_t *chunk2 = buf_0 + size1;
 146                         size_t size2 = i2 - i1;
 147                         uint8_t *chunk3 = buf_0 + size1 + size2;
 148                         size_t size3 = size - size1 - size2;
 149
 150                         fprintf(stderr, "\n%zd:{%zd, %zd, %zd}...\n",
 151                                 size, size1, size2, size3);
 152
 153                         memset(buf_1, 0, size);
 154                         memset(buf_2, 0, size);
 155                         memset(buf_3, 0, size);
 156                         memcpy(buf_1, chunk1, size1);
 157                         memcpy(buf_2, chunk2, size2);
 158                         memcpy(buf_3, chunk3, size3);
 159
 160                         tp = memset(&t, 0, sizeof(t));
 161
 162                         fprintf(stderr, "=> Chunk 1 (%zd):\n", size1);
 163                         rval = ber_decode(0, &asn_DEF_T, (void **)&tp,
 164                                 buf_1, size1);
 165                         assert(rval.code == RC_WMORE);
 166                         assert(rval.consumed <= size1);
 167                         if(rval.consumed < size1) {
 168                                 int leftover = size1 - rval.consumed;
 169                                 memcpy(buf_2, buf_1 + rval.consumed, leftover);
 170                                 memcpy(buf_2 + leftover, chunk2, size2);
 171                                 size2 += leftover;
 172                         }
 173
 174                         fprintf(stderr, "=> Chunk 2 (%zd):\n", size2);
 175                         rval = ber_decode(0, &asn_DEF_T, (void **)&tp,
 176                                 buf_2, size2);
 177                         assert(rval.code == RC_WMORE);
 178                         assert(rval.consumed <= size2);
 179                         if(rval.consumed < size2) {
 180                                 int leftover = size2 - rval.consumed;
 181                                 memcpy(buf_3, buf_2 + rval.consumed, leftover);
 182                                 memcpy(buf_3 + leftover, chunk3, size3);
 183                                 size3 += leftover;
 184                         }
 185
 186                         fprintf(stderr, "=> Chunk 3 (%zd):\n", size3);
 187                         rval = ber_decode(0, &asn_DEF_T, (void **)&tp,
 188                                 buf_3, size3);
 189                         assert(rval.code == RC_OK);
 190                         assert(rval.consumed == size3);
 191
 192                         ASN_STRUCT_RESET(asn_DEF_T, &t);
 193                 }
 194         }
 195 }
 196
 197 int
 198 main(int ac, char **av) {
 199         T_t t;
 200
 201         (void)ac;       /* Unused argument */
 202         (void)av;       /* Unused argument */
 203
 204         /* Check exact buf1 */
 205         check(&t, buf1, sizeof(buf1), sizeof(buf1));
 206         compare(&t, buf1_reconstr, sizeof(buf1_reconstr));
 207         asn_fprint(stderr, &asn_DEF_T, &t);
 208         ASN_STRUCT_RESET(asn_DEF_T, &t);
 209
 210         /* Check slightly more than buf1 */
 211         check(&t, buf1, sizeof(buf1) + 10, sizeof(buf1));
 212         compare(&t, buf1_reconstr, sizeof(buf1_reconstr));
 213         asn_fprint(stderr, &asn_DEF_T, &t);
 214         ASN_STRUCT_RESET(asn_DEF_T, &t);
 215
 216         /* Split the buffer in parts and check decoder restartability */
 217         partial_read(buf1, sizeof(buf1));
 218
 219         return 0;
 220 }