1 /*
2 * ngtcp2
3 *
4 * Copyright (c) 2017 ngtcp2 contributors
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining
7 * a copy of this software and associated documentation files (the
8 * "Software"), to deal in the Software without restriction, including
9 * without limitation the rights to use, copy, modify, merge, publish,
10 * distribute, sublicense, and/or sell copies of the Software, and to
11 * permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
13 *
14 * The above copyright notice and this permission notice shall be
15 * included in all copies or substantial portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
18 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
19 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
20 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
21 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
22 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
23 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
24 */
25 #include "ngtcp2_pkt_test.h"
26
27 #include <CUnit/CUnit.h>
28
29 #include "ngtcp2_pkt.h"
30 #include "ngtcp2_test_helper.h"
31 #include "ngtcp2_conv.h"
32 #include "ngtcp2_cid.h"
33 #include "ngtcp2_str.h"
34 #include "ngtcp2_vec.h"
35
null_retry_encrypt(uint8_t * dest,const ngtcp2_crypto_aead * aead,const ngtcp2_crypto_aead_ctx * aead_ctx,const uint8_t * plaintext,size_t plaintextlen,const uint8_t * nonce,size_t noncelen,const uint8_t * aad,size_t aadlen)36 static int null_retry_encrypt(uint8_t *dest, const ngtcp2_crypto_aead *aead,
37 const ngtcp2_crypto_aead_ctx *aead_ctx,
38 const uint8_t *plaintext, size_t plaintextlen,
39 const uint8_t *nonce, size_t noncelen,
40 const uint8_t *aad, size_t aadlen) {
41 (void)dest;
42 (void)aead;
43 (void)aead_ctx;
44 (void)plaintext;
45 (void)plaintextlen;
46 (void)nonce;
47 (void)noncelen;
48 (void)aad;
49 (void)aadlen;
50
51 if (plaintextlen && plaintext != dest) {
52 memcpy(dest, plaintext, plaintextlen);
53 }
54 memset(dest + plaintextlen, 0, NGTCP2_RETRY_TAGLEN);
55
56 return 0;
57 }
58
test_ngtcp2_pkt_decode_version_cid(void)59 void test_ngtcp2_pkt_decode_version_cid(void) {
60 uint8_t buf[1024];
61 uint32_t version;
62 const uint8_t *dcid, *scid;
63 size_t dcidlen, scidlen;
64 int rv;
65 uint8_t *p;
66
67 /* Supported QUIC version */
68 p = buf;
69 *p++ = NGTCP2_HEADER_FORM_BIT;
70 p = ngtcp2_put_uint32be(p, NGTCP2_PROTO_VER_MAX);
71 *p++ = NGTCP2_MAX_CIDLEN;
72 p = ngtcp2_setmem(p, 0xf1, NGTCP2_MAX_CIDLEN);
73 *p++ = NGTCP2_MAX_CIDLEN - 1;
74 p = ngtcp2_setmem(p, 0xf2, NGTCP2_MAX_CIDLEN - 1);
75
76 rv = ngtcp2_pkt_decode_version_cid(&version, &dcid, &dcidlen, &scid, &scidlen,
77 buf, (size_t)(p - buf), 0);
78
79 CU_ASSERT(0 == rv);
80 CU_ASSERT(NGTCP2_PROTO_VER_MAX == version);
81 CU_ASSERT(NGTCP2_MAX_CIDLEN == dcidlen);
82 CU_ASSERT(&buf[6] == dcid);
83 CU_ASSERT(NGTCP2_MAX_CIDLEN - 1 == scidlen);
84 CU_ASSERT(&buf[6 + NGTCP2_MAX_CIDLEN + 1] == scid);
85
86 /* Unsupported QUIC version */
87 p = buf;
88 *p++ = NGTCP2_HEADER_FORM_BIT;
89 p = ngtcp2_put_uint32be(p, 0xffffff00);
90 *p++ = NGTCP2_MAX_CIDLEN;
91 p = ngtcp2_setmem(p, 0xf1, NGTCP2_MAX_CIDLEN);
92 *p++ = NGTCP2_MAX_CIDLEN - 1;
93 p = ngtcp2_setmem(p, 0xf2, NGTCP2_MAX_CIDLEN - 1);
94
95 rv = ngtcp2_pkt_decode_version_cid(&version, &dcid, &dcidlen, &scid, &scidlen,
96 buf, (size_t)(p - buf), 0);
97
98 CU_ASSERT(NGTCP2_ERR_VERSION_NEGOTIATION == rv);
99 CU_ASSERT(0xffffff00 == version);
100 CU_ASSERT(NGTCP2_MAX_CIDLEN == dcidlen);
101 CU_ASSERT(&buf[6] == dcid);
102 CU_ASSERT(NGTCP2_MAX_CIDLEN - 1 == scidlen);
103 CU_ASSERT(&buf[6 + NGTCP2_MAX_CIDLEN + 1] == scid);
104
105 /* Supported QUIC version with long CID */
106 p = buf;
107 *p++ = NGTCP2_HEADER_FORM_BIT;
108 p = ngtcp2_put_uint32be(p, NGTCP2_PROTO_VER_MAX);
109 *p++ = NGTCP2_MAX_CIDLEN + 1;
110 p = ngtcp2_setmem(p, 0xf1, NGTCP2_MAX_CIDLEN + 1);
111 *p++ = NGTCP2_MAX_CIDLEN;
112 p = ngtcp2_setmem(p, 0xf2, NGTCP2_MAX_CIDLEN);
113
114 rv = ngtcp2_pkt_decode_version_cid(&version, &dcid, &dcidlen, &scid, &scidlen,
115 buf, (size_t)(p - buf), 0);
116
117 CU_ASSERT(NGTCP2_ERR_INVALID_ARGUMENT == rv);
118
119 /* Unsupported QUIC version with long CID */
120 p = buf;
121 *p++ = NGTCP2_HEADER_FORM_BIT;
122 p = ngtcp2_put_uint32be(p, 0xffffff00);
123 *p++ = NGTCP2_MAX_CIDLEN + 1;
124 p = ngtcp2_setmem(p, 0xf1, NGTCP2_MAX_CIDLEN + 1);
125 *p++ = NGTCP2_MAX_CIDLEN;
126 p = ngtcp2_setmem(p, 0xf2, NGTCP2_MAX_CIDLEN);
127
128 rv = ngtcp2_pkt_decode_version_cid(&version, &dcid, &dcidlen, &scid, &scidlen,
129 buf, (size_t)(p - buf), 0);
130
131 CU_ASSERT(NGTCP2_ERR_VERSION_NEGOTIATION == rv);
132 CU_ASSERT(0xffffff00 == version);
133 CU_ASSERT(NGTCP2_MAX_CIDLEN + 1 == dcidlen);
134 CU_ASSERT(&buf[6] == dcid);
135 CU_ASSERT(NGTCP2_MAX_CIDLEN == scidlen);
136 CU_ASSERT(&buf[6 + NGTCP2_MAX_CIDLEN + 1 + 1] == scid);
137
138 /* VN */
139 p = buf;
140 *p++ = NGTCP2_HEADER_FORM_BIT;
141 p = ngtcp2_put_uint32be(p, 0);
142 *p++ = NGTCP2_MAX_CIDLEN;
143 p = ngtcp2_setmem(p, 0xf1, NGTCP2_MAX_CIDLEN);
144 *p++ = NGTCP2_MAX_CIDLEN - 1;
145 p = ngtcp2_setmem(p, 0xf2, NGTCP2_MAX_CIDLEN - 1);
146
147 rv = ngtcp2_pkt_decode_version_cid(&version, &dcid, &dcidlen, &scid, &scidlen,
148 buf, (size_t)(p - buf), 0);
149
150 CU_ASSERT(0 == rv);
151 CU_ASSERT(0 == version);
152 CU_ASSERT(NGTCP2_MAX_CIDLEN == dcidlen);
153 CU_ASSERT(&buf[6] == dcid);
154 CU_ASSERT(NGTCP2_MAX_CIDLEN - 1 == scidlen);
155 CU_ASSERT(&buf[6 + NGTCP2_MAX_CIDLEN + 1] == scid);
156
157 /* VN with long CID */
158 p = buf;
159 *p++ = NGTCP2_HEADER_FORM_BIT;
160 p = ngtcp2_put_uint32be(p, 0);
161 *p++ = NGTCP2_MAX_CIDLEN + 1;
162 p = ngtcp2_setmem(p, 0xf1, NGTCP2_MAX_CIDLEN + 1);
163 *p++ = NGTCP2_MAX_CIDLEN;
164 p = ngtcp2_setmem(p, 0xf2, NGTCP2_MAX_CIDLEN);
165
166 rv = ngtcp2_pkt_decode_version_cid(&version, &dcid, &dcidlen, &scid, &scidlen,
167 buf, (size_t)(p - buf), 0);
168
169 CU_ASSERT(NGTCP2_ERR_INVALID_ARGUMENT == rv);
170
171 /* Malformed Long packet */
172 p = buf;
173 *p++ = NGTCP2_HEADER_FORM_BIT;
174 p = ngtcp2_put_uint32be(p, NGTCP2_PROTO_VER_MAX);
175 *p++ = NGTCP2_MAX_CIDLEN;
176 p = ngtcp2_setmem(p, 0xf1, NGTCP2_MAX_CIDLEN);
177 *p++ = NGTCP2_MAX_CIDLEN - 1;
178 p = ngtcp2_setmem(p, 0xf2, NGTCP2_MAX_CIDLEN - 1);
179 --p;
180
181 rv = ngtcp2_pkt_decode_version_cid(&version, &dcid, &dcidlen, &scid, &scidlen,
182 buf, (size_t)(p - buf), 0);
183
184 CU_ASSERT(NGTCP2_ERR_INVALID_ARGUMENT == rv);
185
186 /* Short packet */
187 p = buf;
188 *p++ = 0;
189 p = ngtcp2_setmem(p, 0xf1, NGTCP2_MAX_CIDLEN);
190
191 rv = ngtcp2_pkt_decode_version_cid(&version, &dcid, &dcidlen, &scid, &scidlen,
192 buf, (size_t)(p - buf), NGTCP2_MAX_CIDLEN);
193
194 CU_ASSERT(0 == rv);
195 CU_ASSERT(0 == version);
196 CU_ASSERT(&buf[1] == dcid);
197 CU_ASSERT(NGTCP2_MAX_CIDLEN == dcidlen);
198 CU_ASSERT(NULL == scid);
199 CU_ASSERT(0 == scidlen);
200
201 /* Malformed Short packet */
202 p = buf;
203 *p++ = 0;
204 p = ngtcp2_setmem(p, 0xf1, NGTCP2_MAX_CIDLEN);
205 --p;
206
207 rv = ngtcp2_pkt_decode_version_cid(&version, &dcid, &dcidlen, &scid, &scidlen,
208 buf, (size_t)(p - buf), NGTCP2_MAX_CIDLEN);
209
210 CU_ASSERT(NGTCP2_ERR_INVALID_ARGUMENT == rv);
211 }
212
test_ngtcp2_pkt_decode_hd_long(void)213 void test_ngtcp2_pkt_decode_hd_long(void) {
214 ngtcp2_pkt_hd hd, nhd;
215 uint8_t buf[256];
216 ngtcp2_ssize rv;
217 ngtcp2_cid dcid, scid;
218 size_t len;
219
220 dcid_init(&dcid);
221 scid_init(&scid);
222
223 /* Handshake */
224 ngtcp2_pkt_hd_init(&hd, NGTCP2_PKT_FLAG_LONG_FORM, NGTCP2_PKT_HANDSHAKE,
225 &dcid, &scid, 0xe1e2e3e4u, 4, 0x000000ff, 16383);
226
227 rv = ngtcp2_pkt_encode_hd_long(buf, sizeof(buf), &hd);
228
229 len = 1 + 4 + 1 + dcid.datalen + 1 + scid.datalen + 2 + 4;
230
231 CU_ASSERT((ngtcp2_ssize)len == rv);
232 CU_ASSERT(buf[0] & NGTCP2_FIXED_BIT_MASK);
233
234 rv = pkt_decode_hd_long(&nhd, buf, len);
235
236 CU_ASSERT((ngtcp2_ssize)len == rv);
237 CU_ASSERT(hd.type == nhd.type);
238 CU_ASSERT(hd.flags == nhd.flags);
239 CU_ASSERT(ngtcp2_cid_eq(&hd.dcid, &nhd.dcid));
240 CU_ASSERT(ngtcp2_cid_eq(&hd.scid, &nhd.scid));
241 CU_ASSERT(0xe1e2e3e4u == nhd.pkt_num);
242 CU_ASSERT(hd.version == nhd.version);
243 CU_ASSERT(hd.len == nhd.len);
244
245 /* Handshake without Fixed Bit set */
246 ngtcp2_pkt_hd_init(
247 &hd, NGTCP2_PKT_FLAG_LONG_FORM | NGTCP2_PKT_FLAG_FIXED_BIT_CLEAR,
248 NGTCP2_PKT_HANDSHAKE, &dcid, &scid, 0xe1e2e3e4u, 4, 0x000000ff, 16383);
249
250 rv = ngtcp2_pkt_encode_hd_long(buf, sizeof(buf), &hd);
251
252 len = 1 + 4 + 1 + dcid.datalen + 1 + scid.datalen + 2 + 4;
253
254 CU_ASSERT((ngtcp2_ssize)len == rv);
255 CU_ASSERT((buf[0] & NGTCP2_FIXED_BIT_MASK) == 0);
256
257 rv = pkt_decode_hd_long(&nhd, buf, len);
258
259 CU_ASSERT((ngtcp2_ssize)len == rv);
260 CU_ASSERT(hd.type == nhd.type);
261 CU_ASSERT(hd.flags == nhd.flags);
262 CU_ASSERT(ngtcp2_cid_eq(&hd.dcid, &nhd.dcid));
263 CU_ASSERT(ngtcp2_cid_eq(&hd.scid, &nhd.scid));
264 CU_ASSERT(0xe1e2e3e4u == nhd.pkt_num);
265 CU_ASSERT(hd.version == nhd.version);
266 CU_ASSERT(hd.len == nhd.len);
267
268 /* VN */
269 /* Set random packet type */
270 ngtcp2_pkt_hd_init(&hd, NGTCP2_PKT_FLAG_LONG_FORM, NGTCP2_PKT_HANDSHAKE,
271 &dcid, &scid, 0, 4, 0, 0);
272
273 rv = ngtcp2_pkt_encode_hd_long(buf, sizeof(buf), &hd);
274
275 len = 1 + 4 + 1 + dcid.datalen + 1 + scid.datalen;
276
277 CU_ASSERT((ngtcp2_ssize)len == rv - 2 /* payloadlen */ - 4 /* pkt_num */);
278
279 rv = pkt_decode_hd_long(&nhd, buf, len);
280
281 CU_ASSERT((ngtcp2_ssize)len == rv);
282 CU_ASSERT(NGTCP2_PKT_VERSION_NEGOTIATION == nhd.type);
283 CU_ASSERT(hd.flags == nhd.flags);
284 CU_ASSERT(ngtcp2_cid_eq(&hd.dcid, &nhd.dcid));
285 CU_ASSERT(ngtcp2_cid_eq(&hd.scid, &nhd.scid));
286 CU_ASSERT(hd.pkt_num == nhd.pkt_num);
287 CU_ASSERT(hd.version == nhd.version);
288 CU_ASSERT(hd.len == nhd.len);
289 }
290
test_ngtcp2_pkt_decode_hd_short(void)291 void test_ngtcp2_pkt_decode_hd_short(void) {
292 ngtcp2_pkt_hd hd, nhd;
293 uint8_t buf[256];
294 ngtcp2_ssize rv;
295 size_t expectedlen;
296 ngtcp2_cid dcid, zcid;
297
298 dcid_init(&dcid);
299 ngtcp2_cid_zero(&zcid);
300
301 /* 4 bytes packet number */
302 ngtcp2_pkt_hd_init(&hd, NGTCP2_PKT_FLAG_NONE, NGTCP2_PKT_SHORT, &dcid, NULL,
303 0xe1e2e3e4u, 4, 0xd1d2d3d4u, 0);
304
305 expectedlen = 1 + dcid.datalen + 4;
306
307 rv = ngtcp2_pkt_encode_hd_short(buf, sizeof(buf), &hd);
308
309 CU_ASSERT((ngtcp2_ssize)expectedlen == rv);
310 CU_ASSERT(buf[0] & NGTCP2_FIXED_BIT_MASK);
311
312 rv = pkt_decode_hd_short(&nhd, buf, expectedlen, dcid.datalen);
313
314 CU_ASSERT((ngtcp2_ssize)expectedlen == rv);
315 CU_ASSERT(hd.flags == nhd.flags);
316 CU_ASSERT(NGTCP2_PKT_SHORT == nhd.type);
317 CU_ASSERT(ngtcp2_cid_eq(&dcid, &nhd.dcid));
318 CU_ASSERT(ngtcp2_cid_empty(&nhd.scid));
319 CU_ASSERT(0xe1e2e3e4u == nhd.pkt_num);
320 CU_ASSERT(hd.pkt_numlen == nhd.pkt_numlen);
321 CU_ASSERT(0 == nhd.version);
322 CU_ASSERT(0 == nhd.len);
323
324 /* 4 bytes packet number without Fixed Bit set */
325 ngtcp2_pkt_hd_init(
326 &hd, NGTCP2_PKT_FLAG_NONE | NGTCP2_PKT_FLAG_FIXED_BIT_CLEAR,
327 NGTCP2_PKT_SHORT, &dcid, NULL, 0xe1e2e3e4u, 4, 0xd1d2d3d4u, 0);
328
329 expectedlen = 1 + dcid.datalen + 4;
330
331 rv = ngtcp2_pkt_encode_hd_short(buf, sizeof(buf), &hd);
332
333 CU_ASSERT((ngtcp2_ssize)expectedlen == rv);
334 CU_ASSERT((buf[0] & NGTCP2_FIXED_BIT_MASK) == 0);
335
336 rv = pkt_decode_hd_short(&nhd, buf, expectedlen, dcid.datalen);
337
338 CU_ASSERT((ngtcp2_ssize)expectedlen == rv);
339 CU_ASSERT(hd.flags == nhd.flags);
340 CU_ASSERT(NGTCP2_PKT_SHORT == nhd.type);
341 CU_ASSERT(ngtcp2_cid_eq(&dcid, &nhd.dcid));
342 CU_ASSERT(ngtcp2_cid_empty(&nhd.scid));
343 CU_ASSERT(0xe1e2e3e4u == nhd.pkt_num);
344 CU_ASSERT(hd.pkt_numlen == nhd.pkt_numlen);
345 CU_ASSERT(0 == nhd.version);
346 CU_ASSERT(0 == nhd.len);
347
348 /* 2 bytes packet number */
349 ngtcp2_pkt_hd_init(&hd, NGTCP2_PKT_FLAG_NONE, NGTCP2_PKT_SHORT, &dcid, NULL,
350 0xe1e2e3e4u, 2, 0xd1d2d3d4u, 0);
351
352 expectedlen = 1 + dcid.datalen + 2;
353
354 rv = ngtcp2_pkt_encode_hd_short(buf, sizeof(buf), &hd);
355
356 CU_ASSERT((ngtcp2_ssize)expectedlen == rv);
357
358 rv = pkt_decode_hd_short(&nhd, buf, expectedlen, dcid.datalen);
359
360 CU_ASSERT((ngtcp2_ssize)expectedlen == rv);
361 CU_ASSERT(hd.flags == nhd.flags);
362 CU_ASSERT(NGTCP2_PKT_SHORT == nhd.type);
363 CU_ASSERT(ngtcp2_cid_eq(&dcid, &nhd.dcid));
364 CU_ASSERT(ngtcp2_cid_empty(&nhd.scid));
365 CU_ASSERT(0xe3e4u == nhd.pkt_num);
366 CU_ASSERT(hd.pkt_numlen == nhd.pkt_numlen);
367 CU_ASSERT(0 == nhd.version);
368 CU_ASSERT(0 == nhd.len);
369
370 /* 1 byte packet number */
371 ngtcp2_pkt_hd_init(&hd, NGTCP2_PKT_FLAG_NONE, NGTCP2_PKT_SHORT, &dcid, NULL,
372 0xe1e2e3e4u, 1, 0xd1d2d3d4u, 0);
373
374 expectedlen = 1 + dcid.datalen + 1;
375
376 rv = ngtcp2_pkt_encode_hd_short(buf, sizeof(buf), &hd);
377
378 CU_ASSERT((ngtcp2_ssize)expectedlen == rv);
379
380 rv = pkt_decode_hd_short(&nhd, buf, expectedlen, dcid.datalen);
381
382 CU_ASSERT((ngtcp2_ssize)expectedlen == rv);
383 CU_ASSERT(hd.flags == nhd.flags);
384 CU_ASSERT(NGTCP2_PKT_SHORT == nhd.type);
385 CU_ASSERT(ngtcp2_cid_eq(&dcid, &nhd.dcid));
386 CU_ASSERT(ngtcp2_cid_empty(&nhd.scid));
387 CU_ASSERT(0xe4 == nhd.pkt_num);
388 CU_ASSERT(hd.pkt_numlen == nhd.pkt_numlen);
389 CU_ASSERT(0 == nhd.version);
390 CU_ASSERT(0 == nhd.len);
391
392 /* With Key Phase */
393 ngtcp2_pkt_hd_init(&hd, NGTCP2_PKT_FLAG_KEY_PHASE, NGTCP2_PKT_SHORT, &dcid,
394 NULL, 0xe1e2e3e4u, 4, 0xd1d2d3d4u, 0);
395
396 expectedlen = 1 + dcid.datalen + 4;
397
398 rv = ngtcp2_pkt_encode_hd_short(buf, sizeof(buf), &hd);
399
400 CU_ASSERT((ngtcp2_ssize)expectedlen == rv);
401
402 rv = pkt_decode_hd_short(&nhd, buf, expectedlen, dcid.datalen);
403
404 CU_ASSERT((ngtcp2_ssize)expectedlen == rv);
405 /* key phase bit is protected by header protection and
406 ngtcp2_pkt_decode_hd_short does not decode it. */
407 CU_ASSERT(NGTCP2_PKT_FLAG_NONE == nhd.flags);
408 CU_ASSERT(NGTCP2_PKT_SHORT == nhd.type);
409 CU_ASSERT(ngtcp2_cid_eq(&dcid, &nhd.dcid));
410 CU_ASSERT(ngtcp2_cid_empty(&nhd.scid));
411 CU_ASSERT(0xe1e2e3e4u == nhd.pkt_num);
412 CU_ASSERT(hd.pkt_numlen == nhd.pkt_numlen);
413 CU_ASSERT(0 == nhd.version);
414 CU_ASSERT(0 == nhd.len);
415
416 /* With empty DCID */
417 ngtcp2_pkt_hd_init(&hd, NGTCP2_PKT_FLAG_NONE, NGTCP2_PKT_SHORT, NULL, NULL,
418 0xe1e2e3e4u, 4, 0xd1d2d3d4u, 0);
419
420 expectedlen = 1 + 4;
421
422 rv = ngtcp2_pkt_encode_hd_short(buf, sizeof(buf), &hd);
423
424 CU_ASSERT((ngtcp2_ssize)expectedlen == rv);
425
426 rv = pkt_decode_hd_short(&nhd, buf, expectedlen, 0);
427
428 CU_ASSERT((ngtcp2_ssize)expectedlen == rv);
429 CU_ASSERT(hd.flags == nhd.flags);
430 CU_ASSERT(NGTCP2_PKT_SHORT == nhd.type);
431 CU_ASSERT(ngtcp2_cid_empty(&nhd.dcid));
432 CU_ASSERT(ngtcp2_cid_empty(&nhd.scid));
433 CU_ASSERT(0xe1e2e3e4u == nhd.pkt_num);
434 CU_ASSERT(hd.pkt_numlen == nhd.pkt_numlen);
435 CU_ASSERT(0 == nhd.version);
436 CU_ASSERT(0 == nhd.len);
437 }
438
test_ngtcp2_pkt_decode_stream_frame(void)439 void test_ngtcp2_pkt_decode_stream_frame(void) {
440 uint8_t buf[256];
441 size_t buflen;
442 ngtcp2_frame fr;
443 ngtcp2_ssize rv;
444 size_t expectedlen;
445
446 /* 32 bits Stream ID + 62 bits Offset + Data Length */
447 buflen = ngtcp2_t_encode_stream_frame(buf, NGTCP2_STREAM_LEN_BIT, 0xf1f2f3f4u,
448 0x31f2f3f4f5f6f7f8llu, 0x14);
449
450 expectedlen = 1 + 8 + 8 + 1 + 20;
451
452 CU_ASSERT(expectedlen == buflen);
453
454 rv = ngtcp2_pkt_decode_stream_frame(&fr.stream, buf, buflen);
455
456 CU_ASSERT((ngtcp2_ssize)expectedlen == rv);
457 CU_ASSERT(0 == fr.stream.fin);
458 CU_ASSERT(0xf1f2f3f4u == fr.stream.stream_id);
459 CU_ASSERT(0x31f2f3f4f5f6f7f8llu == fr.stream.offset);
460 CU_ASSERT(1 == fr.stream.datacnt);
461 CU_ASSERT(0x14 == fr.stream.data[0].len);
462
463 /* Cutting 1 bytes from the tail must cause invalid argument
464 error */
465 rv = ngtcp2_pkt_decode_stream_frame(&fr.stream, buf, buflen - 1);
466
467 CU_ASSERT(NGTCP2_ERR_FRAME_ENCODING == rv);
468
469 memset(&fr, 0, sizeof(fr));
470
471 /* 6 bits Stream ID + no Offset + Data Length */
472 buflen = ngtcp2_t_encode_stream_frame(buf, NGTCP2_STREAM_LEN_BIT, 0x31, 0x00,
473 0x14);
474
475 expectedlen = 1 + 1 + 0 + 1 + 20;
476
477 CU_ASSERT(expectedlen == buflen);
478
479 rv = ngtcp2_pkt_decode_stream_frame(&fr.stream, buf, buflen);
480
481 CU_ASSERT((ngtcp2_ssize)expectedlen == rv);
482 CU_ASSERT(0 == fr.stream.fin);
483 CU_ASSERT(0x31 == fr.stream.stream_id);
484 CU_ASSERT(0x00 == fr.stream.offset);
485 CU_ASSERT(1 == fr.stream.datacnt);
486 CU_ASSERT(0x14 == fr.stream.data[0].len);
487
488 /* Cutting 1 bytes from the tail must cause invalid argument
489 error */
490 rv = ngtcp2_pkt_decode_stream_frame(&fr.stream, buf, buflen - 1);
491
492 CU_ASSERT(NGTCP2_ERR_FRAME_ENCODING == rv);
493
494 memset(&fr, 0, sizeof(fr));
495
496 /* Fin bit set + no Data Length */
497 buflen = ngtcp2_t_encode_stream_frame(buf, NGTCP2_STREAM_FIN_BIT, 0x31f2f3f4u,
498 0x00, 0x14);
499
500 expectedlen = 1 + 4 + 20;
501
502 CU_ASSERT(expectedlen == buflen);
503
504 rv = ngtcp2_pkt_decode_stream_frame(&fr.stream, buf, buflen);
505
506 CU_ASSERT((ngtcp2_ssize)expectedlen == rv);
507 CU_ASSERT(1 == fr.stream.fin);
508 CU_ASSERT(0x31f2f3f4u == fr.stream.stream_id);
509 CU_ASSERT(0x00 == fr.stream.offset);
510 CU_ASSERT(1 == fr.stream.datacnt);
511 CU_ASSERT(0x14 == fr.stream.data[0].len);
512
513 memset(&fr, 0, sizeof(fr));
514 }
515
test_ngtcp2_pkt_decode_ack_frame(void)516 void test_ngtcp2_pkt_decode_ack_frame(void) {
517 uint8_t buf[256];
518 size_t buflen;
519 ngtcp2_frame fr;
520 ngtcp2_ssize rv;
521 size_t expectedlen;
522
523 /* 62 bits Largest Acknowledged */
524 buflen = ngtcp2_t_encode_ack_frame(buf, 0x31f2f3f4f5f6f7f8llu,
525 0x31e2e3e4e5e6e7e8llu, 99,
526 0x31d2d3d4d5d6d7d8llu);
527
528 expectedlen = 1 + 8 + 1 + 1 + 8 + 2 + 8;
529
530 CU_ASSERT(expectedlen == buflen);
531
532 rv = ngtcp2_pkt_decode_ack_frame(&fr.ack, buf, buflen);
533
534 CU_ASSERT((ngtcp2_ssize)expectedlen == rv);
535 CU_ASSERT(0x31f2f3f4f5f6f7f8llu == fr.ack.largest_ack);
536 CU_ASSERT(1 == fr.ack.num_blks);
537 CU_ASSERT(0x31e2e3e4e5e6e7e8llu == fr.ack.first_ack_blklen);
538 CU_ASSERT(99 == fr.ack.blks[0].gap);
539 CU_ASSERT(0x31d2d3d4d5d6d7d8llu == fr.ack.blks[0].blklen);
540 }
541
test_ngtcp2_pkt_decode_padding_frame(void)542 void test_ngtcp2_pkt_decode_padding_frame(void) {
543 uint8_t buf[256];
544 ngtcp2_frame fr;
545 size_t rv;
546 size_t paddinglen = 31;
547
548 memset(buf, 0, paddinglen);
549 buf[paddinglen] = NGTCP2_FRAME_STREAM;
550
551 rv = ngtcp2_pkt_decode_padding_frame(&fr.padding, buf, paddinglen + 1);
552
553 CU_ASSERT(paddinglen == rv);
554 CU_ASSERT((size_t)31 == fr.padding.len);
555 }
556
test_ngtcp2_pkt_encode_stream_frame(void)557 void test_ngtcp2_pkt_encode_stream_frame(void) {
558 const uint8_t data[] = "0123456789abcdef0";
559 uint8_t buf[256];
560 ngtcp2_frame fr, nfr;
561 ngtcp2_ssize rv;
562 size_t framelen;
563 size_t i;
564
565 /* 32 bits Stream ID + 62 bits Offset + Data Length */
566 fr.type = NGTCP2_FRAME_STREAM;
567 fr.stream.fin = 0;
568 fr.stream.stream_id = 0xf1f2f3f4u;
569 fr.stream.offset = 0x31f2f3f4f5f6f7f8llu;
570 fr.stream.datacnt = 1;
571 fr.stream.data[0].len = strsize(data);
572 fr.stream.data[0].base = (uint8_t *)data;
573
574 framelen = 1 + 8 + 8 + 1 + 17;
575
576 rv = ngtcp2_pkt_encode_stream_frame(buf, sizeof(buf), &fr.stream);
577
578 CU_ASSERT((ngtcp2_ssize)framelen == rv);
579
580 rv = ngtcp2_pkt_decode_stream_frame(&nfr.stream, buf, framelen);
581
582 CU_ASSERT((ngtcp2_ssize)framelen == rv);
583 CU_ASSERT(fr.type == nfr.type);
584 CU_ASSERT((NGTCP2_STREAM_OFF_BIT | NGTCP2_STREAM_LEN_BIT) ==
585 nfr.stream.flags);
586 CU_ASSERT(fr.stream.fin == nfr.stream.fin);
587 CU_ASSERT(fr.stream.stream_id == nfr.stream.stream_id);
588 CU_ASSERT(fr.stream.offset == nfr.stream.offset);
589 CU_ASSERT(1 == nfr.stream.datacnt);
590 CU_ASSERT(fr.stream.data[0].len == nfr.stream.data[0].len);
591 CU_ASSERT(0 == memcmp(fr.stream.data[0].base, nfr.stream.data[0].base,
592 fr.stream.data[0].len));
593
594 memset(&nfr, 0, sizeof(nfr));
595
596 /* 6 bits Stream ID + No Offset + Data Length */
597 fr.type = NGTCP2_FRAME_STREAM;
598 fr.stream.fin = 0;
599 fr.stream.stream_id = 0x31;
600 fr.stream.offset = 0;
601 fr.stream.datacnt = 1;
602 fr.stream.data[0].len = strsize(data);
603 fr.stream.data[0].base = (uint8_t *)data;
604
605 framelen = 1 + 1 + 1 + 17;
606
607 rv = ngtcp2_pkt_encode_stream_frame(buf, sizeof(buf), &fr.stream);
608
609 CU_ASSERT((ngtcp2_ssize)framelen == rv);
610
611 rv = ngtcp2_pkt_decode_stream_frame(&nfr.stream, buf, framelen);
612
613 CU_ASSERT((ngtcp2_ssize)framelen == rv);
614 CU_ASSERT(fr.type == nfr.type);
615 CU_ASSERT(NGTCP2_STREAM_LEN_BIT == nfr.stream.flags);
616 CU_ASSERT(fr.stream.fin == nfr.stream.fin);
617 CU_ASSERT(fr.stream.stream_id == nfr.stream.stream_id);
618 CU_ASSERT(fr.stream.offset == nfr.stream.offset);
619 CU_ASSERT(1 == nfr.stream.datacnt);
620 CU_ASSERT(fr.stream.data[0].len == nfr.stream.data[0].len);
621 CU_ASSERT(0 == memcmp(fr.stream.data[0].base, nfr.stream.data[0].base,
622 fr.stream.data[0].len));
623
624 memset(&nfr, 0, sizeof(nfr));
625
626 /* Fin + 32 bits Stream ID + 62 bits Offset + Data Length */
627 fr.type = NGTCP2_FRAME_STREAM;
628 fr.stream.fin = 1;
629 fr.stream.stream_id = 0xf1f2f3f4u;
630 fr.stream.offset = 0x31f2f3f4f5f6f7f8llu;
631 fr.stream.datacnt = 1;
632 fr.stream.data[0].len = strsize(data);
633 fr.stream.data[0].base = (uint8_t *)data;
634
635 framelen = 1 + 8 + 8 + 1 + 17;
636
637 rv = ngtcp2_pkt_encode_stream_frame(buf, sizeof(buf), &fr.stream);
638
639 CU_ASSERT((ngtcp2_ssize)framelen == rv);
640
641 rv = ngtcp2_pkt_decode_stream_frame(&nfr.stream, buf, framelen);
642
643 CU_ASSERT((ngtcp2_ssize)framelen == rv);
644 CU_ASSERT(fr.type == nfr.type);
645 CU_ASSERT((NGTCP2_STREAM_FIN_BIT | NGTCP2_STREAM_OFF_BIT |
646 NGTCP2_STREAM_LEN_BIT) == nfr.stream.flags);
647 CU_ASSERT(fr.stream.fin == nfr.stream.fin);
648 CU_ASSERT(fr.stream.stream_id == nfr.stream.stream_id);
649 CU_ASSERT(fr.stream.offset == nfr.stream.offset);
650 CU_ASSERT(1 == nfr.stream.datacnt);
651 CU_ASSERT(fr.stream.data[0].len == nfr.stream.data[0].len);
652 CU_ASSERT(0 == memcmp(fr.stream.data[0].base, nfr.stream.data[0].base,
653 fr.stream.data[0].len));
654
655 /* Make sure that we check the length properly. */
656 for (i = 1; i < framelen; ++i) {
657 rv = ngtcp2_pkt_decode_stream_frame(&nfr.stream, buf, i);
658
659 CU_ASSERT(NGTCP2_ERR_FRAME_ENCODING == rv);
660 }
661
662 memset(&nfr, 0, sizeof(nfr));
663
664 /* NOBUF: Fin + 32 bits Stream ID + 62 bits Offset + Data Length */
665 fr.type = NGTCP2_FRAME_STREAM;
666 fr.stream.fin = 1;
667 fr.stream.stream_id = 0xf1f2f3f4u;
668 fr.stream.offset = 0x31f2f3f4f5f6f7f8llu;
669 fr.stream.datacnt = 1;
670 fr.stream.data[0].len = strsize(data);
671 fr.stream.data[0].base = (uint8_t *)data;
672
673 framelen = 1 + 8 + 8 + 1 + 17;
674
675 rv = ngtcp2_pkt_encode_stream_frame(buf, framelen - 1, &fr.stream);
676
677 CU_ASSERT(NGTCP2_ERR_NOBUF == rv);
678 }
679
test_ngtcp2_pkt_encode_ack_frame(void)680 void test_ngtcp2_pkt_encode_ack_frame(void) {
681 uint8_t buf[256];
682 ngtcp2_max_frame mfr, nmfr;
683 ngtcp2_frame *fr = &mfr.fr, *nfr = &nmfr.fr;
684 ngtcp2_ssize rv;
685 size_t framelen;
686 size_t i;
687 ngtcp2_ack_blk *blks;
688
689 /* 0 Num Blocks */
690 fr->type = NGTCP2_FRAME_ACK;
691 fr->ack.largest_ack = 0xf1f2f3f4llu;
692 fr->ack.first_ack_blklen = 0;
693 fr->ack.ack_delay = 0;
694 fr->ack.num_blks = 0;
695
696 framelen = 1 + 8 + 1 + 1 + 1;
697
698 rv = ngtcp2_pkt_encode_ack_frame(buf, sizeof(buf), &fr->ack);
699
700 CU_ASSERT((ngtcp2_ssize)framelen == rv);
701
702 rv = ngtcp2_pkt_decode_ack_frame(&nfr->ack, buf, framelen);
703
704 CU_ASSERT((ngtcp2_ssize)framelen == rv);
705 CU_ASSERT(fr->type == nfr->type);
706 CU_ASSERT(fr->ack.largest_ack == nfr->ack.largest_ack);
707 CU_ASSERT(fr->ack.ack_delay == nfr->ack.ack_delay);
708 CU_ASSERT(fr->ack.num_blks == nfr->ack.num_blks);
709
710 memset(&nmfr, 0, sizeof(nmfr));
711
712 /* 2 Num Blocks */
713 fr->type = NGTCP2_FRAME_ACK;
714 fr->ack.largest_ack = 0xf1f2f3f4llu;
715 fr->ack.first_ack_blklen = 0xe1e2e3e4llu;
716 fr->ack.ack_delay = 0xf1f2;
717 fr->ack.num_blks = 2;
718 blks = fr->ack.blks;
719 blks[0].gap = 255;
720 blks[0].blklen = 0xd1d2d3d4llu;
721 blks[1].gap = 1;
722 blks[1].blklen = 0xd1d2d3d4llu;
723
724 framelen = 1 + 8 + 4 + 1 + 8 + (2 + 8) + (1 + 8);
725
726 rv = ngtcp2_pkt_encode_ack_frame(buf, sizeof(buf), &fr->ack);
727
728 CU_ASSERT((ngtcp2_ssize)framelen == rv);
729
730 rv = ngtcp2_pkt_decode_ack_frame(&nfr->ack, buf, framelen);
731
732 CU_ASSERT((ngtcp2_ssize)framelen == rv);
733 CU_ASSERT(fr->type == nfr->type);
734 CU_ASSERT(fr->ack.largest_ack == nfr->ack.largest_ack);
735 CU_ASSERT(fr->ack.ack_delay == nfr->ack.ack_delay);
736 CU_ASSERT(fr->ack.num_blks == nfr->ack.num_blks);
737
738 for (i = 0; i < fr->ack.num_blks; ++i) {
739 CU_ASSERT(fr->ack.blks[i].gap == nfr->ack.blks[i].gap);
740 CU_ASSERT(fr->ack.blks[i].blklen == nfr->ack.blks[i].blklen);
741 }
742
743 memset(&nmfr, 0, sizeof(nmfr));
744 }
745
test_ngtcp2_pkt_encode_ack_ecn_frame(void)746 void test_ngtcp2_pkt_encode_ack_ecn_frame(void) {
747 uint8_t buf[256];
748 ngtcp2_max_frame mfr, nmfr;
749 ngtcp2_frame *fr = &mfr.fr, *nfr = &nmfr.fr;
750 ngtcp2_ssize rv;
751 size_t framelen;
752 size_t i;
753 ngtcp2_ack_blk *blks;
754
755 /* 0 Num Blocks */
756 fr->type = NGTCP2_FRAME_ACK_ECN;
757 fr->ack.largest_ack = 0xf1f2f3f4llu;
758 fr->ack.first_ack_blklen = 0;
759 fr->ack.ack_delay = 0;
760 fr->ack.num_blks = 0;
761 fr->ack.ecn.ect0 = 64;
762 fr->ack.ecn.ect1 = 16384;
763 fr->ack.ecn.ce = 1073741824;
764
765 framelen = 1 + 8 + 1 + 1 + 1 + 2 + 4 + 8;
766
767 rv = ngtcp2_pkt_encode_ack_frame(buf, sizeof(buf), &fr->ack);
768
769 CU_ASSERT((ngtcp2_ssize)framelen == rv);
770
771 rv = ngtcp2_pkt_decode_ack_frame(&nfr->ack, buf, framelen);
772
773 CU_ASSERT((ngtcp2_ssize)framelen == rv);
774 CU_ASSERT(fr->type == nfr->type);
775 CU_ASSERT(fr->ack.largest_ack == nfr->ack.largest_ack);
776 CU_ASSERT(fr->ack.ack_delay == nfr->ack.ack_delay);
777 CU_ASSERT(fr->ack.num_blks == nfr->ack.num_blks);
778 CU_ASSERT(fr->ack.ecn.ect0 == nfr->ack.ecn.ect0);
779 CU_ASSERT(fr->ack.ecn.ect1 == nfr->ack.ecn.ect1);
780 CU_ASSERT(fr->ack.ecn.ce == nfr->ack.ecn.ce);
781
782 memset(&nmfr, 0, sizeof(nmfr));
783
784 /* 2 Num Blocks */
785 fr->type = NGTCP2_FRAME_ACK_ECN;
786 fr->ack.largest_ack = 0xf1f2f3f4llu;
787 fr->ack.first_ack_blklen = 0xe1e2e3e4llu;
788 fr->ack.ack_delay = 0xf1f2;
789 fr->ack.num_blks = 2;
790 blks = fr->ack.blks;
791 blks[0].gap = 255;
792 blks[0].blklen = 0xd1d2d3d4llu;
793 blks[1].gap = 1;
794 blks[1].blklen = 0xd1d2d3d4llu;
795 fr->ack.ecn.ect0 = 0;
796 fr->ack.ecn.ect1 = 64;
797 fr->ack.ecn.ce = 16384;
798
799 framelen = 1 + 8 + 4 + 1 + 8 + (2 + 8) + (1 + 8) + 1 + 2 + 4;
800
801 rv = ngtcp2_pkt_encode_ack_frame(buf, sizeof(buf), &fr->ack);
802
803 CU_ASSERT((ngtcp2_ssize)framelen == rv);
804
805 rv = ngtcp2_pkt_decode_ack_frame(&nfr->ack, buf, framelen);
806
807 CU_ASSERT((ngtcp2_ssize)framelen == rv);
808 CU_ASSERT(fr->type == nfr->type);
809 CU_ASSERT(fr->ack.largest_ack == nfr->ack.largest_ack);
810 CU_ASSERT(fr->ack.ack_delay == nfr->ack.ack_delay);
811 CU_ASSERT(fr->ack.num_blks == nfr->ack.num_blks);
812
813 for (i = 0; i < fr->ack.num_blks; ++i) {
814 CU_ASSERT(fr->ack.blks[i].gap == nfr->ack.blks[i].gap);
815 CU_ASSERT(fr->ack.blks[i].blklen == nfr->ack.blks[i].blklen);
816 }
817
818 CU_ASSERT(fr->ack.ecn.ect0 == nfr->ack.ecn.ect0);
819 CU_ASSERT(fr->ack.ecn.ect1 == nfr->ack.ecn.ect1);
820 CU_ASSERT(fr->ack.ecn.ce == nfr->ack.ecn.ce);
821
822 memset(&nmfr, 0, sizeof(nmfr));
823 }
824
test_ngtcp2_pkt_encode_reset_stream_frame(void)825 void test_ngtcp2_pkt_encode_reset_stream_frame(void) {
826 uint8_t buf[32];
827 ngtcp2_reset_stream fr, nfr;
828 ngtcp2_ssize rv;
829 size_t framelen = 1 + 4 + 4 + 8;
830
831 fr.type = NGTCP2_FRAME_RESET_STREAM;
832 fr.stream_id = 1000000007;
833 fr.app_error_code = 0xe1e2;
834 fr.final_size = 0x31f2f3f4f5f6f7f8llu;
835
836 rv = ngtcp2_pkt_encode_reset_stream_frame(buf, sizeof(buf), &fr);
837
838 CU_ASSERT((ngtcp2_ssize)framelen == rv);
839
840 rv = ngtcp2_pkt_decode_reset_stream_frame(&nfr, buf, framelen);
841
842 CU_ASSERT((ngtcp2_ssize)framelen == rv);
843 CU_ASSERT(fr.type == nfr.type);
844 CU_ASSERT(fr.stream_id == nfr.stream_id);
845 CU_ASSERT(fr.app_error_code == nfr.app_error_code);
846 CU_ASSERT(fr.final_size == nfr.final_size);
847 }
848
test_ngtcp2_pkt_encode_connection_close_frame(void)849 void test_ngtcp2_pkt_encode_connection_close_frame(void) {
850 uint8_t buf[2048];
851 ngtcp2_frame fr, nfr;
852 ngtcp2_ssize rv;
853 size_t framelen;
854 uint8_t reason[1024];
855
856 memset(reason, 0xfa, sizeof(reason));
857
858 /* no Reason Phrase */
859 fr.type = NGTCP2_FRAME_CONNECTION_CLOSE;
860 fr.connection_close.error_code = 0xf1f2u;
861 fr.connection_close.frame_type = 255;
862 fr.connection_close.reasonlen = 0;
863 fr.connection_close.reason = NULL;
864
865 framelen = 1 + 4 + 2 + 1;
866
867 rv = ngtcp2_pkt_encode_connection_close_frame(buf, sizeof(buf),
868 &fr.connection_close);
869
870 CU_ASSERT((ngtcp2_ssize)framelen == rv);
871
872 rv = ngtcp2_pkt_decode_connection_close_frame(&nfr.connection_close, buf,
873 framelen);
874
875 CU_ASSERT((ngtcp2_ssize)framelen == rv);
876 CU_ASSERT(fr.type == nfr.type);
877 CU_ASSERT(fr.connection_close.error_code == nfr.connection_close.error_code);
878 CU_ASSERT(fr.connection_close.reasonlen == nfr.connection_close.reasonlen);
879 CU_ASSERT(fr.connection_close.reason == nfr.connection_close.reason);
880
881 memset(&nfr, 0, sizeof(nfr));
882
883 /* 1024 bytes Reason Phrase */
884 fr.type = NGTCP2_FRAME_CONNECTION_CLOSE;
885 fr.connection_close.error_code = 0xf3f4u;
886 fr.connection_close.frame_type = 0;
887 fr.connection_close.reasonlen = sizeof(reason);
888 fr.connection_close.reason = reason;
889
890 framelen = 1 + 4 + 1 + 2 + sizeof(reason);
891
892 rv = ngtcp2_pkt_encode_connection_close_frame(buf, sizeof(buf),
893 &fr.connection_close);
894
895 CU_ASSERT((ngtcp2_ssize)framelen == rv);
896
897 rv = ngtcp2_pkt_decode_connection_close_frame(&nfr.connection_close, buf,
898 framelen);
899
900 CU_ASSERT((ngtcp2_ssize)framelen == rv);
901 CU_ASSERT(fr.type == nfr.type);
902 CU_ASSERT(fr.connection_close.error_code == nfr.connection_close.error_code);
903 CU_ASSERT(fr.connection_close.reasonlen == nfr.connection_close.reasonlen);
904 CU_ASSERT(0 == memcmp(reason, nfr.connection_close.reason, sizeof(reason)));
905
906 memset(&nfr, 0, sizeof(nfr));
907 }
908
test_ngtcp2_pkt_encode_connection_close_app_frame(void)909 void test_ngtcp2_pkt_encode_connection_close_app_frame(void) {
910 uint8_t buf[2048];
911 ngtcp2_frame fr, nfr;
912 ngtcp2_ssize rv;
913 size_t framelen;
914 uint8_t reason[1024];
915
916 memset(reason, 0xfa, sizeof(reason));
917
918 /* no Reason Phrase */
919 fr.type = NGTCP2_FRAME_CONNECTION_CLOSE_APP;
920 fr.connection_close.error_code = 0xf1f2u;
921 fr.connection_close.frame_type = 0xff; /* This must be ignored. */
922 fr.connection_close.reasonlen = 0;
923 fr.connection_close.reason = NULL;
924
925 framelen = 1 + 4 + 1;
926
927 rv = ngtcp2_pkt_encode_connection_close_frame(buf, sizeof(buf),
928 &fr.connection_close);
929
930 CU_ASSERT((ngtcp2_ssize)framelen == rv);
931
932 rv = ngtcp2_pkt_decode_connection_close_frame(&nfr.connection_close, buf,
933 framelen);
934
935 CU_ASSERT((ngtcp2_ssize)framelen == rv);
936 CU_ASSERT(fr.type == nfr.type);
937 CU_ASSERT(fr.connection_close.error_code == nfr.connection_close.error_code);
938 CU_ASSERT(0 == nfr.connection_close.frame_type);
939 CU_ASSERT(fr.connection_close.reasonlen == nfr.connection_close.reasonlen);
940 CU_ASSERT(fr.connection_close.reason == nfr.connection_close.reason);
941
942 memset(&nfr, 0, sizeof(nfr));
943 }
944
test_ngtcp2_pkt_encode_max_data_frame(void)945 void test_ngtcp2_pkt_encode_max_data_frame(void) {
946 uint8_t buf[16];
947 ngtcp2_max_data fr, nfr;
948 ngtcp2_ssize rv;
949 size_t framelen = 1 + 8;
950
951 fr.type = NGTCP2_FRAME_MAX_DATA;
952 fr.max_data = 0x31f2f3f4f5f6f7f8llu;
953
954 rv = ngtcp2_pkt_encode_max_data_frame(buf, sizeof(buf), &fr);
955
956 CU_ASSERT((ngtcp2_ssize)framelen == rv);
957
958 rv = ngtcp2_pkt_decode_max_data_frame(&nfr, buf, framelen);
959
960 CU_ASSERT((ngtcp2_ssize)framelen == rv);
961 CU_ASSERT(fr.type == nfr.type);
962 CU_ASSERT(fr.max_data == nfr.max_data);
963 }
964
test_ngtcp2_pkt_encode_max_stream_data_frame(void)965 void test_ngtcp2_pkt_encode_max_stream_data_frame(void) {
966 uint8_t buf[17];
967 ngtcp2_max_stream_data fr, nfr;
968 ngtcp2_ssize rv;
969 size_t framelen = 1 + 8 + 8;
970
971 fr.type = NGTCP2_FRAME_MAX_STREAM_DATA;
972 fr.stream_id = 0xf1f2f3f4u;
973 fr.max_stream_data = 0x35f6f7f8f9fafbfcllu;
974
975 rv = ngtcp2_pkt_encode_max_stream_data_frame(buf, sizeof(buf), &fr);
976
977 CU_ASSERT((ngtcp2_ssize)framelen == rv);
978
979 rv = ngtcp2_pkt_decode_max_stream_data_frame(&nfr, buf, framelen);
980
981 CU_ASSERT((ngtcp2_ssize)framelen == rv);
982 CU_ASSERT(fr.type == nfr.type);
983 CU_ASSERT(fr.stream_id == nfr.stream_id);
984 CU_ASSERT(fr.max_stream_data == nfr.max_stream_data);
985 }
986
test_ngtcp2_pkt_encode_max_streams_frame(void)987 void test_ngtcp2_pkt_encode_max_streams_frame(void) {
988 uint8_t buf[16];
989 ngtcp2_max_streams fr, nfr;
990 ngtcp2_ssize rv;
991 size_t framelen = 1 + 8;
992
993 fr.type = NGTCP2_FRAME_MAX_STREAMS_BIDI;
994 fr.max_streams = 0xf1f2f3f4u;
995
996 rv = ngtcp2_pkt_encode_max_streams_frame(buf, sizeof(buf), &fr);
997
998 CU_ASSERT((ngtcp2_ssize)framelen == rv);
999
1000 rv = ngtcp2_pkt_decode_max_streams_frame(&nfr, buf, framelen);
1001
1002 CU_ASSERT((ngtcp2_ssize)framelen == rv);
1003 CU_ASSERT(fr.type == nfr.type);
1004 CU_ASSERT(fr.max_streams == nfr.max_streams);
1005 }
1006
test_ngtcp2_pkt_encode_ping_frame(void)1007 void test_ngtcp2_pkt_encode_ping_frame(void) {
1008 uint8_t buf[3];
1009 ngtcp2_ping fr, nfr;
1010 ngtcp2_ssize rv;
1011 size_t framelen;
1012
1013 fr.type = NGTCP2_FRAME_PING;
1014
1015 framelen = 1;
1016
1017 rv = ngtcp2_pkt_encode_ping_frame(buf, sizeof(buf), &fr);
1018
1019 CU_ASSERT((ngtcp2_ssize)framelen == rv);
1020
1021 rv = ngtcp2_pkt_decode_ping_frame(&nfr, buf, framelen);
1022
1023 CU_ASSERT((ngtcp2_ssize)framelen == rv);
1024 CU_ASSERT(fr.type == nfr.type);
1025 }
1026
test_ngtcp2_pkt_encode_data_blocked_frame(void)1027 void test_ngtcp2_pkt_encode_data_blocked_frame(void) {
1028 uint8_t buf[9];
1029 ngtcp2_data_blocked fr, nfr;
1030 ngtcp2_ssize rv;
1031 size_t framelen = 1 + 8;
1032
1033 fr.type = NGTCP2_FRAME_DATA_BLOCKED;
1034 fr.offset = 0x31f2f3f4f5f6f7f8llu;
1035
1036 rv = ngtcp2_pkt_encode_data_blocked_frame(buf, sizeof(buf), &fr);
1037
1038 CU_ASSERT((ngtcp2_ssize)framelen == rv);
1039
1040 rv = ngtcp2_pkt_decode_data_blocked_frame(&nfr, buf, framelen);
1041
1042 CU_ASSERT((ngtcp2_ssize)framelen == rv);
1043 CU_ASSERT(fr.type == nfr.type);
1044 CU_ASSERT(fr.offset == nfr.offset);
1045 }
1046
test_ngtcp2_pkt_encode_stream_data_blocked_frame(void)1047 void test_ngtcp2_pkt_encode_stream_data_blocked_frame(void) {
1048 uint8_t buf[17];
1049 ngtcp2_stream_data_blocked fr, nfr;
1050 ngtcp2_ssize rv;
1051 size_t framelen = 1 + 8 + 8;
1052
1053 fr.type = NGTCP2_FRAME_STREAM_DATA_BLOCKED;
1054 fr.stream_id = 0xf1f2f3f4u;
1055 fr.offset = 0x35f6f7f8f9fafbfcllu;
1056
1057 rv = ngtcp2_pkt_encode_stream_data_blocked_frame(buf, sizeof(buf), &fr);
1058
1059 CU_ASSERT((ngtcp2_ssize)framelen == rv);
1060
1061 rv = ngtcp2_pkt_decode_stream_data_blocked_frame(&nfr, buf, framelen);
1062
1063 CU_ASSERT((ngtcp2_ssize)framelen == rv);
1064 CU_ASSERT(fr.type == nfr.type);
1065 CU_ASSERT(fr.stream_id == nfr.stream_id);
1066 CU_ASSERT(fr.offset == nfr.offset);
1067 }
1068
test_ngtcp2_pkt_encode_streams_blocked_frame(void)1069 void test_ngtcp2_pkt_encode_streams_blocked_frame(void) {
1070 uint8_t buf[9];
1071 ngtcp2_streams_blocked fr, nfr;
1072 ngtcp2_ssize rv;
1073 size_t framelen = 1 + 8;
1074
1075 fr.type = NGTCP2_FRAME_STREAMS_BLOCKED_BIDI;
1076 fr.max_streams = 0xf1f2f3f4u;
1077
1078 rv = ngtcp2_pkt_encode_streams_blocked_frame(buf, sizeof(buf), &fr);
1079
1080 CU_ASSERT((ngtcp2_ssize)framelen == rv);
1081
1082 rv = ngtcp2_pkt_decode_streams_blocked_frame(&nfr, buf, framelen);
1083
1084 CU_ASSERT((ngtcp2_ssize)framelen == rv);
1085 CU_ASSERT(fr.type == nfr.type);
1086 CU_ASSERT(fr.max_streams == nfr.max_streams);
1087 }
1088
test_ngtcp2_pkt_encode_new_connection_id_frame(void)1089 void test_ngtcp2_pkt_encode_new_connection_id_frame(void) {
1090 uint8_t buf[256];
1091 ngtcp2_new_connection_id fr, nfr;
1092 ngtcp2_ssize rv;
1093 size_t framelen = 1 + 4 + 2 + 1 + 18 + NGTCP2_STATELESS_RESET_TOKENLEN;
1094
1095 fr.type = NGTCP2_FRAME_NEW_CONNECTION_ID;
1096 fr.seq = 1000000009;
1097 fr.retire_prior_to = 255;
1098 scid_init(&fr.cid);
1099 memset(fr.stateless_reset_token, 0xe1, sizeof(fr.stateless_reset_token));
1100
1101 rv = ngtcp2_pkt_encode_new_connection_id_frame(buf, sizeof(buf), &fr);
1102
1103 CU_ASSERT((ngtcp2_ssize)framelen == rv);
1104
1105 rv = ngtcp2_pkt_decode_new_connection_id_frame(&nfr, buf, framelen);
1106
1107 CU_ASSERT((ngtcp2_ssize)framelen == rv);
1108 CU_ASSERT(fr.type == nfr.type);
1109 CU_ASSERT(fr.seq == nfr.seq);
1110 CU_ASSERT(ngtcp2_cid_eq(&fr.cid, &nfr.cid));
1111 CU_ASSERT(0 == memcmp(fr.stateless_reset_token, nfr.stateless_reset_token,
1112 sizeof(fr.stateless_reset_token)));
1113 }
1114
test_ngtcp2_pkt_encode_stop_sending_frame(void)1115 void test_ngtcp2_pkt_encode_stop_sending_frame(void) {
1116 uint8_t buf[16];
1117 ngtcp2_stop_sending fr, nfr;
1118 ngtcp2_ssize rv;
1119 size_t framelen = 1 + 8 + 4;
1120
1121 fr.type = NGTCP2_FRAME_STOP_SENDING;
1122 fr.stream_id = 0xf1f2f3f4u;
1123 fr.app_error_code = 0xe1e2u;
1124
1125 rv = ngtcp2_pkt_encode_stop_sending_frame(buf, sizeof(buf), &fr);
1126
1127 CU_ASSERT((ngtcp2_ssize)framelen == rv);
1128
1129 rv = ngtcp2_pkt_decode_stop_sending_frame(&nfr, buf, framelen);
1130
1131 CU_ASSERT((ngtcp2_ssize)framelen == rv);
1132 CU_ASSERT(fr.type == nfr.type);
1133 CU_ASSERT(fr.stream_id == nfr.stream_id);
1134 CU_ASSERT(fr.app_error_code == nfr.app_error_code);
1135 }
1136
test_ngtcp2_pkt_encode_path_challenge_frame(void)1137 void test_ngtcp2_pkt_encode_path_challenge_frame(void) {
1138 uint8_t buf[9];
1139 ngtcp2_path_challenge fr, nfr;
1140 ngtcp2_ssize rv;
1141 size_t framelen = 1 + 8;
1142 size_t i;
1143
1144 fr.type = NGTCP2_FRAME_PATH_CHALLENGE;
1145 for (i = 0; i < sizeof(fr.data); ++i) {
1146 fr.data[i] = (uint8_t)(i + 1);
1147 }
1148
1149 rv = ngtcp2_pkt_encode_path_challenge_frame(buf, sizeof(buf), &fr);
1150
1151 CU_ASSERT((ngtcp2_ssize)framelen == rv);
1152
1153 rv = ngtcp2_pkt_decode_path_challenge_frame(&nfr, buf, framelen);
1154
1155 CU_ASSERT((ngtcp2_ssize)framelen == rv);
1156 CU_ASSERT(fr.type == nfr.type);
1157 CU_ASSERT(0 == memcmp(fr.data, nfr.data, sizeof(fr.data)));
1158 }
1159
test_ngtcp2_pkt_encode_path_response_frame(void)1160 void test_ngtcp2_pkt_encode_path_response_frame(void) {
1161 uint8_t buf[9];
1162 ngtcp2_path_response fr, nfr;
1163 ngtcp2_ssize rv;
1164 size_t framelen = 1 + 8;
1165 size_t i;
1166
1167 fr.type = NGTCP2_FRAME_PATH_RESPONSE;
1168 for (i = 0; i < sizeof(fr.data); ++i) {
1169 fr.data[i] = (uint8_t)(i + 1);
1170 }
1171
1172 rv = ngtcp2_pkt_encode_path_response_frame(buf, sizeof(buf), &fr);
1173
1174 CU_ASSERT((ngtcp2_ssize)framelen == rv);
1175
1176 rv = ngtcp2_pkt_decode_path_response_frame(&nfr, buf, framelen);
1177
1178 CU_ASSERT((ngtcp2_ssize)framelen == rv);
1179 CU_ASSERT(fr.type == nfr.type);
1180 CU_ASSERT(0 == memcmp(fr.data, nfr.data, sizeof(fr.data)));
1181 }
1182
test_ngtcp2_pkt_encode_crypto_frame(void)1183 void test_ngtcp2_pkt_encode_crypto_frame(void) {
1184 const uint8_t data[] = "0123456789abcdef1";
1185 uint8_t buf[256];
1186 ngtcp2_frame fr, nfr;
1187 ngtcp2_ssize rv;
1188 size_t framelen;
1189
1190 fr.type = NGTCP2_FRAME_CRYPTO;
1191 fr.crypto.offset = 0x31f2f3f4f5f6f7f8llu;
1192 fr.crypto.datacnt = 1;
1193 fr.crypto.data[0].len = strsize(data);
1194 fr.crypto.data[0].base = (uint8_t *)data;
1195
1196 framelen = 1 + 8 + 1 + 17;
1197
1198 rv = ngtcp2_pkt_encode_crypto_frame(buf, sizeof(buf), &fr.crypto);
1199
1200 CU_ASSERT((ngtcp2_ssize)framelen == rv);
1201
1202 rv = ngtcp2_pkt_decode_crypto_frame(&nfr.crypto, buf, framelen);
1203
1204 CU_ASSERT((ngtcp2_ssize)framelen == rv);
1205 CU_ASSERT(fr.type == nfr.type);
1206 CU_ASSERT(fr.crypto.offset == nfr.crypto.offset);
1207 CU_ASSERT(fr.crypto.datacnt == nfr.crypto.datacnt);
1208 CU_ASSERT(fr.crypto.data[0].len == nfr.crypto.data[0].len);
1209 CU_ASSERT(0 == memcmp(fr.crypto.data[0].base, nfr.crypto.data[0].base,
1210 fr.crypto.data[0].len));
1211 }
1212
test_ngtcp2_pkt_encode_new_token_frame(void)1213 void test_ngtcp2_pkt_encode_new_token_frame(void) {
1214 const uint8_t token[] = "0123456789abcdef2";
1215 uint8_t buf[256];
1216 ngtcp2_frame fr, nfr;
1217 ngtcp2_ssize rv;
1218 size_t framelen;
1219
1220 fr.type = NGTCP2_FRAME_NEW_TOKEN;
1221 ngtcp2_vec_init(&fr.new_token.token, token, strsize(token));
1222
1223 framelen = 1 + 1 + strsize(token);
1224
1225 rv = ngtcp2_pkt_encode_new_token_frame(buf, sizeof(buf), &fr.new_token);
1226
1227 CU_ASSERT((ngtcp2_ssize)framelen == rv);
1228
1229 rv = ngtcp2_pkt_decode_new_token_frame(&nfr.new_token, buf, framelen);
1230
1231 CU_ASSERT((ngtcp2_ssize)framelen == rv);
1232 CU_ASSERT(fr.type == nfr.type);
1233 CU_ASSERT(fr.new_token.token.len == nfr.new_token.token.len);
1234 CU_ASSERT(0 == memcmp(fr.new_token.token.base, nfr.new_token.token.base,
1235 fr.new_token.token.len));
1236 }
1237
test_ngtcp2_pkt_encode_retire_connection_id_frame(void)1238 void test_ngtcp2_pkt_encode_retire_connection_id_frame(void) {
1239 uint8_t buf[256];
1240 ngtcp2_frame fr, nfr;
1241 ngtcp2_ssize rv;
1242 size_t framelen;
1243
1244 fr.type = NGTCP2_FRAME_RETIRE_CONNECTION_ID;
1245 fr.retire_connection_id.seq = 1000000007;
1246
1247 framelen = 1 + ngtcp2_put_varint_len(fr.retire_connection_id.seq);
1248
1249 rv = ngtcp2_pkt_encode_retire_connection_id_frame(buf, sizeof(buf),
1250 &fr.retire_connection_id);
1251
1252 CU_ASSERT((ngtcp2_ssize)framelen == rv);
1253
1254 rv = ngtcp2_pkt_decode_retire_connection_id_frame(&nfr.retire_connection_id,
1255 buf, framelen);
1256
1257 CU_ASSERT((ngtcp2_ssize)framelen == rv);
1258 CU_ASSERT(fr.type == nfr.type);
1259 CU_ASSERT(fr.retire_connection_id.seq == nfr.retire_connection_id.seq);
1260 }
1261
test_ngtcp2_pkt_encode_handshake_done_frame(void)1262 void test_ngtcp2_pkt_encode_handshake_done_frame(void) {
1263 uint8_t buf[16];
1264 ngtcp2_handshake_done fr, nfr;
1265 ngtcp2_ssize rv;
1266 size_t framelen = 1;
1267
1268 fr.type = NGTCP2_FRAME_HANDSHAKE_DONE;
1269
1270 rv = ngtcp2_pkt_encode_handshake_done_frame(buf, sizeof(buf), &fr);
1271
1272 CU_ASSERT((ngtcp2_ssize)framelen == rv);
1273
1274 rv = ngtcp2_pkt_decode_handshake_done_frame(&nfr, buf, framelen);
1275
1276 CU_ASSERT((ngtcp2_ssize)framelen == rv);
1277 CU_ASSERT(fr.type == nfr.type);
1278 }
1279
test_ngtcp2_pkt_encode_datagram_frame(void)1280 void test_ngtcp2_pkt_encode_datagram_frame(void) {
1281 const uint8_t data[] = "0123456789abcdef3";
1282 uint8_t buf[256];
1283 ngtcp2_frame fr, nfr;
1284 ngtcp2_ssize rv;
1285 size_t framelen;
1286
1287 fr.type = NGTCP2_FRAME_DATAGRAM_LEN;
1288 fr.datagram.datacnt = 1;
1289 fr.datagram.data = fr.datagram.rdata;
1290 fr.datagram.rdata[0].len = strsize(data);
1291 fr.datagram.rdata[0].base = (uint8_t *)data;
1292
1293 framelen = 1 + 1 + 17;
1294
1295 rv = ngtcp2_pkt_encode_datagram_frame(buf, sizeof(buf), &fr.datagram);
1296
1297 CU_ASSERT((ngtcp2_ssize)framelen == rv);
1298
1299 rv = ngtcp2_pkt_decode_datagram_frame(&nfr.datagram, buf, framelen);
1300
1301 CU_ASSERT((ngtcp2_ssize)framelen == rv);
1302 CU_ASSERT(fr.type == nfr.type);
1303 CU_ASSERT(fr.datagram.datacnt == nfr.datagram.datacnt);
1304 CU_ASSERT(fr.datagram.data->len == nfr.datagram.data->len);
1305 CU_ASSERT(0 == memcmp(fr.datagram.data->base, nfr.datagram.data->base,
1306 fr.datagram.data->len));
1307
1308 memset(&nfr, 0, sizeof(nfr));
1309
1310 /* Without length field */
1311 fr.type = NGTCP2_FRAME_DATAGRAM;
1312 fr.datagram.datacnt = 1;
1313 fr.datagram.data = fr.datagram.rdata;
1314 fr.datagram.rdata[0].len = strsize(data);
1315 fr.datagram.rdata[0].base = (uint8_t *)data;
1316
1317 framelen = 1 + 17;
1318
1319 rv = ngtcp2_pkt_encode_datagram_frame(buf, sizeof(buf), &fr.datagram);
1320
1321 CU_ASSERT((ngtcp2_ssize)framelen == rv);
1322
1323 rv = ngtcp2_pkt_decode_datagram_frame(&nfr.datagram, buf, framelen);
1324
1325 CU_ASSERT((ngtcp2_ssize)framelen == rv);
1326 CU_ASSERT(fr.type == nfr.type);
1327 CU_ASSERT(fr.datagram.datacnt == nfr.datagram.datacnt);
1328 CU_ASSERT(fr.datagram.data->len == nfr.datagram.data->len);
1329 CU_ASSERT(0 == memcmp(fr.datagram.data->base, nfr.datagram.data->base,
1330 fr.datagram.data->len));
1331
1332 memset(&nfr, 0, sizeof(nfr));
1333
1334 /* Zero length data with length field */
1335 fr.type = NGTCP2_FRAME_DATAGRAM_LEN;
1336 fr.datagram.datacnt = 0;
1337 fr.datagram.data = NULL;
1338
1339 framelen = 1 + 1;
1340
1341 rv = ngtcp2_pkt_encode_datagram_frame(buf, sizeof(buf), &fr.datagram);
1342
1343 CU_ASSERT((ngtcp2_ssize)framelen == rv);
1344
1345 rv = ngtcp2_pkt_decode_datagram_frame(&nfr.datagram, buf, framelen);
1346
1347 CU_ASSERT((ngtcp2_ssize)framelen == rv);
1348 CU_ASSERT(fr.type == nfr.type);
1349 CU_ASSERT(fr.datagram.datacnt == nfr.datagram.datacnt);
1350 CU_ASSERT(NULL == nfr.datagram.data);
1351
1352 /* Zero length data without length field */
1353 fr.type = NGTCP2_FRAME_DATAGRAM;
1354 fr.datagram.datacnt = 0;
1355 fr.datagram.data = NULL;
1356
1357 framelen = 1;
1358
1359 rv = ngtcp2_pkt_encode_datagram_frame(buf, sizeof(buf), &fr.datagram);
1360
1361 CU_ASSERT((ngtcp2_ssize)framelen == rv);
1362
1363 rv = ngtcp2_pkt_decode_datagram_frame(&nfr.datagram, buf, framelen);
1364
1365 CU_ASSERT((ngtcp2_ssize)framelen == rv);
1366 CU_ASSERT(fr.type == nfr.type);
1367 CU_ASSERT(fr.datagram.datacnt == nfr.datagram.datacnt);
1368 CU_ASSERT(NULL == nfr.datagram.data);
1369 }
1370
test_ngtcp2_pkt_adjust_pkt_num(void)1371 void test_ngtcp2_pkt_adjust_pkt_num(void) {
1372 CU_ASSERT(0xaa831f94llu ==
1373 ngtcp2_pkt_adjust_pkt_num(0xaa82f30ellu, 0x1f94, 16));
1374
1375 CU_ASSERT(0xff == ngtcp2_pkt_adjust_pkt_num(0x0100, 0xff, 8));
1376 CU_ASSERT(0x01ff == ngtcp2_pkt_adjust_pkt_num(0x01ff, 0xff, 8));
1377 CU_ASSERT(0x0fff == ngtcp2_pkt_adjust_pkt_num(0x1000, 0xff, 8));
1378 CU_ASSERT(0x80 == ngtcp2_pkt_adjust_pkt_num(0x00, 0x80, 8));
1379 CU_ASSERT(0x3fffffffffffffabllu ==
1380 ngtcp2_pkt_adjust_pkt_num(NGTCP2_MAX_PKT_NUM, 0xab, 8));
1381 CU_ASSERT(0x4000000000000000llu ==
1382 ngtcp2_pkt_adjust_pkt_num(NGTCP2_MAX_PKT_NUM, 0x00, 8));
1383 CU_ASSERT(250 == ngtcp2_pkt_adjust_pkt_num(255, 250, 8));
1384 CU_ASSERT(8 == ngtcp2_pkt_adjust_pkt_num(50, 8, 8));
1385 CU_ASSERT(0 == ngtcp2_pkt_adjust_pkt_num(-1, 0, 8));
1386 }
1387
test_ngtcp2_pkt_validate_ack(void)1388 void test_ngtcp2_pkt_validate_ack(void) {
1389 int rv;
1390 ngtcp2_ack fr;
1391
1392 /* too long first_ack_blklen */
1393 fr.largest_ack = 1;
1394 fr.first_ack_blklen = 2;
1395 fr.num_blks = 0;
1396
1397 rv = ngtcp2_pkt_validate_ack(&fr);
1398
1399 CU_ASSERT(NGTCP2_ERR_ACK_FRAME == rv);
1400
1401 /* gap is too large */
1402 fr.largest_ack = 250;
1403 fr.first_ack_blklen = 1;
1404 fr.num_blks = 1;
1405 fr.blks[0].gap = 248;
1406 fr.blks[0].blklen = 0;
1407
1408 rv = ngtcp2_pkt_validate_ack(&fr);
1409
1410 CU_ASSERT(NGTCP2_ERR_ACK_FRAME == rv);
1411
1412 /* too large blklen */
1413 fr.largest_ack = 250;
1414 fr.first_ack_blklen = 0;
1415 fr.num_blks = 1;
1416 fr.blks[0].gap = 248;
1417 fr.blks[0].blklen = 1;
1418
1419 rv = ngtcp2_pkt_validate_ack(&fr);
1420
1421 CU_ASSERT(NGTCP2_ERR_ACK_FRAME == rv);
1422 }
1423
test_ngtcp2_pkt_write_stateless_reset(void)1424 void test_ngtcp2_pkt_write_stateless_reset(void) {
1425 uint8_t buf[256];
1426 ngtcp2_ssize spktlen;
1427 uint8_t token[NGTCP2_STATELESS_RESET_TOKENLEN];
1428 uint8_t rand[256];
1429 size_t i;
1430 uint8_t *p;
1431 size_t randlen;
1432
1433 memset(rand, 0, sizeof(rand));
1434 for (i = 0; i < NGTCP2_STATELESS_RESET_TOKENLEN; ++i) {
1435 token[i] = (uint8_t)(i + 1);
1436 }
1437
1438 spktlen = ngtcp2_pkt_write_stateless_reset(buf, sizeof(buf), token, rand,
1439 sizeof(rand));
1440
1441 p = buf;
1442
1443 CU_ASSERT(256 == spktlen);
1444 CU_ASSERT(0 == (*p & NGTCP2_HEADER_FORM_BIT));
1445 CU_ASSERT((*p & NGTCP2_FIXED_BIT_MASK));
1446
1447 ++p;
1448
1449 randlen = (size_t)(spktlen - (p - buf) - NGTCP2_STATELESS_RESET_TOKENLEN);
1450
1451 CU_ASSERT(0 == memcmp(rand, p, randlen));
1452
1453 p += randlen;
1454
1455 CU_ASSERT(0 == memcmp(token, p, NGTCP2_STATELESS_RESET_TOKENLEN));
1456
1457 p += NGTCP2_STATELESS_RESET_TOKENLEN;
1458
1459 CU_ASSERT(spktlen == p - buf);
1460
1461 /* Not enough buffer */
1462 spktlen = ngtcp2_pkt_write_stateless_reset(
1463 buf,
1464 NGTCP2_MIN_STATELESS_RESET_RANDLEN - 1 + NGTCP2_STATELESS_RESET_TOKENLEN,
1465 token, rand, sizeof(rand));
1466
1467 CU_ASSERT(NGTCP2_ERR_NOBUF == spktlen);
1468 }
1469
test_ngtcp2_pkt_write_retry(void)1470 void test_ngtcp2_pkt_write_retry(void) {
1471 uint8_t buf[256];
1472 ngtcp2_ssize spktlen;
1473 ngtcp2_cid scid, dcid, odcid;
1474 ngtcp2_pkt_hd nhd;
1475 uint8_t token[32];
1476 size_t i;
1477 ngtcp2_pkt_retry retry;
1478 ngtcp2_ssize nread;
1479 int rv;
1480 ngtcp2_crypto_aead aead = {0};
1481 ngtcp2_crypto_aead_ctx aead_ctx = {0};
1482 uint8_t tag[NGTCP2_RETRY_TAGLEN] = {0};
1483
1484 scid_init(&scid);
1485 dcid_init(&dcid);
1486 rcid_init(&odcid);
1487
1488 for (i = 0; i < sizeof(token); ++i) {
1489 token[i] = (uint8_t)i;
1490 }
1491
1492 spktlen = ngtcp2_pkt_write_retry(buf, sizeof(buf), NGTCP2_PROTO_VER_MAX,
1493 &dcid, &scid, &odcid, token, sizeof(token),
1494 null_retry_encrypt, &aead, &aead_ctx);
1495
1496 CU_ASSERT(spktlen > 0);
1497
1498 memset(&nhd, 0, sizeof(nhd));
1499
1500 nread = ngtcp2_pkt_decode_hd_long(&nhd, buf, (size_t)spktlen);
1501
1502 CU_ASSERT(nread > 0);
1503 CU_ASSERT(NGTCP2_PKT_RETRY == nhd.type);
1504 CU_ASSERT(NGTCP2_PROTO_VER_MAX == nhd.version);
1505 CU_ASSERT(ngtcp2_cid_eq(&dcid, &nhd.dcid));
1506 CU_ASSERT(ngtcp2_cid_eq(&scid, &nhd.scid));
1507
1508 rv = ngtcp2_pkt_decode_retry(&retry, buf + nread, (size_t)(spktlen - nread));
1509
1510 CU_ASSERT(0 == rv);
1511 CU_ASSERT(sizeof(token) == retry.token.len);
1512 CU_ASSERT(0 == memcmp(token, retry.token.base, sizeof(token)));
1513 CU_ASSERT(0 == memcmp(tag, retry.tag, sizeof(tag)));
1514 }
1515
test_ngtcp2_pkt_write_version_negotiation(void)1516 void test_ngtcp2_pkt_write_version_negotiation(void) {
1517 uint8_t buf[256];
1518 ngtcp2_ssize spktlen;
1519 const uint32_t sv[] = {0xf1f2f3f4, 0x1f2f3f4f};
1520 uint8_t *p;
1521 size_t i;
1522 ngtcp2_cid dcid, scid;
1523
1524 dcid_init(&dcid);
1525 scid_init(&scid);
1526
1527 spktlen = ngtcp2_pkt_write_version_negotiation(
1528 buf, sizeof(buf), 133, dcid.data, dcid.datalen, scid.data, scid.datalen,
1529 sv, arraylen(sv));
1530
1531 CU_ASSERT((ngtcp2_ssize)(1 + 4 + 1 + dcid.datalen + 1 + scid.datalen +
1532 arraylen(sv) * 4) == spktlen);
1533
1534 p = buf;
1535
1536 CU_ASSERT((0x80 | 133) == buf[0]);
1537
1538 ++p;
1539
1540 CU_ASSERT(0 == ngtcp2_get_uint32(p));
1541
1542 p += sizeof(uint32_t);
1543
1544 CU_ASSERT(dcid.datalen == *p);
1545
1546 ++p;
1547
1548 CU_ASSERT(0 == memcmp(dcid.data, p, dcid.datalen));
1549
1550 p += dcid.datalen;
1551
1552 CU_ASSERT(scid.datalen == *p);
1553
1554 ++p;
1555
1556 CU_ASSERT(0 == memcmp(scid.data, p, scid.datalen));
1557
1558 p += scid.datalen;
1559
1560 for (i = 0; i < arraylen(sv); ++i, p += 4) {
1561 CU_ASSERT(sv[i] == ngtcp2_get_uint32(p));
1562 }
1563 }
1564
test_ngtcp2_pkt_stream_max_datalen(void)1565 void test_ngtcp2_pkt_stream_max_datalen(void) {
1566 size_t len;
1567
1568 len = ngtcp2_pkt_stream_max_datalen(63, 0, 0, 2);
1569
1570 CU_ASSERT((size_t)-1 == len);
1571
1572 len = ngtcp2_pkt_stream_max_datalen(63, 0, 0, 3);
1573
1574 CU_ASSERT(0 == len);
1575
1576 len = ngtcp2_pkt_stream_max_datalen(63, 0, 1, 3);
1577
1578 CU_ASSERT(0 == len);
1579
1580 len = ngtcp2_pkt_stream_max_datalen(63, 0, 1, 4);
1581
1582 CU_ASSERT(1 == len);
1583
1584 len = ngtcp2_pkt_stream_max_datalen(63, 1, 1, 4);
1585
1586 CU_ASSERT(0 == len);
1587
1588 len = ngtcp2_pkt_stream_max_datalen(63, 0, 63, 66);
1589
1590 CU_ASSERT(63 == len);
1591
1592 len = ngtcp2_pkt_stream_max_datalen(63, 0, 63, 65);
1593
1594 CU_ASSERT(62 == len);
1595
1596 len = ngtcp2_pkt_stream_max_datalen(63, 0, 1396, 1400);
1597
1598 CU_ASSERT(1396 == len);
1599
1600 len = ngtcp2_pkt_stream_max_datalen(63, 0, 1396, 1399);
1601
1602 CU_ASSERT(1395 == len);
1603
1604 len = ngtcp2_pkt_stream_max_datalen(63, 0, 1396, 9);
1605
1606 CU_ASSERT(6 == len);
1607
1608 len = ngtcp2_pkt_stream_max_datalen(63, 0, 16385, 16391);
1609
1610 CU_ASSERT(16385 == len);
1611
1612 len = ngtcp2_pkt_stream_max_datalen(63, 0, 16385, 16390);
1613
1614 CU_ASSERT(16384 == len);
1615
1616 len = ngtcp2_pkt_stream_max_datalen(63, 0, 1073741824, 1073741834);
1617
1618 CU_ASSERT(1073741824 == len);
1619
1620 len = ngtcp2_pkt_stream_max_datalen(63, 0, 1073741824, 1073741833);
1621
1622 CU_ASSERT(1073741823 == len);
1623
1624 len = ngtcp2_pkt_stream_max_datalen(63, 0, 16383, 16387);
1625
1626 CU_ASSERT(16383 == len);
1627 }
1628