Branch data Line data Source code
1 : : /*
2 : : Copyright (c) 2022 Eriptic Technologies. See the COPYRIGHT
3 : : file at the top-level directory of this distribution.
4 : :
5 : : Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 : : http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 : : <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 : : option. This file may not be copied, modified, or distributed
9 : : except according to those terms.
10 : : */
11 : :
12 : : #include <string.h>
13 : :
14 : : #include <zephyr/kernel.h>
15 : : #include <zephyr/ztest.h>
16 : :
17 : : #include "common/byte_array.h"
18 : : #include "common/unit_test.h"
19 : :
20 : : #include "oscore/oscore_coap.h"
21 : : #include "oscore/option.h"
22 : :
23 : 0 : static void coap_get_message_type_and_compare(struct o_coap_packet * coap_packet, enum o_coap_msg * msg_type, enum err expected_result, enum o_coap_msg expected_msg_type)
24 : : {
25 : 0 : PRINTF("coap_get_message_type; expected result = %d\n", expected_result);
26 : 0 : enum err result = coap_get_message_type(coap_packet, msg_type);
27 : 0 : zassert_equal(expected_result, result, "unexpected result: %d", result);
28 : :
29 [ # # ]: 0 : if (ok == result)
30 : : {
31 : 0 : zassert_equal(*msg_type, expected_msg_type, "");
32 : : }
33 : 0 : }
34 : :
35 : 0 : static struct o_coap_packet generate_test_packet(uint8_t code, uint8_t options_count, uint8_t * observe_value, uint16_t observe_len)
36 : : {
37 : 0 : struct o_coap_packet result;
38 : 0 : result.header.code = code;
39 : 0 : result.options_cnt = options_count;
40 : 0 : result.options[0].option_number = OBSERVE;
41 : 0 : result.options[0].value = observe_value;
42 : 0 : result.options[0].len = observe_len;
43 : 0 : return result;
44 : : };
45 : :
46 : 13 : static void serialization_test(struct o_coap_option *options, uint8_t opt_cnt,
47 : : struct byte_array *expected)
48 : 13 : {
49 : 13 : uint8_t out_buf[expected->len];
50 : 13 : struct byte_array out = BYTE_ARRAY_INIT(out_buf, sizeof(out_buf));
51 : :
52 : 13 : enum err r = options_serialize(options, opt_cnt, &out);
53 : 13 : zassert_equal(r, ok, "Error in options_serialize. r: %d", r);
54 : :
55 : 13 : PRINT_ARRAY("computed", out.ptr, out.len);
56 : 13 : PRINT_ARRAY("expected", expected->ptr, expected->len);
57 : :
58 : 13 : zassert_mem_equal__(out.ptr, expected->ptr, expected->len,
59 : : "serialization incorrect");
60 : 13 : }
61 : :
62 : 13 : static void deserialization_test(uint8_t *in_data, uint16_t in_data_len,
63 : : struct o_coap_option *options,
64 : : uint32_t options_len_in_byte)
65 : : {
66 : 13 : struct o_coap_packet coap_pkt;
67 : 13 : struct byte_array d = BYTE_ARRAY_INIT(in_data, in_data_len);
68 : 13 : enum err r =
69 : 13 : options_deserialize(&d,
70 : : (struct o_coap_option *)&coap_pkt.options,
71 : : &coap_pkt.options_cnt, &coap_pkt.payload);
72 : :
73 : 13 : zassert_equal(r, ok, "Error in options_deserialize. r: %d", r);
74 : :
75 [ + + ]: 32 : for (uint8_t i = 0; i < coap_pkt.options_cnt; i++) {
76 : 19 : zassert_equal(options[i].delta, coap_pkt.options[i].delta,
77 : : "delta mismatch: %d", coap_pkt.options[i].delta);
78 : 19 : zassert_equal(options[i].len, coap_pkt.options[i].len,
79 : : "len mismatch: %d", coap_pkt.options[i].len);
80 : 19 : zassert_equal(options[i].option_number,
81 : : coap_pkt.options[i].option_number,
82 : : "option_number mismatch: %d",
83 : : coap_pkt.options[i].option_number);
84 : 19 : zassert_mem_equal__(options[i].value, coap_pkt.options[i].value,
85 : : options[i].len, "option value mismatch");
86 : : }
87 : 13 : }
88 : :
89 : 1 : void t200_options_serialize_deserialize(void)
90 : : {
91 : : /*
92 : : * two options
93 : : * short delta (delta < 12)
94 : : * short data length (length < 12)
95 : : */
96 : 1 : uint8_t uri_host_val[] = { 'c', 'o', 'a', 'p', '.', 'm', 'e' };
97 : 1 : uint8_t uri_path_val[] = { 't', 'e', 's', 't' };
98 : 1 : struct o_coap_option options[] = { { .delta = 3,
99 : : .len = sizeof(uri_host_val),
100 : : .value = uri_host_val,
101 : : .option_number = URI_HOST },
102 : : { .delta = 8,
103 : : .len = sizeof(uri_path_val),
104 : : .value = uri_path_val,
105 : : .option_number = URI_PATH } };
106 : :
107 : 1 : uint8_t EXPECTED[] = {
108 : : 0x37, 0x63, 0x6f, 0x61, 0x70, 0x2e, 0x6d,
109 : : 0x65, 0x84, 0x74, 0x65, 0x73, 0x74,
110 : : };
111 : 1 : struct byte_array expt = BYTE_ARRAY_INIT(EXPECTED, sizeof(EXPECTED));
112 : :
113 : 1 : serialization_test(options, sizeof(options) / sizeof(options[0]),
114 : : &expt);
115 : :
116 : 1 : deserialization_test(EXPECTED, sizeof(EXPECTED), options,
117 : : sizeof(options));
118 : :
119 : : /*
120 : : * four options
121 : : * short delta (delta < 12)
122 : : * short data length (length < 12)
123 : : */
124 : 1 : uint8_t location_path1[] = {
125 : : 'l', 'o', 'c', 'a', 't', 'i', 'o', 'n', '1'
126 : : };
127 : 1 : uint8_t location_path2[] = {
128 : : 'l', 'o', 'c', 'a', 't', 'i', 'o', 'n', '2'
129 : : };
130 : 1 : uint8_t location_path3[] = {
131 : : 'l', 'o', 'c', 'a', 't', 'i', 'o', 'n', '3'
132 : : };
133 : 1 : struct o_coap_option options1[] = { { .delta = 8,
134 : : .len = sizeof(location_path1),
135 : : .value = location_path1,
136 : : .option_number = LOCATION_PATH },
137 : : { .delta = 0,
138 : : .len = sizeof(location_path2),
139 : : .value = location_path2,
140 : : .option_number = LOCATION_PATH },
141 : : { .delta = 0,
142 : : .len = sizeof(location_path3),
143 : : .value = location_path3,
144 : : .option_number = LOCATION_PATH },
145 : : { .delta = 4,
146 : : .len = 0,
147 : : .value = NULL,
148 : : .option_number =
149 : : CONTENT_FORMAT } };
150 : :
151 : 1 : uint8_t EXPECTED1[] = { 0x89, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f,
152 : : 0x6e, 0x31, 0x09, 0x6c, 0x6f, 0x63, 0x61, 0x74,
153 : : 0x69, 0x6f, 0x6e, 0x32, 0x09, 0x6c, 0x6f, 0x63,
154 : : 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x33, 0x40 };
155 : :
156 : 1 : struct byte_array expt1 = BYTE_ARRAY_INIT(EXPECTED1, sizeof(EXPECTED1));
157 : :
158 : 1 : serialization_test(options1, sizeof(options1) / sizeof(options1[0]),
159 : : &expt1);
160 : :
161 : 1 : deserialization_test(EXPECTED1, sizeof(EXPECTED1), options1,
162 : : sizeof(options1));
163 : :
164 : : /*
165 : : * three options
166 : : * opt1 and opt2 short delta (delta < 12)
167 : : * opt3 delta 16
168 : : * short data length (length < 12)
169 : : */
170 : 1 : uint8_t uri_host_val2[] = { 'c', 'o', 'a', 'p', '.', 'm', 'e' };
171 : 1 : uint8_t uri_path_val2[] = { 'l', 'a', 'r', 'g', 'e', '-',
172 : : 'u', 'p', 'd', 'a', 't', 'e' };
173 : 1 : uint8_t block1_val[] = { 0x06 };
174 : 1 : struct o_coap_option options2[] = { { .delta = 3,
175 : : .len = sizeof(uri_host_val2),
176 : : .value = uri_host_val,
177 : : .option_number = URI_HOST },
178 : : { .delta = 8,
179 : : .len = sizeof(uri_path_val2),
180 : : .value = uri_path_val2,
181 : : .option_number = URI_PATH },
182 : : { .delta = 16,
183 : : .len = sizeof(block1_val),
184 : : .value = block1_val,
185 : : .option_number = BLOCK1 } };
186 : 1 : uint8_t EXPECTED2[] = { 0x37, 0x63, 0x6f, 0x61, 0x70, 0x2e, 0x6d, 0x65,
187 : : 0x8c, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x2d, 0x75,
188 : : 0x70, 0x64, 0x61, 0x74, 0x65, 0xd1, 0x03, 0x06 };
189 : :
190 : 1 : struct byte_array expt2 = BYTE_ARRAY_INIT(EXPECTED2, sizeof(EXPECTED2));
191 : :
192 : 1 : serialization_test(options2, sizeof(options2) / sizeof(options2[0]),
193 : : &expt2);
194 : 1 : deserialization_test(EXPECTED2, sizeof(EXPECTED2), options2,
195 : : sizeof(options2));
196 : :
197 : : /*
198 : : * one option
199 : : * opt3 delta 13
200 : : * short data length (length < 12)
201 : : */
202 : 1 : uint8_t block1_val3[] = { 0x06 };
203 : 1 : struct o_coap_option options3[] = { { .delta = 27,
204 : : .len = sizeof(block1_val3),
205 : : .value = block1_val3,
206 : : .option_number = BLOCK1 } };
207 : 1 : uint8_t EXPECTED3[] = { 0xd1, 0x0e, 0x06 };
208 : :
209 : 1 : struct byte_array expt3 = BYTE_ARRAY_INIT(EXPECTED3, sizeof(EXPECTED3));
210 : 1 : serialization_test(options3, sizeof(options3) / sizeof(options3[0]),
211 : : &expt3);
212 : 1 : deserialization_test(EXPECTED3, sizeof(EXPECTED3), options3,
213 : : sizeof(options3));
214 : :
215 : : /*
216 : : * one option
217 : : * delta 15
218 : : * length 0
219 : : */
220 : 1 : struct o_coap_option options4[] = { { .delta = 20,
221 : : .len = 0,
222 : : .value = NULL,
223 : : .option_number =
224 : : LOCATION_QUERY } };
225 : 1 : uint8_t EXPECTED4[] = { 0xd0, 0x07 };
226 : :
227 : 1 : struct byte_array expt4 = BYTE_ARRAY_INIT(EXPECTED4, sizeof(EXPECTED4));
228 : 1 : serialization_test(options4, sizeof(options4) / sizeof(options4[0]),
229 : : &expt4);
230 : 1 : deserialization_test(EXPECTED4, sizeof(EXPECTED4), options4,
231 : : sizeof(options4));
232 : :
233 : : /*
234 : : * one option
235 : : * delta 780
236 : : * length 0
237 : : */
238 : 1 : struct o_coap_option options5[] = {
239 : : { .delta = 780, .len = 0, .value = NULL, .option_number = 780 }
240 : : }; //there is no such option actually;)
241 : 1 : uint8_t EXPECTED5[] = { 0xe0, 0x01, 0xff };
242 : :
243 : 1 : struct byte_array expt5 = BYTE_ARRAY_INIT(EXPECTED5, sizeof(EXPECTED5));
244 : 1 : serialization_test(options5, sizeof(options5) / sizeof(options5[0]),
245 : : &expt5);
246 : 1 : deserialization_test(EXPECTED5, sizeof(EXPECTED5), options5,
247 : : sizeof(options5));
248 : :
249 : : /*
250 : : * one option
251 : : * delta 280
252 : : * length 500
253 : : */
254 : 1 : uint8_t val7[500];
255 : 1 : memset(val7, 0, sizeof(val7));
256 : 1 : struct o_coap_option options7[] = { { .delta = 280,
257 : : .len = sizeof(val7),
258 : : .value = val7,
259 : : .option_number = 280 } };
260 : :
261 : 1 : uint8_t EXPECTED7[505];
262 : 1 : memset(EXPECTED7, 0, sizeof(EXPECTED7));
263 : 1 : EXPECTED7[0] = 0xee;
264 : 1 : EXPECTED7[1] = 0x00;
265 : 1 : EXPECTED7[2] = 0x0b;
266 : 1 : EXPECTED7[3] = 0x00;
267 : 1 : EXPECTED7[4] = 0xe7;
268 : :
269 : 1 : struct byte_array expt7 = BYTE_ARRAY_INIT(EXPECTED7, sizeof(EXPECTED7));
270 : 1 : serialization_test(options7, sizeof(options7) / sizeof(options7[0]),
271 : : &expt7);
272 : 1 : deserialization_test(EXPECTED7, sizeof(EXPECTED7), options7,
273 : : sizeof(options7));
274 : :
275 : : /*
276 : : * one option
277 : : * delta 22
278 : : * length 500
279 : : */
280 : 1 : uint8_t val8[500];
281 : 1 : memset(val8, 0, sizeof(val8));
282 : 1 : struct o_coap_option options8[] = { { .delta = 22,
283 : : .len = sizeof(val8),
284 : : .value = val8,
285 : : .option_number = 22 } };
286 : :
287 : 1 : uint8_t EXPECTED8[504];
288 : 1 : memset(EXPECTED8, 0, sizeof(EXPECTED8));
289 : 1 : EXPECTED8[0] = 0xde;
290 : 1 : EXPECTED8[1] = 0x09;
291 : 1 : EXPECTED8[2] = 0x00;
292 : 1 : EXPECTED8[3] = 0xe7;
293 : :
294 : 1 : struct byte_array expt8 = BYTE_ARRAY_INIT(EXPECTED8, sizeof(EXPECTED8));
295 : 1 : serialization_test(options8, sizeof(options8) / sizeof(options8[0]),
296 : : &expt8);
297 : 1 : deserialization_test(EXPECTED8, sizeof(EXPECTED8), options8,
298 : : sizeof(options8));
299 : : /*
300 : : * one option
301 : : * delta 7
302 : : * length 500
303 : : */
304 : 1 : uint8_t val9[500];
305 : 1 : memset(val9, 0, sizeof(val9));
306 : 1 : struct o_coap_option options9[] = { { .delta = 7,
307 : : .len = sizeof(val9),
308 : : .value = val9,
309 : : .option_number = 7 } };
310 : :
311 : 1 : uint8_t EXPECTED9[503];
312 : 1 : memset(EXPECTED9, 0, sizeof(EXPECTED9));
313 : 1 : EXPECTED9[0] = 0x7e;
314 : 1 : EXPECTED9[1] = 0x00;
315 : 1 : EXPECTED9[2] = 0xe7;
316 : :
317 : 1 : struct byte_array expt9 = BYTE_ARRAY_INIT(EXPECTED9, sizeof(EXPECTED9));
318 : 1 : serialization_test(options9, sizeof(options9) / sizeof(options9[0]),
319 : : &expt9);
320 : 1 : deserialization_test(EXPECTED9, sizeof(EXPECTED9), options9,
321 : : sizeof(options9));
322 : : /*
323 : : * one option
324 : : * delta 500
325 : : * length 20
326 : : */
327 : 1 : uint8_t val10[20];
328 : 1 : memset(val10, 0, sizeof(val10));
329 : 1 : struct o_coap_option options10[] = { { .delta = 500,
330 : : .len = sizeof(val10),
331 : : .value = val10,
332 : : .option_number = 500 } };
333 : :
334 : 1 : uint8_t EXPECTED10[24];
335 : 1 : memset(EXPECTED10, 0, sizeof(EXPECTED10));
336 : 1 : EXPECTED10[0] = 0xed;
337 : 1 : EXPECTED10[1] = 0x00;
338 : 1 : EXPECTED10[2] = 0xe7;
339 : 1 : EXPECTED10[3] = 0x07;
340 : :
341 : 1 : struct byte_array expt10 =
342 : : BYTE_ARRAY_INIT(EXPECTED10, sizeof(EXPECTED10));
343 : 1 : serialization_test(options10, sizeof(options10) / sizeof(options10[0]),
344 : : &expt10);
345 : 1 : deserialization_test(EXPECTED10, sizeof(EXPECTED10), options10,
346 : : sizeof(options10));
347 : : /*
348 : : * one option
349 : : * delta 20
350 : : * length 20
351 : : */
352 : 1 : uint8_t val11[20];
353 : 1 : memset(val11, 0, sizeof(val11));
354 : 1 : struct o_coap_option options11[] = { { .delta = 20,
355 : : .len = sizeof(val11),
356 : : .value = val11,
357 : : .option_number = 20 } };
358 : :
359 : 1 : uint8_t EXPECTED11[23];
360 : 1 : memset(EXPECTED11, 0, sizeof(EXPECTED11));
361 : 1 : EXPECTED11[0] = 0xdd;
362 : 1 : EXPECTED11[1] = 0x07;
363 : 1 : EXPECTED11[2] = 0x07;
364 : :
365 : 1 : struct byte_array expt11 =
366 : : BYTE_ARRAY_INIT(EXPECTED11, sizeof(EXPECTED11));
367 : 1 : serialization_test(options11, sizeof(options11) / sizeof(options11[0]),
368 : : &expt11);
369 : 1 : deserialization_test(EXPECTED11, sizeof(EXPECTED11), options11,
370 : : sizeof(options11));
371 : : /*
372 : : * one option
373 : : * delta 4
374 : : * length 20
375 : : */
376 : 1 : uint8_t val12[20];
377 : 1 : memset(val12, 0, sizeof(val12));
378 : 1 : struct o_coap_option options12[] = { { .delta = 4,
379 : : .len = sizeof(val12),
380 : : .value = val12,
381 : : .option_number = 4 } };
382 : :
383 : 1 : uint8_t EXPECTED12[22];
384 : 1 : memset(EXPECTED12, 0, sizeof(EXPECTED12));
385 : 1 : EXPECTED12[0] = 0x4d;
386 : 1 : EXPECTED12[1] = 0x07;
387 : :
388 : 1 : struct byte_array expt12 =
389 : : BYTE_ARRAY_INIT(EXPECTED12, sizeof(EXPECTED12));
390 : 1 : serialization_test(options12, sizeof(options12) / sizeof(options12[0]),
391 : : &expt12);
392 : 1 : deserialization_test(EXPECTED12, sizeof(EXPECTED12), options12,
393 : : sizeof(options12));
394 : :
395 : : /*
396 : : * one option
397 : : * delta 252
398 : : * length 12
399 : : */
400 : 1 : uint8_t val13[] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
401 : : 0x06, 0x07, 0x08, 0x09, 0x10, 0x11 };
402 : 1 : struct o_coap_option options13[] = { { .delta = 252,
403 : : .len = sizeof(val13),
404 : : .value = val13,
405 : : .option_number = ECHO } };
406 : 1 : uint8_t EXPECTED13[] = { 0xdc, 0xef, 0x00, 0x01, 0x02, 0x03, 0x04,
407 : : 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11 };
408 : :
409 : 1 : struct byte_array expt13 =
410 : : BYTE_ARRAY_INIT(EXPECTED13, sizeof(EXPECTED13));
411 : 1 : serialization_test(options13, sizeof(options13) / sizeof(options13[0]),
412 : : &expt13);
413 : 1 : deserialization_test(EXPECTED13, sizeof(EXPECTED13), options13,
414 : : sizeof(options13));
415 : 1 : }
416 : :
417 : 1 : void t201_coap_serialize_deserialize(void)
418 : : {
419 : 1 : enum err r;
420 : : /*test malformed input data*/
421 : 1 : struct byte_array in = BYTE_ARRAY_INIT(NULL, 0);
422 : 1 : struct o_coap_packet out;
423 : :
424 : 1 : r = coap_deserialize(&in, &out);
425 : 1 : zassert_equal(r, not_valid_input_packet,
426 : : "Error in coap_deserialize. r: %d", r);
427 : :
428 : : /*test no token*/
429 : 1 : uint8_t in_buf[] = { 0x40, 0x00, 0x00, 0x00 };
430 : 1 : in.ptr = in_buf;
431 : 1 : in.len = sizeof(in_buf);
432 : :
433 : 1 : r = coap_deserialize(&in, &out);
434 : 1 : zassert_equal(r, ok, "Error in coap_deserialize. r: %d", r);
435 : 1 : zassert_is_null(out.token, "invalid token");
436 : 1 : zassert_equal(out.header.TKL, 0, "invalid TKL");
437 : :
438 : 1 : uint8_t ser_dat[sizeof(in_buf)];
439 : 1 : uint32_t ser_dat_len = 0;
440 : 1 : r = coap_serialize(&out, (uint8_t *)&ser_dat, &ser_dat_len);
441 : 1 : zassert_equal(r, ok, "Error in coap_deserialize. r: %d", r);
442 : 1 : zassert_equal(ser_dat_len, sizeof(in_buf), "wrong ser_dat_len");
443 : 1 : zassert_mem_equal__(ser_dat, in_buf, ser_dat_len, "wrong ser_dat");
444 : :
445 : : /*test too long token*/
446 : 1 : uint8_t in_buf_too_long_tkl[] = { 0x4F, 0x00, 0x00, 0x00 };
447 : 1 : in.ptr = in_buf_too_long_tkl;
448 : 1 : in.len = sizeof(in_buf_too_long_tkl);
449 : :
450 : 1 : r = coap_deserialize(&in, &out);
451 : 1 : zassert_equal(r, oscore_inpkt_invalid_tkl,
452 : : "Error in coap_deserialize. r: %d", r);
453 : :
454 : : /*test valid tkl but no payload*/
455 : 1 : uint8_t in_buf_valid_tkl_no_payload[] = { 0x41, 0x00, 0x00, 0x00 };
456 : 1 : in.ptr = in_buf_valid_tkl_no_payload;
457 : 1 : in.len = sizeof(in_buf_valid_tkl_no_payload);
458 : :
459 : 1 : r = coap_deserialize(&in, &out);
460 : 1 : zassert_equal(r, oscore_inpkt_invalid_tkl,
461 : : "Error in coap_deserialize. r: %d", r);
462 : 1 : }
463 : :
464 : 1 : void t202_options_deserialize_corner_cases(void)
465 : : {
466 : 1 : enum err r;
467 : 1 : struct o_coap_packet coap_pkt;
468 : :
469 : : /*test only payload marker no payload*/
470 : 1 : uint8_t in_data1[] = { 0xff };
471 : 1 : struct byte_array d1 = BYTE_ARRAY_INIT(in_data1, sizeof(in_data1));
472 : :
473 : 1 : r = options_deserialize(&d1, (struct o_coap_option *)&coap_pkt.options,
474 : : &coap_pkt.options_cnt, &coap_pkt.payload);
475 : :
476 : 1 : zassert_equal(r, not_valid_input_packet,
477 : : "Error in options_deserialize. r: %d", r);
478 : :
479 : : /*test invalid delta*/
480 : 1 : uint8_t in_data2[] = { 0xf0 }; //delta is 15 -> not a valid value
481 : 1 : struct byte_array d2 = BYTE_ARRAY_INIT(in_data2, sizeof(in_data2));
482 : :
483 : 1 : r = options_deserialize(&d2, (struct o_coap_option *)&coap_pkt.options,
484 : : &coap_pkt.options_cnt, &coap_pkt.payload);
485 : :
486 : 1 : zassert_equal(r, oscore_inpkt_invalid_option_delta,
487 : : "Error in options_deserialize. r: %d", r);
488 : :
489 : : /*test invalid len*/
490 : 1 : uint8_t in_data3[] = { 0x0f }; //len is 15 -> not a valid value
491 : 1 : struct byte_array d3 = BYTE_ARRAY_INIT(in_data3, sizeof(in_data3));
492 : :
493 : 1 : r = options_deserialize(&d3, (struct o_coap_option *)&coap_pkt.options,
494 : : &coap_pkt.options_cnt, &coap_pkt.payload);
495 : :
496 : 1 : zassert_equal(r, oscore_inpkt_invalid_optionlen,
497 : : "Error in options_deserialize. r: %d", r);
498 : :
499 : : /*test too many options*/
500 : 1 : uint8_t in_data4[] = {
501 : : 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
502 : : 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
503 : : 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
504 : : }; //21 options with option number 1
505 : 1 : struct byte_array d4 = BYTE_ARRAY_INIT(in_data4, sizeof(in_data4));
506 : :
507 : 1 : r = options_deserialize(&d4, (struct o_coap_option *)&coap_pkt.options,
508 : : &coap_pkt.options_cnt, &coap_pkt.payload);
509 : :
510 : 1 : zassert_equal(r, too_many_options,
511 : : "Error in options_deserialize. r: %d", r);
512 : 1 : }
513 : :
514 : 0 : void t203_coap_get_message_type(void)
515 : : {
516 : 0 : struct o_coap_packet packet_request_1 = generate_test_packet(CODE_REQ_GET, 0, NULL, 0); //no OBSERVE option
517 : 0 : struct o_coap_packet packet_request_2 = generate_test_packet(CODE_REQ_POST, 1, "\x01\x02\x03", 3);
518 : 0 : struct o_coap_packet packet_registration_1 = generate_test_packet(CODE_REQ_GET, 1, "\x00", 1);
519 : 0 : struct o_coap_packet packet_registration_2 = generate_test_packet(CODE_REQ_POST, 1, NULL, 0); //empty OBSERVE option
520 : 0 : struct o_coap_packet packet_cancellation = generate_test_packet(CODE_REQ_GET, 1, "\x01", 1);
521 : 0 : struct o_coap_packet packet_response = generate_test_packet(CODE_RESP_CONTENT, 0, NULL, 0);
522 : 0 : struct o_coap_packet packet_notification_1 = generate_test_packet(CODE_RESP_CONTENT, 1, NULL, 0);
523 : 0 : struct o_coap_packet packet_notification_2 = generate_test_packet(CODE_RESP_CONTENT, 1, "\x01\x02", 2);
524 : :
525 : : /* Test null pointers. */
526 : 0 : enum o_coap_msg msg_type;
527 : 0 : coap_get_message_type_and_compare(NULL, &msg_type, wrong_parameter, 0);
528 : 0 : coap_get_message_type_and_compare(&packet_request_1, NULL, wrong_parameter, 0);
529 : :
530 : : /* Test different valid packets. */
531 : 0 : coap_get_message_type_and_compare(&packet_request_1, &msg_type, ok, COAP_MSG_REQUEST);
532 : 0 : coap_get_message_type_and_compare(&packet_request_2, &msg_type, ok, COAP_MSG_REQUEST);
533 : 0 : coap_get_message_type_and_compare(&packet_registration_1, &msg_type, ok, COAP_MSG_REGISTRATION);
534 : 0 : coap_get_message_type_and_compare(&packet_registration_2, &msg_type, ok, COAP_MSG_REGISTRATION);
535 : 0 : coap_get_message_type_and_compare(&packet_cancellation, &msg_type, ok, COAP_MSG_CANCELLATION);
536 : 0 : coap_get_message_type_and_compare(&packet_response, &msg_type, ok, COAP_MSG_RESPONSE);
537 : 0 : coap_get_message_type_and_compare(&packet_notification_1, &msg_type, ok, COAP_MSG_NOTIFICATION);
538 : 0 : coap_get_message_type_and_compare(&packet_notification_2, &msg_type, ok, COAP_MSG_NOTIFICATION);
539 : 0 : }
|
