1  #include "config_cbor_map_srv_reply_msg.h"
  2  #include "FreeRTOS.h"
  3  
  4  CborError ConfigCborMapSrvReplyMsg::encode(Data &d, uint8_t *cbor_buffer, size_t size,
  5                                       size_t *encoded_len) {
  6    CborError err;
  7    CborEncoder encoder, map_encoder;
  8    cbor_encoder_init(&encoder, cbor_buffer, size, 0);
  9  
 10    do {
 11      err = cbor_encoder_create_map(&encoder, &map_encoder, NUM_FIELDS);
 12      if (err != CborNoError) {
 13        printf("cbor_encoder_create_map failed: %d\n", err);
 14        if (err != CborErrorOutOfMemory) {
 15          break;
 16        }
 17      }
 18  
 19      // node_id
 20      err = cbor_encode_text_stringz(&map_encoder, "node_id");
 21      if (err != CborNoError) {
 22        printf("cbor_encode_text_stringz failed for node_id key: %d\n", err);
 23        if (err != CborErrorOutOfMemory) {
 24          break;
 25        }
 26      }
 27      err = cbor_encode_uint(&map_encoder, d.node_id);
 28      if (err != CborNoError) {
 29        printf("cbor_encode_uint failed for node_id value: %d\n", err);
 30        if (err != CborErrorOutOfMemory) {
 31          break;
 32        }
 33      }
 34  
 35      // partition_id
 36      err = cbor_encode_text_stringz(&map_encoder, "partition_id");
 37      if (err != CborNoError) {
 38        printf("cbor_encode_text_stringz failed for partition_id key: %d\n", err);
 39        if (err != CborErrorOutOfMemory) {
 40          break;
 41        }
 42      }
 43      err = cbor_encode_uint(&map_encoder, d.partition_id);
 44      if (err != CborNoError) {
 45        printf("cbor_encode_uint failed for partition_id value: %d\n", err);
 46        if (err != CborErrorOutOfMemory) {
 47          break;
 48        }
 49      }
 50  
 51      // success
 52      err = cbor_encode_text_stringz(&map_encoder, "success");
 53      if (err != CborNoError) {
 54        printf("cbor_encode_text_stringz failed for success key: %d\n", err);
 55        if (err != CborErrorOutOfMemory) {
 56          break;
 57        }
 58      }
 59      err = cbor_encode_uint(&map_encoder, d.success);
 60      if (err != CborNoError) {
 61        printf("cbor_encode_uint failed for success value: %d\n", err);
 62        if (err != CborErrorOutOfMemory) {
 63          break;
 64        }
 65      }
 66  
 67      // cbor_encoded_map_len
 68      err = cbor_encode_text_stringz(&map_encoder, "cbor_encoded_map_len");
 69      if (err != CborNoError) {
 70        printf("cbor_encode_text_stringz failed for cbor_encoded_map_len key: %d\n", err);
 71        if (err != CborErrorOutOfMemory) {
 72          break;
 73        }
 74      }
 75      err = cbor_encode_uint(&map_encoder, d.cbor_encoded_map_len);
 76      if (err != CborNoError) {
 77        printf("cbor_encode_uint failed for cbor_encoded_map_len value: %d\n", err);
 78        if (err != CborErrorOutOfMemory) {
 79          break;
 80        }
 81      }
 82  
 83      // cbor_data
 84      err = cbor_encode_text_stringz(&map_encoder, "cbor_data");
 85      if (err != CborNoError) {
 86        printf("cbor_encode_text_stringz failed for cbor_data key: %d\n", err);
 87        if (err != CborErrorOutOfMemory) {
 88          break;
 89        }
 90      }
 91      err = cbor_encode_byte_string(&map_encoder, d.cbor_data, d.cbor_encoded_map_len);
 92      if (err != CborNoError) {
 93        printf("cbor_encode_byte_string failed for partition_id value: %d\n", err);
 94        if (err != CborErrorOutOfMemory) {
 95          break;
 96        }
 97      }
 98  
 99      if (err != CborNoError && err != CborErrorOutOfMemory) {
100        break;
101      }
102  
103      err = cbor_encoder_close_container(&encoder, &map_encoder);
104      if (err == CborNoError) {
105        *encoded_len = cbor_encoder_get_buffer_size(&encoder, cbor_buffer);
106      } else {
107        printf("cbor_encoder_close_container failed: %d\n", err);
108        if (err != CborErrorOutOfMemory) {
109          break;
110        }
111        size_t extra_bytes_needed = cbor_encoder_get_extra_bytes_needed(&encoder);
112        printf("extra_bytes_needed: %zu\n", extra_bytes_needed);
113      }
114    } while (0);
115  
116    return err;
117  }
118  
119  // allocates memory for d.cbor_data, caller must free.
120  CborError ConfigCborMapSrvReplyMsg::decode(ConfigCborMapSrvReplyMsg::Data &d, const uint8_t *cbor_buffer,
121                                       size_t size) {
122    CborParser parser;
123    CborValue map;
124    CborError err = cbor_parser_init(cbor_buffer, size, 0, &parser, &map);
125    uint64_t tmp_uint64;
126    d.cbor_data = NULL;
127    
128    do {
129      if (err != CborNoError) {
130        break;
131      }
132      err = cbor_value_validate_basic(&map);
133      if (err != CborNoError) {
134        break;
135      }
136      if (!cbor_value_is_map(&map)) {
137        err = CborErrorIllegalType;
138        break;
139      }
140  
141      size_t num_fields;
142      err = cbor_value_get_map_length(&map, &num_fields);
143      if (err != CborNoError) {
144        break;
145      }
146      if (num_fields != ConfigCborMapSrvReplyMsg::NUM_FIELDS) {
147        err = CborErrorUnknownLength;
148        printf("expected %zu fields but got %zu\n", ConfigCborMapSrvReplyMsg::NUM_FIELDS, num_fields);
149        break;
150      }
151  
152      CborValue value;
153      err = cbor_value_enter_container(&map, &value);
154      if (err != CborNoError) {
155        break;
156      }
157  
158      // node_id
159      if (!cbor_value_is_text_string(&value)) {
160        err = CborErrorIllegalType;
161        printf("expected string key but got something else\n");
162        break;
163      }
164      err = cbor_value_advance(&value);
165      if (err != CborNoError) {
166        break;
167      }
168      err = cbor_value_get_uint64(&value, &tmp_uint64);
169      d.node_id = tmp_uint64;
170      if (err != CborNoError) {
171        break;
172      }
173      err = cbor_value_advance(&value);
174      if (err != CborNoError) {
175        break;
176      }
177  
178      // partition_id
179      if (!cbor_value_is_text_string(&value)) {
180        err = CborErrorIllegalType;
181        printf("expected string key but got something else\n");
182        break;
183      }
184      err = cbor_value_advance(&value);
185      if (err != CborNoError) {
186        break;
187      }
188      err = cbor_value_get_uint64(&value, &tmp_uint64);
189      d.partition_id = static_cast<uint32_t>(tmp_uint64);
190      if (err != CborNoError) {
191        break;
192      }
193      err = cbor_value_advance(&value);
194      if (err != CborNoError) {
195        break;
196      }
197  
198      // success
199      if (!cbor_value_is_text_string(&value)) {
200        err = CborErrorIllegalType;
201        printf("expected string key but got something else\n");
202        break;
203      }
204      err = cbor_value_advance(&value);
205      if (err != CborNoError) {
206        break;
207      }
208      err = cbor_value_get_uint64(&value, &tmp_uint64);
209      d.success = static_cast<bool>(tmp_uint64);
210      if (err != CborNoError) {
211        break;
212      }
213      err = cbor_value_advance(&value);
214      if (err != CborNoError) {
215        break;
216      }
217  
218      // cbor_encoded_map_len
219      if (!cbor_value_is_text_string(&value)) {
220        err = CborErrorIllegalType;
221        printf("expected string key but got something else\n");
222        break;
223      }
224      err = cbor_value_advance(&value);
225      if (err != CborNoError) {
226        break;
227      }
228      err = cbor_value_get_uint64(&value, &tmp_uint64);
229      d.cbor_encoded_map_len = static_cast<uint32_t>(tmp_uint64);
230      if (err != CborNoError) {
231        break;
232      }
233      err = cbor_value_advance(&value);
234      if (err != CborNoError) {
235        break;
236      }
237  
238      // cbor_data
239      if (!cbor_value_is_text_string(&value)) {
240        err = CborErrorIllegalType;
241        printf("expected string key but got something else\n");
242        break;
243      }
244      err = cbor_value_advance(&value);
245      if (err != CborNoError) {
246        break;
247      }
248      if(d.cbor_encoded_map_len && d.success) {
249        size_t buflen = d.cbor_encoded_map_len;
250        uint8_t *buf = static_cast<uint8_t *>(pvPortMalloc(buflen));
251        configASSERT(buf);
252        err = cbor_value_copy_byte_string(&value, buf, &buflen, NULL) ;
253        d.cbor_data = buf;
254        if (err != CborNoError) {
255          break;
256        }
257        if(buflen != d.cbor_encoded_map_len) {
258          err = CborErrorIllegalType;
259          break;
260        }
261      } else {
262        d.cbor_data = NULL;
263      }
264      err = cbor_value_advance(&value);
265      if (err != CborNoError) {
266        break;
267      }
268  
269      if (err == CborNoError) {
270        err = cbor_value_leave_container(&map, &value);
271        if (err != CborNoError) {
272          break;
273        }
274        if (!cbor_value_at_end(&map)) {
275          err = CborErrorGarbageAtEnd;
276          break;
277        }
278      }
279    } while (0);
280  
281    return err;
282  }