EDP KIT from OneNet
Embed:
(wiki syntax)
Show/hide line numbers
EdpKit.cpp
00001 #include <stdlib.h> 00002 #include <stdio.h> 00003 #include <string.h> 00004 #include <time.h> 00005 #include <assert.h> 00006 #include "EdpKit.h" 00007 00008 #define MKFUN_PACKET_SAVE_DATA(TYPE, NAME) \ 00009 EdpPacket* PacketSavedata##NAME(SaveDataType type, \ 00010 const char* dst_devid, \ 00011 const char* ds_id, \ 00012 TYPE value, \ 00013 time_t at, \ 00014 const char* token){ \ 00015 EdpPacket* pkg = NULL; \ 00016 switch (type){ \ 00017 case kTypeFullJson: \ 00018 pkg = PacketSavedataType1##NAME(dst_devid, ds_id, \ 00019 value, at, token); \ 00020 break; \ 00021 case kTypeSimpleJsonWithoutTime: \ 00022 pkg = PacketSavedataType2##NAME(dst_devid, ds_id, \ 00023 value, at, token); \ 00024 break; \ 00025 case kTypeSimpleJsonWithTime: \ 00026 pkg = PacketSavedataType3##NAME(dst_devid, ds_id, \ 00027 value, at, token); \ 00028 break; \ 00029 default: \ 00030 break; \ 00031 } \ 00032 \ 00033 return pkg; \ 00034 } 00035 00036 #define MKFUN_PACKET_SAVE_DATA_TYPE1(TYPE, NAME, MED) \ 00037 static EdpPacket* PacketSavedataType1##NAME(const char* dst_devid, \ 00038 const char* ds_id, \ 00039 TYPE value, \ 00040 time_t at, \ 00041 const char* token){ \ 00042 cJSON* json_obj = NULL; \ 00043 cJSON* ds_array = NULL; \ 00044 cJSON* json_obj_ds = NULL; \ 00045 cJSON* dp_array = NULL; \ 00046 cJSON* dp_item = NULL; \ 00047 char ss[100] = {0}; \ 00048 EdpPacket* pkg = NULL; \ 00049 \ 00050 json_obj = cJSON_CreateObject(); \ 00051 \ 00052 if(token) { \ 00053 cJSON_AddStringToObject(json_obj, "token", token); \ 00054 } \ 00055 \ 00056 ds_array = cJSON_CreateArray(); \ 00057 json_obj_ds = cJSON_CreateObject(); \ 00058 \ 00059 cJSON_AddStringToObject(json_obj_ds, "id", ds_id); \ 00060 \ 00061 dp_array = cJSON_CreateArray(); \ 00062 dp_item = cJSON_CreateObject(); \ 00063 \ 00064 FormatAt(ss, 100, at); \ 00065 cJSON_AddStringToObject(dp_item, "at", ss); \ 00066 cJSON_Add##MED##ToObject(dp_item, "value", value); \ 00067 cJSON_AddItemToArray(dp_array, dp_item); \ 00068 \ 00069 cJSON_AddItemToObject(json_obj_ds, "datapoints", dp_array); \ 00070 cJSON_AddItemToArray(ds_array, json_obj_ds); \ 00071 cJSON_AddItemToObject(json_obj, "datastreams", ds_array); \ 00072 \ 00073 pkg = PacketSavedataJson(dst_devid, json_obj, \ 00074 kTypeFullJson); \ 00075 cJSON_Delete(json_obj); \ 00076 \ 00077 return pkg; \ 00078 } 00079 00080 #define MKFUN_PACKET_SAVE_DATA_TYPE2(TYPE, NAME, MED) \ 00081 static EdpPacket* PacketSavedataType2##NAME(const char* dst_devid, \ 00082 const char* ds_id, \ 00083 TYPE value, \ 00084 time_t at, \ 00085 const char* token) \ 00086 { \ 00087 cJSON* json_obj = NULL; \ 00088 EdpPacket* pkg = NULL; \ 00089 \ 00090 json_obj = cJSON_CreateObject(); \ 00091 cJSON_Add##MED##ToObject(json_obj, ds_id, value); \ 00092 \ 00093 pkg = PacketSavedataJson(dst_devid, json_obj, \ 00094 kTypeSimpleJsonWithoutTime); \ 00095 cJSON_Delete(json_obj); \ 00096 \ 00097 return pkg; \ 00098 } 00099 00100 00101 #define MKFUN_PACKET_SAVE_DATA_TYPE3(TYPE, NAME, MED) \ 00102 static EdpPacket* PacketSavedataType3##NAME(const char* dst_devid, \ 00103 const char* ds_id, \ 00104 TYPE value, \ 00105 time_t at, \ 00106 const char* token){ \ 00107 cJSON* json_obj = NULL; \ 00108 cJSON* json_obj_ds = NULL; \ 00109 char ss[100] = {0}; \ 00110 EdpPacket* pkg = NULL; \ 00111 \ 00112 json_obj = cJSON_CreateObject(); \ 00113 FormatAt(ss, 100, at); \ 00114 json_obj_ds = cJSON_CreateObject(); \ 00115 cJSON_Add##MED##ToObject(json_obj_ds, ss, value); \ 00116 cJSON_AddItemToObject(json_obj, ds_id, json_obj_ds); \ 00117 \ 00118 pkg = PacketSavedataJson(dst_devid, json_obj, \ 00119 kTypeSimpleJsonWithTime); \ 00120 cJSON_Delete(json_obj); \ 00121 \ 00122 return pkg; \ 00123 } 00124 00125 #define MKFUN_UNPACK_SAVE_DATA(TYPE, NAME) \ 00126 int32 UnpackSavedata##NAME(SaveDataType type, \ 00127 EdpPacket* pkg, \ 00128 char** ds_id, \ 00129 TYPE* value) \ 00130 { \ 00131 int ret = -1; \ 00132 switch (type){ \ 00133 case kTypeFullJson: \ 00134 ret = UnpackSavedataType1##NAME(pkg, ds_id, value); \ 00135 break; \ 00136 case kTypeSimpleJsonWithoutTime: \ 00137 ret = UnpackSavedataType2##NAME(pkg, ds_id, value); \ 00138 break; \ 00139 case kTypeSimpleJsonWithTime: \ 00140 ret = UnpackSavedataType3##NAME(pkg, ds_id, value); \ 00141 break; \ 00142 default: \ 00143 break; \ 00144 } \ 00145 \ 00146 return ret; \ 00147 } 00148 00149 #define MKFUN_UNPACK_SAVE_DATA_TYPE1(TYPE, NAME, MED) \ 00150 static int32 UnpackSavedataType1##NAME(EdpPacket* pkg, \ 00151 char** ds_id, \ 00152 TYPE* value) \ 00153 { \ 00154 cJSON* json_obj = NULL; \ 00155 cJSON* ds_array = NULL; \ 00156 cJSON* ds_item = NULL; \ 00157 char* id = NULL; \ 00158 cJSON* dp_array = NULL; \ 00159 cJSON* dp_item = NULL; \ 00160 char* valuestring = NULL; \ 00161 \ 00162 if(0 != UnpackSavedataJson(pkg, &json_obj)) \ 00163 return ERR_UNPACK_SAVED_JSON; \ 00164 \ 00165 ds_array = cJSON_GetObjectItem(json_obj, "datastreams"); \ 00166 if((0 == ds_array) || (1 != cJSON_GetArraySize(ds_array))) \ 00167 return ERR_UNPACK_SAVED_JSON; \ 00168 \ 00169 ds_item = cJSON_GetArrayItem(ds_array, 0); \ 00170 if(0 == ds_item) \ 00171 return ERR_UNPACK_SAVED_JSON; \ 00172 \ 00173 id = cJSON_GetObjectItem(ds_item, "id")->valuestring; \ 00174 *ds_id = (char*)malloc(strlen(id)+1); \ 00175 memcpy((char*)(*ds_id), id, strlen(id)+1); \ 00176 \ 00177 dp_array = cJSON_GetObjectItem(ds_item, "datapoints"); \ 00178 if((0 == dp_array) || (1 != cJSON_GetArraySize(dp_array))) \ 00179 return ERR_UNPACK_SAVED_JSON; \ 00180 \ 00181 dp_item = cJSON_GetArrayItem(dp_array, 0); \ 00182 00183 00184 #define UNPACK_SAVE_DATA_TYPE1_END_STRING \ 00185 valuestring = cJSON_GetObjectItem(dp_item, "value")->valuestring; \ 00186 *value = (char*)malloc(strlen(valuestring)+1); \ 00187 memcpy((char*)(*value), valuestring, strlen(valuestring)+1); \ 00188 cJSON_Delete(json_obj); \ 00189 return 0; \ 00190 } 00191 00192 #define UNPACK_SAVE_DATA_TYPE1_END_NUMBER(TYPE) \ 00193 *value = cJSON_GetObjectItem(dp_item, "value")->value##TYPE; \ 00194 cJSON_Delete(json_obj); \ 00195 return 0; \ 00196 } 00197 00198 #define MKFUN_UNPACK_SAVE_DATA_TYPE2(TYPE, NAME, MED) \ 00199 static int32 UnpackSavedataType2##NAME(EdpPacket* pkg, \ 00200 char** ds_id, \ 00201 TYPE* value) \ 00202 { \ 00203 cJSON* json_obj = NULL; \ 00204 cJSON* json_child = NULL; \ 00205 size_t len = 0; \ 00206 char* valuestring = NULL; \ 00207 \ 00208 if(0 != UnpackSavedataJson(pkg, &json_obj)) \ 00209 return ERR_UNPACK_SAVED_JSON; \ 00210 if (!json_obj->child){ \ 00211 cJSON_Delete(json_obj); \ 00212 return ERR_UNPACK_SAVED_JSON; \ 00213 } \ 00214 json_child = json_obj->child; \ 00215 len = strlen(json_child->string) + 1; \ 00216 *ds_id = (char*)malloc(len); \ 00217 memcpy((char*)(*ds_id), json_child->string, len); \ 00218 00219 #define UNPACK_SAVE_DATA_TYPE23_END_NUMBER(TYPE) \ 00220 *value = json_child->value##TYPE; \ 00221 cJSON_Delete(json_obj); \ 00222 return 0; \ 00223 } 00224 00225 #define UNPACK_SAVE_DATA_TYPE23_END_STRING() \ 00226 valuestring = json_child->valuestring; \ 00227 *value = (char*)malloc(strlen(valuestring)+1); \ 00228 memcpy((char*)(*value), valuestring, strlen(valuestring)+1); \ 00229 cJSON_Delete(json_obj); \ 00230 return 0; \ 00231 } 00232 00233 #define MKFUN_UNPACK_SAVE_DATA_TYPE3(TYPE, NAME, MED) \ 00234 static int32 UnpackSavedataType3##NAME(EdpPacket* pkg, \ 00235 char** ds_id, \ 00236 TYPE* value) \ 00237 { \ 00238 cJSON* json_obj = NULL; \ 00239 cJSON* json_child = NULL; \ 00240 char* valuestring = NULL; \ 00241 size_t len = 0; \ 00242 \ 00243 if(0 != UnpackSavedataJson(pkg, &json_obj)) \ 00244 return ERR_UNPACK_SAVED_JSON; \ 00245 \ 00246 json_child = json_obj->child; \ 00247 if (!json_child || !json_child->string){ \ 00248 cJSON_Delete(json_obj); \ 00249 return ERR_UNPACK_SAVED_JSON; \ 00250 } \ 00251 \ 00252 len = strlen(json_child->string) + 1; \ 00253 *ds_id = (char*)malloc(len); \ 00254 memcpy(*ds_id, json_child->string, len); \ 00255 \ 00256 json_child = json_child->child; \ 00257 if (!json_child){ \ 00258 cJSON_Delete(json_obj); \ 00259 return ERR_UNPACK_SAVED_JSON; \ 00260 } 00261 00262 00263 static void FormatAt(char* buffer, int len, time_t now) 00264 { 00265 struct tm timinfo; 00266 00267 if (now == 0){ 00268 now = 0; //time(0); 00269 } 00270 00271 #if defined(linux) || defined(__linux) || defined(__linux__) 00272 strftime(buffer, len, "%F %T", localtime_r(&now, &timinfo)); 00273 #elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32) 00274 localtime_s(&timinfo, &now); 00275 strftime(buffer, len, "%F %T", &timinfo); 00276 #endif 00277 } 00278 00279 /*---------------------------------------------------------------------------*/ 00280 Buffer* NewBuffer() 00281 { 00282 Buffer* buf = (Buffer*)malloc(sizeof(Buffer)); 00283 buf->_data = (uint8*)malloc(sizeof(uint8) * BUFFER_SIZE); 00284 buf->_write_pos = 0; 00285 buf->_read_pos = 0; 00286 buf->_capacity = BUFFER_SIZE; 00287 return buf; 00288 } 00289 00290 void DeleteBuffer(Buffer** buf) 00291 { 00292 uint8* pdata = (*buf)->_data; 00293 free(pdata); 00294 free(*buf); 00295 *buf = 0; 00296 } 00297 00298 int32 CheckCapacity(Buffer* buf, uint32 len) 00299 { 00300 uint32 cap_len = buf->_capacity; 00301 int32 flag = 0; 00302 uint8* pdata = NULL; 00303 00304 while (cap_len - buf->_write_pos < len) /* remain len < len */ 00305 { 00306 cap_len = cap_len << 1; 00307 if (++flag > 32) 00308 break; /* overflow */ 00309 } 00310 if (flag > 32) 00311 return -1; 00312 if (cap_len > buf->_capacity) 00313 { 00314 pdata = (uint8*)malloc(sizeof(uint8) * cap_len); 00315 memcpy(pdata, buf->_data, buf->_write_pos); 00316 free(buf->_data); 00317 buf->_data = pdata; 00318 buf->_capacity = cap_len; 00319 } 00320 return 0; 00321 } 00322 00323 /*---------------------------------------------------------------------------*/ 00324 int32 ReadByte(EdpPacket* pkg, uint8* val) 00325 { 00326 if (pkg->_read_pos+1 > pkg->_write_pos) 00327 return -1; 00328 *val = pkg->_data[pkg->_read_pos]; 00329 pkg->_read_pos += 1; 00330 return 0; 00331 } 00332 00333 int32 ReadBytes(EdpPacket* pkg, uint8** val, uint32 count) 00334 { 00335 if (pkg->_read_pos+count > pkg->_write_pos) 00336 return -1; 00337 *val = (uint8*)malloc(sizeof(uint8) * count); 00338 memcpy(*val, pkg->_data + pkg->_read_pos, count); 00339 pkg->_read_pos += count; 00340 return 0; 00341 } 00342 00343 int32 ReadUint16(EdpPacket* pkg, uint16* val) 00344 { 00345 uint8 msb, lsb; 00346 if (pkg->_read_pos+2 > pkg->_write_pos) 00347 return -1; 00348 msb = pkg->_data[pkg->_read_pos]; 00349 pkg->_read_pos++; 00350 lsb = pkg->_data[pkg->_read_pos]; 00351 pkg->_read_pos++; 00352 *val = (msb<<8) + lsb; 00353 return 0; 00354 } 00355 00356 int32 ReadUint32(EdpPacket* pkg, uint32* val) 00357 { 00358 int32 i = 0; 00359 uint32 tmpval = 0; 00360 if (pkg->_read_pos+4 > pkg->_write_pos) 00361 return -1; 00362 while (i++ < 4) { 00363 tmpval = (tmpval << 8) | (pkg->_data[pkg->_read_pos]); 00364 pkg->_read_pos++; 00365 } 00366 *val = tmpval; 00367 return 0; 00368 } 00369 00370 int32 ReadStr(EdpPacket* pkg, char** val) 00371 { 00372 uint16 len = 0; 00373 int rc = 0; 00374 /* read str len */ 00375 rc = ReadUint16(pkg, &len); 00376 if (rc) 00377 return rc; 00378 if (pkg->_read_pos+len > pkg->_write_pos) 00379 return -1; 00380 /* copy str val */ 00381 *val = (char*)malloc(sizeof(char) * (len + 1)); 00382 memset(*val, 0, len+1); 00383 strncpy(*val, (const char *)(pkg->_data + pkg->_read_pos), len); 00384 pkg->_read_pos += len; 00385 return 0; 00386 } 00387 00388 int32 ReadRemainlen(EdpPacket* pkg, uint32* len_val) 00389 { 00390 uint32 multiplier = 1; 00391 uint32 len_len = 0; 00392 uint8 onebyte = 0; 00393 int32 rc; 00394 *len_val = 0; 00395 do { 00396 rc = ReadByte(pkg, &onebyte); 00397 if (rc) 00398 return rc; 00399 00400 *len_val += (onebyte & 0x7f) * multiplier; 00401 multiplier *= 0x80; 00402 00403 len_len++; 00404 if (len_len > 4) { 00405 return -1;/*len of len more than 4;*/ 00406 } 00407 } while((onebyte & 0x80) != 0); 00408 return 0; 00409 } 00410 00411 /*---------------------------------------------------------------------------*/ 00412 int32 WriteByte(Buffer* buf, uint8 byte) 00413 { 00414 assert(buf->_read_pos == 0); 00415 if (CheckCapacity(buf, 1)) 00416 return -1; 00417 buf->_data[buf->_write_pos] = byte; 00418 buf->_write_pos++; 00419 return 0; 00420 } 00421 00422 int32 WriteBytes(Buffer* buf, const void* bytes, uint32 count) 00423 { 00424 assert(buf->_read_pos == 0); 00425 if (CheckCapacity(buf, count)) 00426 return -1; 00427 memcpy(buf->_data + buf->_write_pos, bytes, count); 00428 buf->_write_pos += count; 00429 return 0; 00430 } 00431 00432 int32 WriteUint16(Buffer* buf, uint16 val) 00433 { 00434 assert(buf->_read_pos == 0); 00435 return WriteByte(buf, MOSQ_MSB(val)) 00436 || WriteByte(buf, MOSQ_LSB(val)); 00437 } 00438 00439 int32 WriteUint32(Buffer* buf, uint32 val) 00440 { 00441 assert(buf->_read_pos == 0); 00442 return WriteByte(buf, (val >> 24) & 0x00FF) 00443 || WriteByte(buf, (val >> 16) & 0x00FF) 00444 || WriteByte(buf, (val >> 8) & 0x00FF) 00445 || WriteByte(buf, (val) & 0x00FF); 00446 } 00447 00448 int32 WriteStr(Buffer* buf, const char *str) 00449 { 00450 uint16 length = 0; 00451 assert(buf->_read_pos == 0); 00452 length = strlen(str); 00453 return WriteUint16(buf, length) 00454 || WriteBytes(buf, str, length); 00455 } 00456 00457 int32 WriteRemainlen(Buffer* buf, uint32 len_val) 00458 { 00459 uint32 remaining_length = len_val; 00460 int32 remaining_count = 0; 00461 uint8 byte = 0; 00462 00463 assert(buf->_read_pos == 0); 00464 00465 do { 00466 byte = remaining_length % 128; 00467 remaining_length = remaining_length / 128; 00468 /* If there are more digits to encode, set the top bit of this digit */ 00469 if (remaining_length > 0) { 00470 byte = byte | 0x80; 00471 } 00472 buf->_data[buf->_write_pos++] = byte; 00473 remaining_count++; 00474 }while(remaining_length > 0 && remaining_count < 5); 00475 assert(remaining_count != 5); 00476 return 0; 00477 } 00478 00479 /*---------------------------------------------------------------------------*/ 00480 /* connect1 (C->S): devid + apikey */ 00481 EdpPacket* PacketConnect1(const char* devid, const char* auth_key) 00482 { 00483 EdpPacket* pkg = NewBuffer(); 00484 uint32 remainlen; 00485 /* msg type */ 00486 WriteByte(pkg, CONNREQ); 00487 /* remain len */ 00488 remainlen = (2+3)+1+1+2+(2+strlen(devid))+(2+strlen(auth_key)); 00489 WriteRemainlen(pkg, remainlen); 00490 /* protocol desc */ 00491 WriteStr(pkg, PROTOCOL_NAME); 00492 /* protocol version */ 00493 WriteByte(pkg, PROTOCOL_VERSION); 00494 /* connect flag */ 00495 WriteByte(pkg, 0x40); 00496 /* keep time */ 00497 WriteUint16(pkg, 0x0080); 00498 /* DEVID */ 00499 WriteStr(pkg, devid); 00500 /* auth key */ 00501 WriteStr(pkg, auth_key); 00502 return pkg; 00503 } 00504 00505 /* connect2 (C->S): userid + auth_info */ 00506 EdpPacket* PacketConnect2(const char* userid, const char* auth_info) 00507 { 00508 EdpPacket* pkg = NULL; 00509 uint32 remainlen; 00510 00511 pkg = NewBuffer(); 00512 /* msg type */ 00513 WriteByte(pkg, CONNREQ); 00514 /* remain len */ 00515 remainlen = (2+3)+1+1+2+2+(2+strlen(userid))+(2+strlen(auth_info)); 00516 WriteRemainlen(pkg, remainlen); 00517 /* protocol desc */ 00518 WriteStr(pkg, PROTOCOL_NAME); 00519 /* protocol version */ 00520 WriteByte(pkg, PROTOCOL_VERSION); 00521 /* connect flag */ 00522 WriteByte(pkg, 0xC0); 00523 /* keep time */ 00524 WriteUint16(pkg, 0x0080); 00525 /* devid */ 00526 WriteByte(pkg, 0x00); 00527 WriteByte(pkg, 0x00); 00528 /* USERID */ 00529 WriteStr(pkg, userid); 00530 /* auth info */ 00531 WriteStr(pkg, auth_info); 00532 return pkg; 00533 } 00534 00535 /* push_data (C->S) */ 00536 EdpPacket* PacketPushdata(const char* dst_devid, const char* data, uint32 data_len) 00537 { 00538 EdpPacket* pkg = NULL; 00539 uint32 remainlen; 00540 00541 pkg = NewBuffer(); 00542 /* msg type */ 00543 WriteByte(pkg, PUSHDATA); 00544 /* remain len */ 00545 remainlen = (2+strlen(dst_devid))+data_len; 00546 WriteRemainlen(pkg, remainlen); 00547 /* dst devid */ 00548 WriteStr(pkg, dst_devid); 00549 /* data */ 00550 WriteBytes(pkg, data, data_len); 00551 return pkg; 00552 } 00553 00554 /* sava_data (C->S) */ 00555 EdpPacket* PacketSavedataJson(const char* dst_devid, cJSON* json_obj, int type) 00556 { 00557 EdpPacket* pkg = NULL; 00558 uint32 remainlen = 0; 00559 char* json_out = NULL; 00560 uint32 json_len = 0; 00561 00562 pkg = NewBuffer(); 00563 00564 json_out = cJSON_Print(json_obj); 00565 json_len = strlen(json_out); 00566 00567 /* msg type */ 00568 WriteByte(pkg, SAVEDATA); 00569 if (dst_devid) 00570 { 00571 /* remain len */ 00572 remainlen = 1+(2+strlen(dst_devid))+1+(2+json_len); 00573 WriteRemainlen(pkg, remainlen); 00574 /* translate address flag */ 00575 WriteByte(pkg, 0x80); 00576 /* dst devid */ 00577 WriteStr(pkg, dst_devid); 00578 } 00579 else 00580 { 00581 /* remain len */ 00582 remainlen = 1+1+(2+json_len); 00583 WriteRemainlen(pkg, remainlen); 00584 /* translate address flag */ 00585 WriteByte(pkg, 0x00); 00586 } 00587 /* json flag */ 00588 WriteByte(pkg, type); 00589 /* json */ 00590 WriteStr(pkg, json_out); 00591 free(json_out); 00592 return pkg; 00593 } 00594 00595 /* 00596 * 定义3种JSON格式的打包和解包函数, 00597 * 每种格式都支持int,double和char*三种类型 00598 */ 00599 MKFUN_PACKET_SAVE_DATA_TYPE1(int, Int, Number) 00600 MKFUN_PACKET_SAVE_DATA_TYPE1(double, Double, Number) 00601 MKFUN_PACKET_SAVE_DATA_TYPE1(const char*, String, String) 00602 00603 MKFUN_PACKET_SAVE_DATA_TYPE2(int, Int, Number) 00604 MKFUN_PACKET_SAVE_DATA_TYPE2(double, Double, Number) 00605 MKFUN_PACKET_SAVE_DATA_TYPE2(const char*, String, String) 00606 00607 MKFUN_PACKET_SAVE_DATA_TYPE3(int, Int, Number) 00608 MKFUN_PACKET_SAVE_DATA_TYPE3(double, Double, Number) 00609 MKFUN_PACKET_SAVE_DATA_TYPE3(const char*, String, String) 00610 00611 MKFUN_PACKET_SAVE_DATA(int, Int) 00612 MKFUN_PACKET_SAVE_DATA(double, Double) 00613 MKFUN_PACKET_SAVE_DATA(const char*, String) 00614 00615 /* 解包函数 */ 00616 MKFUN_UNPACK_SAVE_DATA_TYPE1(int, Int, Number) 00617 UNPACK_SAVE_DATA_TYPE1_END_NUMBER(int) 00618 MKFUN_UNPACK_SAVE_DATA_TYPE1(double, Double, Number) 00619 UNPACK_SAVE_DATA_TYPE1_END_NUMBER(double) 00620 MKFUN_UNPACK_SAVE_DATA_TYPE1(char*, String, String) 00621 UNPACK_SAVE_DATA_TYPE1_END_STRING 00622 00623 MKFUN_UNPACK_SAVE_DATA_TYPE2(int, Int, Number) 00624 UNPACK_SAVE_DATA_TYPE23_END_NUMBER(int) 00625 MKFUN_UNPACK_SAVE_DATA_TYPE2(double, Double, Number) 00626 UNPACK_SAVE_DATA_TYPE23_END_NUMBER(double) 00627 MKFUN_UNPACK_SAVE_DATA_TYPE2(char*, String, String) 00628 UNPACK_SAVE_DATA_TYPE23_END_STRING() 00629 00630 MKFUN_UNPACK_SAVE_DATA_TYPE3(int, Int, Number) 00631 UNPACK_SAVE_DATA_TYPE23_END_NUMBER(int) 00632 MKFUN_UNPACK_SAVE_DATA_TYPE3(double, Double, Number) 00633 UNPACK_SAVE_DATA_TYPE23_END_NUMBER(double) 00634 MKFUN_UNPACK_SAVE_DATA_TYPE3(char*, String, String) 00635 UNPACK_SAVE_DATA_TYPE23_END_STRING() 00636 00637 MKFUN_UNPACK_SAVE_DATA(int, Int) 00638 MKFUN_UNPACK_SAVE_DATA(double, Double) 00639 MKFUN_UNPACK_SAVE_DATA(char*, String) 00640 00641 int32 UnpackSavedataAck(EdpPacket* pkg, char** json_ack){ 00642 uint32 remainlen = 0; 00643 uint8 flag = 0; 00644 uint16 json_len = 0; 00645 00646 if (ReadRemainlen(pkg, &remainlen)) 00647 return ERR_UNPACK_SAVEDATA_ACK; 00648 00649 if (ReadByte(pkg, &flag)) 00650 return ERR_UNPACK_SAVEDATA_ACK; 00651 00652 if (ReadUint16(pkg, &json_len)) 00653 return ERR_UNPACK_SAVEDATA_ACK; 00654 00655 if (ReadBytes(pkg, (uint8**)(json_ack), json_len)) 00656 return ERR_UNPACK_SAVEDATA_ACK; 00657 00658 return 0; 00659 } 00660 00661 /* sava_data bin (C->S) */ 00662 EdpPacket* PacketSavedataBin(const char* dst_devid, 00663 cJSON* desc_obj, const uint8* bin_data, uint32 bin_len) 00664 { 00665 EdpPacket* pkg = NULL; 00666 uint32 remainlen = 0; 00667 char* desc_out = NULL; 00668 uint32 desc_len = 0; 00669 00670 /* check arguments */ 00671 desc_out = cJSON_Print(desc_obj); 00672 desc_len = strlen(desc_out); 00673 if (desc_len > (0x01 << 16) || bin_len > (3 * (0x01 << 20)) 00674 /* desc < 2^16 && bin_len < 3M*/ 00675 || cJSON_GetObjectItem(desc_obj, "ds_id") == 0) 00676 /* desc_obj MUST has ds_id */ 00677 { 00678 free(desc_out); 00679 return 0; 00680 } 00681 pkg = NewBuffer(); 00682 /* msg type */ 00683 WriteByte(pkg, SAVEDATA); 00684 if (dst_devid) 00685 { 00686 /* remain len */ 00687 remainlen = 1+(2+strlen(dst_devid))+1+(2+desc_len)+(4+bin_len); 00688 WriteRemainlen(pkg, remainlen); 00689 /* translate address flag */ 00690 WriteByte(pkg, 0x80); 00691 /* dst devid */ 00692 WriteStr(pkg, dst_devid); 00693 } 00694 else 00695 { 00696 /* remain len */ 00697 remainlen = 1+1+(2+desc_len)+(4+bin_len); 00698 WriteRemainlen(pkg, remainlen); 00699 /* translate address flag */ 00700 WriteByte(pkg, 0x00); 00701 } 00702 /* bin flag */ 00703 WriteByte(pkg, 0x02); 00704 /* desc */ 00705 WriteStr(pkg, desc_out); 00706 free(desc_out); 00707 /* bin data */ 00708 WriteUint32(pkg, bin_len); 00709 WriteBytes(pkg, bin_data, bin_len); 00710 return pkg; 00711 } 00712 00713 EdpPacket* PacketSavedataBinStr(const char* dst_devid, 00714 const char* desc_str, const uint8* bin_data, uint32 bin_len) 00715 { 00716 EdpPacket* pkg = NULL; 00717 uint32 remainlen = 0; 00718 uint32 desc_len = 0; 00719 00720 /* check arguments */ 00721 desc_len = strlen(desc_str); 00722 if (desc_len > (0x01 << 16) || bin_len > (3 * (0x01 << 20))) 00723 { /* desc < 2^16 && bin_len < 3M*/ 00724 return 0; 00725 } 00726 pkg = NewBuffer(); 00727 /* msg type */ 00728 WriteByte(pkg, SAVEDATA); 00729 if (dst_devid) 00730 { 00731 /* remain len */ 00732 remainlen = 1+(2+strlen(dst_devid))+1+(2+desc_len)+(4+bin_len); 00733 WriteRemainlen(pkg, remainlen); 00734 /* translate address flag */ 00735 WriteByte(pkg, 0x80); 00736 /* dst devid */ 00737 WriteStr(pkg, dst_devid); 00738 } 00739 else 00740 { 00741 /* remain len */ 00742 remainlen = 1+1+(2+desc_len)+(4+bin_len); 00743 WriteRemainlen(pkg, remainlen); 00744 /* translate address flag */ 00745 WriteByte(pkg, 0x00); 00746 } 00747 /* bin flag */ 00748 WriteByte(pkg, 0x02); 00749 /* desc */ 00750 WriteStr(pkg, desc_str); 00751 /* bin data */ 00752 WriteUint32(pkg, bin_len); 00753 WriteBytes(pkg, bin_data, bin_len); 00754 return pkg; 00755 } 00756 00757 EdpPacket* PacketCmdResp(const char* cmdid, uint16 cmdid_len, 00758 const char* resp, uint32 resp_len) 00759 { 00760 EdpPacket* send_pkg = NULL; 00761 unsigned remainlen = 0; 00762 00763 send_pkg = NewBuffer(); 00764 /* 6 = 2 + 4 = len(cmdid_len) + len(resp_len) */ 00765 remainlen = cmdid_len + resp_len + (resp_len ? 6 : 2); 00766 WriteByte(send_pkg, CMDRESP); 00767 WriteRemainlen(send_pkg, remainlen); 00768 WriteUint16(send_pkg, cmdid_len); 00769 WriteBytes(send_pkg, cmdid, cmdid_len); 00770 if (resp_len){ 00771 WriteUint32(send_pkg, resp_len); 00772 WriteBytes(send_pkg, resp, resp_len); 00773 } 00774 return send_pkg; 00775 } 00776 00777 /* ping (C->S) */ 00778 EdpPacket* PacketPing(void) 00779 { 00780 EdpPacket* pkg = NULL; 00781 00782 pkg = NewBuffer(); 00783 /* msg type */ 00784 WriteByte(pkg, PINGREQ); 00785 /* remain len */ 00786 WriteRemainlen(pkg, 0); 00787 return pkg; 00788 } 00789 00790 /*---------------------------------------------------------------------------*/ 00791 /* recv stream to a edp packet (S->C) */ 00792 EdpPacket* GetEdpPacket(RecvBuffer* buf) 00793 { 00794 EdpPacket* pkg = NULL; 00795 int32 flag = 0; 00796 00797 assert(buf->_read_pos == 0); 00798 flag = IsPkgComplete(buf); 00799 if (flag <= 0) 00800 return pkg; 00801 pkg = NewBuffer(); 00802 WriteBytes(pkg, buf->_data, flag); 00803 /* shrink buffer */ 00804 memmove(buf->_data, buf->_data + flag, buf->_write_pos - flag); 00805 buf->_write_pos -= flag; 00806 return pkg; 00807 } 00808 00809 /* is the recv buffer has a complete edp packet? */ 00810 int32 IsPkgComplete(RecvBuffer* buf) 00811 { 00812 uint8* data = NULL; 00813 uint32 data_len = 0; 00814 uint32 multiplier = 1; 00815 uint32 len_val = 0; 00816 uint32 len_len = 1; 00817 uint8* pdigit = NULL; 00818 uint32 pkg_total_len = 0; 00819 00820 data = buf->_data; 00821 data_len = buf->_write_pos; 00822 00823 if (data_len <= 1) { 00824 return 0; /* continue receive */ 00825 } 00826 /* recevie remaining len */ 00827 pdigit = data; 00828 00829 do { 00830 if (len_len > 4) { 00831 return -1; /* protocol error; */ 00832 } 00833 if (len_len > data_len - 1) { 00834 return 0; /* continue receive */ 00835 } 00836 len_len++; 00837 pdigit++; 00838 len_val += ((*pdigit) & 0x7f) * multiplier; 00839 multiplier *= 0x80; 00840 }while(((*pdigit) & 0x80) != 0); 00841 00842 pkg_total_len = len_len + len_val; 00843 /* receive payload */ 00844 if (pkg_total_len <= (uint32)data_len){ 00845 #ifdef _DEBUG 00846 printf("a complete packet len:%d\n", pkg_total_len); 00847 #endif 00848 return pkg_total_len; /* all data for this pkg is read */ 00849 }else{ 00850 return 0; /* continue receive */ 00851 } 00852 } 00853 00854 /* get edp packet type, client should use this type to invoke Unpack??? function */ 00855 uint8 EdpPacketType(EdpPacket* pkg) 00856 { 00857 uint8 mtype = 0x00; 00858 ReadByte(pkg, &mtype); 00859 return mtype; 00860 } 00861 00862 /* connect_resp (S->C)*/ 00863 int32 UnpackConnectResp(EdpPacket* pkg) 00864 { 00865 uint8 flag, rtn; 00866 uint32 remainlen; 00867 if (ReadRemainlen(pkg, &remainlen)) 00868 return ERR_UNPACK_CONNRESP_REMAIN; 00869 if (ReadByte(pkg, &flag)) 00870 return ERR_UNPACK_CONNRESP_FLAG; 00871 if (ReadByte(pkg, &rtn)) 00872 return ERR_UNPACK_CONNRESP_RTN; 00873 assert(pkg->_read_pos == pkg->_write_pos); 00874 return (int32)rtn; 00875 } 00876 00877 /* push_data (S->C) */ 00878 int32 UnpackPushdata(EdpPacket* pkg, char** src_devid, char** data, uint32* data_len) 00879 { 00880 uint32 remainlen; 00881 if (ReadRemainlen(pkg, &remainlen)) 00882 return ERR_UNPACK_PUSHD_REMAIN; 00883 if (ReadStr(pkg, src_devid)) 00884 return ERR_UNPACK_PUSHD_DEVID; 00885 remainlen -= (2 + strlen(*src_devid)); 00886 if (ReadBytes(pkg, (uint8**)data, remainlen)) 00887 return ERR_UNPACK_PUSHD_DATA; 00888 *data_len = remainlen; 00889 assert(pkg->_read_pos == pkg->_write_pos); 00890 return 0; 00891 } 00892 00893 /* save_data (S->C) */ 00894 int32 UnpackSavedata(EdpPacket* pkg, char** src_devid, uint8* jb_flag) 00895 { 00896 uint32 remainlen; 00897 uint8 ta_flag; 00898 if (ReadRemainlen(pkg, &remainlen)) 00899 return ERR_UNPACK_SAVED_REMAIN; 00900 /* translate address flag */ 00901 if (ReadByte(pkg, &ta_flag)) 00902 return ERR_UNPACK_SAVED_TANSFLAG; 00903 if (ta_flag == 0x80) 00904 { 00905 if (ReadStr(pkg, src_devid)) 00906 return ERR_UNPACK_SAVED_DEVID; 00907 } 00908 else 00909 { 00910 *src_devid = 0; 00911 } 00912 /* json or bin */ 00913 if (ReadByte(pkg, jb_flag)) 00914 return ERR_UNPACK_SAVED_DATAFLAG; 00915 return 0; 00916 } 00917 00918 int32 UnpackSavedataJson(EdpPacket* pkg, cJSON** json_obj) 00919 { 00920 char* json_str; 00921 if (ReadStr(pkg, &json_str)) 00922 return ERR_UNPACK_SAVED_JSON; 00923 *json_obj = cJSON_Parse(json_str); 00924 free(json_str); 00925 if (*json_obj == 0) 00926 return ERR_UNPACK_SAVED_PARSEJSON; 00927 assert(pkg->_read_pos == pkg->_write_pos); 00928 return 0; 00929 } 00930 00931 int32 UnpackSavedataBin(EdpPacket* pkg, cJSON** desc_obj, 00932 uint8** bin_data, uint32* bin_len) 00933 { 00934 char* desc_str; 00935 if (ReadStr(pkg, &desc_str)) 00936 return ERR_UNPACK_SAVED_BIN_DESC; 00937 *desc_obj = cJSON_Parse(desc_str); 00938 free(desc_str); 00939 if (*desc_obj == 0) 00940 return ERR_UNPACK_SAVED_PARSEDESC; 00941 if (ReadUint32(pkg, bin_len)) 00942 return ERR_UNPACK_SAVED_BINLEN; 00943 if (ReadBytes(pkg, bin_data, *bin_len)) 00944 return ERR_UNPACK_SAVED_BINDATA; 00945 assert(pkg->_read_pos == pkg->_write_pos); 00946 return 0; 00947 } 00948 00949 int32 UnpackSavedataBinStr(EdpPacket* pkg, char** desc_str, 00950 uint8** bin_data, uint32* bin_len) 00951 { 00952 if (ReadStr(pkg, desc_str)) 00953 return ERR_UNPACK_SAVED_BIN_DESC; 00954 if (ReadUint32(pkg, bin_len)) 00955 return ERR_UNPACK_SAVED_BINLEN; 00956 if (ReadBytes(pkg, bin_data, *bin_len)) 00957 return ERR_UNPACK_SAVED_BINDATA; 00958 assert(pkg->_read_pos == pkg->_write_pos); 00959 return 0; 00960 } 00961 00962 int32 UnpackCmdReq(EdpPacket* pkg, char** cmdid, uint16* cmdid_len, 00963 char** req, uint32* req_len) 00964 { 00965 uint32 remainlen; 00966 int rc; 00967 if (ReadRemainlen(pkg, &remainlen)) 00968 return ERR_UNPACK_CMDREQ; 00969 00970 rc = ReadUint16(pkg, cmdid_len); 00971 if (rc) 00972 return rc; 00973 if (ReadBytes(pkg, (uint8**)cmdid, *cmdid_len)) 00974 return ERR_UNPACK_CMDREQ; 00975 00976 rc = ReadUint32(pkg, req_len); 00977 if (rc) 00978 return rc; 00979 if (ReadBytes(pkg, (uint8**)req, *req_len)) 00980 return ERR_UNPACK_CMDREQ; 00981 00982 assert(pkg->_read_pos == pkg->_write_pos); 00983 return 0; 00984 } 00985 00986 /* ping_resp (S->C) */ 00987 int32 UnpackPingResp(EdpPacket* pkg) 00988 { 00989 uint32 remainlen; 00990 if (ReadRemainlen(pkg, &remainlen)) 00991 return ERR_UNPACK_PING_REMAIN; 00992 assert(pkg->_read_pos == pkg->_write_pos); 00993 return 0; 00994 } 00995 00996 /* sava_data (C->S) */ 00997 EdpPacket* PacketSavedataSimpleString(const char* dst_devid, const char* input) 00998 { 00999 EdpPacket* pkg = NULL; 01000 uint32 remainlen = 0; 01001 uint32 input_len = 0; 01002 01003 pkg = NewBuffer(); 01004 input_len = strlen(input); 01005 /* msg type */ 01006 WriteByte(pkg, SAVEDATA); 01007 if (dst_devid) 01008 { 01009 /* remain len */ 01010 remainlen = 1+(2+strlen(dst_devid))+1+(2+input_len); 01011 WriteRemainlen(pkg, remainlen); 01012 /* translate address flag */ 01013 WriteByte(pkg, 0x80); 01014 /* dst devid */ 01015 WriteStr(pkg, dst_devid); 01016 } 01017 else 01018 { 01019 /* remain len */ 01020 remainlen = 1+1+(2+input_len); 01021 WriteRemainlen(pkg, remainlen); 01022 /* translate address flag */ 01023 WriteByte(pkg, 0x00); 01024 } 01025 /* json flag */ 01026 WriteByte(pkg, kTypeString); 01027 /* json */ 01028 WriteStr(pkg, input); 01029 01030 return pkg; 01031 } 01032 01033 int32 UnpackSavedataSimpleString(EdpPacket* pkg, char** output) 01034 { 01035 if (ReadStr(pkg, output)) 01036 return ERR_UNPACK_SAVED_JSON; 01037 return 0; 01038 } 01039
Generated on Fri Jul 15 2022 20:43:41 by
1.7.2