12 32 | (2 << 6), /* [0], constructed */
15 /* string [0] IMPLICIT UTF8String, */
18 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z',
20 /* beta [2] IMPLICIT INTEGER OPTIONAL */
21 (2 << 6) + 2, /* [2] */
30 uint8_t buf1_reconstr[] = {
31 32 | (2 << 6), /* [0], constructed */
34 /* string [0] IMPLICIT UTF8String, */
37 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z', 'z',
39 /* beta [2] IMPLICIT INTEGER OPTIONAL */
40 (2 << 6) + 2, /* [2] */
50 check(T_t *tp, uint8_t *buf, size_t size, size_t consumed) {
53 tp = memset(tp, 0, sizeof(*tp));
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);
60 assert(rval.code == RC_OK);
61 assert(rval.consumed == consumed);
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);
75 buf_fill(const void *buffer, size_t size, void *app_key) {
77 (void)app_key; /* Unused argument */
79 if(buf_pos + size > buf_size) {
80 fprintf(stderr, "%zd + %zd > %zd\n",
81 buf_pos, size, buf_size);
85 memcpy(buf + buf_pos, buffer, size);
87 fprintf(stderr, " written %zd (%zd)\n", size, buf_pos);
93 compare(T_t *tp, uint8_t *cmp_buf, size_t cmp_buf_size) {
96 buf_size = cmp_buf_size + 100;
97 uint8_t scratch[buf_size];
102 * Try to re-create using DER encoding.
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);
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",
119 assert(buf[i] == cmp_buf[i]);
126 partial_read(uint8_t *buf_0, size_t size) {
133 fprintf(stderr, "\nPartial read sequence...\n");
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.
141 for(size_t i1 = 0; i1 < size; i1++) {
142 for(size_t i2 = i1; i2 < size; i2++) {
143 uint8_t *chunk1 = buf_0;
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;
150 fprintf(stderr, "\n%zd:{%zd, %zd, %zd}...\n",
151 size, size1, size2, size3);
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);
160 tp = memset(&t, 0, sizeof(t));
162 fprintf(stderr, "=> Chunk 1 (%zd):\n", size1);
163 rval = ber_decode(0, &asn_DEF_T, (void **)&tp,
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);
174 fprintf(stderr, "=> Chunk 2 (%zd):\n", size2);
175 rval = ber_decode(0, &asn_DEF_T, (void **)&tp,
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);
186 fprintf(stderr, "=> Chunk 3 (%zd):\n", size3);
187 rval = ber_decode(0, &asn_DEF_T, (void **)&tp,
189 assert(rval.code == RC_OK);
190 assert(rval.consumed == size3);
192 ASN_STRUCT_RESET(asn_DEF_T, &t);
198 main(int ac, char **av) {
201 (void)ac; /* Unused argument */
202 (void)av; /* Unused argument */
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);
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);
216 /* Split the buffer in parts and check decoder restartability */
217 partial_read(buf1, sizeof(buf1));