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