EDP KIT from OneNet

Embed: (wiki syntax)

« Back to documentation index

Show/hide line numbers EdpKit.cpp Source File

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