1 /*
2 * Copyright (C) 2015-2018 Alibaba Group Holding Limited
3 */
4
5 #include "iotx_dm_internal.h"
6
7 #ifdef DEPRECATED_LINKKIT
8
9 /* #define IOTX_DM_TSL_DEVELOP_TEST */
10
11 /*****************************Internal Definition*****************************/
12
13 typedef int (*dm_shw_data_set)(_IN_ dm_shw_data_value_t *data_value,
14 _IN_ void *value, _IN_ int value_len);
15 typedef int (*dm_shw_array_set)(_IN_ dm_shw_data_value_t *data_value,
16 _IN_ void *value, _IN_ int value_len,
17 _IN_ int index);
18 typedef int (*dm_shw_data_get)(_IN_ dm_shw_data_value_t *data_value,
19 _IN_ void *value);
20 typedef int (*dm_shw_array_get)(_IN_ dm_shw_data_value_t *data_value,
21 _IN_ void *value, _IN_ int index);
22 typedef void (*dm_shw_data_free)(_IN_ dm_shw_data_value_t *data_value);
23 typedef void (*dm_shw_array_free)(_IN_ dm_shw_data_value_t *data_value);
24 typedef void (*dm_shw_data_print)(_IN_ dm_shw_data_value_t *data_value);
25
26 typedef struct {
27 dm_shw_data_type_e type;
28 const char *name;
29 dm_shw_data_set func_set;
30 dm_shw_array_set func_array_set;
31 dm_shw_data_get func_get;
32 dm_shw_array_get func_array_get;
33 dm_shw_data_free func_free;
34 dm_shw_array_free func_array_free;
35 } dm_shw_data_type_mapping_t;
36
37 /* Data Set */
38 static int _dm_shw_int_set(_IN_ dm_shw_data_value_t *data_value,
39 _IN_ void *value, _IN_ int value_len);
40 static int _dm_shw_float_set(_IN_ dm_shw_data_value_t *data_value,
41 _IN_ void *value, _IN_ int value_len);
42 static int _dm_shw_double_set(_IN_ dm_shw_data_value_t *data_value,
43 _IN_ void *value, _IN_ int value_len);
44 static int _dm_shw_text_set(_IN_ dm_shw_data_value_t *data_value,
45 _IN_ void *value, _IN_ int value_len);
46 static int _dm_shw_enum_set(_IN_ dm_shw_data_value_t *data_value,
47 _IN_ void *value, _IN_ int value_len);
48 static int _dm_shw_date_set(_IN_ dm_shw_data_value_t *data_value,
49 _IN_ void *value, _IN_ int value_len);
50 static int _dm_shw_bool_set(_IN_ dm_shw_data_value_t *data_value,
51 _IN_ void *value, _IN_ int value_len);
52
53 /* Array Data Set */
54 static int _dm_shw_array_int_set(_IN_ dm_shw_data_value_t *data_value,
55 _IN_ void *value, _IN_ int value_len,
56 _IN_ int index);
57 static int _dm_shw_array_float_set(_IN_ dm_shw_data_value_t *data_value,
58 _IN_ void *value, _IN_ int value_len,
59 _IN_ int index);
60 static int _dm_shw_array_double_set(_IN_ dm_shw_data_value_t *data_value,
61 _IN_ void *value, _IN_ int value_len,
62 _IN_ int index);
63 static int _dm_shw_array_text_set(_IN_ dm_shw_data_value_t *data_value,
64 _IN_ void *value, _IN_ int value_len,
65 _IN_ int index);
66 static int _dm_shw_array_enum_set(_IN_ dm_shw_data_value_t *data_value,
67 _IN_ void *value, _IN_ int value_len,
68 _IN_ int index);
69 static int _dm_shw_array_date_set(_IN_ dm_shw_data_value_t *data_value,
70 _IN_ void *value, _IN_ int value_len,
71 _IN_ int index);
72 static int _dm_shw_array_bool_set(_IN_ dm_shw_data_value_t *data_value,
73 _IN_ void *value, _IN_ int value_len,
74 _IN_ int index);
75
76 /* Data Get */
77 static int _dm_shw_int_get(_IN_ dm_shw_data_value_t *data_value,
78 _IN_ void *value);
79 static int _dm_shw_float_get(_IN_ dm_shw_data_value_t *data_value,
80 _IN_ void *value);
81 static int _dm_shw_double_get(_IN_ dm_shw_data_value_t *data_value,
82 _IN_ void *value);
83 static int _dm_shw_text_get(_IN_ dm_shw_data_value_t *data_value,
84 _IN_ void *value);
85 static int _dm_shw_enum_get(_IN_ dm_shw_data_value_t *data_value,
86 _IN_ void *value);
87 static int _dm_shw_date_get(_IN_ dm_shw_data_value_t *data_value,
88 _IN_ void *value);
89 static int _dm_shw_bool_get(_IN_ dm_shw_data_value_t *data_value,
90 _IN_ void *value);
91
92 /* Array Data Get */
93 static int _dm_shw_array_int_get(_IN_ dm_shw_data_value_t *data_value,
94 _IN_ void *value, _IN_ int index);
95 static int _dm_shw_array_float_get(_IN_ dm_shw_data_value_t *data_value,
96 _IN_ void *value, _IN_ int index);
97 static int _dm_shw_array_double_get(_IN_ dm_shw_data_value_t *data_value,
98 _IN_ void *value, _IN_ int index);
99 static int _dm_shw_array_text_get(_IN_ dm_shw_data_value_t *data_value,
100 _IN_ void *value, _IN_ int index);
101 static int _dm_shw_array_enum_get(_IN_ dm_shw_data_value_t *data_value,
102 _IN_ void *value, _IN_ int index);
103 static int _dm_shw_array_date_get(_IN_ dm_shw_data_value_t *data_value,
104 _IN_ void *value, _IN_ int index);
105 static int _dm_shw_array_bool_get(_IN_ dm_shw_data_value_t *data_value,
106 _IN_ void *value, _IN_ int index);
107
108 /* Data Free */
109 static void _dm_shw_int_free(_IN_ dm_shw_data_value_t *data_value);
110 static void _dm_shw_float_free(_IN_ dm_shw_data_value_t *data_value);
111 static void _dm_shw_double_free(_IN_ dm_shw_data_value_t *data_value);
112 static void _dm_shw_text_free(_IN_ dm_shw_data_value_t *data_value);
113 static void _dm_shw_enum_free(_IN_ dm_shw_data_value_t *data_value);
114 static void _dm_shw_date_free(_IN_ dm_shw_data_value_t *data_value);
115 static void _dm_shw_bool_free(_IN_ dm_shw_data_value_t *data_value);
116 static void _dm_shw_array_free(_IN_ dm_shw_data_value_t *data_value);
117 static void _dm_shw_struct_free(_IN_ dm_shw_data_value_t *data_value);
118 static void _dm_shw_property_free(_IN_ dm_shw_data_t *property);
119
120 /* Array Data Free */
121 static void _dm_shw_array_int_free(_IN_ dm_shw_data_value_t *data_value);
122 static void _dm_shw_array_float_free(_IN_ dm_shw_data_value_t *data_value);
123 static void _dm_shw_array_double_free(_IN_ dm_shw_data_value_t *data_value);
124 static void _dm_shw_array_text_free(_IN_ dm_shw_data_value_t *data_value);
125 static void _dm_shw_array_enum_free(_IN_ dm_shw_data_value_t *data_value);
126 static void _dm_shw_array_date_free(_IN_ dm_shw_data_value_t *data_value);
127 static void _dm_shw_array_bool_free(_IN_ dm_shw_data_value_t *data_value);
128 static void _dm_shw_array_array_free(_IN_ dm_shw_data_value_t *data_value);
129 static void _dm_shw_array_struct_free(_IN_ dm_shw_data_value_t *data_value);
130
131 /* Data Search */
132 static int _dm_shw_data_struct_search(_IN_ dm_shw_data_t *input, _IN_ char *key,
133 _IN_ int key_len,
134 _OU_ dm_shw_data_t **output,
135 _OU_ int *index);
136
137 static dm_shw_data_type_mapping_t g_iotx_data_type_mapping[] = {
138 { DM_SHW_DATA_TYPE_NONE, "none", NULL, NULL, NULL, NULL, NULL, NULL },
139 { DM_SHW_DATA_TYPE_INT, "int", _dm_shw_int_set, _dm_shw_array_int_set,
140 _dm_shw_int_get, _dm_shw_array_int_get, _dm_shw_int_free,
141 _dm_shw_array_int_free },
142 {
143 DM_SHW_DATA_TYPE_FLOAT,
144 "float",
145 _dm_shw_float_set,
146 _dm_shw_array_float_set,
147 _dm_shw_float_get,
148 _dm_shw_array_float_get,
149 _dm_shw_float_free,
150 _dm_shw_array_float_free,
151 },
152 {
153 DM_SHW_DATA_TYPE_DOUBLE,
154 "double",
155 _dm_shw_double_set,
156 _dm_shw_array_double_set,
157 _dm_shw_double_get,
158 _dm_shw_array_double_get,
159 _dm_shw_double_free,
160 _dm_shw_array_double_free,
161 },
162 {
163 DM_SHW_DATA_TYPE_TEXT,
164 "text",
165 _dm_shw_text_set,
166 _dm_shw_array_text_set,
167 _dm_shw_text_get,
168 _dm_shw_array_text_get,
169 _dm_shw_text_free,
170 _dm_shw_array_text_free,
171 },
172 {
173 DM_SHW_DATA_TYPE_ENUM,
174 "enum",
175 _dm_shw_enum_set,
176 _dm_shw_array_enum_set,
177 _dm_shw_enum_get,
178 _dm_shw_array_enum_get,
179 _dm_shw_enum_free,
180 _dm_shw_array_enum_free,
181 },
182 {
183 DM_SHW_DATA_TYPE_DATE,
184 "date",
185 _dm_shw_date_set,
186 _dm_shw_array_date_set,
187 _dm_shw_date_get,
188 _dm_shw_array_date_get,
189 _dm_shw_date_free,
190 _dm_shw_array_date_free,
191 },
192 {
193 DM_SHW_DATA_TYPE_BOOL,
194 "bool",
195 _dm_shw_bool_set,
196 _dm_shw_array_bool_set,
197 _dm_shw_bool_get,
198 _dm_shw_array_bool_get,
199 _dm_shw_bool_free,
200 _dm_shw_array_bool_free,
201 },
202 {
203 DM_SHW_DATA_TYPE_ARRAY,
204 "array",
205 NULL,
206 NULL,
207 NULL,
208 NULL,
209 _dm_shw_array_free,
210 _dm_shw_array_array_free,
211 },
212 {
213 DM_SHW_DATA_TYPE_STRUCT,
214 "struct",
215 NULL,
216 NULL,
217 NULL,
218 NULL,
219 _dm_shw_struct_free,
220 _dm_shw_array_struct_free,
221 }
222 };
223
224 /*****************************************************************************/
225
_dm_shw_data_array_search(_IN_ dm_shw_data_t * input,_IN_ int input_index,_IN_ char * key,_IN_ int key_len,_OU_ dm_shw_data_t ** output,_OU_ int * output_index)226 static int _dm_shw_data_array_search(_IN_ dm_shw_data_t *input,
227 _IN_ int input_index, _IN_ char *key,
228 _IN_ int key_len,
229 _OU_ dm_shw_data_t **output,
230 _OU_ int *output_index)
231 {
232 int res = 0, deli_offset = 0;
233
234 dm_shw_data_value_complex_t *complex_struct =
235 (dm_shw_data_value_complex_t *)input->data_value.value;
236 /* dm_log_debug("Current Key: %s, Len: %d",key,key_len);
237 dm_log_debug("Current Item Identifier: %s",input->identifier); */
238 res = dm_utils_memtok(key, key_len, DM_SHW_KEY_DELIMITER, 1, &deli_offset);
239 if (res != SUCCESS_RETURN) {
240 deli_offset = key_len;
241 }
242
243 switch (complex_struct->type) {
244 case DM_SHW_DATA_TYPE_INT:
245 case DM_SHW_DATA_TYPE_FLOAT:
246 case DM_SHW_DATA_TYPE_DOUBLE:
247 case DM_SHW_DATA_TYPE_TEXT:
248 case DM_SHW_DATA_TYPE_ENUM:
249 case DM_SHW_DATA_TYPE_DATE:
250 case DM_SHW_DATA_TYPE_BOOL:
251 {
252 if (deli_offset != key_len) {
253 return FAIL_RETURN;
254 }
255 if (output) {
256 *output = input;
257 }
258 if (output_index) {
259 *output_index = input_index;
260 }
261 return SUCCESS_RETURN;
262 }
263 break;
264 case DM_SHW_DATA_TYPE_STRUCT:
265 {
266 dm_shw_data_t *search_data = NULL;
267 if (complex_struct->value == NULL) {
268 return FAIL_RETURN;
269 }
270 search_data = (dm_shw_data_t *)complex_struct->value + input_index;
271 return _dm_shw_data_struct_search(search_data, key, deli_offset,
272 output, output_index);
273 }
274 break;
275 default:
276 dm_log_err("Unknown Data Type: %d", complex_struct->type);
277 break;
278 }
279
280 return FAIL_RETURN;
281 }
282
_dm_shw_data_struct_search(_IN_ dm_shw_data_t * input,_IN_ char * key,_IN_ int key_len,_OU_ dm_shw_data_t ** output,_OU_ int * index)283 static int _dm_shw_data_struct_search(_IN_ dm_shw_data_t *input, _IN_ char *key,
284 _IN_ int key_len,
285 _OU_ dm_shw_data_t **output,
286 _OU_ int *index)
287 {
288 int res = 0, item_index = 0, deli_offset = 0, partial_offset = 0;
289 int partial_input_len = 0, array_input_len = 0, array_index = 0;
290 dm_shw_data_t *data_item = NULL;
291
292 /* dm_log_debug("Current Key: %.*s",key_len,key); */
293
294 dm_shw_data_value_complex_t *complex_struct =
295 (dm_shw_data_value_complex_t *)input->data_value.value;
296
297 res = dm_utils_memtok(key, key_len, DM_SHW_KEY_DELIMITER, 1, &deli_offset);
298 if (res != SUCCESS_RETURN) {
299 deli_offset = key_len;
300 }
301
302 partial_offset = deli_offset;
303 res = dm_utils_strarr_index(key, deli_offset, &partial_input_len,
304 &array_input_len, &array_index);
305 if (res == SUCCESS_RETURN) {
306 /* dm_log_debug("Current Index: %d",array_index); */
307 partial_offset = partial_input_len;
308 }
309
310 for (item_index = 0; item_index < complex_struct->size; item_index++) {
311 data_item = (dm_shw_data_t *)complex_struct->value + item_index;
312 if (strlen(data_item->identifier) != partial_offset ||
313 memcmp(data_item->identifier, key, partial_offset) != 0) {
314 continue;
315 }
316
317 switch (data_item->data_value.type) {
318 case DM_SHW_DATA_TYPE_INT:
319 case DM_SHW_DATA_TYPE_FLOAT:
320 case DM_SHW_DATA_TYPE_DOUBLE:
321 case DM_SHW_DATA_TYPE_TEXT:
322 case DM_SHW_DATA_TYPE_ENUM:
323 case DM_SHW_DATA_TYPE_DATE:
324 case DM_SHW_DATA_TYPE_BOOL:
325 {
326 if (partial_input_len != 0 || deli_offset != key_len) {
327 return FAIL_RETURN;
328 }
329 if (output) {
330 *output = data_item;
331 }
332 return SUCCESS_RETURN;
333 }
334 break;
335 case DM_SHW_DATA_TYPE_ARRAY:
336 {
337 int key_offset = (deli_offset == key_len) ? (deli_offset - 1)
338 : (deli_offset + 1);
339 int key_len_offset =
340 (deli_offset == key_len) ? (key_len) : (deli_offset + 1);
341 if ((partial_input_len == 0) && (deli_offset == key_len)) {
342 if (output) {
343 *output = data_item;
344 }
345 return SUCCESS_RETURN;
346 }
347 if (partial_input_len == 0) {
348 return FAIL_RETURN;
349 }
350 return _dm_shw_data_array_search(
351 data_item, array_index, key + key_offset,
352 key_len - key_len_offset, output, index);
353 }
354 case DM_SHW_DATA_TYPE_STRUCT:
355 {
356 if (deli_offset == key_len) {
357 if (output) {
358 *output = data_item;
359 }
360 return SUCCESS_RETURN;
361 }
362 if (partial_input_len != 0) {
363 return FAIL_RETURN;
364 }
365 return _dm_shw_data_struct_search(
366 data_item, key + deli_offset + 1, key_len - deli_offset - 1,
367 output, index);
368 }
369 default:
370 dm_log_err("Unknown Data Type");
371 break;
372 }
373 }
374
375 return FAIL_RETURN;
376 }
377
_dm_shw_data_search(_IN_ dm_shw_data_t * input,_IN_ char * key,_IN_ int key_len,_OU_ dm_shw_data_t ** output,_OU_ int * index)378 static int _dm_shw_data_search(_IN_ dm_shw_data_t *input, _IN_ char *key,
379 _IN_ int key_len, _OU_ dm_shw_data_t **output,
380 _OU_ int *index)
381 {
382 int res = 0, deli_offset = 0, partial_offset = 0;
383 int partial_input_len = 0, array_input_len = 0, array_index = 0;
384
385 if (input == NULL || key == NULL || key_len <= 0) {
386 return DM_INVALID_PARAMETER;
387 }
388
389 res = dm_utils_memtok(key, key_len, DM_SHW_KEY_DELIMITER, 1, &deli_offset);
390 if (res != SUCCESS_RETURN) {
391 deli_offset = key_len;
392 }
393
394 partial_offset = deli_offset;
395 res = dm_utils_strarr_index(key, deli_offset, &partial_input_len,
396 &array_input_len, &array_index);
397 if (res == SUCCESS_RETURN) {
398 /* dm_log_debug("Current Index: %d",array_index); */
399 partial_offset = partial_input_len;
400 }
401
402 /* dm_log_debug("Current Input Identifier: %s",input->identifier);
403 dm_log_debug("Current Compare Key: %.*s",partial_offset,key); */
404
405 if (strlen(input->identifier) != partial_offset ||
406 memcmp(input->identifier, key, partial_offset) != 0) {
407 return FAIL_RETURN;
408 }
409 dm_log_debug("Identifier Found: %s", input->identifier);
410
411 switch (input->data_value.type) {
412 case DM_SHW_DATA_TYPE_INT:
413 case DM_SHW_DATA_TYPE_FLOAT:
414 case DM_SHW_DATA_TYPE_DOUBLE:
415 case DM_SHW_DATA_TYPE_TEXT:
416 case DM_SHW_DATA_TYPE_ENUM:
417 case DM_SHW_DATA_TYPE_DATE:
418 case DM_SHW_DATA_TYPE_BOOL:
419 {
420 if (partial_input_len != 0 || deli_offset != key_len) {
421 return FAIL_RETURN;
422 }
423 if (output) {
424 *output = input;
425 }
426 return SUCCESS_RETURN;
427 }
428 break;
429 case DM_SHW_DATA_TYPE_ARRAY:
430 {
431 int key_offset = (deli_offset == key_len) ? (deli_offset - 1)
432 : (deli_offset + 1);
433 int key_len_offset =
434 (deli_offset == key_len) ? (key_len) : (deli_offset + 1);
435 if ((partial_input_len == 0) && (deli_offset == key_len)) {
436 if (output) {
437 *output = input;
438 }
439 return SUCCESS_RETURN;
440 }
441 if (partial_input_len == 0) {
442 return FAIL_RETURN;
443 }
444 return _dm_shw_data_array_search(
445 input, array_index, key + key_offset, key_len - key_len_offset,
446 output, index);
447 }
448 break;
449 case DM_SHW_DATA_TYPE_STRUCT:
450 {
451 if (deli_offset == key_len) {
452 if (output) {
453 *output = input;
454 }
455 return SUCCESS_RETURN;
456 }
457 if (partial_input_len != 0) {
458 return FAIL_RETURN;
459 }
460 return _dm_shw_data_struct_search(input, key + deli_offset + 1,
461 key_len - deli_offset - 1, output,
462 index);
463 }
464 break;
465 default:
466 dm_log_err("Unknow Data Type");
467 break;
468 }
469
470 return FAIL_RETURN;
471 }
472
_dm_shw_property_search(_IN_ dm_shw_t * shadow,_IN_ char * key,_IN_ int key_len,_OU_ dm_shw_data_t ** property,_OU_ int * index)473 static int _dm_shw_property_search(_IN_ dm_shw_t *shadow, _IN_ char *key,
474 _IN_ int key_len,
475 _OU_ dm_shw_data_t **property,
476 _OU_ int *index)
477 {
478 int res = 0, item_index = 0;
479 dm_shw_data_t *property_item = NULL;
480
481 if (shadow == NULL || key == NULL || key_len <= 0) {
482 return DM_INVALID_PARAMETER;
483 }
484
485 if (shadow->property_number == 0 || shadow->properties == NULL) {
486 return DM_TSL_PROPERTY_NOT_EXIST;
487 }
488
489 for (item_index = 0; item_index < shadow->property_number; item_index++) {
490 property_item = shadow->properties + item_index;
491 res = _dm_shw_data_search(property_item, key, key_len, property, index);
492 if (res == SUCCESS_RETURN) {
493 return SUCCESS_RETURN;
494 }
495 }
496
497 return FAIL_RETURN;
498 }
499
_dm_shw_event_output_search(_IN_ dm_shw_data_t * outputdatas,_IN_ int number,_IN_ char * key,_IN_ int key_len,_OU_ dm_shw_data_t ** event_data,_OU_ int * index)500 static int _dm_shw_event_output_search(_IN_ dm_shw_data_t *outputdatas,
501 _IN_ int number, _IN_ char *key,
502 _IN_ int key_len,
503 _OU_ dm_shw_data_t **event_data,
504 _OU_ int *index)
505 {
506 int res = 0, item_index = 0;
507 dm_shw_data_t *outputdata = NULL;
508
509 if (outputdatas == NULL || number <= 0 || key == NULL || key_len <= 0) {
510 return DM_INVALID_PARAMETER;
511 }
512
513 for (item_index = 0; item_index < number; item_index++) {
514 outputdata = outputdatas + item_index;
515 res = _dm_shw_data_search(outputdata, key, key_len, event_data, index);
516 if (res == SUCCESS_RETURN) {
517 return SUCCESS_RETURN;
518 }
519 }
520
521 return SUCCESS_RETURN;
522 }
523
_dm_shw_event_search(_IN_ dm_shw_t * shadow,_IN_ char * key,_IN_ int key_len,_OU_ dm_shw_event_t ** event)524 static int _dm_shw_event_search(_IN_ dm_shw_t *shadow, _IN_ char *key,
525 _IN_ int key_len, _OU_ dm_shw_event_t **event)
526 {
527 int index = 0;
528 dm_shw_event_t *dtsl_event = NULL;
529
530 if (shadow == NULL || key == NULL || key_len <= 0) {
531 return DM_INVALID_PARAMETER;
532 }
533
534 for (index = 0; index < shadow->event_number; index++) {
535 dtsl_event = shadow->events + index;
536 if ((strlen(dtsl_event->identifier) == key_len) &&
537 (memcmp(dtsl_event->identifier, key, key_len) == 0)) {
538 /* dm_log_debug("TSL Event Found: %s",dtsl_event->identifier); */
539 if (event) {
540 *event = dtsl_event;
541 }
542 return SUCCESS_RETURN;
543 }
544 }
545
546 /* dm_log_debug("TSL Event Not Found: %.*s",key_len,key); */
547
548 return FAIL_RETURN;
549 }
550
_dm_shw_service_input_output_search(_IN_ dm_shw_data_target_e type,_IN_ dm_shw_service_t * service,_IN_ char * key,_IN_ int key_len,_OU_ dm_shw_data_t ** service_data,_OU_ int * index)551 static int _dm_shw_service_input_output_search(
552 _IN_ dm_shw_data_target_e type, _IN_ dm_shw_service_t *service,
553 _IN_ char *key, _IN_ int key_len, _OU_ dm_shw_data_t **service_data,
554 _OU_ int *index)
555 {
556 int res = 0, item_index = 0, datas_number = 0;
557 dm_shw_data_t *datas = NULL;
558 dm_shw_data_t *data = NULL;
559
560 if (type == DM_SHW_DATA_TARGET_SERVICE_INPUT_DATA) {
561 datas = service->input_datas;
562 datas_number = service->input_data_number;
563 } else {
564 datas = service->output_datas;
565 datas_number = service->output_data_number;
566 }
567
568 for (item_index = 0; item_index < datas_number; item_index++) {
569 data = datas + item_index;
570 res = _dm_shw_data_search(data, key, key_len, service_data, index);
571 if (res == SUCCESS_RETURN) {
572 return SUCCESS_RETURN;
573 }
574 }
575
576 return SUCCESS_RETURN;
577 }
578
_dm_shw_service_search(_IN_ dm_shw_t * shadow,_IN_ char * key,_IN_ int key_len,_OU_ dm_shw_service_t ** service)579 static int _dm_shw_service_search(_IN_ dm_shw_t *shadow, _IN_ char *key,
580 _IN_ int key_len,
581 _OU_ dm_shw_service_t **service)
582 {
583 int index = 0;
584 dm_shw_service_t *dtsl_service = NULL;
585
586 if (shadow == NULL || key == NULL || key_len <= 0) {
587 return DM_INVALID_PARAMETER;
588 }
589
590 for (index = 0; index < shadow->service_number; index++) {
591 dtsl_service = shadow->services + index;
592 if ((strlen(dtsl_service->identifier) == key_len) &&
593 (memcmp(dtsl_service->identifier, key, key_len) == 0)) {
594 /* dm_log_debug("TSL Service Found: %s",dtsl_service->identifier);
595 */
596 if (service) {
597 *service = dtsl_service;
598 }
599 return SUCCESS_RETURN;
600 }
601 }
602
603 /* dm_log_debug("TSL Service Not Found: %.*s",key_len,key); */
604
605 return FAIL_RETURN;
606 }
607
dm_shw_create(_IN_ iotx_dm_tsl_type_t type,_IN_ const char * tsl,_IN_ int tsl_len,_OU_ dm_shw_t ** shadow)608 int dm_shw_create(_IN_ iotx_dm_tsl_type_t type, _IN_ const char *tsl,
609 _IN_ int tsl_len, _OU_ dm_shw_t **shadow)
610 {
611 int res = 0;
612
613 if (shadow == NULL || *shadow != NULL || tsl == NULL || tsl_len <= 0) {
614 return DM_INVALID_PARAMETER;
615 }
616
617 switch (type) {
618 case IOTX_DM_TSL_TYPE_ALINK:
619 {
620 res = dm_tsl_alink_create(tsl, tsl_len, shadow);
621 }
622 break;
623 case IOTX_DM_TSL_TYPE_TLV:
624 {
625 /* TODO for yusan*/
626 res = FAIL_RETURN;
627 }
628 break;
629 default:
630 dm_log_err("Unknown TSL Type");
631 res = FAIL_RETURN;
632 break;
633 }
634
635 return res;
636 }
637
dm_shw_get_property_data(_IN_ dm_shw_t * shadow,_IN_ char * key,_IN_ int key_len,_OU_ void ** data)638 int dm_shw_get_property_data(_IN_ dm_shw_t *shadow, _IN_ char *key,
639 _IN_ int key_len, _OU_ void **data)
640 {
641 int res = 0;
642
643 if (shadow == NULL || key == NULL || key_len <= 0 || data == NULL ||
644 *data != NULL) {
645 return DM_INVALID_PARAMETER;
646 }
647
648 res = _dm_shw_property_search(shadow, key, key_len, (dm_shw_data_t **)data,
649 NULL);
650 if (res != SUCCESS_RETURN) {
651 return DM_TSL_PROPERTY_NOT_EXIST;
652 }
653
654 return SUCCESS_RETURN;
655 }
656
dm_shw_get_service_input_output_data(_IN_ dm_shw_data_target_e type,_IN_ dm_shw_t * shadow,_IN_ char * key,_IN_ int key_len,_OU_ void ** data)657 int dm_shw_get_service_input_output_data(_IN_ dm_shw_data_target_e type,
658 _IN_ dm_shw_t *shadow, _IN_ char *key,
659 _IN_ int key_len, _OU_ void **data)
660 {
661 int res = 0;
662 int offset = 0, array_index = 0;
663 char *pos = NULL;
664 dm_shw_service_t *service = NULL;
665 dm_shw_data_t *service_data = NULL;
666
667 if (type < DM_SHW_DATA_TARGET_SERVICE_INPUT_DATA ||
668 type > DM_SHW_DATA_TARGET_SERVICE_OUTPUT_DATA || shadow == NULL ||
669 key == NULL || key_len <= 0) {
670 return DM_INVALID_PARAMETER;
671 }
672
673 res = dm_utils_memtok(key, key_len, DM_SHW_KEY_DELIMITER, 1, &offset);
674 if (res != SUCCESS_RETURN) {
675 return FAIL_RETURN;
676 }
677
678 dm_log_debug("Key: %.*s", key_len, key);
679
680 res = _dm_shw_service_search(shadow, key, offset, &service);
681 if (res != SUCCESS_RETURN) {
682 return DM_TSL_EVENT_NOT_EXIST;
683 }
684
685 pos = key + offset + 1;
686 dm_log_debug("TSL Service input/output Data Search, Event Data ID: %s",
687 pos);
688
689 res = _dm_shw_service_input_output_search(type, service, pos, strlen(pos),
690 &service_data, &array_index);
691 if (res != SUCCESS_RETURN) {
692 return DM_TSL_EVENT_NOT_EXIST;
693 }
694
695 if (data) {
696 *data = (void *)service_data;
697 }
698
699 return SUCCESS_RETURN;
700 }
701
dm_shw_get_event_output_data(_IN_ dm_shw_t * shadow,_IN_ char * key,_IN_ int key_len,_OU_ void ** data)702 int dm_shw_get_event_output_data(_IN_ dm_shw_t *shadow, _IN_ char *key,
703 _IN_ int key_len, _OU_ void **data)
704 {
705 int res = 0;
706 int offset = 0, array_index = 0;
707 char *pos = NULL;
708 dm_shw_event_t *event = NULL;
709 dm_shw_data_t *event_data = NULL;
710
711 if (shadow == NULL || key == NULL || key_len <= 0) {
712 return DM_INVALID_PARAMETER;
713 }
714
715 res = dm_utils_memtok(key, key_len, DM_SHW_KEY_DELIMITER, 1, &offset);
716 if (res != SUCCESS_RETURN) {
717 return FAIL_RETURN;
718 }
719
720 dm_log_debug("Key: %.*s", key_len, key);
721
722 res = _dm_shw_event_search(shadow, key, offset, &event);
723 if (res != SUCCESS_RETURN) {
724 return DM_TSL_EVENT_NOT_EXIST;
725 }
726
727 pos = key + offset + 1;
728 /* dm_log_debug("TSL Event Output Data Search, Event Data ID: %s",pos); */
729
730 res = _dm_shw_event_output_search(event->output_datas,
731 event->output_data_number, pos,
732 strlen(pos), &event_data, &array_index);
733 if (res != SUCCESS_RETURN) {
734 return DM_TSL_EVENT_NOT_EXIST;
735 }
736
737 if (data) {
738 *data = (void *)event_data;
739 }
740
741 return SUCCESS_RETURN;
742 }
743
dm_shw_get_data_type(_IN_ void * data,_OU_ dm_shw_data_type_e * type)744 int dm_shw_get_data_type(_IN_ void *data, _OU_ dm_shw_data_type_e *type)
745 {
746 dm_shw_data_t *data_item = (dm_shw_data_t *)data;
747
748 if (data_item == NULL || type == NULL) {
749 return DM_INVALID_PARAMETER;
750 }
751
752 if (data_item->data_value.type == DM_SHW_DATA_TYPE_ARRAY) {
753 dm_shw_data_value_complex_t *complex_value =
754 (dm_shw_data_value_complex_t *)data_item->data_value.value;
755 *type = complex_value->type;
756 } else {
757 *type = data_item->data_value.type;
758 }
759
760 return SUCCESS_RETURN;
761 }
762
dm_shw_get_event(_IN_ dm_shw_t * shadow,_IN_ char * key,_IN_ int key_len,_OU_ void ** event)763 int dm_shw_get_event(_IN_ dm_shw_t *shadow, _IN_ char *key, _IN_ int key_len,
764 _OU_ void **event)
765 {
766 int index = 0;
767 dm_shw_event_t *dtsl_event = NULL;
768
769 if (shadow == NULL || key == NULL || key_len <= 0) {
770 return DM_INVALID_PARAMETER;
771 }
772
773 for (index = 0; index < shadow->event_number; index++) {
774 dtsl_event = shadow->events + index;
775 if ((strlen(dtsl_event->identifier) == key_len) &&
776 (memcmp(dtsl_event->identifier, key, key_len) == 0)) {
777 if (event) {
778 *event = (dm_shw_event_t *)dtsl_event;
779 }
780 return SUCCESS_RETURN;
781 }
782 }
783
784 return FAIL_RETURN;
785 }
786
dm_shw_get_service(_IN_ dm_shw_t * shadow,_IN_ char * key,_IN_ int key_len,_OU_ void ** service)787 int dm_shw_get_service(_IN_ dm_shw_t *shadow, _IN_ char *key, _IN_ int key_len,
788 _OU_ void **service)
789 {
790 int index = 0;
791 dm_shw_service_t *dtsl_service = NULL;
792
793 if (shadow == NULL || key == NULL || key_len <= 0) {
794 return DM_INVALID_PARAMETER;
795 }
796
797 for (index = 0; index < shadow->event_number; index++) {
798 dtsl_service = shadow->services + index;
799 if ((strlen(dtsl_service->identifier) == key_len) &&
800 (memcmp(dtsl_service->identifier, key, key_len) == 0)) {
801 if (service) {
802 *service = (dm_shw_service_t *)dtsl_service;
803 }
804 return SUCCESS_RETURN;
805 }
806 }
807
808 return FAIL_RETURN;
809 }
810
dm_shw_get_property_number(_IN_ dm_shw_t * shadow,_OU_ int * number)811 int dm_shw_get_property_number(_IN_ dm_shw_t *shadow, _OU_ int *number)
812 {
813 if (shadow == NULL || number == NULL) {
814 return DM_INVALID_PARAMETER;
815 }
816
817 *number = shadow->property_number;
818
819 return SUCCESS_RETURN;
820 }
821
dm_shw_get_service_number(_IN_ dm_shw_t * shadow,_OU_ int * number)822 int dm_shw_get_service_number(_IN_ dm_shw_t *shadow, _OU_ int *number)
823 {
824 if (shadow == NULL || number == NULL) {
825 return DM_INVALID_PARAMETER;
826 }
827
828 *number = shadow->service_number;
829
830 return SUCCESS_RETURN;
831 }
832
dm_shw_get_event_number(_IN_ dm_shw_t * shadow,_OU_ int * number)833 int dm_shw_get_event_number(_IN_ dm_shw_t *shadow, _OU_ int *number)
834 {
835 if (shadow == NULL || number == NULL) {
836 return DM_INVALID_PARAMETER;
837 }
838
839 *number = shadow->event_number;
840
841 return SUCCESS_RETURN;
842 }
843
dm_shw_get_property_by_index(_IN_ dm_shw_t * shadow,_IN_ int index,_OU_ void ** property)844 int dm_shw_get_property_by_index(_IN_ dm_shw_t *shadow, _IN_ int index,
845 _OU_ void **property)
846 {
847 if (shadow == NULL || index < 0 || index >= shadow->property_number ||
848 property == NULL || *property != NULL) {
849 return DM_INVALID_PARAMETER;
850 }
851
852 *property = (void *)(shadow->properties + index);
853
854 return SUCCESS_RETURN;
855 }
856
dm_shw_get_service_by_index(_IN_ dm_shw_t * shadow,_IN_ int index,_OU_ void ** service)857 int dm_shw_get_service_by_index(_IN_ dm_shw_t *shadow, _IN_ int index,
858 _OU_ void **service)
859 {
860 if (shadow == NULL || index < 0 || index >= shadow->service_number ||
861 service == NULL || *service != NULL) {
862 return DM_INVALID_PARAMETER;
863 }
864
865 *service = (void *)(shadow->services + index);
866
867 return SUCCESS_RETURN;
868 }
869
dm_shw_get_event_by_index(_IN_ dm_shw_t * shadow,_IN_ int index,_OU_ void ** event)870 int dm_shw_get_event_by_index(_IN_ dm_shw_t *shadow, _IN_ int index,
871 _OU_ void **event)
872 {
873 if (shadow == NULL || index < 0 || index >= shadow->event_number ||
874 event == NULL || *event != NULL) {
875 return DM_INVALID_PARAMETER;
876 }
877
878 *event = (void *)(shadow->events + index);
879
880 return SUCCESS_RETURN;
881 }
882
dm_shw_get_service_by_identifier(_IN_ dm_shw_t * shadow,_IN_ char * identifier,_OU_ void ** service)883 int dm_shw_get_service_by_identifier(_IN_ dm_shw_t *shadow,
884 _IN_ char *identifier, _OU_ void **service)
885 {
886 int index = 0;
887 dm_shw_service_t *search_service = NULL;
888
889 if (shadow == NULL || identifier == NULL || service == NULL ||
890 *service != NULL) {
891 return DM_INVALID_PARAMETER;
892 }
893
894 for (index = 0; index < shadow->service_number; index++) {
895 search_service = shadow->services + index;
896 if ((strlen(search_service->identifier) == strlen(identifier)) &&
897 (memcmp(search_service->identifier, identifier,
898 strlen(identifier)) == 0)) {
899 *service = (void *)search_service;
900 return SUCCESS_RETURN;
901 }
902 }
903
904 return FAIL_RETURN;
905 }
906
dm_shw_get_event_by_identifier(_IN_ dm_shw_t * shadow,_IN_ char * identifier,_OU_ void ** event)907 int dm_shw_get_event_by_identifier(_IN_ dm_shw_t *shadow, _IN_ char *identifier,
908 _OU_ void **event)
909 {
910 int index = 0;
911 dm_shw_event_t *search_event = NULL;
912
913 if (shadow == NULL || identifier == NULL || event == NULL ||
914 *event != NULL) {
915 return DM_INVALID_PARAMETER;
916 }
917
918 for (index = 0; index < shadow->event_number; index++) {
919 search_event = shadow->events + index;
920 if ((strlen(search_event->identifier) == strlen(identifier)) &&
921 (memcmp(search_event->identifier, identifier, strlen(identifier)) ==
922 0)) {
923 *event = (void *)search_event;
924 return SUCCESS_RETURN;
925 }
926 }
927
928 return FAIL_RETURN;
929 }
930
dm_shw_get_property_identifier(_IN_ void * property,_OU_ char ** identifier)931 int dm_shw_get_property_identifier(_IN_ void *property, _OU_ char **identifier)
932 {
933 dm_shw_data_t *property_item = (dm_shw_data_t *)property;
934
935 if (property_item == NULL || identifier == NULL || *identifier != NULL) {
936 return DM_INVALID_PARAMETER;
937 }
938
939 *identifier = property_item->identifier;
940
941 return SUCCESS_RETURN;
942 }
943
dm_shw_get_service_method(_IN_ void * service,_OU_ char ** method)944 int dm_shw_get_service_method(_IN_ void *service, _OU_ char **method)
945 {
946 int service_method_len = 0;
947 const char *service_method_fmt = "thing.service.%s";
948 dm_shw_service_t *service_item = (dm_shw_service_t *)service;
949
950 if (service_item == NULL || method == NULL || *method != NULL) {
951 return DM_INVALID_PARAMETER;
952 }
953
954 service_method_len =
955 (strlen(service_method_fmt) + strlen(service_item->identifier) + 1);
956 *method = DM_malloc(service_method_len);
957 if (*method == NULL) {
958 return DM_MEMORY_NOT_ENOUGH;
959 }
960 memset(*method, 0, service_method_len);
961 HAL_Snprintf(*method, service_method_len, service_method_fmt,
962 service_item->identifier);
963
964 return SUCCESS_RETURN;
965 }
966
dm_shw_get_event_method(_IN_ void * event,_OU_ char ** method)967 int dm_shw_get_event_method(_IN_ void *event, _OU_ char **method)
968 {
969 int event_method_len = 0;
970 const char *post_identifier = "post";
971 const char *property_identifier = "property";
972 const char *identifier = NULL;
973 const char *event_method_fmt = "thing.event.%s.post";
974 dm_shw_event_t *event_item = (dm_shw_event_t *)event;
975
976 if (event_item == NULL || method == NULL || *method != NULL) {
977 return DM_INVALID_PARAMETER;
978 }
979
980 /* God Damn It Special Case! */
981 if ((strlen(event_item->identifier) == strlen(post_identifier)) &&
982 (memcmp(event_item->identifier, post_identifier,
983 strlen(post_identifier)) == 0)) {
984 identifier = property_identifier;
985 } else {
986 identifier = (const char *)event_item->identifier;
987 }
988
989 event_method_len = (strlen(event_method_fmt) + strlen(identifier) + 1);
990 *method = DM_malloc(event_method_len);
991 if (*method == NULL) {
992 return DM_MEMORY_NOT_ENOUGH;
993 }
994 memset(*method, 0, event_method_len);
995 HAL_Snprintf(*method, event_method_len, event_method_fmt, identifier);
996
997 return SUCCESS_RETURN;
998 }
999
_dm_shw_int_set(_IN_ dm_shw_data_value_t * data_value,_IN_ void * value,_IN_ int value_len)1000 static int _dm_shw_int_set(_IN_ dm_shw_data_value_t *data_value,
1001 _IN_ void *value, _IN_ int value_len)
1002 {
1003 int int_set = (value == NULL) ? (0) : (*(int *)value);
1004
1005 data_value->value_int = int_set;
1006 dm_log_debug("Current Int Value Be Set(Int): %d", data_value->value_int);
1007
1008 return SUCCESS_RETURN;
1009 }
1010
_dm_shw_float_set(_IN_ dm_shw_data_value_t * data_value,_IN_ void * value,_IN_ int value_len)1011 static int _dm_shw_float_set(_IN_ dm_shw_data_value_t *data_value,
1012 _IN_ void *value, _IN_ int value_len)
1013 {
1014 float float_set = (value == NULL) ? (0) : (*(float *)value);
1015
1016 data_value->value_float = float_set;
1017 dm_log_debug("Current Float Value Be Set(Float): %f",
1018 data_value->value_float);
1019
1020 return SUCCESS_RETURN;
1021 }
1022
_dm_shw_double_set(_IN_ dm_shw_data_value_t * data_value,_IN_ void * value,_IN_ int value_len)1023 static int _dm_shw_double_set(_IN_ dm_shw_data_value_t *data_value,
1024 _IN_ void *value, _IN_ int value_len)
1025 {
1026 double double_set = (value == NULL) ? (0) : (*(double *)value);
1027
1028 data_value->value_double = double_set;
1029 dm_log_debug("Current Double Value Be Set(Double): %f",
1030 data_value->value_double);
1031
1032 return SUCCESS_RETURN;
1033 }
1034
_dm_shw_text_set(_IN_ dm_shw_data_value_t * data_value,_IN_ void * value,_IN_ int value_len)1035 static int _dm_shw_text_set(_IN_ dm_shw_data_value_t *data_value,
1036 _IN_ void *value, _IN_ int value_len)
1037 {
1038 int res = 0;
1039 char *value_set = (value == NULL) ? ("NULL") : ((char *)value);
1040 int value_set_len = (value == NULL) ? (strlen("NULL")) : (value_len);
1041
1042 if (data_value->value) {
1043 DM_free(data_value->value);
1044 data_value->value = NULL;
1045 }
1046 res = dm_utils_copy(value_set, value_set_len, &data_value->value,
1047 value_set_len + 1);
1048 if (res != SUCCESS_RETURN) {
1049 return DM_MEMORY_NOT_ENOUGH;
1050 }
1051 dm_log_debug("Current Text Value Be Set(String): %s", data_value->value);
1052
1053 return SUCCESS_RETURN;
1054 }
1055
_dm_shw_enum_set(_IN_ dm_shw_data_value_t * data_value,_IN_ void * value,_IN_ int value_len)1056 static int _dm_shw_enum_set(_IN_ dm_shw_data_value_t *data_value,
1057 _IN_ void *value, _IN_ int value_len)
1058 {
1059 int enum_set = (value == NULL) ? (0) : (*(int *)value);
1060
1061 enum_set = (enum_set < 0) ? (0) : (enum_set);
1062
1063 data_value->value_int = enum_set;
1064 dm_log_debug("Current Enum Value Be Set(Enum): %d", data_value->value_int);
1065
1066 return SUCCESS_RETURN;
1067 }
1068
_dm_shw_date_set(_IN_ dm_shw_data_value_t * data_value,_IN_ void * value,_IN_ int value_len)1069 static int _dm_shw_date_set(_IN_ dm_shw_data_value_t *data_value,
1070 _IN_ void *value, _IN_ int value_len)
1071 {
1072 int res = 0;
1073 char *value_set = (value == NULL) ? ("NULL") : ((char *)value);
1074 int value_set_len = (value == NULL) ? (strlen("NULL")) : (value_len);
1075
1076 if (data_value->value) {
1077 DM_free(data_value->value);
1078 data_value->value = NULL;
1079 }
1080 res = dm_utils_copy(value_set, value_set_len, &data_value->value,
1081 value_set_len + 1);
1082 if (res != SUCCESS_RETURN) {
1083 return DM_MEMORY_NOT_ENOUGH;
1084 }
1085 dm_log_debug("Current Date Value Be Set(String): %s", data_value->value);
1086
1087 return SUCCESS_RETURN;
1088 }
1089
_dm_shw_bool_set(_IN_ dm_shw_data_value_t * data_value,_IN_ void * value,_IN_ int value_len)1090 static int _dm_shw_bool_set(_IN_ dm_shw_data_value_t *data_value,
1091 _IN_ void *value, _IN_ int value_len)
1092 {
1093 int int_set = (value == NULL) ? (0) : (*(int *)value);
1094
1095 int_set = (int_set == 0) ? (int_set) : ((int_set == 1) ? (int_set) : (0));
1096
1097 data_value->value_int = int_set;
1098 dm_log_debug("Current Bool Value Be Set(Bool): %d", data_value->value_int);
1099
1100 return SUCCESS_RETURN;
1101 }
1102
_dm_shw_array_int_set(_IN_ dm_shw_data_value_t * data_value,_IN_ void * value,_IN_ int value_len,_IN_ int index)1103 static int _dm_shw_array_int_set(_IN_ dm_shw_data_value_t *data_value,
1104 _IN_ void *value, _IN_ int value_len,
1105 _IN_ int index)
1106 {
1107 dm_shw_data_value_complex_t *complex_array = data_value->value;
1108 int int_set = (value == NULL) ? (0) : (*(int *)value);
1109
1110 *((int *)(complex_array->value) + index) = int_set;
1111 dm_log_debug("Current Array Value Be Set(Int), Index: %d, Value: %d", index,
1112 *((int *)(complex_array->value) + index));
1113
1114 return SUCCESS_RETURN;
1115 }
1116
_dm_shw_array_float_set(_IN_ dm_shw_data_value_t * data_value,_IN_ void * value,_IN_ int value_len,_IN_ int index)1117 static int _dm_shw_array_float_set(_IN_ dm_shw_data_value_t *data_value,
1118 _IN_ void *value, _IN_ int value_len,
1119 _IN_ int index)
1120 {
1121 dm_shw_data_value_complex_t *complex_array = data_value->value;
1122 float float_set = (value == NULL) ? (0) : (*(float *)value);
1123
1124 *((float *)(complex_array->value) + index) = float_set;
1125 dm_log_debug("Current Array Value Be Set(Float), Index: %d, Value: %f",
1126 index, *((float *)(complex_array->value) + index));
1127
1128 return SUCCESS_RETURN;
1129 }
1130
_dm_shw_array_double_set(_IN_ dm_shw_data_value_t * data_value,_IN_ void * value,_IN_ int value_len,_IN_ int index)1131 static int _dm_shw_array_double_set(_IN_ dm_shw_data_value_t *data_value,
1132 _IN_ void *value, _IN_ int value_len,
1133 _IN_ int index)
1134 {
1135 dm_shw_data_value_complex_t *complex_array = data_value->value;
1136 double double_set = (value == NULL) ? (0) : (*(double *)value);
1137
1138 *((double *)(complex_array->value) + index) = double_set;
1139 dm_log_debug("Current Array Value Be Set(Double), Index: %d, Value: %f",
1140 index, *((double *)(complex_array->value) + index));
1141
1142 return SUCCESS_RETURN;
1143 }
1144
_dm_shw_array_text_set(_IN_ dm_shw_data_value_t * data_value,_IN_ void * value,_IN_ int value_len,_IN_ int index)1145 static int _dm_shw_array_text_set(_IN_ dm_shw_data_value_t *data_value,
1146 _IN_ void *value, _IN_ int value_len,
1147 _IN_ int index)
1148 {
1149 int res = 0;
1150 dm_shw_data_value_complex_t *complex_array = data_value->value;
1151 char *text_set = (value == NULL) ? ("NULL") : ((char *)value);
1152 int value_set_len = (value == NULL) ? (strlen("NULL")) : (value_len);
1153
1154 if (*((char **)(complex_array->value) + index)) {
1155 DM_free(*((char **)(complex_array->value) + index));
1156 *((char **)(complex_array->value) + index) = NULL;
1157 }
1158
1159 res = dm_utils_copy(text_set, value_set_len,
1160 (void **)((char **)(complex_array->value) + index),
1161 value_set_len + 1);
1162 if (res != SUCCESS_RETURN) {
1163 return FAIL_RETURN;
1164 }
1165 dm_log_debug(
1166 "Current Array Value Be Set(Text String), Index: %d, Value: %s", index,
1167 *((char **)(complex_array->value) + index));
1168
1169 return SUCCESS_RETURN;
1170 }
1171
_dm_shw_array_enum_set(_IN_ dm_shw_data_value_t * data_value,_IN_ void * value,_IN_ int value_len,_IN_ int index)1172 static int _dm_shw_array_enum_set(_IN_ dm_shw_data_value_t *data_value,
1173 _IN_ void *value, _IN_ int value_len,
1174 _IN_ int index)
1175 {
1176 dm_shw_data_value_complex_t *complex_array = data_value->value;
1177 int int_set = (value == NULL) ? (0) : (*(int *)value);
1178
1179 *((int *)(complex_array->value) + index) = int_set;
1180 dm_log_debug("Current Array Value Be Set(Enum), Index: %d, Value: %d",
1181 index, *((int *)(complex_array->value) + index));
1182
1183 return SUCCESS_RETURN;
1184 }
1185
_dm_shw_array_date_set(_IN_ dm_shw_data_value_t * data_value,_IN_ void * value,_IN_ int value_len,_IN_ int index)1186 static int _dm_shw_array_date_set(_IN_ dm_shw_data_value_t *data_value,
1187 _IN_ void *value, _IN_ int value_len,
1188 _IN_ int index)
1189 {
1190 int res = 0;
1191 dm_shw_data_value_complex_t *complex_array = data_value->value;
1192 char *text_set = (value == NULL) ? ("NULL") : ((char *)value);
1193 int value_set_len = (value == NULL) ? (strlen("NULL")) : (value_len);
1194
1195 if (*((char **)(complex_array->value) + index)) {
1196 DM_free(*((char **)(complex_array->value) + index));
1197 *((char **)(complex_array->value) + index) = NULL;
1198 }
1199
1200 res = dm_utils_copy(text_set, value_set_len,
1201 (void **)((char **)(complex_array->value) + index),
1202 value_set_len + 1);
1203 if (res != SUCCESS_RETURN) {
1204 return FAIL_RETURN;
1205 }
1206 dm_log_debug(
1207 "Current Array Value Be Set(Date String), Index: %d, Value: %s", index,
1208 *((char **)(complex_array->value) + index));
1209
1210 return SUCCESS_RETURN;
1211 }
1212
_dm_shw_array_bool_set(_IN_ dm_shw_data_value_t * data_value,_IN_ void * value,_IN_ int value_len,_IN_ int index)1213 static int _dm_shw_array_bool_set(_IN_ dm_shw_data_value_t *data_value,
1214 _IN_ void *value, _IN_ int value_len,
1215 _IN_ int index)
1216 {
1217 dm_shw_data_value_complex_t *complex_array = data_value->value;
1218 int int_set = (value == NULL) ? (0) : (*(int *)value);
1219
1220 *((int *)(complex_array->value) + index) = int_set;
1221 dm_log_debug("Current Array Value Be Set(Bool), Index: %d, Value: %d",
1222 index, *((int *)(complex_array->value) + index));
1223
1224 return SUCCESS_RETURN;
1225 }
1226
_dm_shw_data_array_set(_IN_ dm_shw_data_value_t * data_value,_IN_ void * value,_IN_ int value_len,_IN_ int index)1227 static int _dm_shw_data_array_set(_IN_ dm_shw_data_value_t *data_value,
1228 _IN_ void *value, _IN_ int value_len,
1229 _IN_ int index)
1230 {
1231 dm_shw_data_value_complex_t *complex_array = data_value->value;
1232
1233 if (complex_array == NULL || index < 0 || index >= complex_array->size) {
1234 return DM_INVALID_PARAMETER;
1235 }
1236
1237 if (g_iotx_data_type_mapping[complex_array->type].func_array_set == NULL) {
1238 return FAIL_RETURN;
1239 }
1240
1241 return g_iotx_data_type_mapping[complex_array->type].func_array_set(
1242 data_value, value, value_len, index);
1243 }
1244
_dm_shw_data_set(_IN_ dm_shw_data_value_t * data_value,_IN_ void * value,_IN_ int value_len)1245 static int _dm_shw_data_set(_IN_ dm_shw_data_value_t *data_value,
1246 _IN_ void *value, _IN_ int value_len)
1247 {
1248 if (g_iotx_data_type_mapping[data_value->type].func_set == NULL) {
1249 return FAIL_RETURN;
1250 }
1251
1252 return g_iotx_data_type_mapping[data_value->type].func_set(
1253 data_value, value, value_len);
1254 }
1255
dm_shw_set_property_value(_IN_ dm_shw_t * shadow,_IN_ char * key,_IN_ int key_len,_IN_ void * value,_IN_ int value_len)1256 int dm_shw_set_property_value(_IN_ dm_shw_t *shadow, _IN_ char *key,
1257 _IN_ int key_len, _IN_ void *value,
1258 _IN_ int value_len)
1259 {
1260 int res = 0, array_index = 0;
1261 dm_shw_data_t *data = NULL;
1262
1263 if (shadow == NULL || key == NULL || key_len <= 0) {
1264 return FAIL_RETURN;
1265 }
1266
1267 dm_log_debug("Key:%d %s", key_len, key);
1268 res = _dm_shw_property_search(shadow, key, key_len, &data, &array_index);
1269 if (res != SUCCESS_RETURN) {
1270 return FAIL_RETURN;
1271 }
1272
1273 if (data->data_value.type == DM_SHW_DATA_TYPE_ARRAY) {
1274 dm_log_debug("Current Found Data Index: %d", array_index);
1275 res = _dm_shw_data_array_set(&data->data_value, value, value_len,
1276 array_index);
1277 if (res != SUCCESS_RETURN) {
1278 return DM_TSL_PROPERTY_SET_FAILED;
1279 }
1280 } else {
1281 res = _dm_shw_data_set(&data->data_value, value, value_len);
1282 if (res != SUCCESS_RETURN) {
1283 return DM_TSL_PROPERTY_SET_FAILED;
1284 }
1285 }
1286
1287 return SUCCESS_RETURN;
1288 }
1289
_dm_shw_int_get(_IN_ dm_shw_data_value_t * data_value,_IN_ void * value)1290 static int _dm_shw_int_get(_IN_ dm_shw_data_value_t *data_value,
1291 _IN_ void *value)
1292 {
1293 *(int *)(value) = data_value->value_int;
1294 return SUCCESS_RETURN;
1295 }
1296
_dm_shw_float_get(_IN_ dm_shw_data_value_t * data_value,_IN_ void * value)1297 static int _dm_shw_float_get(_IN_ dm_shw_data_value_t *data_value,
1298 _IN_ void *value)
1299 {
1300 *(float *)(value) = data_value->value_float;
1301 return SUCCESS_RETURN;
1302 }
1303
_dm_shw_double_get(_IN_ dm_shw_data_value_t * data_value,_IN_ void * value)1304 static int _dm_shw_double_get(_IN_ dm_shw_data_value_t *data_value,
1305 _IN_ void *value)
1306 {
1307 *(double *)(value) = data_value->value_double;
1308 return SUCCESS_RETURN;
1309 }
1310
_dm_shw_text_get(_IN_ dm_shw_data_value_t * data_value,_IN_ void * value)1311 static int _dm_shw_text_get(_IN_ dm_shw_data_value_t *data_value,
1312 _IN_ void *value)
1313 {
1314 int res = 0;
1315
1316 if (*(char **)value != NULL || data_value->value == NULL) {
1317 return FAIL_RETURN;
1318 }
1319
1320 res = dm_utils_copy_direct(data_value->value, strlen(data_value->value),
1321 (void **)value, strlen(data_value->value) + 1);
1322 if (res != SUCCESS_RETURN) {
1323 return FAIL_RETURN;
1324 }
1325
1326 return SUCCESS_RETURN;
1327 }
1328
_dm_shw_enum_get(_IN_ dm_shw_data_value_t * data_value,_IN_ void * value)1329 static int _dm_shw_enum_get(_IN_ dm_shw_data_value_t *data_value,
1330 _IN_ void *value)
1331 {
1332 *(int *)(value) = data_value->value_int;
1333 return SUCCESS_RETURN;
1334 }
1335
_dm_shw_date_get(_IN_ dm_shw_data_value_t * data_value,_IN_ void * value)1336 static int _dm_shw_date_get(_IN_ dm_shw_data_value_t *data_value,
1337 _IN_ void *value)
1338 {
1339 int res = 0;
1340
1341 if (*(char **)value != NULL || data_value->value == NULL) {
1342 return FAIL_RETURN;
1343 }
1344
1345 res = dm_utils_copy_direct(data_value->value, strlen(data_value->value),
1346 (void **)value, strlen(data_value->value) + 1);
1347 if (res != SUCCESS_RETURN) {
1348 return FAIL_RETURN;
1349 }
1350
1351 return SUCCESS_RETURN;
1352 }
1353
_dm_shw_bool_get(_IN_ dm_shw_data_value_t * data_value,_IN_ void * value)1354 static int _dm_shw_bool_get(_IN_ dm_shw_data_value_t *data_value,
1355 _IN_ void *value)
1356 {
1357 *(int *)(value) = data_value->value_int;
1358 return SUCCESS_RETURN;
1359 }
1360
_dm_shw_array_int_get(_IN_ dm_shw_data_value_t * data_value,_IN_ void * value,_IN_ int index)1361 static int _dm_shw_array_int_get(_IN_ dm_shw_data_value_t *data_value,
1362 _IN_ void *value, _IN_ int index)
1363 {
1364 dm_shw_data_value_complex_t *complex_array = data_value->value;
1365
1366 if (complex_array->value == NULL ||
1367 ((int *)(complex_array->value) + index) == NULL) {
1368 return DM_INVALID_PARAMETER;
1369 }
1370
1371 *((int *)value) = *((int *)(complex_array->value) + index);
1372
1373 return SUCCESS_RETURN;
1374 }
1375
_dm_shw_array_float_get(_IN_ dm_shw_data_value_t * data_value,_IN_ void * value,_IN_ int index)1376 static int _dm_shw_array_float_get(_IN_ dm_shw_data_value_t *data_value,
1377 _IN_ void *value, _IN_ int index)
1378 {
1379 dm_shw_data_value_complex_t *complex_array = data_value->value;
1380
1381 if (complex_array->value == NULL ||
1382 ((float *)(complex_array->value) + index) == NULL) {
1383 return DM_INVALID_PARAMETER;
1384 }
1385
1386 *((float *)value) = *((float *)(complex_array->value) + index);
1387
1388 return SUCCESS_RETURN;
1389 }
1390
_dm_shw_array_double_get(_IN_ dm_shw_data_value_t * data_value,_IN_ void * value,_IN_ int index)1391 static int _dm_shw_array_double_get(_IN_ dm_shw_data_value_t *data_value,
1392 _IN_ void *value, _IN_ int index)
1393 {
1394 dm_shw_data_value_complex_t *complex_array = data_value->value;
1395
1396 if (complex_array->value == NULL ||
1397 ((double *)(complex_array->value) + index) == NULL) {
1398 return DM_INVALID_PARAMETER;
1399 }
1400
1401 *((double *)value) = *((double *)(complex_array->value) + index);
1402
1403 return SUCCESS_RETURN;
1404 }
1405
_dm_shw_array_text_get(_IN_ dm_shw_data_value_t * data_value,_IN_ void * value,_IN_ int index)1406 static int _dm_shw_array_text_get(_IN_ dm_shw_data_value_t *data_value,
1407 _IN_ void *value, _IN_ int index)
1408 {
1409 int res = 0;
1410 dm_shw_data_value_complex_t *complex_array = data_value->value;
1411
1412 if (complex_array->value == NULL ||
1413 *((char **)(complex_array->value) + index) == NULL ||
1414 *(char **)value != NULL) {
1415 return DM_INVALID_PARAMETER;
1416 }
1417
1418 res = dm_utils_copy_direct(
1419 *((char **)(complex_array->value) + index),
1420 strlen(*((char **)(complex_array->value) + index)), (void **)value,
1421 strlen(*((char **)(complex_array->value) + index)) + 1);
1422 if (res != SUCCESS_RETURN) {
1423 return FAIL_RETURN;
1424 }
1425
1426 return SUCCESS_RETURN;
1427 }
1428
_dm_shw_array_enum_get(_IN_ dm_shw_data_value_t * data_value,_IN_ void * value,_IN_ int index)1429 static int _dm_shw_array_enum_get(_IN_ dm_shw_data_value_t *data_value,
1430 _IN_ void *value, _IN_ int index)
1431 {
1432 dm_shw_data_value_complex_t *complex_array = data_value->value;
1433
1434 if (complex_array->value == NULL ||
1435 ((int *)(complex_array->value) + index) == NULL) {
1436 return DM_INVALID_PARAMETER;
1437 }
1438
1439 *((int *)value) = *((int *)(complex_array->value) + index);
1440
1441 return SUCCESS_RETURN;
1442 }
1443
_dm_shw_array_date_get(_IN_ dm_shw_data_value_t * data_value,_IN_ void * value,_IN_ int index)1444 static int _dm_shw_array_date_get(_IN_ dm_shw_data_value_t *data_value,
1445 _IN_ void *value, _IN_ int index)
1446 {
1447 int res = 0;
1448 dm_shw_data_value_complex_t *complex_array = data_value->value;
1449
1450 if (complex_array->value == NULL ||
1451 *((char **)(complex_array->value) + index) == NULL ||
1452 *(char **)value != NULL) {
1453 return DM_INVALID_PARAMETER;
1454 }
1455
1456 res = dm_utils_copy_direct(
1457 *((char **)(complex_array->value) + index),
1458 strlen(*((char **)(complex_array->value) + index)), (void **)value,
1459 strlen(*((char **)(complex_array->value) + index)) + 1);
1460 if (res != SUCCESS_RETURN) {
1461 return FAIL_RETURN;
1462 }
1463
1464 return SUCCESS_RETURN;
1465 }
1466
_dm_shw_array_bool_get(_IN_ dm_shw_data_value_t * data_value,_IN_ void * value,_IN_ int index)1467 static int _dm_shw_array_bool_get(_IN_ dm_shw_data_value_t *data_value,
1468 _IN_ void *value, _IN_ int index)
1469 {
1470 dm_shw_data_value_complex_t *complex_array = data_value->value;
1471
1472 if (complex_array->value == NULL ||
1473 ((int *)(complex_array->value) + index) == NULL) {
1474 return DM_INVALID_PARAMETER;
1475 }
1476
1477 *((int *)value) = *((int *)(complex_array->value) + index);
1478
1479 return SUCCESS_RETURN;
1480 }
1481
_dm_shw_data_array_get(_IN_ dm_shw_data_value_t * data_value,_IN_ void * value,_IN_ int index)1482 static int _dm_shw_data_array_get(_IN_ dm_shw_data_value_t *data_value,
1483 _IN_ void *value, _IN_ int index)
1484 {
1485 dm_shw_data_value_complex_t *complex_array = data_value->value;
1486
1487 if (complex_array == NULL || index < 0 || index >= complex_array->size) {
1488 return FAIL_RETURN;
1489 }
1490
1491 if (g_iotx_data_type_mapping[complex_array->type].func_array_get == NULL) {
1492 return FAIL_RETURN;
1493 }
1494
1495 return g_iotx_data_type_mapping[complex_array->type].func_array_get(
1496 data_value, value, index);
1497 }
1498
_dm_shw_data_get(_IN_ dm_shw_data_value_t * data_value,_IN_ void * value)1499 static int _dm_shw_data_get(_IN_ dm_shw_data_value_t *data_value,
1500 _IN_ void *value)
1501 {
1502 if (g_iotx_data_type_mapping[data_value->type].func_get == NULL) {
1503 return FAIL_RETURN;
1504 }
1505
1506 return g_iotx_data_type_mapping[data_value->type].func_get(data_value,
1507 value);
1508 }
1509
dm_shw_get_property_value(_IN_ dm_shw_t * shadow,_IN_ char * key,_IN_ int key_len,_OU_ void * value)1510 int dm_shw_get_property_value(_IN_ dm_shw_t *shadow, _IN_ char *key,
1511 _IN_ int key_len, _OU_ void *value)
1512 {
1513 int res = 0, array_index = 0;
1514 dm_shw_data_t *data = NULL;
1515
1516 if (shadow == NULL || key == NULL || key_len <= 0) {
1517 return DM_INVALID_PARAMETER;
1518 }
1519
1520 res = _dm_shw_property_search(shadow, key, key_len, &data, &array_index);
1521 if (res != SUCCESS_RETURN) {
1522 return FAIL_RETURN;
1523 }
1524 dm_log_debug("Current Found Data: %s", data->identifier);
1525 if (data->data_value.type == DM_SHW_DATA_TYPE_ARRAY) {
1526 dm_log_debug("Current Found Data Index: %d", array_index);
1527 res = _dm_shw_data_array_get(&data->data_value, value, array_index);
1528 if (res != SUCCESS_RETURN) {
1529 return DM_TSL_PROPERTY_GET_FAILED;
1530 }
1531 } else {
1532 res = _dm_shw_data_get(&data->data_value, value);
1533 if (res != SUCCESS_RETURN) {
1534 return DM_TSL_PROPERTY_GET_FAILED;
1535 }
1536 }
1537
1538 return SUCCESS_RETURN;
1539 }
1540
dm_shw_set_event_output_value(_IN_ dm_shw_t * shadow,_IN_ char * key,_IN_ int key_len,_IN_ void * value,_IN_ int value_len)1541 int dm_shw_set_event_output_value(_IN_ dm_shw_t *shadow, _IN_ char *key,
1542 _IN_ int key_len, _IN_ void *value,
1543 _IN_ int value_len)
1544 {
1545 int res = 0, array_index = 0;
1546 int offset = 0;
1547 char *pos = NULL;
1548 dm_shw_event_t *event = NULL;
1549 dm_shw_data_t *event_data = NULL;
1550
1551 if (shadow == NULL || key == NULL || key_len <= 0) {
1552 return DM_INVALID_PARAMETER;
1553 }
1554
1555 res = dm_utils_memtok(key, key_len, DM_SHW_KEY_DELIMITER, 1, &offset);
1556 if (res != SUCCESS_RETURN) {
1557 return FAIL_RETURN;
1558 }
1559
1560 dm_log_debug("Key: %.*s", key_len, key);
1561
1562 res = _dm_shw_event_search(shadow, key, offset, &event);
1563 if (res != SUCCESS_RETURN) {
1564 return DM_TSL_EVENT_NOT_EXIST;
1565 }
1566
1567 pos = key + offset + 1;
1568 /* dm_log_debug("TSL Event Output Data Search, Event Data ID: %s",pos); */
1569
1570 res = _dm_shw_event_output_search(event->output_datas,
1571 event->output_data_number, pos,
1572 strlen(pos), &event_data, &array_index);
1573 if (res != SUCCESS_RETURN) {
1574 return DM_TSL_EVENT_NOT_EXIST;
1575 }
1576
1577 if (event_data->data_value.type == DM_SHW_DATA_TYPE_ARRAY) {
1578 res = _dm_shw_data_array_set(&event_data->data_value, value, value_len,
1579 array_index);
1580 if (res != SUCCESS_RETURN) {
1581 return DM_TSL_EVENT_SET_FAILED;
1582 }
1583 } else {
1584 res = _dm_shw_data_set(&event_data->data_value, value, value_len);
1585 if (res != SUCCESS_RETURN) {
1586 return DM_TSL_EVENT_SET_FAILED;
1587 }
1588 }
1589
1590 return SUCCESS_RETURN;
1591 }
1592
dm_shw_get_event_output_value(_IN_ dm_shw_t * shadow,_IN_ char * key,_IN_ int key_len,_IN_ void * value)1593 int dm_shw_get_event_output_value(_IN_ dm_shw_t *shadow, _IN_ char *key,
1594 _IN_ int key_len, _IN_ void *value)
1595 {
1596 int res = 0;
1597 int offset = 0, array_index = 0;
1598 char *pos = NULL;
1599 dm_shw_event_t *event = NULL;
1600 dm_shw_data_t *event_data = NULL;
1601
1602 if (shadow == NULL || key == NULL || key_len <= 0) {
1603 return DM_INVALID_PARAMETER;
1604 }
1605
1606 res = dm_utils_memtok(key, key_len, DM_SHW_KEY_DELIMITER, 1, &offset);
1607 if (res != SUCCESS_RETURN) {
1608 return FAIL_RETURN;
1609 }
1610
1611 dm_log_debug("Key: %.*s", key_len, key);
1612
1613 res = _dm_shw_event_search(shadow, key, offset, &event);
1614 if (res != SUCCESS_RETURN) {
1615 return DM_TSL_EVENT_NOT_EXIST;
1616 }
1617
1618 pos = key + offset + 1;
1619 dm_log_debug("TSL Event Output Data Search, Event Data ID: %s", pos);
1620
1621 res = _dm_shw_event_output_search(event->output_datas,
1622 event->output_data_number, pos,
1623 strlen(pos), &event_data, &array_index);
1624 if (res != SUCCESS_RETURN) {
1625 return DM_TSL_EVENT_NOT_EXIST;
1626 }
1627
1628 if (event_data->data_value.type == DM_SHW_DATA_TYPE_ARRAY) {
1629 res =
1630 _dm_shw_data_array_get(&event_data->data_value, value, array_index);
1631 if (res != SUCCESS_RETURN) {
1632 return DM_TSL_EVENT_GET_FAILED;
1633 }
1634 } else {
1635 res = _dm_shw_data_get(&event_data->data_value, value);
1636 if (res != SUCCESS_RETURN) {
1637 return DM_TSL_EVENT_GET_FAILED;
1638 }
1639 }
1640
1641 return SUCCESS_RETURN;
1642 }
1643
dm_shw_set_service_input_output_value(_IN_ dm_shw_data_target_e type,_IN_ dm_shw_t * shadow,_IN_ char * key,_IN_ int key_len,_IN_ void * value,_IN_ int value_len)1644 int dm_shw_set_service_input_output_value(_IN_ dm_shw_data_target_e type,
1645 _IN_ dm_shw_t *shadow, _IN_ char *key,
1646 _IN_ int key_len, _IN_ void *value,
1647 _IN_ int value_len)
1648 {
1649 int res = 0, array_index = 0;
1650 int offset = 0;
1651 char *pos = NULL;
1652 dm_shw_service_t *service = NULL;
1653 dm_shw_data_t *service_data = NULL;
1654
1655 if (type < DM_SHW_DATA_TARGET_SERVICE_INPUT_DATA ||
1656 type > DM_SHW_DATA_TARGET_SERVICE_OUTPUT_DATA || shadow == NULL ||
1657 key == NULL || key_len <= 0) {
1658 return DM_INVALID_PARAMETER;
1659 }
1660
1661 res = dm_utils_memtok(key, key_len, DM_SHW_KEY_DELIMITER, 1, &offset);
1662 if (res != SUCCESS_RETURN) {
1663 return FAIL_RETURN;
1664 }
1665
1666 dm_log_debug("Key: %.*s", key_len, key);
1667
1668 res = _dm_shw_service_search(shadow, key, offset, &service);
1669 if (res != SUCCESS_RETURN) {
1670 return DM_TSL_SERVICE_NOT_EXIST;
1671 }
1672
1673 pos = key + offset + 1;
1674 dm_log_debug("TSL Service Input/Output Data Search, Event Data ID: %s",
1675 pos);
1676
1677 res = _dm_shw_service_input_output_search(type, service, pos, strlen(pos),
1678 &service_data, &array_index);
1679 if (res != SUCCESS_RETURN) {
1680 return DM_TSL_SERVICE_NOT_EXIST;
1681 }
1682
1683 if (service_data->data_value.type == DM_SHW_DATA_TYPE_ARRAY) {
1684 res = _dm_shw_data_array_set(&service_data->data_value, value,
1685 value_len, array_index);
1686 if (res != SUCCESS_RETURN) {
1687 return DM_TSL_SERVICE_SET_FAILED;
1688 }
1689 } else {
1690 res = _dm_shw_data_set(&service_data->data_value, value, value_len);
1691 if (res != SUCCESS_RETURN) {
1692 return DM_TSL_SERVICE_SET_FAILED;
1693 }
1694 }
1695
1696 return SUCCESS_RETURN;
1697 }
1698
dm_shw_get_service_input_output_value(_IN_ dm_shw_data_target_e type,_IN_ dm_shw_t * shadow,_IN_ char * key,_IN_ int key_len,_IN_ void * value)1699 int dm_shw_get_service_input_output_value(_IN_ dm_shw_data_target_e type,
1700 _IN_ dm_shw_t *shadow, _IN_ char *key,
1701 _IN_ int key_len, _IN_ void *value)
1702 {
1703 int res = 0;
1704 int offset = 0, array_index = 0;
1705 char *pos = NULL;
1706 dm_shw_service_t *service = NULL;
1707 dm_shw_data_t *service_data = NULL;
1708
1709 if (shadow == NULL || key == NULL || key_len <= 0) {
1710 return DM_INVALID_PARAMETER;
1711 }
1712
1713 res = dm_utils_memtok(key, key_len, DM_SHW_KEY_DELIMITER, 1, &offset);
1714 if (res != SUCCESS_RETURN) {
1715 return FAIL_RETURN;
1716 }
1717
1718 dm_log_debug("key: %.*s", key_len, key);
1719
1720 res = _dm_shw_service_search(shadow, key, offset, &service);
1721 if (res != SUCCESS_RETURN) {
1722 return DM_TSL_SERVICE_NOT_EXIST;
1723 }
1724
1725 pos = key + offset + 1;
1726 dm_log_debug("TSL Service Input/Output Data Search, Event Data ID: %s",
1727 pos);
1728
1729 res = _dm_shw_service_input_output_search(type, service, pos, strlen(pos),
1730 &service_data, &array_index);
1731 if (res != SUCCESS_RETURN) {
1732 return DM_TSL_SERVICE_NOT_EXIST;
1733 }
1734
1735 if (service_data->data_value.type == DM_SHW_DATA_TYPE_ARRAY) {
1736 res = _dm_shw_data_array_get(&service_data->data_value, value,
1737 array_index);
1738 if (res != SUCCESS_RETURN) {
1739 return DM_TSL_SERVICE_GET_FAILED;
1740 }
1741 } else {
1742 res = _dm_shw_data_get(&service_data->data_value, value);
1743 if (res != SUCCESS_RETURN) {
1744 return DM_TSL_SERVICE_GET_FAILED;
1745 }
1746 }
1747
1748 return SUCCESS_RETURN;
1749 }
1750
_dm_shw_int_insert_json_item(_IN_ dm_shw_data_t * data,_IN_ lite_cjson_item_t * lite)1751 static int _dm_shw_int_insert_json_item(_IN_ dm_shw_data_t *data,
1752 _IN_ lite_cjson_item_t *lite)
1753 {
1754 lite_cjson_add_number_to_object(lite, data->identifier,
1755 data->data_value.value_int);
1756
1757 return SUCCESS_RETURN;
1758 }
1759
_dm_shw_float_insert_json_item(_IN_ dm_shw_data_t * data,_IN_ lite_cjson_item_t * lite)1760 static int _dm_shw_float_insert_json_item(_IN_ dm_shw_data_t *data,
1761 _IN_ lite_cjson_item_t *lite)
1762 {
1763 lite_cjson_add_number_to_object(lite, data->identifier,
1764 data->data_value.value_float);
1765
1766 return SUCCESS_RETURN;
1767 }
1768
_dm_shw_double_insert_json_item(_IN_ dm_shw_data_t * data,_IN_ lite_cjson_item_t * lite)1769 static int _dm_shw_double_insert_json_item(_IN_ dm_shw_data_t *data,
1770 _IN_ lite_cjson_item_t *lite)
1771 {
1772 lite_cjson_add_number_to_object(lite, data->identifier,
1773 data->data_value.value_double);
1774
1775 return SUCCESS_RETURN;
1776 }
1777
_dm_shw_string_insert_json_item(_IN_ dm_shw_data_t * data,_IN_ lite_cjson_item_t * lite)1778 static int _dm_shw_string_insert_json_item(_IN_ dm_shw_data_t *data,
1779 _IN_ lite_cjson_item_t *lite)
1780 {
1781 char *value =
1782 (data->data_value.value == NULL) ? ("") : (data->data_value.value);
1783 lite_cjson_add_string_to_object(lite, data->identifier, value);
1784
1785 return SUCCESS_RETURN;
1786 }
1787
1788 static int _dm_shw_array_insert_json_item(_IN_ dm_shw_data_t *data,
1789 _IN_ lite_cjson_item_t *lite);
1790 static int _dm_shw_struct_insert_json_item(_IN_ dm_shw_data_t *data,
1791 _IN_ lite_cjson_item_t *lite);
1792 static int _dm_shw_data_insert_json_item(_IN_ dm_shw_data_t *data,
1793 _IN_ lite_cjson_item_t *lite);
1794
_dm_shw_array_insert_json_item(_IN_ dm_shw_data_t * data,_IN_ lite_cjson_item_t * lite)1795 static int _dm_shw_array_insert_json_item(_IN_ dm_shw_data_t *data,
1796 _IN_ lite_cjson_item_t *lite)
1797 {
1798 int res = SUCCESS_RETURN, index = 0;
1799 lite_cjson_item_t *array = NULL, *array_item = NULL;
1800 dm_shw_data_value_complex_t *complex_array = NULL;
1801
1802 if (data == NULL || lite == NULL) {
1803 return DM_INVALID_PARAMETER;
1804 }
1805
1806 complex_array = data->data_value.value;
1807
1808 if (lite->type == cJSON_Array) {
1809 array = lite_cjson_create_object();
1810 if (array == NULL) {
1811 return DM_MEMORY_NOT_ENOUGH;
1812 }
1813 }
1814
1815 array_item = lite_cjson_create_array();
1816 if (array_item == NULL) {
1817 if (array) {
1818 lite_cjson_delete(array);
1819 }
1820 return DM_MEMORY_NOT_ENOUGH;
1821 }
1822
1823 switch (complex_array->type) {
1824 case DM_SHW_DATA_TYPE_INT:
1825 case DM_SHW_DATA_TYPE_BOOL:
1826 case DM_SHW_DATA_TYPE_ENUM:
1827 {
1828 int value = 0;
1829 for (index = 0; index < complex_array->size; index++) {
1830 value = *((int *)(complex_array->value) + index);
1831 lite_cjson_add_item_to_array(
1832 array_item, lite_cjson_create_number((double)value));
1833 }
1834 if (lite->type == cJSON_Array) {
1835 lite_cjson_add_item_to_object(array, data->identifier,
1836 array_item);
1837 lite_cjson_add_item_to_array(lite, array);
1838 } else {
1839 lite_cjson_add_item_to_object(lite, data->identifier,
1840 array_item);
1841 lite_cjson_delete(array);
1842 }
1843 }
1844 break;
1845 case DM_SHW_DATA_TYPE_FLOAT:
1846 {
1847 float value = 0;
1848 for (index = 0; index < complex_array->size; index++) {
1849 value = *((float *)(complex_array->value) + index);
1850 lite_cjson_add_item_to_array(
1851 array_item, lite_cjson_create_number((double)value));
1852 }
1853 if (lite->type == cJSON_Array) {
1854 lite_cjson_add_item_to_object(array, data->identifier,
1855 array_item);
1856 lite_cjson_add_item_to_array(lite, array);
1857 } else {
1858 lite_cjson_add_item_to_object(lite, data->identifier,
1859 array_item);
1860 lite_cjson_delete(array);
1861 }
1862 }
1863 break;
1864 case DM_SHW_DATA_TYPE_DOUBLE:
1865 {
1866 double value = 0;
1867 for (index = 0; index < complex_array->size; index++) {
1868 value = *((double *)(complex_array->value) + index);
1869 lite_cjson_add_item_to_array(array_item,
1870 lite_cjson_create_number(value));
1871 }
1872 if (lite->type == cJSON_Array) {
1873 lite_cjson_add_item_to_object(array, data->identifier,
1874 array_item);
1875 lite_cjson_add_item_to_array(lite, array);
1876 } else {
1877 lite_cjson_add_item_to_object(lite, data->identifier,
1878 array_item);
1879 lite_cjson_delete(array);
1880 }
1881 }
1882 break;
1883 case DM_SHW_DATA_TYPE_TEXT:
1884 case DM_SHW_DATA_TYPE_DATE:
1885 {
1886 char *value = NULL;
1887 for (index = 0; index < complex_array->size; index++) {
1888 value = *((char **)(complex_array->value) + index);
1889 value = (value == NULL) ? ("") : (value);
1890 lite_cjson_add_item_to_array(
1891 array_item, lite_cjson_create_string((const char *)value));
1892 }
1893 if (lite->type == cJSON_Array) {
1894 lite_cjson_add_item_to_object(array, data->identifier,
1895 array_item);
1896 lite_cjson_add_item_to_array(lite, array);
1897 } else {
1898 lite_cjson_add_item_to_object(lite, data->identifier,
1899 array_item);
1900 lite_cjson_delete(array);
1901 }
1902 }
1903 break;
1904 case DM_SHW_DATA_TYPE_ARRAY:
1905 {
1906 /* TODO */
1907 }
1908 break;
1909 case DM_SHW_DATA_TYPE_STRUCT:
1910 {
1911 dm_shw_data_t *array_data = NULL;
1912 for (index = 0; index < complex_array->size; index++) {
1913 array_data = (dm_shw_data_t *)(complex_array->value) + index;
1914 if (array_data) {
1915 _dm_shw_struct_insert_json_item(array_data, array_item);
1916 }
1917 }
1918
1919 if (lite->type == cJSON_Array) {
1920 lite_cjson_add_item_to_object(array, data->identifier,
1921 array_item);
1922 lite_cjson_add_item_to_array(lite, array);
1923 } else {
1924 lite_cjson_add_item_to_object(lite, data->identifier,
1925 array_item);
1926 lite_cjson_delete(array);
1927 }
1928 }
1929 break;
1930 default:
1931 {
1932 lite_cjson_delete(array_item);
1933 lite_cjson_delete(array);
1934 }
1935 break;
1936 }
1937
1938 return res;
1939 }
1940
_dm_shw_struct_insert_json_item(_IN_ dm_shw_data_t * data,_IN_ lite_cjson_item_t * lite)1941 static int _dm_shw_struct_insert_json_item(_IN_ dm_shw_data_t *data,
1942 _IN_ lite_cjson_item_t *lite)
1943 {
1944 int res = 0, index = 0;
1945 lite_cjson_item_t *lite_object = NULL, *lite_item = NULL;
1946 dm_shw_data_t *current_data = NULL;
1947 dm_shw_data_value_complex_t *complex_struct = NULL;
1948
1949 if (data == NULL || lite == NULL) {
1950 return DM_INVALID_PARAMETER;
1951 }
1952
1953 if (lite->type == cJSON_Array) {
1954 lite_object = lite_cjson_create_object();
1955 if (lite_object == NULL) {
1956 return DM_MEMORY_NOT_ENOUGH;
1957 }
1958 }
1959
1960 lite_item = lite_cjson_create_object();
1961 if (lite_item == NULL) {
1962 lite_cjson_delete(lite_object);
1963 return DM_MEMORY_NOT_ENOUGH;
1964 }
1965
1966 complex_struct = data->data_value.value;
1967
1968 for (index = 0; index < complex_struct->size; index++) {
1969 current_data = (dm_shw_data_t *)complex_struct->value + index;
1970 _dm_shw_data_insert_json_item(current_data, lite_item);
1971 }
1972 if (lite->type == cJSON_Array) {
1973 if (data->identifier) {
1974 lite_cjson_add_item_to_object(lite_object, data->identifier,
1975 lite_item);
1976 lite_cjson_add_item_to_array(lite, lite_object);
1977 } else {
1978 lite_cjson_add_item_to_array(lite, lite_item);
1979 lite_cjson_delete(lite_object);
1980 }
1981 } else {
1982 if (data->identifier) {
1983 lite_cjson_add_item_to_object(lite, data->identifier, lite_item);
1984 lite_cjson_delete(lite_object);
1985 } else {
1986 res = FAIL_RETURN;
1987 lite_cjson_delete(lite_item);
1988 lite_cjson_delete(lite_object);
1989 }
1990 }
1991
1992 return res;
1993 }
1994
_dm_shw_data_insert_json_item(_IN_ dm_shw_data_t * data,_IN_ lite_cjson_item_t * lite)1995 static int _dm_shw_data_insert_json_item(_IN_ dm_shw_data_t *data,
1996 _IN_ lite_cjson_item_t *lite)
1997 {
1998 int res = 0;
1999 lite_cjson_item_t *data_object = NULL;
2000
2001 if (data == NULL || lite == NULL) {
2002 return DM_INVALID_PARAMETER;
2003 }
2004
2005 if (lite->type == cJSON_Array) {
2006 data_object = lite_cjson_create_object();
2007 if (data_object == NULL) {
2008 return DM_MEMORY_NOT_ENOUGH;
2009 }
2010 }
2011
2012 switch (data->data_value.type) {
2013 case DM_SHW_DATA_TYPE_INT:
2014 case DM_SHW_DATA_TYPE_BOOL:
2015 case DM_SHW_DATA_TYPE_ENUM:
2016 {
2017 if (lite->type == cJSON_Array) {
2018 res = _dm_shw_int_insert_json_item(data, data_object);
2019 if (res == SUCCESS_RETURN) {
2020 lite_cjson_add_item_to_array(lite, data_object);
2021 }
2022 } else {
2023 res = _dm_shw_int_insert_json_item(data, lite);
2024 lite_cjson_delete(data_object);
2025 }
2026 }
2027 break;
2028 case DM_SHW_DATA_TYPE_FLOAT:
2029 {
2030 if (lite->type == cJSON_Array) {
2031 res = _dm_shw_float_insert_json_item(data, data_object);
2032 if (res == SUCCESS_RETURN) {
2033 lite_cjson_add_item_to_array(lite, data_object);
2034 }
2035 } else {
2036 res = _dm_shw_float_insert_json_item(data, lite);
2037 lite_cjson_delete(data_object);
2038 }
2039 }
2040 break;
2041 case DM_SHW_DATA_TYPE_DOUBLE:
2042 {
2043 if (lite->type == cJSON_Array) {
2044 res = _dm_shw_double_insert_json_item(data, data_object);
2045 if (res == SUCCESS_RETURN) {
2046 lite_cjson_add_item_to_array(lite, data_object);
2047 }
2048 } else {
2049 res = _dm_shw_double_insert_json_item(data, lite);
2050 lite_cjson_delete(data_object);
2051 }
2052 }
2053 break;
2054 case DM_SHW_DATA_TYPE_TEXT:
2055 case DM_SHW_DATA_TYPE_DATE:
2056 {
2057 if (lite->type == cJSON_Array) {
2058 res = _dm_shw_string_insert_json_item(data, data_object);
2059 if (res == SUCCESS_RETURN) {
2060 lite_cjson_add_item_to_array(lite, data_object);
2061 }
2062 } else {
2063 res = _dm_shw_string_insert_json_item(data, lite);
2064 lite_cjson_delete(data_object);
2065 }
2066 }
2067 break;
2068 case DM_SHW_DATA_TYPE_ARRAY:
2069 {
2070 /* dm_log_debug("DM_SHW_DATA_TYPE_ARRAY"); */
2071 if (lite->type == cJSON_Array) {
2072 res = _dm_shw_array_insert_json_item(data, data_object);
2073 if (res == SUCCESS_RETURN) {
2074 lite_cjson_add_item_to_array(lite, data_object);
2075 }
2076 } else {
2077 res = _dm_shw_array_insert_json_item(data, lite);
2078 lite_cjson_delete(data_object);
2079 }
2080 }
2081 break;
2082 case DM_SHW_DATA_TYPE_STRUCT:
2083 {
2084 /* dm_log_debug("DM_SHW_DATA_TYPE_STRUCT"); */
2085 if (lite->type == cJSON_Array) {
2086 res = _dm_shw_struct_insert_json_item(data, data_object);
2087 if (res == SUCCESS_RETURN) {
2088 lite_cjson_add_item_to_array(lite, data_object);
2089 }
2090 } else {
2091 res = _dm_shw_struct_insert_json_item(data, lite);
2092 lite_cjson_delete(data_object);
2093 }
2094 }
2095 break;
2096 default:
2097 lite_cjson_delete(data_object);
2098 res = FAIL_RETURN;
2099 break;
2100 }
2101
2102 return res;
2103 }
2104
dm_shw_assemble_property(_IN_ dm_shw_t * shadow,_IN_ char * identifier,_IN_ int identifier_len,_IN_ lite_cjson_item_t * lite)2105 int dm_shw_assemble_property(_IN_ dm_shw_t *shadow, _IN_ char *identifier,
2106 _IN_ int identifier_len,
2107 _IN_ lite_cjson_item_t *lite)
2108 {
2109 int res = 0, index = 0;
2110 dm_shw_data_t *property = NULL;
2111
2112 if (shadow == NULL || identifier == NULL || identifier_len <= 0 ||
2113 lite == NULL || lite->type != cJSON_Object) {
2114 return DM_INVALID_PARAMETER;
2115 }
2116
2117 for (index = 0; index < shadow->property_number; index++) {
2118 property = shadow->properties + index;
2119 if ((strlen(property->identifier) == identifier_len) &&
2120 (memcmp(property->identifier, identifier, identifier_len) == 0)) {
2121 /* dm_log_debug("Property Found: %.*s",identifier_len,identifier);
2122 */
2123 break;
2124 }
2125 }
2126
2127 if (index == shadow->property_number) {
2128 dm_log_debug("Property Not Found: %.*s", identifier_len, identifier);
2129 return FAIL_RETURN;
2130 }
2131
2132 res = _dm_shw_data_insert_json_item(property, lite);
2133 if (res != SUCCESS_RETURN) {
2134 return FAIL_RETURN;
2135 }
2136
2137 return SUCCESS_RETURN;
2138 }
2139
dm_shw_assemble_event_output(_IN_ dm_shw_t * shadow,_IN_ char * identifier,_IN_ int identifier_len,_IN_ lite_cjson_item_t * lite)2140 int dm_shw_assemble_event_output(_IN_ dm_shw_t *shadow, _IN_ char *identifier,
2141 _IN_ int identifier_len,
2142 _IN_ lite_cjson_item_t *lite)
2143 {
2144 int res = 0, index = 0;
2145 dm_shw_data_t *event_outputdata = NULL;
2146 dm_shw_event_t *event = NULL;
2147
2148 if (shadow == NULL || identifier == NULL || identifier_len <= 0 ||
2149 lite == NULL || lite->type != cJSON_Object) {
2150 return DM_INVALID_PARAMETER;
2151 }
2152
2153 for (index = 0; index < shadow->event_number; index++) {
2154 event = shadow->events + index;
2155 if ((strlen(event->identifier) == identifier_len) &&
2156 (memcmp(event->identifier, identifier, identifier_len) == 0)) {
2157 /* dm_log_debug("Event Found: %.*s",identifier_len,identifier); */
2158 break;
2159 }
2160 }
2161
2162 if (index == shadow->event_number) {
2163 dm_log_debug("Event Not Found: %.*s", identifier_len, identifier);
2164 return FAIL_RETURN;
2165 }
2166
2167 for (index = 0; index < event->output_data_number; index++) {
2168 event_outputdata = event->output_datas + index;
2169
2170 res = _dm_shw_data_insert_json_item(event_outputdata, lite);
2171 if (res != SUCCESS_RETURN) {
2172 return FAIL_RETURN;
2173 }
2174 }
2175
2176 return SUCCESS_RETURN;
2177 }
2178
dm_shw_assemble_service_output(_IN_ dm_shw_t * shadow,_IN_ char * identifier,_IN_ int identifier_len,_IN_ lite_cjson_item_t * lite)2179 int dm_shw_assemble_service_output(_IN_ dm_shw_t *shadow, _IN_ char *identifier,
2180 _IN_ int identifier_len,
2181 _IN_ lite_cjson_item_t *lite)
2182 {
2183 int res = 0, index = 0;
2184 dm_shw_data_t *service_outputdata = NULL;
2185 dm_shw_service_t *service = NULL;
2186
2187 if (shadow == NULL || identifier == NULL || identifier_len <= 0 ||
2188 lite == NULL || lite->type != cJSON_Object) {
2189 return DM_INVALID_PARAMETER;
2190 }
2191
2192 for (index = 0; index < shadow->service_number; index++) {
2193 service = shadow->services + index;
2194 if ((strlen(service->identifier) == identifier_len) &&
2195 (memcmp(service->identifier, identifier, identifier_len) == 0)) {
2196 /* dm_log_debug("Service Found: %.*s",identifier_len,identifier); */
2197 break;
2198 }
2199 }
2200
2201 if (index == shadow->service_number) {
2202 dm_log_debug("Service Not Found: %.*s", identifier_len, identifier);
2203 return FAIL_RETURN;
2204 }
2205
2206 for (index = 0; index < service->output_data_number; index++) {
2207 service_outputdata = service->output_datas + index;
2208
2209 res = _dm_shw_data_insert_json_item(service_outputdata, lite);
2210 if (res != SUCCESS_RETURN) {
2211 return FAIL_RETURN;
2212 }
2213 }
2214
2215 return SUCCESS_RETURN;
2216 }
2217
_dm_shw_int_free(_IN_ dm_shw_data_value_t * data_value)2218 static void _dm_shw_int_free(_IN_ dm_shw_data_value_t *data_value)
2219 {
2220 /* Free Value */
2221 /* if (data_value->value) {DM_free(data_value->value);data_value->value =
2222 * NULL;} */
2223 }
2224
_dm_shw_float_free(_IN_ dm_shw_data_value_t * data_value)2225 static void _dm_shw_float_free(_IN_ dm_shw_data_value_t *data_value)
2226 {
2227 /* Free Value */
2228 /* if (data_value->value) {DM_free(data_value->value);data_value->value =
2229 * NULL;} */
2230 }
2231
_dm_shw_double_free(_IN_ dm_shw_data_value_t * data_value)2232 static void _dm_shw_double_free(_IN_ dm_shw_data_value_t *data_value)
2233 {
2234 /* Free Value */
2235 /* if (data_value->value) {DM_free(data_value->value);data_value->value =
2236 * NULL;} */
2237 }
2238
_dm_shw_text_free(_IN_ dm_shw_data_value_t * data_value)2239 static void _dm_shw_text_free(_IN_ dm_shw_data_value_t *data_value)
2240 {
2241 /* Free Value */
2242 if (data_value->value) {
2243 DM_free(data_value->value);
2244 data_value->value = NULL;
2245 }
2246 }
2247
_dm_shw_enum_free(_IN_ dm_shw_data_value_t * data_value)2248 static void _dm_shw_enum_free(_IN_ dm_shw_data_value_t *data_value)
2249 {
2250 /* Free Value */
2251 /* if (data_value->value) {DM_free(data_value->value);data_value->value =
2252 * NULL;} */
2253 }
2254
_dm_shw_date_free(_IN_ dm_shw_data_value_t * data_value)2255 static void _dm_shw_date_free(_IN_ dm_shw_data_value_t *data_value)
2256 {
2257 /* Free Value */
2258 if (data_value->value) {
2259 DM_free(data_value->value);
2260 data_value->value = NULL;
2261 }
2262 }
2263
_dm_shw_bool_free(_IN_ dm_shw_data_value_t * data_value)2264 static void _dm_shw_bool_free(_IN_ dm_shw_data_value_t *data_value)
2265 {
2266 /* Free Value */
2267 /* if (data_value->value) {DM_free(data_value->value);data_value->value =
2268 * NULL;} */
2269 }
2270
_dm_shw_array_int_free(_IN_ dm_shw_data_value_t * data_value)2271 static void _dm_shw_array_int_free(_IN_ dm_shw_data_value_t *data_value)
2272 {
2273 }
2274
_dm_shw_array_float_free(_IN_ dm_shw_data_value_t * data_value)2275 static void _dm_shw_array_float_free(_IN_ dm_shw_data_value_t *data_value)
2276 {
2277 }
2278
_dm_shw_array_double_free(_IN_ dm_shw_data_value_t * data_value)2279 static void _dm_shw_array_double_free(_IN_ dm_shw_data_value_t *data_value)
2280 {
2281 }
2282
_dm_shw_array_text_free(_IN_ dm_shw_data_value_t * data_value)2283 static void _dm_shw_array_text_free(_IN_ dm_shw_data_value_t *data_value)
2284 {
2285 int index = 0;
2286 dm_shw_data_value_complex_t *complex_array = data_value->value;
2287
2288 /* Free Value */
2289 if (complex_array) {
2290 for (index = 0; index < complex_array->size; index++) {
2291 if (*((char **)(complex_array->value) + index)) {
2292 DM_free(*((char **)(complex_array->value) + index));
2293 *((char **)(complex_array->value) + index) = NULL;
2294 }
2295 }
2296 }
2297 }
2298
_dm_shw_array_enum_free(_IN_ dm_shw_data_value_t * data_value)2299 static void _dm_shw_array_enum_free(_IN_ dm_shw_data_value_t *data_value)
2300 {
2301 }
2302
_dm_shw_array_date_free(_IN_ dm_shw_data_value_t * data_value)2303 static void _dm_shw_array_date_free(_IN_ dm_shw_data_value_t *data_value)
2304 {
2305 int index = 0;
2306 dm_shw_data_value_complex_t *complex_array = data_value->value;
2307
2308 /* Free Value */
2309 if (complex_array) {
2310 for (index = 0; index < complex_array->size; index++) {
2311 if (*((char **)(complex_array->value) + index)) {
2312 DM_free(*((char **)(complex_array->value) + index));
2313 *((char **)(complex_array->value) + index) = NULL;
2314 }
2315 }
2316 }
2317 }
2318
_dm_shw_array_bool_free(_IN_ dm_shw_data_value_t * data_value)2319 static void _dm_shw_array_bool_free(_IN_ dm_shw_data_value_t *data_value)
2320 {
2321 }
2322
_dm_shw_array_array_free(_IN_ dm_shw_data_value_t * data_value)2323 static void _dm_shw_array_array_free(_IN_ dm_shw_data_value_t *data_value)
2324 {
2325 }
2326
_dm_shw_array_struct_free(_IN_ dm_shw_data_value_t * data_value)2327 static void _dm_shw_array_struct_free(_IN_ dm_shw_data_value_t *data_value)
2328 {
2329 int index = 0;
2330 dm_shw_data_t *data = NULL;
2331
2332 dm_shw_data_value_complex_t *complex_struct =
2333 (dm_shw_data_value_complex_t *)data_value->value;
2334
2335 if (complex_struct) {
2336 for (index = 0; index < complex_struct->size; index++) {
2337 data = (dm_shw_data_t *)complex_struct->value + index;
2338 _dm_shw_property_free(data);
2339 }
2340 }
2341 }
2342
_dm_shw_array_free(_IN_ dm_shw_data_value_t * data_value)2343 static void _dm_shw_array_free(_IN_ dm_shw_data_value_t *data_value)
2344 {
2345 dm_shw_data_value_complex_t *complex_array = data_value->value;
2346
2347 /* Free Value */
2348 if (complex_array) {
2349 /* dm_log_err("complex_array->type: %d",complex_array->type); */
2350 if (g_iotx_data_type_mapping[complex_array->type].func_array_free !=
2351 NULL) {
2352 g_iotx_data_type_mapping[complex_array->type].func_array_free(
2353 data_value);
2354 }
2355 if (complex_array->value) {
2356 DM_free(complex_array->value);
2357 }
2358 DM_free(complex_array);
2359 data_value->value = NULL;
2360 }
2361 }
2362
_dm_shw_struct_free(_IN_ dm_shw_data_value_t * data_value)2363 static void _dm_shw_struct_free(_IN_ dm_shw_data_value_t *data_value)
2364 {
2365 int index = 0;
2366 dm_shw_data_t *property = NULL;
2367 dm_shw_data_value_complex_t *complex_array = data_value->value;
2368
2369 /* Free Value */
2370 if (complex_array) {
2371 for (index = 0; index < complex_array->size; index++) {
2372 property = (dm_shw_data_t *)(complex_array->value) + index;
2373 _dm_shw_property_free(property);
2374 }
2375 if (complex_array->value) {
2376 DM_free(complex_array->value);
2377 }
2378 DM_free(complex_array);
2379 data_value->value = NULL;
2380 }
2381 }
2382
_dm_shw_data_free(dm_shw_data_value_t * data_value)2383 static void _dm_shw_data_free(dm_shw_data_value_t *data_value)
2384 {
2385 if (g_iotx_data_type_mapping[data_value->type].func_free == NULL) {
2386 return;
2387 }
2388 g_iotx_data_type_mapping[data_value->type].func_free(data_value);
2389 }
2390
_dm_shw_property_free(_IN_ dm_shw_data_t * property)2391 static void _dm_shw_property_free(_IN_ dm_shw_data_t *property)
2392 {
2393 if (property->identifier) {
2394 DM_free(property->identifier);
2395 }
2396 _dm_shw_data_free(&property->data_value);
2397 }
2398
_dm_shw_properties_free(_IN_ dm_shw_data_t * properties,_IN_ int number)2399 static void _dm_shw_properties_free(_IN_ dm_shw_data_t *properties,
2400 _IN_ int number)
2401 {
2402 int index = 0;
2403 dm_shw_data_t *property = NULL;
2404
2405 for (index = 0; index < number; index++) {
2406 property = properties + index;
2407 _dm_shw_property_free(property);
2408 }
2409 }
2410
_dm_shw_event_outputdata_free(_IN_ dm_shw_data_t * outputdata)2411 static void _dm_shw_event_outputdata_free(_IN_ dm_shw_data_t *outputdata)
2412 {
2413 if (outputdata->identifier) {
2414 DM_free(outputdata->identifier);
2415 outputdata->identifier = NULL;
2416 }
2417 _dm_shw_data_free(&outputdata->data_value);
2418 }
2419
_dm_shw_event_outputdatas_free(_IN_ dm_shw_data_t * outputdatas,_IN_ int number)2420 static void _dm_shw_event_outputdatas_free(_IN_ dm_shw_data_t *outputdatas,
2421 _IN_ int number)
2422 {
2423 int index = 0;
2424 dm_shw_data_t *outputdata = NULL;
2425
2426 for (index = 0; index < number; index++) {
2427 outputdata = outputdatas + index;
2428 _dm_shw_event_outputdata_free(outputdata);
2429 }
2430 }
2431
_dm_shw_event_free(_IN_ dm_shw_event_t * event)2432 static void _dm_shw_event_free(_IN_ dm_shw_event_t *event)
2433 {
2434 if (event->identifier) {
2435 DM_free(event->identifier);
2436 event->identifier = NULL;
2437 }
2438 if (event->output_datas) {
2439 _dm_shw_event_outputdatas_free(event->output_datas,
2440 event->output_data_number);
2441 DM_free(event->output_datas);
2442 event->output_datas = NULL;
2443 }
2444 }
2445
_dm_shw_events_free(_IN_ dm_shw_event_t * events,_IN_ int number)2446 static void _dm_shw_events_free(_IN_ dm_shw_event_t *events, _IN_ int number)
2447 {
2448 int index = 0;
2449 dm_shw_event_t *event = NULL;
2450
2451 for (index = 0; index < number; index++) {
2452 event = events + index;
2453 _dm_shw_event_free(event);
2454 }
2455 }
2456
_dm_shw_service_outputdata_free(_IN_ dm_shw_data_t * outputdata)2457 static void _dm_shw_service_outputdata_free(_IN_ dm_shw_data_t *outputdata)
2458 {
2459 if (outputdata->identifier) {
2460 DM_free(outputdata->identifier);
2461 outputdata->identifier = NULL;
2462 }
2463 _dm_shw_data_free(&outputdata->data_value);
2464 }
2465
_dm_shw_service_outputdatas_free(_IN_ dm_shw_data_t * outputdatas,_IN_ int number)2466 static void _dm_shw_service_outputdatas_free(_IN_ dm_shw_data_t *outputdatas,
2467 _IN_ int number)
2468 {
2469 int index = 0;
2470 dm_shw_data_t *outputdata = NULL;
2471
2472 for (index = 0; index < number; index++) {
2473 outputdata = outputdatas + index;
2474 _dm_shw_service_outputdata_free(outputdata);
2475 }
2476 }
2477
_dm_shw_service_inputdata_free(_IN_ dm_shw_data_t * inputdata)2478 static void _dm_shw_service_inputdata_free(_IN_ dm_shw_data_t *inputdata)
2479 {
2480 if (inputdata->identifier) {
2481 DM_free(inputdata->identifier);
2482 inputdata->identifier = NULL;
2483 }
2484 _dm_shw_data_free(&inputdata->data_value);
2485 }
2486
_dm_shw_service_inputdatas_free(_IN_ dm_shw_data_t * inputdatas,_IN_ int number)2487 static void _dm_shw_service_inputdatas_free(_IN_ dm_shw_data_t *inputdatas,
2488 _IN_ int number)
2489 {
2490 int index = 0;
2491 dm_shw_data_t *inputdata = NULL;
2492
2493 for (index = 0; index < number; index++) {
2494 inputdata = inputdatas + index;
2495 _dm_shw_service_inputdata_free(inputdata);
2496 }
2497 }
2498
_dm_shw_service_free(_IN_ dm_shw_service_t * service)2499 static void _dm_shw_service_free(_IN_ dm_shw_service_t *service)
2500 {
2501 if (service->identifier) {
2502 DM_free(service->identifier);
2503 service->identifier = NULL;
2504 }
2505 if (service->output_datas) {
2506 _dm_shw_service_outputdatas_free(service->output_datas,
2507 service->output_data_number);
2508 DM_free(service->output_datas);
2509 service->output_datas = NULL;
2510 }
2511 if (service->input_datas) {
2512 _dm_shw_service_inputdatas_free(service->input_datas,
2513 service->input_data_number);
2514 DM_free(service->input_datas);
2515 service->input_datas = NULL;
2516 }
2517 }
2518
_dm_shw_services_free(_IN_ dm_shw_service_t * services,_IN_ int number)2519 static void _dm_shw_services_free(_IN_ dm_shw_service_t *services,
2520 _IN_ int number)
2521 {
2522 int index = 0;
2523 dm_shw_service_t *service = NULL;
2524
2525 for (index = 0; index < number; index++) {
2526 service = services + index;
2527 _dm_shw_service_free(service);
2528 }
2529 }
2530
dm_shw_destroy(_IN_ dm_shw_t ** shadow)2531 void dm_shw_destroy(_IN_ dm_shw_t **shadow)
2532 {
2533 if (shadow == NULL || *shadow == NULL) {
2534 return;
2535 }
2536
2537 /* Free Properties */
2538 if ((*shadow)->properties) {
2539 _dm_shw_properties_free((*shadow)->properties,
2540 (*shadow)->property_number);
2541 DM_free((*shadow)->properties);
2542 (*shadow)->properties = NULL;
2543 }
2544
2545 /* Free Events */
2546 if ((*shadow)->events) {
2547 _dm_shw_events_free((*shadow)->events, (*shadow)->event_number);
2548 DM_free((*shadow)->events);
2549 (*shadow)->events = NULL;
2550 }
2551
2552 /* Free Services */
2553 if ((*shadow)->services) {
2554 _dm_shw_services_free((*shadow)->services, (*shadow)->service_number);
2555 DM_free((*shadow)->services);
2556 (*shadow)->services = NULL;
2557 }
2558
2559 DM_free(*shadow);
2560 *shadow = NULL;
2561 }
2562
2563 #endif
2564