mbed client lightswitch demo
Dependencies: mbed Socket lwip-eth lwip-sys lwip
Fork of mbed-client-classic-example-lwip by
m2mtlvserializer.cpp
00001 /* 00002 * Copyright (c) 2015 ARM Limited. All rights reserved. 00003 * SPDX-License-Identifier: Apache-2.0 00004 * Licensed under the Apache License, Version 2.0 (the License); you may 00005 * not use this file except in compliance with the License. 00006 * You may obtain a copy of the License at 00007 * 00008 * http://www.apache.org/licenses/LICENSE-2.0 00009 * 00010 * Unless required by applicable law or agreed to in writing, software 00011 * distributed under the License is distributed on an AS IS BASIS, WITHOUT 00012 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 00013 * See the License for the specific language governing permissions and 00014 * limitations under the License. 00015 */ 00016 #include <stdio.h> 00017 #include "include/m2mtlvserializer.h" 00018 #include "mbed-client/m2mconstants.h" 00019 00020 M2MTLVSerializer::M2MTLVSerializer() 00021 { 00022 } 00023 00024 M2MTLVSerializer::~M2MTLVSerializer() 00025 { 00026 } 00027 00028 uint8_t* M2MTLVSerializer::serialize(M2MObjectInstanceList object_instance_list, uint32_t &size) 00029 { 00030 return serialize_object_instances(object_instance_list, size); 00031 } 00032 00033 uint8_t* M2MTLVSerializer::serialize(M2MResourceList resource_list, uint32_t &size) 00034 { 00035 bool valid = true; 00036 return serialize_resources(resource_list, size,valid); 00037 } 00038 00039 uint8_t* M2MTLVSerializer::serialize(M2MResource *resource, uint32_t &size) 00040 { 00041 uint8_t* data = NULL; 00042 serialize(resource, data, size); 00043 return data; 00044 } 00045 00046 uint8_t* M2MTLVSerializer::serialize_object_instances(M2MObjectInstanceList object_instance_list, uint32_t &size) 00047 { 00048 uint8_t *data = NULL; 00049 00050 if(!object_instance_list.empty()) { 00051 M2MObjectInstanceList::const_iterator it; 00052 it = object_instance_list.begin(); 00053 for (; it!=object_instance_list.end(); it++) { 00054 uint16_t id = (*it)->instance_id(); 00055 serialize(id, *it, data, size); 00056 } 00057 } 00058 return data; 00059 } 00060 00061 uint8_t* M2MTLVSerializer::serialize_resources(M2MResourceList resource_list, uint32_t &size, bool &valid) 00062 { 00063 uint8_t *data = NULL; 00064 00065 if(!resource_list.empty()) { 00066 M2MResourceList::const_iterator it; 00067 it = resource_list.begin(); 00068 for (; it!=resource_list.end(); it++) { 00069 if((*it)->name_id() == -1) { 00070 valid = false; 00071 break; 00072 } 00073 } 00074 if(valid) { 00075 it = resource_list.begin(); 00076 for (; it!=resource_list.end(); it++) { 00077 serialize(*it, data, size); 00078 } 00079 } 00080 } 00081 return data; 00082 } 00083 00084 void M2MTLVSerializer::serialize(uint16_t id, M2MObjectInstance *object_instance, uint8_t *&data, uint32_t &size) 00085 { 00086 uint8_t *resource_data = NULL; 00087 uint32_t resource_size = 0; 00088 00089 bool valid = true; 00090 resource_data = serialize_resources(object_instance->resources(),resource_size,valid); 00091 if(valid) { 00092 serialize_TILV(TYPE_OBJECT_INSTANCE, id, resource_data, resource_size, data, size); 00093 } 00094 free(resource_data); 00095 } 00096 00097 bool M2MTLVSerializer::serialize(M2MResource *resource, uint8_t *&data, uint32_t &size) 00098 { 00099 bool success = false; 00100 if(resource->name_id() != -1) { 00101 success = resource->supports_multiple_instances() ? 00102 serialize_multiple_resource(resource, data, size) : 00103 serialize_resource(resource, data, size); 00104 } 00105 return success; 00106 } 00107 00108 bool M2MTLVSerializer::serialize_resource(M2MResource *resource, uint8_t *&data, uint32_t &size) 00109 { 00110 bool success = false; 00111 if(resource->name_id() != -1) { 00112 success = true; 00113 serialize_TILV(TYPE_RESOURCE, resource->name_id(), resource->value(), resource->value_length(), data, size); 00114 } 00115 return success; 00116 } 00117 00118 bool M2MTLVSerializer::serialize_multiple_resource(M2MResource *resource, uint8_t *&data, uint32_t &size) 00119 { 00120 bool success = false; 00121 uint8_t *nested_data = NULL; 00122 uint32_t nested_data_size = 0; 00123 00124 M2MResourceInstanceList instance_list = resource->resource_instances(); 00125 if(!instance_list.empty()) { 00126 M2MResourceInstanceList::const_iterator it; 00127 it = instance_list.begin(); 00128 for (; it!=instance_list.end(); it++) { 00129 uint16_t id = (*it)->instance_id(); 00130 serialize_resource_instance(id, (*it), nested_data, nested_data_size); 00131 } 00132 } 00133 if(resource->name_id() != -1) { 00134 success = true; 00135 serialize_TILV(TYPE_MULTIPLE_RESOURCE, resource->name_id(), nested_data, nested_data_size, data, size); 00136 } 00137 00138 free(nested_data); 00139 nested_data = NULL; 00140 return success; 00141 } 00142 00143 void M2MTLVSerializer::serialize_resource_instance(uint16_t id, M2MResourceInstance *resource, uint8_t *&data, uint32_t &size) 00144 { 00145 serialize_TILV(TYPE_RESOURCE_INSTANCE, id, resource->value(), resource->value_length(), data, size); 00146 } 00147 00148 void M2MTLVSerializer::serialize_TILV(uint8_t type, uint16_t id, uint8_t *value, uint32_t value_length, uint8_t *&data, uint32_t &size) 00149 { 00150 uint8_t *tlv = 0; 00151 uint32_t type_length = 1; 00152 type += id < 256 ? 0 : ID16; 00153 type += value_length < 8 ? value_length : 00154 value_length < 256 ? LENGTH8 : 00155 value_length < 65536 ? LENGTH16 : LENGTH24; 00156 uint8_t *tlv_type = (uint8_t*)malloc(type_length+1); 00157 memset(tlv_type,0,type_length+1); 00158 *tlv_type = type & 0xFF; 00159 00160 uint32_t id_size = 0; 00161 uint8_t* id_ptr = serialize_id(id, id_size); 00162 00163 uint32_t length_size = 0; 00164 uint8_t* length_ptr = serialize_length(value_length, length_size); 00165 00166 tlv = (uint8_t*)malloc(size + type_length + id_size + length_size + value_length+1); 00167 memset(tlv,0,size + type_length + id_size + length_size + value_length+1); 00168 if(data) { 00169 memcpy(tlv, data, size); 00170 } 00171 memcpy(tlv+size, tlv_type, type_length); 00172 memcpy(tlv+size+type_length, id_ptr, id_size); 00173 memcpy(tlv+size+type_length+id_size, length_ptr, length_size); 00174 memcpy(tlv+size+type_length+id_size+length_size, value, value_length); 00175 00176 if(tlv_type) { 00177 free(tlv_type) ; 00178 } 00179 if(length_ptr) { 00180 free(length_ptr); 00181 } 00182 if(id_ptr) { 00183 free(id_ptr); 00184 } 00185 if(data) { 00186 free(data); 00187 data = NULL; 00188 } 00189 data = tlv; 00190 size += type_length + id_size + length_size + value_length; 00191 } 00192 00193 uint8_t* M2MTLVSerializer::serialize_id(uint16_t id, uint32_t &size) 00194 { 00195 uint32_t id_size = id > 255 ? 2 : 1; 00196 uint8_t *id_ptr = (uint8_t*)malloc(id_size); 00197 memset(id_ptr, 0 , id_size); 00198 size += id_size; 00199 if(id > 255) { 00200 *id_ptr = (id & 0xFF00) >> 8; 00201 id_ptr++; 00202 *id_ptr = id & 0xFF; 00203 id_ptr--; 00204 } else { 00205 *id_ptr = id & 0xFF; 00206 } 00207 return id_ptr; 00208 } 00209 00210 uint8_t* M2MTLVSerializer::serialize_length(uint32_t length, uint32_t &size) 00211 { 00212 uint8_t *length_ptr = 0; 00213 uint32_t length_size = 0; 00214 if (length > 65535) { 00215 length_size = 3; 00216 length_ptr = (uint8_t*)malloc(length_size+1); 00217 memset(length_ptr,0,length_size+1); 00218 *length_ptr = (length & 0xFF0000) >> 16; 00219 length_ptr++; 00220 *length_ptr = (length & 0xFF00) >> 8; 00221 length_ptr++; 00222 *length_ptr = length & 0xFF; 00223 length_ptr--; 00224 length_ptr--; 00225 } else if (length > 255) { 00226 length_size = 2; 00227 length_ptr = (uint8_t*)malloc(length_size+1); 00228 memset(length_ptr,0,length_size+1); 00229 *length_ptr = (length & 0xFF00) >> 8; 00230 length_ptr++; 00231 *length_ptr = length & 0xFF; 00232 length_ptr--; 00233 } else if (length > 7) { 00234 length_size = 1; 00235 length_ptr = (uint8_t*)malloc(length_size+1); 00236 memset(length_ptr,0,length_size+1); 00237 *length_ptr = length & 0xFF; 00238 } 00239 size += length_size; 00240 return length_ptr; 00241 } 00242
Generated on Tue Jul 12 2022 18:27:24 by 1.7.2