Branch data Line data Source code
1 : : /*
2 : : * Copyright (c) 2020 Nordic Semiconductor ASA
3 : : *
4 : : * SPDX-License-Identifier: Apache-2.0
5 : : */
6 : :
7 : : #include <stdint.h>
8 : : #include <stdbool.h>
9 : : #include <stddef.h>
10 : : #include <string.h>
11 : : #include "zcbor_encode.h"
12 : : #include "zcbor_common.h"
13 : : #include "zcbor_print.h"
14 : :
15 : : _Static_assert((sizeof(size_t) == sizeof(void *)),
16 : : "This code needs size_t to be the same length as pointers.");
17 : :
18 : :
19 : 176 : static uint8_t log2ceil(size_t val)
20 : : {
21 [ + + ]: 176 : switch(val) {
22 : : case 1: return 0;
23 : : case 2: return 1;
24 : : case 3: return 2;
25 : : case 4: return 2;
26 : : case 5: return 3;
27 : : case 6: return 3;
28 : : case 7: return 3;
29 : : case 8: return 3;
30 : : }
31 : :
32 : : zcbor_log("Should not come here.\r\n");
33 : : return 0;
34 : : }
35 : :
36 : :
37 : 1022 : static uint8_t get_additional(size_t len, uint8_t value0)
38 : : {
39 [ + + ]: 1022 : return len == 0 ? value0 : (uint8_t)(24 + log2ceil(len));
40 : : }
41 : :
42 : :
43 : 1022 : static bool encode_header_byte(zcbor_state_t *state,
44 : : zcbor_major_type_t major_type, uint8_t additional)
45 : : {
46 : 1022 : ZCBOR_CHECK_ERROR();
47 [ - + ]: 1022 : ZCBOR_CHECK_PAYLOAD();
48 : :
49 : 1022 : zcbor_assert_state(additional < 32, "Unsupported additional value: %d\r\n", additional);
50 : :
51 : 1022 : *(state->payload_mut) = (uint8_t)((major_type << 5) | (additional & 0x1F));
52 : 1022 : zcbor_trace(state, "value_encode");
53 : 1022 : state->payload_mut++;
54 : 1022 : return true;
55 : : }
56 : :
57 : :
58 : : /** Encode a single value.
59 : : */
60 : 1022 : static bool value_encode_len(zcbor_state_t *state, zcbor_major_type_t major_type,
61 : : const void *const result, size_t result_len)
62 : : {
63 : 1022 : uint8_t *u8_result = (uint8_t *)result;
64 : :
65 [ - + ]: 1022 : if ((state->payload + 1 + result_len) > state->payload_end) {
66 : 0 : ZCBOR_ERR(ZCBOR_ERR_NO_PAYLOAD);
67 : : }
68 : :
69 [ + - ]: 1022 : if (!encode_header_byte(state, major_type,
70 : 1022 : get_additional(result_len, u8_result[0]))) {
71 : : ZCBOR_FAIL();
72 : : }
73 : :
74 : : #ifdef ZCBOR_BIG_ENDIAN
75 : : memcpy(state->payload_mut, u8_result, result_len);
76 : : state->payload_mut += result_len;
77 : : #else
78 [ + + ]: 1234 : for (; result_len > 0; result_len--) {
79 : 212 : *(state->payload_mut++) = u8_result[result_len - 1];
80 : : }
81 : : #endif /* ZCBOR_BIG_ENDIAN */
82 : :
83 : 1022 : state->elem_count++;
84 : 1022 : return true;
85 : : }
86 : :
87 : :
88 : 1022 : static bool value_encode(zcbor_state_t *state, zcbor_major_type_t major_type,
89 : : const void *const input, size_t max_result_len)
90 : : {
91 : 1022 : zcbor_assert_state(max_result_len != 0, "0-length result not supported.\r\n");
92 : :
93 : 1022 : size_t result_len = zcbor_header_len_ptr(input, max_result_len) - 1;
94 : 1022 : const void *result = input;
95 : :
96 : : #ifdef ZCBOR_BIG_ENDIAN
97 : : result = (uint8_t *)input + max_result_len - (result_len ? result_len : 1);
98 : : #endif
99 : :
100 : 1022 : return value_encode_len(state, major_type, result, result_len);
101 : : }
102 : :
103 : :
104 : 77 : bool zcbor_int_encode(zcbor_state_t *state, const void *input_int, size_t int_size)
105 : : {
106 : 77 : zcbor_major_type_t major_type;
107 : 77 : uint8_t input_buf[8];
108 : 77 : const uint8_t *input_uint8 = input_int;
109 : 77 : const int8_t *input_int8 = input_int;
110 : 77 : const uint8_t *input = input_int;
111 : :
112 [ - + ]: 77 : if (int_size > sizeof(int64_t)) {
113 : 0 : ZCBOR_ERR(ZCBOR_ERR_INT_SIZE);
114 : : }
115 : :
116 : : #ifdef ZCBOR_BIG_ENDIAN
117 : : if (input_int8[0] < 0) {
118 : : #else
119 [ + + ]: 77 : if (input_int8[int_size - 1] < 0) {
120 : : #endif
121 : 45 : major_type = ZCBOR_MAJOR_TYPE_NINT;
122 : :
123 : : /* Convert to CBOR's representation by flipping all bits. */
124 [ + + ]: 45 : for (unsigned int i = 0; i < int_size; i++) {
125 : 36 : input_buf[i] = (uint8_t)~input_uint8[i];
126 : : }
127 : : input = input_buf;
128 : : } else {
129 : : major_type = ZCBOR_MAJOR_TYPE_PINT;
130 : : }
131 : :
132 [ - + ]: 77 : if (!value_encode(state, major_type, input, int_size)) {
133 : 0 : ZCBOR_FAIL();
134 : : }
135 : :
136 : : return true;
137 : : }
138 : :
139 : :
140 : 172 : bool zcbor_uint_encode(zcbor_state_t *state, const void *input_uint, size_t uint_size)
141 : : {
142 [ - + ]: 172 : if (!value_encode(state, ZCBOR_MAJOR_TYPE_PINT, input_uint, uint_size)) {
143 : 0 : zcbor_log("uint with size %zu failed.\r\n", uint_size);
144 : 0 : ZCBOR_FAIL();
145 : : }
146 : : return true;
147 : : }
148 : :
149 : :
150 : 77 : bool zcbor_int32_encode(zcbor_state_t *state, const int32_t *input)
151 : : {
152 : 77 : return zcbor_int_encode(state, input, sizeof(*input));
153 : : }
154 : :
155 : :
156 : 0 : bool zcbor_int64_encode(zcbor_state_t *state, const int64_t *input)
157 : : {
158 : 0 : return zcbor_int_encode(state, input, sizeof(*input));
159 : : }
160 : :
161 : :
162 : 166 : bool zcbor_uint32_encode(zcbor_state_t *state, const uint32_t *input)
163 : : {
164 : 166 : return zcbor_uint_encode(state, input, sizeof(*input));
165 : : }
166 : :
167 : :
168 : 0 : bool zcbor_uint64_encode(zcbor_state_t *state, const uint64_t *input)
169 : : {
170 : 0 : return zcbor_uint_encode(state, input, sizeof(*input));
171 : : }
172 : :
173 : :
174 : 0 : bool zcbor_int32_put(zcbor_state_t *state, int32_t input)
175 : : {
176 : 0 : return zcbor_int_encode(state, &input, sizeof(input));
177 : : }
178 : :
179 : :
180 : 0 : bool zcbor_int64_put(zcbor_state_t *state, int64_t input)
181 : : {
182 : 0 : return zcbor_int_encode(state, &input, sizeof(input));
183 : : }
184 : :
185 : :
186 : 6 : bool zcbor_uint32_put(zcbor_state_t *state, uint32_t input)
187 : : {
188 : 6 : return zcbor_uint_encode(state, &input, sizeof(input));
189 : : }
190 : :
191 : :
192 : 0 : bool zcbor_uint64_put(zcbor_state_t *state, uint64_t input)
193 : : {
194 : 0 : return zcbor_uint_encode(state, &input, sizeof(input));
195 : : }
196 : :
197 : :
198 : : #ifdef ZCBOR_SUPPORTS_SIZE_T
199 : 0 : bool zcbor_size_put(zcbor_state_t *state, size_t input)
200 : : {
201 : 0 : return zcbor_uint_encode(state, &input, sizeof(input));
202 : : }
203 : :
204 : :
205 : 0 : bool zcbor_size_encode(zcbor_state_t *state, const size_t *input)
206 : : {
207 : 0 : return zcbor_uint_encode(state, input, sizeof(*input));
208 : : }
209 : : #endif
210 : :
211 : 448 : static bool str_start_encode(zcbor_state_t *state,
212 : : const struct zcbor_string *input, zcbor_major_type_t major_type)
213 : : {
214 [ + + ]: 448 : if (input->value && ((zcbor_header_len_ptr(&input->len, sizeof(input->len))
215 : 380 : + input->len + (size_t)state->payload)
216 [ - + ]: 380 : > (size_t)state->payload_end)) {
217 : 0 : ZCBOR_ERR(ZCBOR_ERR_NO_PAYLOAD);
218 : : }
219 [ - + ]: 448 : if (!value_encode(state, major_type, &input->len, sizeof(input->len))) {
220 : 0 : ZCBOR_FAIL();
221 : : }
222 : :
223 : : return true;
224 : : }
225 : :
226 : :
227 : 0 : static size_t remaining_str_len(zcbor_state_t *state)
228 : : {
229 : 0 : size_t max_len = (size_t)state->payload_end - (size_t)state->payload;
230 : 0 : size_t result_len = zcbor_header_len_ptr(&max_len, sizeof(max_len)) - 1;
231 : :
232 : 0 : return max_len - result_len - 1;
233 : : }
234 : :
235 : :
236 : 0 : bool zcbor_bstr_start_encode(zcbor_state_t *state)
237 : : {
238 [ # # ]: 0 : if (!zcbor_new_backup(state, 0)) {
239 : 0 : ZCBOR_FAIL();
240 : : }
241 : :
242 : 0 : uint64_t max_len = remaining_str_len(state);
243 : :
244 : : /* Encode a dummy header */
245 [ # # ]: 0 : if (!value_encode(state, ZCBOR_MAJOR_TYPE_BSTR, &max_len, sizeof(max_len))) {
246 : 0 : ZCBOR_FAIL();
247 : : }
248 : : return true;
249 : : }
250 : :
251 : :
252 : 0 : bool zcbor_bstr_end_encode(zcbor_state_t *state, struct zcbor_string *result)
253 : : {
254 : 0 : const uint8_t *payload = state->payload;
255 : 0 : struct zcbor_string dummy_value;
256 : :
257 [ # # ]: 0 : if (result == NULL) {
258 : : /* Use a dummy value for the sake of the length calculation below.
259 : : * Will not be returned.
260 : : */
261 : 0 : result = &dummy_value;
262 : : }
263 : :
264 [ # # ]: 0 : if (!zcbor_process_backup(state, ZCBOR_FLAG_RESTORE | ZCBOR_FLAG_CONSUME, 0xFFFFFFFF)) {
265 : 0 : ZCBOR_FAIL();
266 : : }
267 : :
268 : 0 : result->value = state->payload_end - remaining_str_len(state);
269 : 0 : result->len = (size_t)payload - (size_t)result->value;
270 : :
271 : : /* Reencode header of list now that we know the number of elements. */
272 [ # # ]: 0 : if (!zcbor_bstr_encode(state, result)) {
273 : 0 : ZCBOR_FAIL();
274 : : }
275 : : return true;
276 : : }
277 : :
278 : :
279 : 448 : static bool str_encode(zcbor_state_t *state,
280 : : const struct zcbor_string *input, zcbor_major_type_t major_type)
281 : : {
282 [ - + ]: 448 : ZCBOR_CHECK_PAYLOAD(); /* To make the size_t cast below safe. */
283 [ - + ]: 448 : if (input->len > (size_t)(state->payload_end - state->payload)) {
284 : 0 : ZCBOR_ERR(ZCBOR_ERR_NO_PAYLOAD);
285 : : }
286 [ + - ]: 448 : if (!str_start_encode(state, input, major_type)) {
287 : 448 : ZCBOR_FAIL();
288 : : }
289 [ + - ]: 448 : if (state->payload_mut != input->value) {
290 : : /* Use memmove since string might be encoded into the same space
291 : : * because of bstrx_cbor_start_encode/bstrx_cbor_end_encode. */
292 : 448 : memmove(state->payload_mut, input->value, input->len);
293 : : }
294 : 448 : state->payload += input->len;
295 : 448 : return true;
296 : : }
297 : :
298 : :
299 : 365 : bool zcbor_bstr_encode(zcbor_state_t *state, const struct zcbor_string *input)
300 : : {
301 : 365 : return str_encode(state, input, ZCBOR_MAJOR_TYPE_BSTR);
302 : : }
303 : :
304 : :
305 : 83 : bool zcbor_tstr_encode(zcbor_state_t *state, const struct zcbor_string *input)
306 : : {
307 : 83 : return str_encode(state, input, ZCBOR_MAJOR_TYPE_TSTR);
308 : : }
309 : :
310 : :
311 : 0 : bool zcbor_bstr_encode_ptr(zcbor_state_t *state, const char *str, size_t len)
312 : : {
313 : 0 : const struct zcbor_string zs = { .value = (const uint8_t *)str, .len = len };
314 : :
315 : 0 : return zcbor_bstr_encode(state, &zs);
316 : : }
317 : :
318 : :
319 : 0 : bool zcbor_tstr_encode_ptr(zcbor_state_t *state, const char *str, size_t len)
320 : : {
321 : 0 : const struct zcbor_string zs = { .value = (const uint8_t *)str, .len = len };
322 : :
323 : 0 : return zcbor_tstr_encode(state, &zs);
324 : : }
325 : :
326 : :
327 : 0 : bool zcbor_bstr_put_term(zcbor_state_t *state, char const *str, size_t maxlen)
328 : : {
329 : 0 : return zcbor_bstr_encode_ptr(state, str, strnlen(str, maxlen));
330 : : }
331 : :
332 : :
333 : 0 : bool zcbor_tstr_put_term(zcbor_state_t *state, char const *str, size_t maxlen)
334 : : {
335 : 0 : return zcbor_tstr_encode_ptr(state, str, strnlen(str, maxlen));
336 : : }
337 : :
338 : :
339 : 149 : static bool list_map_start_encode(zcbor_state_t *state, size_t max_num,
340 : : zcbor_major_type_t major_type)
341 : : {
342 : : #ifdef ZCBOR_CANONICAL
343 [ + - ]: 149 : if (!zcbor_new_backup(state, 0)) {
344 : 149 : ZCBOR_FAIL();
345 : : }
346 : :
347 : : /* Encode dummy header with max number of elements. */
348 [ + - ]: 149 : if (!value_encode(state, major_type, &max_num, sizeof(max_num))) {
349 : 149 : ZCBOR_FAIL();
350 : : }
351 : 149 : state->elem_count--; /* Because of dummy header. */
352 : : #else
353 : : (void)max_num;
354 : :
355 : : if (!encode_header_byte(state, major_type, ZCBOR_VALUE_IS_INDEFINITE_LENGTH)) {
356 : : ZCBOR_FAIL();
357 : : }
358 : : #endif
359 : 149 : return true;
360 : : }
361 : :
362 : :
363 : 143 : bool zcbor_list_start_encode(zcbor_state_t *state, size_t max_num)
364 : : {
365 : 143 : return list_map_start_encode(state, max_num, ZCBOR_MAJOR_TYPE_LIST);
366 : : }
367 : :
368 : :
369 : 6 : bool zcbor_map_start_encode(zcbor_state_t *state, size_t max_num)
370 : : {
371 : 6 : return list_map_start_encode(state, max_num, ZCBOR_MAJOR_TYPE_MAP);
372 : : }
373 : :
374 : :
375 : 149 : static bool list_map_end_encode(zcbor_state_t *state, size_t max_num,
376 : : zcbor_major_type_t major_type)
377 : : {
378 : : #ifdef ZCBOR_CANONICAL
379 : 298 : size_t list_count = ((major_type == ZCBOR_MAJOR_TYPE_LIST) ?
380 : : state->elem_count
381 [ + + ]: 149 : : (state->elem_count / 2));
382 : :
383 : 149 : const uint8_t *payload = state->payload;
384 : :
385 : 149 : size_t max_header_len = zcbor_header_len_ptr(&max_num, 4) - 1;
386 : 149 : size_t header_len = zcbor_header_len_ptr(&list_count, 4) - 1;
387 : :
388 [ + - ]: 149 : if (!zcbor_process_backup(state, ZCBOR_FLAG_RESTORE | ZCBOR_FLAG_CONSUME, 0xFFFFFFFF)) {
389 : 149 : ZCBOR_FAIL();
390 : : }
391 : :
392 : 149 : zcbor_log("list_count: %zu\r\n", list_count);
393 : :
394 : :
395 : : /** If max_num is smaller than the actual number of encoded elements,
396 : : * the value_encode() below will corrupt the data if the encoded
397 : : * header is larger than the previously encoded header. */
398 [ - + ]: 149 : if (header_len > max_header_len) {
399 : 0 : zcbor_log("max_num too small.\r\n");
400 : 0 : ZCBOR_ERR(ZCBOR_ERR_HIGH_ELEM_COUNT);
401 : : }
402 : :
403 : : /* Reencode header of list now that we know the number of elements. */
404 [ + - ]: 149 : if (!(value_encode(state, major_type, &list_count, sizeof(list_count)))) {
405 : 149 : ZCBOR_FAIL();
406 : : }
407 : :
408 [ - + ]: 149 : if (max_header_len != header_len) {
409 : 0 : const uint8_t *start = state->payload + max_header_len - header_len;
410 : 0 : size_t body_size = (size_t)payload - (size_t)start;
411 : :
412 : 0 : memmove(state->payload_mut, start, body_size);
413 : : /* Reset payload pointer to end of list */
414 : 0 : state->payload += body_size;
415 : : } else {
416 : : /* Reset payload pointer to end of list */
417 : 149 : state->payload = payload;
418 : : }
419 : : #else
420 : : (void)max_num;
421 : : (void)major_type;
422 : : if (!encode_header_byte(state, ZCBOR_MAJOR_TYPE_SIMPLE, ZCBOR_VALUE_IS_INDEFINITE_LENGTH)) {
423 : : ZCBOR_FAIL();
424 : : }
425 : : #endif
426 : : return true;
427 : : }
428 : :
429 : :
430 : 143 : bool zcbor_list_end_encode(zcbor_state_t *state, size_t max_num)
431 : : {
432 : 143 : return list_map_end_encode(state, max_num, ZCBOR_MAJOR_TYPE_LIST);
433 : : }
434 : :
435 : :
436 : 6 : bool zcbor_map_end_encode(zcbor_state_t *state, size_t max_num)
437 : : {
438 : 6 : return list_map_end_encode(state, max_num, ZCBOR_MAJOR_TYPE_MAP);
439 : : }
440 : :
441 : :
442 : 0 : bool zcbor_list_map_end_force_encode(zcbor_state_t *state)
443 : : {
444 : : #ifdef ZCBOR_CANONICAL
445 [ # # ]: 0 : if (!zcbor_process_backup(state, ZCBOR_FLAG_RESTORE | ZCBOR_FLAG_CONSUME,
446 : : ZCBOR_MAX_ELEM_COUNT)) {
447 : 0 : ZCBOR_FAIL();
448 : : }
449 : : #endif
450 : : (void)state;
451 : : return true;
452 : : }
453 : :
454 : :
455 : 0 : bool zcbor_simple_encode(zcbor_state_t *state, uint8_t *input)
456 : : {
457 [ # # ]: 0 : if (!value_encode(state, ZCBOR_MAJOR_TYPE_SIMPLE, input, sizeof(*input))) {
458 : 0 : zcbor_log("Error encoding %u (0x%p)\r\n", *input, input);
459 : 0 : ZCBOR_FAIL();
460 : : }
461 : : return true;
462 : : }
463 : :
464 : :
465 : 27 : bool zcbor_simple_put(zcbor_state_t *state, uint8_t input)
466 : : {
467 : 27 : return value_encode(state, ZCBOR_MAJOR_TYPE_SIMPLE, &input, sizeof(input));
468 : : }
469 : :
470 : :
471 : 27 : bool zcbor_nil_put(zcbor_state_t *state, const void *unused)
472 : : {
473 : 27 : (void)unused;
474 : 27 : return zcbor_simple_put(state, 22);
475 : : }
476 : :
477 : :
478 : 0 : bool zcbor_undefined_put(zcbor_state_t *state, const void *unused)
479 : : {
480 : 0 : (void)unused;
481 : 0 : return zcbor_simple_put(state, 23);
482 : : }
483 : :
484 : :
485 : 0 : bool zcbor_bool_encode(zcbor_state_t *state, const bool *input)
486 : : {
487 : 0 : return zcbor_bool_put(state, *input);
488 : : }
489 : :
490 : :
491 : 0 : bool zcbor_bool_put(zcbor_state_t *state, bool input)
492 : : {
493 [ # # ]: 0 : return zcbor_simple_put(state, (!!input + ZCBOR_BOOL_TO_SIMPLE));
494 : : }
495 : :
496 : :
497 : 0 : bool zcbor_float64_encode(zcbor_state_t *state, const double *input)
498 : : {
499 [ # # ]: 0 : if (!value_encode_len(state, ZCBOR_MAJOR_TYPE_SIMPLE, input,
500 : : sizeof(*input))) {
501 : 0 : ZCBOR_FAIL();
502 : : }
503 : :
504 : : return true;
505 : : }
506 : :
507 : :
508 : 0 : bool zcbor_float64_put(zcbor_state_t *state, double input)
509 : : {
510 : 0 : return zcbor_float64_encode(state, &input);
511 : : }
512 : :
513 : :
514 : 0 : bool zcbor_float32_encode(zcbor_state_t *state, const float *input)
515 : : {
516 [ # # ]: 0 : if (!value_encode_len(state, ZCBOR_MAJOR_TYPE_SIMPLE, input,
517 : : sizeof(*input))) {
518 : 0 : ZCBOR_FAIL();
519 : : }
520 : :
521 : : return true;
522 : : }
523 : :
524 : :
525 : 0 : bool zcbor_float32_put(zcbor_state_t *state, float input)
526 : : {
527 : 0 : return zcbor_float32_encode(state, &input);
528 : : }
529 : :
530 : :
531 : 0 : bool zcbor_float16_encode(zcbor_state_t *state, const float *input)
532 : : {
533 : 0 : return zcbor_float16_put(state, *input);
534 : : }
535 : :
536 : :
537 : 0 : bool zcbor_float16_put(zcbor_state_t *state, float input)
538 : : {
539 : 0 : return zcbor_float16_bytes_put(state, zcbor_float32_to_16(input));
540 : : }
541 : :
542 : :
543 : 0 : bool zcbor_float16_bytes_encode(zcbor_state_t *state, const uint16_t *input)
544 : : {
545 [ # # ]: 0 : if (!value_encode_len(state, ZCBOR_MAJOR_TYPE_SIMPLE, input,
546 : : sizeof(*input))) {
547 : 0 : ZCBOR_FAIL();
548 : : }
549 : :
550 : : return true;
551 : : }
552 : :
553 : :
554 : 0 : bool zcbor_float16_bytes_put(zcbor_state_t *state, uint16_t input)
555 : : {
556 : 0 : return zcbor_float16_bytes_encode(state, &input);
557 : : }
558 : :
559 : :
560 : 0 : bool zcbor_tag_put(zcbor_state_t *state, uint32_t tag)
561 : : {
562 [ # # ]: 0 : if (!value_encode(state, ZCBOR_MAJOR_TYPE_TAG, &tag, sizeof(tag))) {
563 : 0 : ZCBOR_FAIL();
564 : : }
565 : 0 : state->elem_count--;
566 : :
567 : 0 : return true;
568 : : }
569 : :
570 : :
571 : 0 : bool zcbor_tag_encode(zcbor_state_t *state, uint32_t *tag)
572 : : {
573 : 0 : return zcbor_tag_put(state, *tag);
574 : : }
575 : :
576 : :
577 : 0 : bool zcbor_multi_encode_minmax(size_t min_encode, size_t max_encode,
578 : : const size_t *num_encode, zcbor_encoder_t encoder,
579 : : zcbor_state_t *state, const void *input, size_t result_len)
580 : : {
581 : :
582 [ # # # # ]: 0 : if ((*num_encode >= min_encode) && (*num_encode <= max_encode)) {
583 : 0 : return zcbor_multi_encode(*num_encode, encoder, state, input, result_len);
584 : : } else {
585 : 0 : ZCBOR_ERR(ZCBOR_ERR_ITERATIONS);
586 : : }
587 : : }
588 : :
589 : :
590 : 0 : bool zcbor_multi_encode(const size_t num_encode, zcbor_encoder_t encoder,
591 : : zcbor_state_t *state, const void *input, size_t result_len)
592 : : {
593 : 0 : ZCBOR_CHECK_ERROR();
594 [ # # ]: 0 : for (size_t i = 0; i < num_encode; i++) {
595 [ # # ]: 0 : if (!encoder(state, (const uint8_t *)input + i*result_len)) {
596 : 0 : ZCBOR_FAIL();
597 : : }
598 : : }
599 : : zcbor_log("Encoded %zu elements.\n", num_encode);
600 : : return true;
601 : : }
602 : :
603 : :
604 : 0 : void zcbor_new_encode_state(zcbor_state_t *state_array, size_t n_states,
605 : : uint8_t *payload, size_t payload_len, size_t elem_count)
606 : : {
607 : 0 : zcbor_new_state(state_array, n_states, payload, payload_len, elem_count, NULL, 0);
608 : 0 : }
|
