1  #include "device_test_svc_reply_msg.h"
  2  #ifndef CI_TEST
  3  #include "FreeRTOS.h"
  4  #else // CI_TEST
  5  #include <cstdlib>
  6  #endif // CI_TEST
  7  
  8  CborError DeviceTestSvcReplyMsg::encode(Data &d, uint8_t *cbor_buffer,
  9                                          size_t size, size_t *encoded_len) {
 10    CborError err;
 11    CborEncoder encoder, map_encoder;
 12    cbor_encoder_init(&encoder, cbor_buffer, size, 0);
 13  
 14    do {
 15      err = cbor_encoder_create_map(&encoder, &map_encoder, NUM_FIELDS);
 16      if (err != CborNoError) {
 17        printf("cbor_encoder_create_map failed: %d\n", err);
 18        if (err != CborErrorOutOfMemory) {
 19          break;
 20        }
 21      }
 22  
 23      // success
 24      err = cbor_encode_text_stringz(&map_encoder, "success");
 25      if (err != CborNoError) {
 26        printf("cbor_encode_text_stringz failed for success key: %d\n", err);
 27        if (err != CborErrorOutOfMemory) {
 28          break;
 29        }
 30      }
 31      err = cbor_encode_uint(&map_encoder, d.success);
 32      if (err != CborNoError) {
 33        printf("cbor_encode_uint failed for partition_id value: %d\n", err);
 34        if (err != CborErrorOutOfMemory) {
 35          break;
 36        }
 37      }
 38  
 39      // data_len
 40      err = cbor_encode_text_stringz(&map_encoder, "data_len");
 41      if (err != CborNoError) {
 42        printf("cbor_encode_text_stringz failed for data_len key: %d\n", err);
 43        if (err != CborErrorOutOfMemory) {
 44          break;
 45        }
 46      }
 47      err = cbor_encode_uint(&map_encoder, d.data_len);
 48      if (err != CborNoError) {
 49        printf("cbor_encode_uint failed for data_len value: %d\n", err);
 50        if (err != CborErrorOutOfMemory) {
 51          break;
 52        }
 53      }
 54  
 55      // data
 56      err = cbor_encode_text_stringz(&map_encoder, "data");
 57      if (err != CborNoError) {
 58        printf("cbor_encode_text_stringz failed for data key: %d\n", err);
 59        if (err != CborErrorOutOfMemory) {
 60          break;
 61        }
 62      }
 63      err = cbor_encode_byte_string(&map_encoder, d.data, d.data_len);
 64      if (err != CborNoError) {
 65        printf("cbor_encode_byte_string failed for data value: %d\n", err);
 66        if (err != CborErrorOutOfMemory) {
 67          break;
 68        }
 69      }
 70  
 71      if (err != CborNoError && err != CborErrorOutOfMemory) {
 72        break;
 73      }
 74  
 75      err = cbor_encoder_close_container(&encoder, &map_encoder);
 76      if (err == CborNoError) {
 77        *encoded_len = cbor_encoder_get_buffer_size(&encoder, cbor_buffer);
 78      } else {
 79        printf("cbor_encoder_close_container failed: %d\n", err);
 80        if (err != CborErrorOutOfMemory) {
 81          break;
 82        }
 83        size_t extra_bytes_needed = cbor_encoder_get_extra_bytes_needed(&encoder);
 84        printf("extra_bytes_needed: %zu\n", extra_bytes_needed);
 85      }
 86    } while (0);
 87  
 88    return err;
 89  }
 90  
 91  CborError DeviceTestSvcReplyMsg::decode(Data &d, const uint8_t *cbor_buffer,
 92                                          size_t size) {
 93    CborParser parser;
 94    CborValue map;
 95    CborError err = cbor_parser_init(cbor_buffer, size, 0, &parser, &map);
 96    uint64_t tmp_uint64;
 97    do {
 98      if (err != CborNoError) {
 99        break;
100      }
101      err = cbor_value_validate_basic(&map);
102      if (err != CborNoError) {
103        break;
104      }
105      if (!cbor_value_is_map(&map)) {
106        err = CborErrorIllegalType;
107        break;
108      }
109  
110      size_t num_fields;
111      err = cbor_value_get_map_length(&map, &num_fields);
112      if (err != CborNoError) {
113        break;
114      }
115      if (num_fields != NUM_FIELDS) {
116        err = CborErrorUnknownLength;
117        printf("expected %zu fields but got %zu\n", NUM_FIELDS, num_fields);
118        break;
119      }
120  
121      CborValue value;
122      err = cbor_value_enter_container(&map, &value);
123      if (err != CborNoError) {
124        break;
125      }
126  
127      // success
128      if (!cbor_value_is_text_string(&value)) {
129        err = CborErrorIllegalType;
130        printf("expected string key but got something else\n");
131        break;
132      }
133      err = cbor_value_advance(&value);
134      if (err != CborNoError) {
135        break;
136      }
137      err = cbor_value_get_uint64(&value, &tmp_uint64);
138      d.success = static_cast<uint32_t>(tmp_uint64);
139      if (err != CborNoError) {
140        break;
141      }
142      err = cbor_value_advance(&value);
143      if (err != CborNoError) {
144        break;
145      }
146  
147      // data_len
148      if (!cbor_value_is_text_string(&value)) {
149        err = CborErrorIllegalType;
150        printf("expected string key but got something else\n");
151        break;
152      }
153      err = cbor_value_advance(&value);
154      if (err != CborNoError) {
155        break;
156      }
157      err = cbor_value_get_uint64(&value, &tmp_uint64);
158      d.data_len = static_cast<uint32_t>(tmp_uint64);
159      if (err != CborNoError) {
160        break;
161      }
162      err = cbor_value_advance(&value);
163      if (err != CborNoError) {
164        break;
165      }
166  
167      // data
168      if (!cbor_value_is_text_string(&value)) {
169        err = CborErrorIllegalType;
170        printf("expected string key but got something else\n");
171        break;
172      }
173      err = cbor_value_advance(&value);
174      if (err != CborNoError) {
175        break;
176      }
177      if (d.data_len) {
178        size_t buflen = d.data_len;
179  #ifndef CI_TEST
180        uint8_t *buf = static_cast<uint8_t *>(pvPortMalloc(buflen));
181        configASSERT(buf);
182  #else
183        uint8_t *buf = static_cast<uint8_t *>(malloc(buflen));
184  #endif // CI_TEST
185        err = cbor_value_copy_byte_string(&value, buf, &buflen, NULL);
186        d.data = buf;
187        if (err != CborNoError) {
188          break;
189        }
190        if (buflen != d.data_len) {
191          err = CborErrorIllegalType;
192          break;
193        }
194      } else {
195        d.data = NULL;
196      }
197      err = cbor_value_advance(&value);
198      if (err != CborNoError) {
199        break;
200      }
201  
202      if (err == CborNoError) {
203        err = cbor_value_leave_container(&map, &value);
204        if (err != CborNoError) {
205          break;
206        }
207        if (!cbor_value_at_end(&map)) {
208          err = CborErrorGarbageAtEnd;
209          break;
210        }
211      }
212    } while (0);
213  
214    return err;
215  }