← Back to branch summary

~ubuntu-branches/ubuntu/dapper/asn1c/dapper

« back to all changes in this revision

Viewing changes to asn1c/tests/check-41.-fnative-integers.c

  • Committer: Bazaar Package Importer
  • Author(s): W. Borgert
  • Date: 2005-05-28 12:36:42 UTC
  • Revision ID: james.westby@ubuntu.com-20050528123642-3h6kstws5u0xcovl
Tags: upstream-0.9.14
Import upstream version 0.9.14

Show diffs side-by-side

added added

removed removed

Lines of Context:
asn1c/tests/check-41.-fnative-integers.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, int size, size_t consumed) {
 
51
        asn_dec_rval_t rval;
 
52
 
 
53
        tp = memset(tp, 0, sizeof(*tp));
 
54
 
 
55
        fprintf(stderr, "Buf %p (%d)\n", buf, size);
 
56
        rval = ber_decode(0, &asn_DEF_T, (void **)&tp, buf, size);
 
57
        fprintf(stderr, "Returned code %d, consumed %d\n",
 
58
                (int)rval.code, (int)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(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, "%d + %d > %d\n",
 
81
                        (int)buf_pos, (int)size, (int)buf_size);
 
82
                return -1;
 
83
        }
 
84
 
 
85
        memcpy(buf + buf_pos, buffer, size);
 
86
        buf_pos += size;
 
87
        fprintf(stderr, "   written %d (%d)\n", (int)size, (int)buf_pos);
 
88
 
 
89
        return 0;
 
90
}
 
91
 
 
92
static void
 
93
compare(T_t *tp, uint8_t *cmp_buf, int cmp_buf_size) {
 
94
        asn_enc_rval_t erval;
 
95
        int i;
 
96
 
 
97
        buf_size = cmp_buf_size + 100;
 
98
        buf = alloca(buf_size);
 
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(erval.encoded != cmp_buf_size) {
 
107
                printf("%d != %d\n", erval.encoded, cmp_buf_size);
 
108
        }
 
109
        assert(erval.encoded == cmp_buf_size);
 
110
        for(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 %d, %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
 
 
123
static void
 
124
partial_read(uint8_t *buf_0, size_t size) {
 
125
        T_t t, *tp;
 
126
        asn_dec_rval_t rval;
 
127
        size_t i1, i2;
 
128
        uint8_t *buf_1 = alloca(size);
 
129
        uint8_t *buf_2 = alloca(size);
 
130
        uint8_t *buf_3 = alloca(size);
 
131
 
 
132
        fprintf(stderr, "\nPartial read sequence...\n");
 
133
 
 
134
        /*
 
135
         * Divide the space (size) into three blocks in various combinations:
 
136
         *   |<----->i1<----->i2<----->|
 
137
         *   ^ buf_0                    ^ buf_0+size
 
138
         * Try to read block by block.
 
139
         */
 
140
        for(i1 = 0; i1 < size; i1++) {
 
141
                for(i2 = i1; i2 < size; i2++) {
 
142
                        uint8_t *chunk1 = buf_0;
 
143
                        size_t size1 = i1;
 
144
                        uint8_t *chunk2 = buf_0 + size1;
 
145
                        size_t size2 = i2 - i1;
 
146
                        uint8_t *chunk3 = buf_0 + size1 + size2;
 
147
                        size_t size3 = size - size1 - size2;
 
148
 
 
149
                        fprintf(stderr, "\n%d:{%d, %d, %d}...\n",
 
150
                                (int)size, (int)size1, (int)size2, (int)size3);
 
151
 
 
152
                        memset(buf_1, 0, size);
 
153
                        memset(buf_2, 0, size);
 
154
                        memset(buf_3, 0, size);
 
155
                        memcpy(buf_1, chunk1, size1);
 
156
                        memcpy(buf_2, chunk2, size2);
 
157
                        memcpy(buf_3, chunk3, size3);
 
158
 
 
159
                        tp = memset(&t, 0, sizeof(t));
 
160
 
 
161
                        fprintf(stderr, "=> Chunk 1 (%d):\n", (int)size1);
 
162
                        rval = ber_decode(0, &asn_DEF_T, (void **)&tp,
 
163
                                buf_1, size1);
 
164
                        assert(rval.code == RC_WMORE);
 
165
                        assert(rval.consumed <= size1);
 
166
                        if(rval.consumed < size1) {
 
167
                                int leftover = size1 - rval.consumed;
 
168
                                memcpy(buf_2, buf_1 + rval.consumed, leftover);
 
169
                                memcpy(buf_2 + leftover, chunk2, size2);
 
170
                                size2 += leftover;
 
171
                        }
 
172
 
 
173
                        fprintf(stderr, "=> Chunk 2 (%d):\n", (int)size2);
 
174
                        rval = ber_decode(0, &asn_DEF_T, (void **)&tp,
 
175
                                buf_2, size2);
 
176
                        assert(rval.code == RC_WMORE);
 
177
                        assert(rval.consumed <= size2);
 
178
                        if(rval.consumed < size2) {
 
179
                                int leftover = size2 - rval.consumed;
 
180
                                memcpy(buf_3, buf_2 + rval.consumed, leftover);
 
181
                                memcpy(buf_3 + leftover, chunk3, size3);
 
182
                                size3 += leftover;
 
183
                        }
 
184
 
 
185
                        fprintf(stderr, "=> Chunk 3 (%d):\n", (int)size3);
 
186
                        rval = ber_decode(0, &asn_DEF_T, (void **)&tp,
 
187
                                buf_3, size3);
 
188
                        assert(rval.code == RC_OK);
 
189
                        assert(rval.consumed == size3);
 
190
 
 
191
                        asn_DEF_T.free_struct(&asn_DEF_T, &t, 1);
 
192
                }
 
193
        }
 
194
}
 
195
 
 
196
int
 
197
main(int ac, char **av) {
 
198
        T_t t;
 
199
 
 
200
        (void)ac;       /* Unused argument */
 
201
        (void)av;       /* Unused argument */
 
202
 
 
203
        /* Check exact buf1 */
 
204
        check(&t, buf1, sizeof(buf1), sizeof(buf1));
 
205
        compare(&t, buf1_reconstr, sizeof(buf1_reconstr));
 
206
        asn_fprint(stderr, &asn_DEF_T, &t);
 
207
        asn_DEF_T.free_struct(&asn_DEF_T, &t, 1);
 
208
 
 
209
        /* Check slightly more than buf1 */
 
210
        check(&t, buf1, sizeof(buf1) + 10, sizeof(buf1));
 
211
        compare(&t, buf1_reconstr, sizeof(buf1_reconstr));
 
212
        asn_fprint(stderr, &asn_DEF_T, &t);
 
213
        asn_DEF_T.free_struct(&asn_DEF_T, &t, 1);
 
214
 
 
215
        /* Split the buffer in parts and check decoder restartability */
 
216
        partial_read(buf1, sizeof(buf1));
 
217
 
 
218
        return 0;
 
219
}