【修改内容】1. 添加获取当前时间秒数；2.网关有数据，更新网关时间

【提交人】huang.zhenling

【修改内容】1. 添加获取当前时间秒数；2.网关有数据，更新网关时间
【提交人】huang.zhenling
aab93033 · 黄振令 · 87d2de68 · aab93033 · aab93033 · aab93033
Commit aab93033 authored Sep 02, 2020 by 黄振令
Showing with 1485 additions and 1469 deletions

common/hal/HAL_OS_linux.c common/hal/HAL_OS_linux.c +743 -731

midware/midware/dm/kk_dm_msg.c midware/midware/dm/kk_dm_msg.c +737 -737

midware/midware/midware.c midware/midware/midware.c +5 -1

No files found.
--- a/common/hal/HAL_OS_linux.c
+++ b/common/hal/HAL_OS_linux.c
 /*
 * Copyright (C) 2015-2018 Alibaba Group Holding Limited
 */
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdarg.h>
 #include <memory.h>
 #include <pthread.h>
 #include <unistd.h>
 #include <sys/prctl.h>
 #include <sys/time.h>
 #include <semaphore.h>
 #include <errno.h>
 #include <assert.h>
 #include <net/if.h>       // struct ifreq
 #include <sys/socket.h>
 #include <netinet/in.h>
 #include <arpa/inet.h>
 #include <sys/ioctl.h>
 #include <sys/reboot.h>
 #include <sys/time.h>
 #include <time.h>
 #include <signal.h>
 #include "kk_product.h"
 //#include "iot_import.h"
 char g_product_type[PRODUCT_TYPE_LEN]={0};
 char g_product_code[PRODUCT_CODE_LEN]={0};
 char g_device_code[DEVICE_CODE_LEN] = {0};
 #define PLATFORM_WAIT_INFINITE (~0)
 void *HAL_Malloc(_IN_ uint32_t size)
 {
    return malloc(size);
 }
 void *HAL_Realloc(_IN_ void *ptr, _IN_ uint32_t size)
 {
    return realloc(ptr, size);
 }
 void *HAL_Calloc(_IN_ uint32_t nmemb, _IN_ uint32_t size)
 {
    return calloc(nmemb, size);
 }
 void HAL_Free(_IN_ void *ptr)
 {
    free(ptr);
 }
 void *HAL_MutexCreate(void)
 {
    int err_num;
    pthread_mutex_t *mutex = (pthread_mutex_t *)HAL_Malloc(sizeof(pthread_mutex_t));
    if (NULL == mutex) {
        return NULL;
    }
    if (0 != (err_num = pthread_mutex_init(mutex, NULL))) {
        printf("create mutex failed");
        HAL_Free(mutex);
        return NULL;
    }
    return mutex;
 }
 void HAL_MutexDestroy(_IN_ void *mutex)
 {
    int err_num;
    if (!mutex) {
        printf("mutex want to destroy is NULL!");
        return;
    }
    if (0 != (err_num = pthread_mutex_destroy((pthread_mutex_t *)mutex))) {
        printf("destroy mutex failed");
    }
    HAL_Free(mutex);
 }
 void HAL_MutexLock(_IN_ void *mutex)
 {
    int err_num;
    if (0 != (err_num = pthread_mutex_lock((pthread_mutex_t *)mutex))) {
        printf("lock mutex failed: - '%s' (%d)", strerror(err_num), err_num);
    }
 }
 void HAL_MutexUnlock(_IN_ void *mutex)
 {
    int err_num;
    if (0 != (err_num = pthread_mutex_unlock((pthread_mutex_t *)mutex))) {
        printf("unlock mutex failed - '%s' (%d)", strerror(err_num), err_num);
    }
 }
 uint64_t HAL_UptimeMs(void)
 {
    uint64_t            time_ms;
    struct timespec     ts;
    clock_gettime(CLOCK_MONOTONIC, &ts);
    time_ms = ((uint64_t)ts.tv_sec * (uint64_t)1000) + (ts.tv_nsec / 1000 / 1000);
    return time_ms;
 }
-char *HAL_GetTimeStr(_IN_ char *buf, _IN_ int len)
+uint64_t HAL_GetTimeMs(void)
 {
-    struct timeval tv;
+    uint64_t            time_ms;
-    struct tm      tm;
+    struct timespec     ts;
-    int str_len    = 0;
+    clock_gettime(CLOCK_REALTIME, &ts);
-    if (buf == NULL || len < 28) {
+    time_ms = ((uint64_t)ts.tv_sec * (uint64_t)1000) + (ts.tv_nsec / 1000 / 1000);
-        return NULL;
-    }
+    return time_ms;
-    gettimeofday(&tv, NULL);
+}
-    localtime_r(&tv.tv_sec, &tm);
-    strftime(buf, 28, "%m-%d %H:%M:%S", &tm);
-    str_len = strlen(buf);
+char *HAL_GetTimeStr(_IN_ char *buf, _IN_ int len)
-    if (str_len + 3 < len) {
+{
-        snprintf(buf + str_len, len, ".%3.3d", (int)(tv.tv_usec) / 1000);
+    struct timeval tv;
-    }
+    struct tm      tm;
-    return buf;
+    int str_len    = 0;
-}
+    if (buf == NULL || len < 28) {
+        return NULL;
-void HAL_SleepMs(_IN_ uint32_t ms)
+    }
-{
+    gettimeofday(&tv, NULL);
-    usleep(1000 * ms);
+    localtime_r(&tv.tv_sec, &tm);
-}
+    strftime(buf, 28, "%m-%d %H:%M:%S", &tm);
+    str_len = strlen(buf);
-void HAL_Srandom(uint32_t seed)
+    if (str_len + 3 < len) {
-{
+        snprintf(buf + str_len, len, ".%3.3d", (int)(tv.tv_usec) / 1000);
-    srandom(seed);
+    }
-}
+    return buf;
+}
-uint32_t HAL_Random(uint32_t region)
-{
-    return (region > 0) ? (random() % region) : 0;
+void HAL_SleepMs(_IN_ uint32_t ms)
-}
+{
+    usleep(1000 * ms);
-int HAL_Snprintf(_IN_ char *str, const int len, const char *fmt, ...)
+}
-{
-    va_list args;
+void HAL_Srandom(uint32_t seed)
-    int     rc;
+{
+    srandom(seed);
-    va_start(args, fmt);
+}
-    rc = vsnprintf(str, len, fmt, args);
-    va_end(args);
+uint32_t HAL_Random(uint32_t region)
+{
-    return rc;
+    return (region > 0) ? (random() % region) : 0;
 }
-int HAL_Vsnprintf(_IN_ char *str, _IN_ const int len, _IN_ const char *format, va_list ap)
+int HAL_Snprintf(_IN_ char *str, const int len, const char *fmt, ...)
 {
-    return vsnprintf(str, len, format, ap);
+    va_list args;
-}
+    int     rc;
-void HAL_Printf(_IN_ const char *fmt, ...)
+    va_start(args, fmt);
-{
+    rc = vsnprintf(str, len, fmt, args);
-    va_list args;
+    va_end(args);
-    va_start(args, fmt);
+    return rc;
-    vprintf(fmt, args);
+}
-    va_end(args);
+int HAL_Vsnprintf(_IN_ char *str, _IN_ const int len, _IN_ const char *format, va_list ap)
-    fflush(stdout);
+{
-}
+    return vsnprintf(str, len, format, ap);
+}
-int HAL_SetProduct_Type(_IN_ char *product_type)
-{
+void HAL_Printf(_IN_ const char *fmt, ...)
-    int len = strlen(product_type);
+{
+    va_list args;
-    if (len > PRODUCT_TYPE_LEN) {
-        return -1;
+    va_start(args, fmt);
-    }
+    vprintf(fmt, args);
-    memset(g_product_type, 0x0, PRODUCT_TYPE_LEN);
+    va_end(args);
-    strncpy(g_product_type, product_type, len);
-    return len;
+    fflush(stdout);
 }
+int HAL_SetProduct_Type(_IN_ char *product_type)
-int HAL_SetProduct_Code(_IN_ char *product_code)
+{
-{
+    int len = strlen(product_type);
-    int len = strlen(product_code);
-    if (len > PRODUCT_CODE_LEN) {
+    if (len > PRODUCT_TYPE_LEN) {
        return -1;
    }
-    memset(g_product_code, 0x0, PRODUCT_CODE_LEN);
+    memset(g_product_type, 0x0, PRODUCT_TYPE_LEN);
-    strncpy(g_product_code, product_code, len);
+    strncpy(g_product_type, product_type, len);
    return len;
 }
-int HAL_SetDevice_Code(_IN_ char *device_code)
+int HAL_SetProduct_Code(_IN_ char *product_code)
 {
-    int len = strlen(device_code);
+    int len = strlen(product_code);
+    if (len > PRODUCT_CODE_LEN) {
-    if (len > DEVICE_CODE_LEN) {
+        return -1;
-        return -1;
+    }
-    }
+    memset(g_product_code, 0x0, PRODUCT_CODE_LEN);
-    memset(g_device_code, 0x0, DEVICE_CODE_LEN);
+    strncpy(g_product_code, product_code, len);
-    strncpy(g_device_code, DEVICE_CODE_LEN, len);
+    return len;
+}
-    return len;
-}
-int HAL_GetProduct_Type(_OU_ char *product_type)
+int HAL_SetDevice_Code(_IN_ char *device_code)
 {
-    int len = strlen(g_product_type);
+    int len = strlen(device_code);
-    memset(product_type, 0x0, PRODUCT_TYPE_LEN);
-    strncpy(product_type, g_product_type, len);
+    if (len > DEVICE_CODE_LEN) {
+        return -1;
-    return len;
+    }
-}
+    memset(g_device_code, 0x0, DEVICE_CODE_LEN);
+    strncpy(g_device_code, DEVICE_CODE_LEN, len);
-int HAL_GetProduct_Code(_OU_ char *product_code)
-{
+    return len;
-    int len = strlen(g_product_code);
+}
-    memset(product_code, 0x0, PRODUCT_CODE_LEN);
+int HAL_GetProduct_Type(_OU_ char *product_type)
-    strncpy(product_code, g_product_code, len);
+{
-    return len;
+    int len = strlen(g_product_type);
-}
+    memset(product_type, 0x0, PRODUCT_TYPE_LEN);
+    strncpy(product_type, g_product_type, len);
-int HAL_GetDevice_Code(_OU_ char *device_code)
-{
+    return len;
-    int len = strlen(g_device_code);
+}
-    memset(device_code, 0x0, DEVICE_CODE_LEN);
-    //strncpy(device_code, g_device_code, len);
+int HAL_GetProduct_Code(_OU_ char *product_code)
-    strncpy(device_code, "CCU_66666", strlen("CCU_66666"));
+{
-    return len;
+    int len = strlen(g_product_code);
-}
+    memset(product_code, 0x0, PRODUCT_CODE_LEN);
-int HAL_GetVersion(_OU_ char *version)
+    strncpy(product_code, g_product_code, len);
-{
+    return len;
-    char *ver = "test-1.0.0";
+}
-    int len = strlen(ver);
-    memset(version, 0x0, VERSION_MAXLEN);
+int HAL_GetDevice_Code(_OU_ char *device_code)
-    strncpy(version, ver, len);
+{
-    version[len] = '\0';
+    int len = strlen(g_device_code);
-    return strlen(version);
+    memset(device_code, 0x0, DEVICE_CODE_LEN);
-}
+    //strncpy(device_code, g_device_code, len);
+    strncpy(device_code, "CCU_66666", strlen("CCU_66666"));
+    return len;
-/*
+}
- * This need to be same with app version as in uOTA module (ota_version.h)
+int HAL_GetVersion(_OU_ char *version)
+{
-    #ifndef SYSINFO_APP_VERSION
+    char *ver = "test-1.0.0";
-    #define SYSINFO_APP_VERSION "app-1.0.0-20180101.1000"
+    int len = strlen(ver);
-    #endif
+    memset(version, 0x0, VERSION_MAXLEN);
- *
+    strncpy(version, ver, len);
- */
+    version[len] = '\0';
-int HAL_GetFirmwareVersion(_OU_ char *version)
+    return strlen(version);
-{
+}
-    char *ver = "app-1.0.0-20180101.1000";
-    int len = strlen(ver);
-    memset(version, 0x0, FIRMWARE_VERSION_MAXLEN);
+/*
-    strncpy(version, ver, len);
+ * This need to be same with app version as in uOTA module (ota_version.h)
-    version[len] = '\0';
+    #ifndef SYSINFO_APP_VERSION
-    return strlen(version);
+    #define SYSINFO_APP_VERSION "app-1.0.0-20180101.1000"
-}
+    #endif
+ *
-void *HAL_SemaphoreCreate(void)
+ */
-{
+int HAL_GetFirmwareVersion(_OU_ char *version)
-    sem_t *sem = (sem_t *)malloc(sizeof(sem_t));
+{
-    if (NULL == sem) {
+    char *ver = "app-1.0.0-20180101.1000";
-        return NULL;
+    int len = strlen(ver);
-    }
+    memset(version, 0x0, FIRMWARE_VERSION_MAXLEN);
+    strncpy(version, ver, len);
-    if (0 != sem_init(sem, 0, 0)) {
+    version[len] = '\0';
-        free(sem);
-        return NULL;
+    return strlen(version);
-    }
+}
-    return sem;
+void *HAL_SemaphoreCreate(void)
-}
+{
+    sem_t *sem = (sem_t *)malloc(sizeof(sem_t));
-void HAL_SemaphoreDestroy(_IN_ void *sem)
+    if (NULL == sem) {
-{
+        return NULL;
-    sem_destroy((sem_t *)sem);
+    }
-    free(sem);
-}
+    if (0 != sem_init(sem, 0, 0)) {
+        free(sem);
-void HAL_SemaphorePost(_IN_ void *sem)
+        return NULL;
-{
+    }
-    sem_post((sem_t *)sem);
-}
+    return sem;
+}
-int HAL_SemaphoreWait(_IN_ void *sem, _IN_ uint32_t timeout_ms)
-{
+void HAL_SemaphoreDestroy(_IN_ void *sem)
-    if (PLATFORM_WAIT_INFINITE == timeout_ms) {
+{
-        sem_wait(sem);
+    sem_destroy((sem_t *)sem);
-        return 0;
+    free(sem);
-    } else {
+}
-        struct timespec ts;
-        int s;
+void HAL_SemaphorePost(_IN_ void *sem)
-        /* Restart if interrupted by handler */
+{
-        do {
+    sem_post((sem_t *)sem);
-            if (clock_gettime(CLOCK_REALTIME, &ts) == -1) {
+}
-                return -1;
-            }
+int HAL_SemaphoreWait(_IN_ void *sem, _IN_ uint32_t timeout_ms)
+{
-            s = 0;
+    if (PLATFORM_WAIT_INFINITE == timeout_ms) {
-            ts.tv_nsec += (timeout_ms % 1000) * 1000000;
+        sem_wait(sem);
-            if (ts.tv_nsec >= 1000000000) {
+        return 0;
-                ts.tv_nsec -= 1000000000;
+    } else {
-                s = 1;
+        struct timespec ts;
-            }
+        int s;
+        /* Restart if interrupted by handler */
-            ts.tv_sec += timeout_ms / 1000 + s;
+        do {
+            if (clock_gettime(CLOCK_REALTIME, &ts) == -1) {
-        } while (((s = sem_timedwait(sem, &ts)) != 0) && errno == EINTR);
+                return -1;
+            }
-        return (s == 0) ? 0 : -1;
-    }
+            s = 0;
-}
+            ts.tv_nsec += (timeout_ms % 1000) * 1000000;
+            if (ts.tv_nsec >= 1000000000) {
-int HAL_ThreadCreate(
+                ts.tv_nsec -= 1000000000;
-            _OU_ void **thread_handle,
+                s = 1;
-            _IN_ void *(*work_routine)(void *),
+            }
-            _IN_ void *arg,
-            _OU_ int *stack_used)
+            ts.tv_sec += timeout_ms / 1000 + s;
-{
-    int ret = -1;
+        } while (((s = sem_timedwait(sem, &ts)) != 0) && errno == EINTR);
-    ret = pthread_create((pthread_t *)thread_handle, NULL, work_routine, arg);
+        return (s == 0) ? 0 : -1;
+    }
-    return ret;
+}
-}
+int HAL_ThreadCreate(
-void HAL_ThreadDetach(_IN_ void *thread_handle)
+            _OU_ void **thread_handle,
-{
+            _IN_ void *(*work_routine)(void *),
-    pthread_detach((pthread_t)thread_handle);
+            _IN_ void *arg,
-}
+            _OU_ int *stack_used)
+{
-void HAL_ThreadDelete(_IN_ void *thread_handle)
+    int ret = -1;
-{
-    if (NULL == thread_handle) {
+    ret = pthread_create((pthread_t *)thread_handle, NULL, work_routine, arg);
-        pthread_exit(0);
-    } else {
+    return ret;
-        /*main thread delete child thread*/
+}
-        pthread_cancel((pthread_t)thread_handle);
-        pthread_join((pthread_t)thread_handle, 0);
+void HAL_ThreadDetach(_IN_ void *thread_handle)
-    }
+{
-}
+    pthread_detach((pthread_t)thread_handle);
-#if 1
+}
-static FILE *fp;
+void HAL_ThreadDelete(_IN_ void *thread_handle)
+{
-#define otafilename "/tmp/kkota.bin"
+    if (NULL == thread_handle) {
-#define __DEMO__
+        pthread_exit(0);
+    } else {
-void HAL_Firmware_Persistence_Start(void* fileName)
+        /*main thread delete child thread*/
-{
+        pthread_cancel((pthread_t)thread_handle);
-#ifdef __DEMO__
+        pthread_join((pthread_t)thread_handle, 0);
-    char * file = NULL;
+    }
-    if (fileName == NULL){
+}
-        file = otafilename;
+#if 1
-    }else{
-        file = fileName;
+static FILE *fp;
-    }
-    fp = fopen(file, "w");
+#define otafilename "/tmp/kkota.bin"
-    //    assert(fp);
+#define __DEMO__
-#endif
-    return;
+void HAL_Firmware_Persistence_Start(void* fileName)
-}
+{
+#ifdef __DEMO__
-int HAL_Firmware_Persistence_Write(_IN_ char *buffer, _IN_ uint32_t length)
+    char * file = NULL;
-{
+    if (fileName == NULL){
-#ifdef __DEMO__
+        file = otafilename;
-    unsigned int written_len = 0;
+    }else{
-    written_len = fwrite(buffer, 1, length, fp);
+        file = fileName;
+    }
-    if (written_len != length) {
+    fp = fopen(file, "w");
-        return -1;
+    //    assert(fp);
-    }
+#endif
-#endif
+    return;
-    return 0;
+}
-}
+int HAL_Firmware_Persistence_Write(_IN_ char *buffer, _IN_ uint32_t length)
-int HAL_Firmware_Persistence_Stop(void)
+{
-{
+#ifdef __DEMO__
-#ifdef __DEMO__
+    unsigned int written_len = 0;
-    if (fp != NULL) {
+    written_len = fwrite(buffer, 1, length, fp);
-        fclose(fp);
-    }
+    if (written_len != length) {
-#endif
+        return -1;
+    }
-    /* check file md5, and burning it to flash ... finally reboot system */
+#endif
+    return 0;
-    return 0;
+}
-}
+int HAL_Firmware_Persistence_Stop(void)
-int HAL_Config_Write(const char *buffer, int length)
+{
-{
+#ifdef __DEMO__
-    FILE *fp;
+    if (fp != NULL) {
-    size_t written_len;
+        fclose(fp);
-    char filepath[128] = {0};
+    }
+#endif
-    if (!buffer || length <= 0) {
-        return -1;
+    /* check file md5, and burning it to flash ... finally reboot system */
-    }
+    return 0;
-    snprintf(filepath, sizeof(filepath), "./%s", "alinkconf");
+}
-    fp = fopen(filepath, "w");
-    if (!fp) {
+int HAL_Config_Write(const char *buffer, int length)
-        return -1;
+{
-    }
+    FILE *fp;
+    size_t written_len;
-    written_len = fwrite(buffer, 1, length, fp);
+    char filepath[128] = {0};
-    fclose(fp);
+    if (!buffer || length <= 0) {
+        return -1;
-    return ((written_len != length) ? -1 : 0);
+    }
-}
+    snprintf(filepath, sizeof(filepath), "./%s", "alinkconf");
-int HAL_Config_Read(char *buffer, int length)
+    fp = fopen(filepath, "w");
-{
+    if (!fp) {
-    FILE *fp;
+        return -1;
-    size_t read_len;
+    }
-    char filepath[128] = {0};
+    written_len = fwrite(buffer, 1, length, fp);
-    if (!buffer || length <= 0) {
-        return -1;
+    fclose(fp);
-    }
+    return ((written_len != length) ? -1 : 0);
-    snprintf(filepath, sizeof(filepath), "./%s", "alinkconf");
+}
-    fp = fopen(filepath, "r");
-    if (!fp) {
+int HAL_Config_Read(char *buffer, int length)
-        return -1;
+{
-    }
+    FILE *fp;
+    size_t read_len;
-    read_len = fread(buffer, 1, length, fp);
+    char filepath[128] = {0};
-    fclose(fp);
+    if (!buffer || length <= 0) {
-    return ((read_len != length) ? -1 : 0);
+        return -1;
-}
+    }
-#define REBOOT_CMD "reboot"
+    snprintf(filepath, sizeof(filepath), "./%s", "alinkconf");
-void HAL_Reboot(void)
+    fp = fopen(filepath, "r");
-{
+    if (!fp) {
-    if (system(REBOOT_CMD)) {
+        return -1;
-        perror("HAL_Reboot failed");
+    }
-    }
-}
+    read_len = fread(buffer, 1, length, fp);
-#endif
+    fclose(fp);
-#define ROUTER_INFO_PATH        "/proc/net/route"
-#define ROUTER_RECORD_SIZE      256
+    return ((read_len != length) ? -1 : 0);
+}
-static char *_get_default_routing_ifname(char *ifname, int ifname_size)
+#define REBOOT_CMD "reboot"
-{
+void HAL_Reboot(void)
-    FILE *fp = NULL;
+{
-    char line[ROUTER_RECORD_SIZE] = {0};
+    if (system(REBOOT_CMD)) {
-    char iface[IFNAMSIZ] = {0};
+        perror("HAL_Reboot failed");
-    char *result = NULL;
+    }
-    unsigned int destination, gateway, flags, mask;
+}
-    unsigned int refCnt, use, metric, mtu, window, irtt;
+#endif
+#define ROUTER_INFO_PATH        "/proc/net/route"
-    fp = fopen(ROUTER_INFO_PATH, "r");
+#define ROUTER_RECORD_SIZE      256
-    if (fp == NULL) {
-        perror("fopen");
-        return result;
+static char *_get_default_routing_ifname(char *ifname, int ifname_size)
-    }
+{
+    FILE *fp = NULL;
-    char *buff = fgets(line, sizeof(line), fp);
+    char line[ROUTER_RECORD_SIZE] = {0};
-    if (buff == NULL) {
+    char iface[IFNAMSIZ] = {0};
-        perror("fgets");
+    char *result = NULL;
-        goto out;
+    unsigned int destination, gateway, flags, mask;
-    }
+    unsigned int refCnt, use, metric, mtu, window, irtt;
-    while (fgets(line, sizeof(line), fp)) {
+    fp = fopen(ROUTER_INFO_PATH, "r");
-        if (11 !=
+    if (fp == NULL) {
-            sscanf(line, "%s %08x %08x %x %d %d %d %08x %d %d %d",
+        perror("fopen");
-                   iface, &destination, &gateway, &flags, &refCnt, &use,
+        return result;
-                   &metric, &mask, &mtu, &window, &irtt)) {
+    }
-            perror("sscanf");
-            continue;
+    char *buff = fgets(line, sizeof(line), fp);
-        }
+    if (buff == NULL) {
+        perror("fgets");
-        /*default route */
+        goto out;
-        if ((destination == 0) && (mask == 0)) {
+    }
-            strncpy(ifname, iface, ifname_size - 1);
-            result = ifname;
+    while (fgets(line, sizeof(line), fp)) {
-            break;
+        if (11 !=
-        }
+            sscanf(line, "%s %08x %08x %x %d %d %d %08x %d %d %d",
-    }
+                   iface, &destination, &gateway, &flags, &refCnt, &use,
+                   &metric, &mask, &mtu, &window, &irtt)) {
-out:
+            perror("sscanf");
-    if (fp) {
+            continue;
-        fclose(fp);
+        }
-    }
+        /*default route */
-    return result;
+        if ((destination == 0) && (mask == 0)) {
-}
+            strncpy(ifname, iface, ifname_size - 1);
+            result = ifname;
+            break;
-int HAL_Get_mac(char* mac)
+        }
-{
+    }
-    struct ifreq tmp;
-    int sock_mac;
+out:
-    char mac_addr[30];
+    if (fp) {
-    sock_mac = socket(AF_INET, SOCK_STREAM, 0);
+        fclose(fp);
-    if( sock_mac == -1){
+    }
-        perror("create socket fail\n");
-        return -1;
+    return result;
-    }
+}
-    memset(&tmp,0,sizeof(tmp));
-    strncpy(tmp.ifr_name,"ens33",sizeof(tmp.ifr_name)-1 );
-    if( (ioctl( sock_mac, SIOCGIFHWADDR, &tmp)) < 0 ){
+int HAL_Get_mac(char* mac)
-        printf("mac ioctl error\n");
+{
-        return -1;
+    struct ifreq tmp;
-    }
+    int sock_mac;
-    sprintf(mac_addr, "%02x%02x%02x%02x%02x%02x",
+    char mac_addr[30];
-            (unsigned char)tmp.ifr_hwaddr.sa_data[0],
+    sock_mac = socket(AF_INET, SOCK_STREAM, 0);
-            (unsigned char)tmp.ifr_hwaddr.sa_data[1],
+    if( sock_mac == -1){
-            (unsigned char)tmp.ifr_hwaddr.sa_data[2],
+        perror("create socket fail\n");
-            (unsigned char)tmp.ifr_hwaddr.sa_data[3],
+        return -1;
-            (unsigned char)tmp.ifr_hwaddr.sa_data[4],
+    }
-            (unsigned char)tmp.ifr_hwaddr.sa_data[5]
+    memset(&tmp,0,sizeof(tmp));
-            );
+    strncpy(tmp.ifr_name,"ens33",sizeof(tmp.ifr_name)-1 );
-    printf("local mac:%s\n", mac_addr);
+    if( (ioctl( sock_mac, SIOCGIFHWADDR, &tmp)) < 0 ){
-    close(sock_mac);
+        printf("mac ioctl error\n");
-    memcpy(mac,mac_addr,strlen(mac_addr));
+        return -1;
-    return 0;
+    }
-}
+    sprintf(mac_addr, "%02x%02x%02x%02x%02x%02x",
+            (unsigned char)tmp.ifr_hwaddr.sa_data[0],
+            (unsigned char)tmp.ifr_hwaddr.sa_data[1],
-int HAL_Get_SN(char sn[SN_ADDR_LEN])
+            (unsigned char)tmp.ifr_hwaddr.sa_data[2],
-{
+            (unsigned char)tmp.ifr_hwaddr.sa_data[3],
-	strncpy(sn,"15",SN_ADDR_LEN);
+            (unsigned char)tmp.ifr_hwaddr.sa_data[4],
-	return 0;//just for test
+            (unsigned char)tmp.ifr_hwaddr.sa_data[5]
-}
+            );
+    printf("local mac:%s\n", mac_addr);
-int HAL_Get_port(void)
+    close(sock_mac);
-{
+    memcpy(mac,mac_addr,strlen(mac_addr));
-	return 5555;//just for test
+    return 0;
 }
-uint32_t HAL_Get_IP(char ip_str[NETWORK_ADDR_LEN], const char *ifname)
-{
-    struct ifreq ifreq;
+int HAL_Get_SN(char sn[SN_ADDR_LEN])
-    int sock = -1;
+{
-    char ifname_buff[IFNAMSIZ] = {0};
+	strncpy(sn,"15",SN_ADDR_LEN);
+	return 0;//just for test
-    if ((NULL == ifname || strlen(ifname) == 0) &&
+}
-        NULL == (ifname = _get_default_routing_ifname(ifname_buff, sizeof(ifname_buff)))) {
-        perror("get default routeing ifname");
+int HAL_Get_port(void)
-        return -1;
+{
-    }
+	return 5555;//just for test
+}
-    if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
+uint32_t HAL_Get_IP(char ip_str[NETWORK_ADDR_LEN], const char *ifname)
-        perror("socket");
+{
-        return -1;
+    struct ifreq ifreq;
-    }
+    int sock = -1;
+    char ifname_buff[IFNAMSIZ] = {0};
-    ifreq.ifr_addr.sa_family = AF_INET; //ipv4 address
-    strncpy(ifreq.ifr_name, ifname, IFNAMSIZ - 1);
+    if ((NULL == ifname || strlen(ifname) == 0) &&
+        NULL == (ifname = _get_default_routing_ifname(ifname_buff, sizeof(ifname_buff)))) {
-    if (ioctl(sock, SIOCGIFADDR, &ifreq) < 0) {
+        perror("get default routeing ifname");
-        close(sock);
+        return -1;
-        perror("ioctl");
+    }
-        return -1;
-    }
+    if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
+        perror("socket");
-    close(sock);
+        return -1;
+    }
-    strncpy(ip_str,
-            inet_ntoa(((struct sockaddr_in *)&ifreq.ifr_addr)->sin_addr),
+    ifreq.ifr_addr.sa_family = AF_INET; //ipv4 address
-            NETWORK_ADDR_LEN);
+    strncpy(ifreq.ifr_name, ifname, IFNAMSIZ - 1);
-    return ((struct sockaddr_in *)&ifreq.ifr_addr)->sin_addr.s_addr;
+    if (ioctl(sock, SIOCGIFADDR, &ifreq) < 0) {
-}
+        close(sock);
-#if 0
+        perror("ioctl");
+        return -1;
-static kv_file_t *kvfile = NULL;
+    }
-int HAL_Kv_Set(const char *key, const void *val, int len, int sync)
+    close(sock);
-{
-    if (!kvfile) {
+    strncpy(ip_str,
-        kvfile = kv_open("/tmp/kvfile.db");
+            inet_ntoa(((struct sockaddr_in *)&ifreq.ifr_addr)->sin_addr),
-        if (!kvfile) {
+            NETWORK_ADDR_LEN);
-            return -1;
-        }
+    return ((struct sockaddr_in *)&ifreq.ifr_addr)->sin_addr.s_addr;
-    }
+}
+#if 0
-    return kv_set_blob(kvfile, (char *)key, (char *)val, len);
-}
+static kv_file_t *kvfile = NULL;
-int HAL_Kv_Get(const char *key, void *buffer, int *buffer_len)
+int HAL_Kv_Set(const char *key, const void *val, int len, int sync)
 {
    if (!kvfile) {
        kvfile = kv_open("/tmp/kvfile.db");
        if (!kvfile) {
            return -1;
        }
    }
-    return kv_get_blob(kvfile, (char *)key, buffer, buffer_len);
+    return kv_set_blob(kvfile, (char *)key, (char *)val, len);
 }
-int HAL_Kv_Del(const char *key)
+int HAL_Kv_Get(const char *key, void *buffer, int *buffer_len)
 {
    if (!kvfile) {
        kvfile = kv_open("/tmp/kvfile.db");
        if (!kvfile) {
            return -1;
        }
    }
-    return kv_del(kvfile, (char *)key);
+    return kv_get_blob(kvfile, (char *)key, buffer, buffer_len);
 }
-static long long os_time_get(void)
+int HAL_Kv_Del(const char *key)
 {
-    struct timeval tv;
+    if (!kvfile) {
-    long long ms;
+        kvfile = kv_open("/tmp/kvfile.db");
-    gettimeofday(&tv, NULL);
+        if (!kvfile) {
-    ms = tv.tv_sec * 1000LL + tv.tv_usec / 1000;
+            return -1;
-    return ms;
+        }
-}
+    }
-static long long delta_time = 0;
+    return kv_del(kvfile, (char *)key);
+}
-void HAL_UTC_Set(long long ms)
-{
+static long long os_time_get(void)
-    delta_time = ms - os_time_get();
+{
-}
+    struct timeval tv;
+    long long ms;
-long long HAL_UTC_Get(void)
+    gettimeofday(&tv, NULL);
-{
+    ms = tv.tv_sec * 1000LL + tv.tv_usec / 1000;
-    return delta_time + os_time_get();
+    return ms;
 }
-void *HAL_Timer_Create(const char *name, void (*func)(void *), void *user_data)
+static long long delta_time = 0;
-{
-    timer_t *timer = NULL;
+void HAL_UTC_Set(long long ms)
+{
-    struct sigevent ent;
+    delta_time = ms - os_time_get();
+}
-    /* check parameter */
-    if (func == NULL) {
+long long HAL_UTC_Get(void)
-        return NULL;
+{
-    }
+    return delta_time + os_time_get();
+}
-    timer = (timer_t *)malloc(sizeof(time_t));
+void *HAL_Timer_Create(const char *name, void (*func)(void *), void *user_data)
-    /* Init */
+{
-    memset(&ent, 0x00, sizeof(struct sigevent));
+    timer_t *timer = NULL;
-    /* create a timer */
+    struct sigevent ent;
-    ent.sigev_notify = SIGEV_THREAD;
-    ent.sigev_notify_function = (void (*)(union sigval))func;
+    /* check parameter */
-    ent.sigev_value.sival_ptr = user_data;
+    if (func == NULL) {
+        return NULL;
-    printf("HAL_Timer_Create\n");
+    }
-    if (timer_create(CLOCK_MONOTONIC, &ent, timer) != 0) {
+    timer = (timer_t *)malloc(sizeof(time_t));
-        free(timer);
-        return NULL;
+    /* Init */
-    }
+    memset(&ent, 0x00, sizeof(struct sigevent));
-    return (void *)timer;
+    /* create a timer */
-}
+    ent.sigev_notify = SIGEV_THREAD;
+    ent.sigev_notify_function = (void (*)(union sigval))func;
-int HAL_Timer_Start(void *timer, int ms)
+    ent.sigev_value.sival_ptr = user_data;
-{
-    struct itimerspec ts;
+    printf("HAL_Timer_Create\n");
-    /* check parameter */
+    if (timer_create(CLOCK_MONOTONIC, &ent, timer) != 0) {
-    if (timer == NULL) {
+        free(timer);
-        return -1;
+        return NULL;
    }
-    /* it_interval=0: timer run only once */
+    return (void *)timer;
-    ts.it_interval.tv_sec = 0;
+}
-    ts.it_interval.tv_nsec = 0;
+int HAL_Timer_Start(void *timer, int ms)
-    /* it_value=0: stop timer */
+{
-    ts.it_value.tv_sec = ms / 1000;
+    struct itimerspec ts;
-    ts.it_value.tv_nsec = (ms % 1000) * 1000;
+    /* check parameter */
-    return timer_settime(*(timer_t *)timer, 0, &ts, NULL);
+    if (timer == NULL) {
-}
+        return -1;
+    }
-int HAL_Timer_Stop(void *timer)
-{
+    /* it_interval=0: timer run only once */
-    struct itimerspec ts;
+    ts.it_interval.tv_sec = 0;
+    ts.it_interval.tv_nsec = 0;
-    /* check parameter */
-    if (timer == NULL) {
+    /* it_value=0: stop timer */
-        return -1;
+    ts.it_value.tv_sec = ms / 1000;
-    }
+    ts.it_value.tv_nsec = (ms % 1000) * 1000;
-    /* it_interval=0: timer run only once */
+    return timer_settime(*(timer_t *)timer, 0, &ts, NULL);
-    ts.it_interval.tv_sec = 0;
+}
-    ts.it_interval.tv_nsec = 0;
+int HAL_Timer_Stop(void *timer)
-    /* it_value=0: stop timer */
+{
-    ts.it_value.tv_sec = 0;
+    struct itimerspec ts;
-    ts.it_value.tv_nsec = 0;
+    /* check parameter */
-    return timer_settime(*(timer_t *)timer, 0, &ts, NULL);
+    if (timer == NULL) {
-}
+        return -1;
+    }
-int HAL_Timer_Delete(void *timer)
-{
+    /* it_interval=0: timer run only once */
-    int ret = 0;
+    ts.it_interval.tv_sec = 0;
+    ts.it_interval.tv_nsec = 0;
-    /* check parameter */
-    if (timer == NULL) {
+    /* it_value=0: stop timer */
-        return -1;
+    ts.it_value.tv_sec = 0;
-    }
+    ts.it_value.tv_nsec = 0;
-    ret = timer_delete(*(timer_t *)timer);
+    return timer_settime(*(timer_t *)timer, 0, &ts, NULL);
+}
-    free(timer);
+int HAL_Timer_Delete(void *timer)
-    return ret;
+{
-}
+    int ret = 0;
-#endif
+    /* check parameter */
+    if (timer == NULL) {
+        return -1;
+    }
+    ret = timer_delete(*(timer_t *)timer);
+    free(timer);
+    return ret;
+}
+#endif
--- a/midware/midware/dm/kk_dm_msg.c
+++ b/midware/midware/dm/kk_dm_msg.c
 #include "kk_dm_msg.h"
 #include "kk_dm_mng.h"
 #include "kk_tsl_api.h"
 #include "lite-cjson.h"
 #include "cJSON.h"
 #include "com_api.h"
 #include "kk_log.h"
 const char DM_MSG_REQUEST[] DM_READ_ONLY = "{\"msgId\":\"%d\",\"version\":\"%s\",\"params\":%s,\"time\":\"%lu\",\"method\":\"%s\"}";
 const char DM_MSG_INFO[] DM_READ_ONLY = "{\"msgtype\":\"%s\",\"productCode\":\"%s\",\"deviceCode\":\"%s\"}";
 void kk_sendData2app(void *info, void *payload){
    cJSON *root=cJSON_CreateObject();
    cJSON* infoObj = cJSON_Parse(info);
    cJSON* payloadObj = cJSON_Parse(payload);
    cJSON_AddItemToObject(root, "info", infoObj);
    cJSON_AddItemToObject(root, "payload",payloadObj);	
    void *buf = cJSON_Print(root);
    kk_ipc_send(IPC_MID2APP, buf, strlen(buf) + 1);
    free(buf);
    cJSON_Delete(root);
 }
 const char DM_MSG_THING_SUB_REGISTER_METHOD[] = "thing.sub.register";
 const char DM_MSG_THING_SUB_REGISTER_PARAMS[] = "[{\"productCode\":\"%s\",\"deviceCode\":\"%s\"}]";
 int dm_msg_thing_sub_register(_IN_ char productCode[DEVICE_CODE_MAXLEN], _IN_ char deviceCode[DEVICE_CODE_MAXLEN],
                              _OU_ dm_msg_request_t *request)
 {
    int params_len = 0;
    char *params = NULL;
    if (request == NULL || deviceCode == NULL ||
        (strlen(deviceCode) >= DEVICE_CODE_MAXLEN) ||
        (strlen(request->deviceCode) >= DEVICE_CODE_MAXLEN)) {
        return INVALID_PARAMETER;
    }
    params_len = strlen(DM_MSG_THING_SUB_REGISTER_PARAMS) +strlen(productCode) + strlen(deviceCode) + 1;
    params = malloc(params_len);
    if (params == NULL) {
        return MEMORY_NOT_ENOUGH;
    }
    memset(params, 0, params_len);
    snprintf(params, params_len, DM_MSG_THING_SUB_REGISTER_PARAMS,productCode, deviceCode);
    /* Get Params */
    request->params = params;
    request->params_len = strlen(request->params);
    /* Get Method */
    request->method = (char *)DM_MSG_THING_SUB_REGISTER_METHOD;
    return SUCCESS_RETURN;
 }
 const char DM_MSG_THING_SUB_UNREGISTER_METHOD[] DM_READ_ONLY = "thing.sub.unregister";
 const char DM_MSG_THING_SUB_UNREGISTER_PARAMS[] DM_READ_ONLY = "[{\"deviceCode\":\"%s\"}]";
 int dm_msg_thing_sub_unregister(_IN_ char deviceCode[DEVICE_CODE_MAXLEN],_OU_ dm_msg_request_t *request)
 {
    int params_len = 0;
    char *params = NULL;
    if (request == NULL || deviceCode == NULL ||
        (strlen(deviceCode) >= DEVICE_CODE_MAXLEN) ||
        (strlen(request->deviceCode) >= DEVICE_CODE_MAXLEN)) {
        return INVALID_PARAMETER;
    }
    params_len = strlen(DM_MSG_THING_SUB_UNREGISTER_PARAMS) + strlen(deviceCode) + 1;
    params = malloc(params_len);
    if (params == NULL) {
    return MEMORY_NOT_ENOUGH;
    }
    memset(params, 0, params_len);
    snprintf(params, params_len, DM_MSG_THING_SUB_UNREGISTER_PARAMS, deviceCode);
    /* Get Params */
    request->params = params;
    request->params_len = strlen(request->params);
    /* Get Method */
    request->method = (char *)DM_MSG_THING_SUB_UNREGISTER_METHOD;
    return SUCCESS_RETURN;
 }
 const char DM_MSG_THING_TOPO_ADD_SIGN_SOURCE[] DM_READ_ONLY = "clientId%sdeviceCode%stimestamp%s";
 const char DM_MSG_THING_TOPO_ADD_METHOD[] DM_READ_ONLY = "thing.topo.add";
 const char DM_MSG_THING_TOPO_ADD_PARAMS[] DM_READ_ONLY =
          //"[{\"productKey\":\"%s\",\"deviceName\":\"%s\",\"signmethod\":\"%s\",\"sign\":\"%s\",\"timestamp\":\"%s\",\"clientId\":\"%s\"}]";
          "{\"productCode\":\"%s\",\"deviceCode\":\"%s\",\"mac\":\"%s\"}";
 int dm_msg_thing_topo_add(_IN_ char productCode[PRODUCT_CODE_MAXLEN],
                        _IN_ char deviceCode[DEVICE_CODE_MAXLEN], _IN_ char mac[DEVICE_MAC_MAXLEN],
                        _OU_ dm_msg_request_t *request)
 {
    char *params = NULL;
    int params_len = 0;
    char timestamp[DM_UTILS_UINT64_STRLEN] = {0};
    char client_id[PRODUCT_TYPE_MAXLEN + DEVICE_CODE_MAXLEN + 1] = {0};
    char *sign_source = NULL;
    int sign_source_len = 0;
    char *sign_method = DM_MSG_SIGN_METHOD_HMACSHA1;
    char sign[65] = {0};
    if (request == NULL ||
         deviceCode == NULL ||
        (strlen(productCode) >= PRODUCT_CODE_MAXLEN) ||
        (strlen(deviceCode) >= DEVICE_CODE_MAXLEN) ||
        (strlen(request->deviceCode) >= DEVICE_CODE_MAXLEN)) {
        return INVALID_PARAMETER;
    }
 #if 0
    /* TimeStamp */
    HAL_Snprintf(timestamp, DM_UTILS_UINT64_STRLEN, "%llu", (unsigned long long)HAL_UptimeMs());
    /* dm_log_debug("Time Stamp: %s", timestamp); */
    /* Client ID */
    HAL_Snprintf(client_id, DEVICE_CODE_MAXLEN + 1, "%s", deviceCode);
    /* Sign */
    sign_source_len = strlen(DM_MSG_THING_TOPO_ADD_SIGN_SOURCE) + strlen(client_id) +
                    strlen(deviceCode) + strlen(timestamp) + 1;
    sign_source = malloc(sign_source_len);
    if (sign_source == NULL) {
      return MEMORY_NOT_ENOUGH;
    }
    memset(sign_source, 0, sign_source_len);
    HAL_Snprintf(sign_source, sign_source_len, DM_MSG_THING_TOPO_ADD_SIGN_SOURCE, client_id,
               deviceCode, timestamp);
    /* dm_log_debug("Sign Srouce: %s", sign_source); */
 #if 0
  if (strcmp(sign_method, DM_MSG_SIGN_METHOD_HMACMD5) == 0) {
      utils_hmac_md5(sign_source, strlen(sign_source), sign, device_secret, strlen(device_secret));
  } else if (strcmp(sign_method, DM_MSG_SIGN_METHOD_HMACSHA1) == 0) {
      utils_hmac_sha1(sign_source, strlen(sign_source), sign, device_secret, strlen(device_secret));
  } else if (strcmp(sign_method, DM_MSG_SIGN_METHOD_HMACSHA256) == 0) {
      utils_hmac_sha256(sign_source, strlen(sign_source), sign, device_secret, strlen(device_secret));
  } else {
      DM_free(sign_source);
      return FAIL_RETURN;
  }
 #else
  //utils_hmac_sha1(sign_source, strlen(sign_source), sign, device_secret, strlen(device_secret));
 #endif
  free(sign_source);
  /* dm_log_debug("Sign : %s", sign); */
 #endif
  /* Params */
  request->method = (char *)DM_MSG_THING_TOPO_ADD_METHOD;
  //params_len = strlen(DM_MSG_THING_TOPO_ADD_PARAMS) + strlen(deviceCode) +
  //             strlen(sign_method) + strlen(sign) + strlen(timestamp) + strlen(client_id) + 1;
  params_len = strlen(DM_MSG_THING_TOPO_ADD_PARAMS) + strlen(deviceCode) +
               strlen(productCode) + strlen(mac) + strlen(client_id) + 1;          
  params = malloc(params_len);
  if (params == NULL) {
      return MEMORY_NOT_ENOUGH;
  }
  memset(params, 0, params_len);
  //HAL_Snprintf(params, params_len, DM_MSG_THING_TOPO_ADD_PARAMS, productType, deviceCode,
  //             sign_method, sign, timestamp, client_id);
  HAL_Snprintf(params, params_len, DM_MSG_THING_TOPO_ADD_PARAMS, productCode, deviceCode,mac);
  request->params = params;
  request->params_len = strlen(request->params);
  return SUCCESS_RETURN;
 }
 const char DM_MSG_THING_TOPO_DELETE_METHOD[] DM_READ_ONLY = "thing.topo.delete";
 const char DM_MSG_THING_TOPO_DELETE_PARAMS[] DM_READ_ONLY = "[{\"deviceCode\":\"%s\"}]";
 int dm_msg_thing_topo_delete(_IN_ char deviceCode[DEVICE_CODE_MAXLEN],_OU_ dm_msg_request_t *request)
 {
    char *params = NULL;
    int params_len = 0;
    if (request == NULL ||
        deviceCode == NULL ||
        (strlen(deviceCode) >= DEVICE_CODE_MAXLEN) ||
        (strlen(request->deviceCode) >= DEVICE_CODE_MAXLEN)) {
        return INVALID_PARAMETER;
    }
    /* Params */
    request->method = (char *)DM_MSG_THING_TOPO_DELETE_METHOD;
    params_len = strlen(DM_MSG_THING_TOPO_DELETE_PARAMS) + strlen(deviceCode) + 1;
    params = malloc(params_len);
    if (params == NULL) {
        return MEMORY_NOT_ENOUGH;
    }
    memset(params, 0, params_len);
    HAL_Snprintf(params, params_len, DM_MSG_THING_TOPO_DELETE_PARAMS, deviceCode);
    request->params = params;
    request->params_len = strlen(request->params);
    return SUCCESS_RETURN;
 }
 const char DM_MSG_THING_TOPO_GET_METHOD[] DM_READ_ONLY = "thing.topo.get";
 const char DM_MSG_THING_TOPO_GET_PARAMS[] DM_READ_ONLY = "{}";
 int dm_msg_thing_topo_get(_OU_ dm_msg_request_t *request)
 {
     char *params = NULL;
     int params_len = 0;
     /* Params */
     request->method = (char *)DM_MSG_THING_TOPO_GET_METHOD;
     params_len = strlen(DM_MSG_THING_TOPO_GET_PARAMS) + 1;
     params = malloc(params_len);
     if (params == NULL) {
         return MEMORY_NOT_ENOUGH;
     }
     memset(params, 0, params_len);
     memcpy(params, DM_MSG_THING_TOPO_GET_PARAMS, strlen(DM_MSG_THING_TOPO_GET_PARAMS));
     request->params = params;
     request->params_len = strlen(request->params);
     return SUCCESS_RETURN;
 }
 const char DM_MSG_THING_LIST_FOUND_METHOD[] DM_READ_ONLY = "thing.list.found";
 const char DM_MSG_THING_LIST_FOUND_PARAMS[] DM_READ_ONLY = "[{\"deviceCode\":\"%s\"}]";
 int dm_msg_thing_list_found(_IN_ char deviceCode[DEVICE_CODE_MAXLEN],
                             _OU_ dm_msg_request_t *request)
 {
     char *params = NULL;
     int params_len = 0;
     if ( deviceCode == NULL ||
         (strlen(deviceCode) >= DEVICE_CODE_MAXLEN) ||
         request == NULL) {
         return INVALID_PARAMETER;
     }
     /* Params */
     request->method = (char *)DM_MSG_THING_LIST_FOUND_METHOD;
     params_len = strlen(DM_MSG_THING_LIST_FOUND_PARAMS) + strlen(deviceCode) + 1;
     params = malloc(params_len);
     if (params == NULL) {
         return MEMORY_NOT_ENOUGH;
     }
     memset(params, 0, params_len);
     HAL_Snprintf(params, params_len, DM_MSG_THING_LIST_FOUND_PARAMS, deviceCode);
     request->params = params;
     request->params_len = strlen(request->params);
     return SUCCESS_RETURN;
 }
 const char DM_MSG_STATUS_CLOUD_METHOD[] DM_READ_ONLY = "thing.ccu.cloudstate";							 
 const char DM_MSG_STATUS_CLOUD[] DM_READ_ONLY =
            "{\"deviceCode\":\"%s\"}";							 
 int dm_msg_status_cloud(_IN_ char productCode[PRODUCT_CODE_MAXLEN],
 						  _IN_ char deviceCode[DEVICE_CODE_MAXLEN], _OU_ dm_msg_request_t *request)
 {
 	 char *params = NULL;
 	 int params_len = 0;
 	 if (request == NULL || 
 		 deviceCode == NULL || productCode == NULL ||
 		 (strlen(deviceCode) >= DEVICE_CODE_MAXLEN) ||
 		 (strlen(productCode) >= PRODUCT_CODE_MAXLEN) ||
 		 (strlen(request->deviceCode) >= DEVICE_CODE_MAXLEN)) {
 		 return INVALID_PARAMETER;
 	 }
 	 /* Params */
 	 request->method = (char *)DM_MSG_STATUS_CLOUD_METHOD;
 	 params_len = strlen(DM_MSG_STATUS_CLOUD) + strlen(deviceCode)  + 1;
 	 params = malloc(params_len);
 	 if (params == NULL) {
 		 return DM_MEMORY_NOT_ENOUGH;
 	 }
 	 memset(params, 0, params_len);
 	 HAL_Snprintf(params, params_len, DM_MSG_STATUS_CLOUD,deviceCode);
 	 request->params = params;
 	 request->params_len = strlen(request->params);
 	 return SUCCESS_RETURN;
 }
 const char DM_MSG_COMBINE_STATUS_ONLINE_METHOD[] DM_READ_ONLY = "thing.status.online";							 
 const char DM_MSG_COMBINE_STATUS_ONLINE[] DM_READ_ONLY =
            "{\"deviceCode\":\"%s\"}";							 
 int dm_msg_status_online(_IN_ char productCode[PRODUCT_CODE_MAXLEN],
 						  _IN_ char deviceCode[DEVICE_CODE_MAXLEN], _OU_ dm_msg_request_t *request)
 {
 	 char *params = NULL;
 	 int params_len = 0;
 	 char timestamp[DM_UTILS_UINT64_STRLEN] = {0};
 	 char client_id[PRODUCT_TYPE_MAXLEN + DEVICE_CODE_MAXLEN + 20] = {0};
 	 char *sign_method = DM_MSG_SIGN_METHOD_HMACSHA1;
 	 char sign[64] = {0};
 	 if (request == NULL || 
 		 deviceCode == NULL || productCode == NULL ||
 		 (strlen(deviceCode) >= DEVICE_CODE_MAXLEN) ||
 		 (strlen(productCode) >= PRODUCT_CODE_MAXLEN) ||
 		 (strlen(request->deviceCode) >= DEVICE_CODE_MAXLEN)) {
 		 return INVALID_PARAMETER;
 	 }
 	 /* TimeStamp */
-	 HAL_Snprintf(timestamp, DM_UTILS_UINT64_STRLEN, "%llu", (unsigned long long)HAL_UptimeMs());
+	 HAL_Snprintf(timestamp, DM_UTILS_UINT64_STRLEN, "%llu", (unsigned long long)HAL_GetTimeMs());
 	 /* dm_log_debug("Time Stamp: %s", timestamp); */
 	 /* Params */
 	 request->method = (char *)DM_MSG_COMBINE_STATUS_ONLINE_METHOD;
 	 params_len = strlen(DM_MSG_COMBINE_STATUS_ONLINE) + strlen(deviceCode)  + 1;
 	 params = malloc(params_len);
 	 if (params == NULL) {
 		 return DM_MEMORY_NOT_ENOUGH;
 	 }
 	 memset(params, 0, params_len);
 	 HAL_Snprintf(params, params_len, DM_MSG_COMBINE_STATUS_ONLINE,deviceCode);
 	 request->params = params;
 	 request->params_len = strlen(request->params);
 	 return SUCCESS_RETURN;
 }
 const char DM_MSG_COMBINE_STATUS_OFFLINE_METHOD[] DM_READ_ONLY = "thing.status.offline";						   
 const char DM_MSG_COMBINE_STATUS_OFFLINE[] DM_READ_ONLY =
 		  "{\"deviceCode\":\"%s\"}";						   
 int dm_msg_status_offline(_IN_ char productCode[PRODUCT_CODE_MAXLEN],
 						_IN_ char deviceCode[DEVICE_CODE_MAXLEN], _OU_ dm_msg_request_t *request)
 {
   char *params = NULL;
   int params_len = 0;
   char timestamp[DM_UTILS_UINT64_STRLEN] = {0};
   char client_id[PRODUCT_TYPE_MAXLEN + DEVICE_CODE_MAXLEN + 20] = {0};
   char *sign_method = DM_MSG_SIGN_METHOD_HMACSHA1;
   char sign[64] = {0};
   if (request == NULL || 
 	   deviceCode == NULL || productCode == NULL ||
 	   (strlen(deviceCode) >= DEVICE_CODE_MAXLEN) ||
 	   (strlen(productCode) >= PRODUCT_CODE_MAXLEN) ||
 	   (strlen(request->deviceCode) >= DEVICE_CODE_MAXLEN)) {
 	   return INVALID_PARAMETER;
   }
   /* TimeStamp */
-   HAL_Snprintf(timestamp, DM_UTILS_UINT64_STRLEN, "%llu", (unsigned long long)HAL_UptimeMs());
+   HAL_Snprintf(timestamp, DM_UTILS_UINT64_STRLEN, "%llu", (unsigned long long)HAL_GetTimeMs());
   /* dm_log_debug("Time Stamp: %s", timestamp); */
   /* Params */
   request->method = (char *)DM_MSG_COMBINE_STATUS_OFFLINE_METHOD;
   params_len = strlen(DM_MSG_COMBINE_STATUS_OFFLINE) + strlen(deviceCode)  + 1;
   params = malloc(params_len);
   if (params == NULL) {
 	   return DM_MEMORY_NOT_ENOUGH;
   }
   memset(params, 0, params_len);
   HAL_Snprintf(params, params_len, DM_MSG_COMBINE_STATUS_OFFLINE,deviceCode);
   request->params = params;
   request->params_len = strlen(request->params);
   return SUCCESS_RETURN;
 }
 const char DM_MSG_COMBINE_LOGIN_SIGN_SOURCE[] DM_READ_ONLY = "clientId%sdeviceCode%stimestamp%s";
 const char DM_MSG_COMBINE_LOGIN_METHOD[] DM_READ_ONLY = "combine.login";
 const char DM_MSG_COMBINE_LOGIN_PARAMS[] DM_READ_ONLY =
            "{\"deviceCode\":\"%s\",\"clientId\":\"%s\",\"timestamp\":\"%s\",\"signMethod\":\"%s\",\"sign\":\"%s\",\"cleanSession\":\"%s\"}";
 int dm_msg_combine_login(_IN_ char productCode[PRODUCT_CODE_MAXLEN],
                         _IN_ char deviceCode[DEVICE_CODE_MAXLEN], _OU_ dm_msg_request_t *request)
 {
    char *params = NULL;
    int params_len = 0;
    char timestamp[DM_UTILS_UINT64_STRLEN] = {0};
    char client_id[PRODUCT_TYPE_MAXLEN + DEVICE_CODE_MAXLEN + 20] = {0};
    char *sign_source = NULL;
    int sign_source_len = 0;
    char *sign_method = DM_MSG_SIGN_METHOD_HMACSHA1;
    char sign[64] = {0};
    if (request == NULL ||
        deviceCode == NULL || productCode == NULL ||
        (strlen(deviceCode) >= DEVICE_CODE_MAXLEN) ||
        (strlen(productCode) >= PRODUCT_CODE_MAXLEN) ||
        (strlen(request->deviceCode) >= DEVICE_CODE_MAXLEN)) {
        return INVALID_PARAMETER;
    }
    /* TimeStamp */
-    HAL_Snprintf(timestamp, DM_UTILS_UINT64_STRLEN, "%llu", (unsigned long long)HAL_UptimeMs());
+    HAL_Snprintf(timestamp, DM_UTILS_UINT64_STRLEN, "%llu", (unsigned long long)HAL_GetTimeMs());
    /* dm_log_debug("Time Stamp: %s", timestamp); */
    /* Client ID */
    HAL_Snprintf(client_id, PRODUCT_TYPE_MAXLEN + DEVICE_CODE_MAXLEN + 20, "%s|_v=sdk-c-3.0.1|", deviceCode);
    /* Sign */
    sign_source_len = strlen(DM_MSG_COMBINE_LOGIN_SIGN_SOURCE) + strlen(client_id) +
                      strlen(deviceCode) + strlen(timestamp) + 1;
    sign_source = malloc(sign_source_len);
    if (sign_source == NULL) {
        return DM_MEMORY_NOT_ENOUGH;
    }
    memset(sign_source, 0, sign_source_len);
    HAL_Snprintf(sign_source, sign_source_len, DM_MSG_COMBINE_LOGIN_SIGN_SOURCE, client_id,
                 deviceCode, timestamp);
    /* dm_log_debug("Sign Srouce: %s", sign_source); */
 #if 0
    if (strcmp(sign_method, DM_MSG_SIGN_METHOD_HMACMD5) == 0) {
        utils_hmac_md5(sign_source, strlen(sign_source), sign, device_secret, strlen(device_secret));
    } else if (strcmp(sign_method, DM_MSG_SIGN_METHOD_HMACSHA1) == 0) {
        utils_hmac_sha1(sign_source, strlen(sign_source), sign, device_secret, strlen(device_secret));
    } else if (strcmp(sign_method, DM_MSG_SIGN_METHOD_HMACSHA256) == 0) {
        utils_hmac_sha256(sign_source, strlen(sign_source), sign, device_secret, strlen(device_secret));
    } else {
        DM_free(sign_source);
        return FAIL_RETURN;
    }
 #else
    //utils_hmac_sha1(sign_source, strlen(sign_source), sign, device_secret, strlen(device_secret));
 #endif
    free(sign_source);
    /* dm_log_debug("Sign : %s", sign); */
    /* Params */
    request->method = (char *)DM_MSG_COMBINE_LOGIN_METHOD;
    params_len = strlen(DM_MSG_COMBINE_LOGIN_PARAMS) + strlen(deviceCode) +
                 strlen(sign_method) + strlen(sign) + strlen(timestamp) + strlen(client_id) + 1;
    params = malloc(params_len);
    if (params == NULL) {
        return DM_MEMORY_NOT_ENOUGH;
    }
    memset(params, 0, params_len);
    HAL_Snprintf(params, params_len, DM_MSG_COMBINE_LOGIN_PARAMS, deviceCode,
                 client_id, timestamp, sign_method, sign, "true");
    request->params = params;
    request->params_len = strlen(request->params);
    return SUCCESS_RETURN;
 }
 const char DM_MSG_COMBINE_LOGOUT_METHOD[] DM_READ_ONLY = "combine.logout";
 const char DM_MSG_COMBINE_LOGOUT_PARAMS[] DM_READ_ONLY = "{\"deviceCode\":\"%s\"}";
 int dm_msg_combine_logout(_IN_ char deviceCode[DEVICE_CODE_MAXLEN],_OU_ dm_msg_request_t *request)
 {
    char *params = NULL;
    int params_len = 0;
    if ( deviceCode == NULL ||
        (strlen(deviceCode) >= DEVICE_CODE_MAXLEN) ||
        request == NULL){
        return INVALID_PARAMETER;
    }
    /* Params */
    request->method = (char *)DM_MSG_COMBINE_LOGOUT_METHOD;
    params_len = strlen(DM_MSG_COMBINE_LOGOUT_PARAMS) + strlen(deviceCode) + 1;
    params = malloc(params_len);
    if (params == NULL) {
        return MEMORY_NOT_ENOUGH;
    }
    memset(params, 0, params_len);
    HAL_Snprintf(params, params_len, DM_MSG_COMBINE_LOGOUT_PARAMS, deviceCode);
    request->params = params;
    request->params_len = strlen(request->params);
    return SUCCESS_RETURN;
 }
 const char DM_MSG_OTA_VERSION_PARAMS[] DM_READ_ONLY = "{\"version\":\"%s\"}";
 int dm_msg_ota_report_version(_IN_ char *version,
                                      _OU_ dm_msg_request_t *request)
 {
     char *params = NULL;
     int params_len = 0;
     if (NULL == version ){
         return INVALID_PARAMETER;
     }
     /* Params */
     request->method = (char *)"";
     params_len = strlen(DM_MSG_OTA_VERSION_PARAMS) + strlen(version) + 1;
     params = malloc(params_len);
     if (params == NULL) {
         return MEMORY_NOT_ENOUGH;
     }
     memset(params, 0, params_len);
     HAL_Snprintf(params, params_len, DM_MSG_OTA_VERSION_PARAMS, version);
     request->params = params;
     request->params_len = strlen(request->params);
     return SUCCESS_RETURN;
 }
 int dm_msg_request (_IN_ dm_msg_request_t *request)
 {
    int res = 0, payload_len = 0,req_info_len = 0;
    char *payload = NULL;
    lite_cjson_t lite;
 	char *req_info = NULL;
    if (request == NULL || request->params == NULL || request->method == NULL) {
        return INVALID_PARAMETER;
    }
    payload_len = strlen(DM_MSG_REQUEST) + 10 + strlen(DM_MSG_VERSION) + request->params_len + strlen(
                              request->method) + 1 + 20;
    payload = malloc(payload_len);
    if (payload == NULL) {
        return MEMORY_NOT_ENOUGH;
    }
    memset(payload, 0, payload_len);
    snprintf(payload, payload_len, DM_MSG_REQUEST, request->msgid,
-                 DM_MSG_VERSION, request->params,HAL_UptimeMs(), request->method);
+                 DM_MSG_VERSION, request->params,HAL_GetTimeMs(), request->method);
 	req_info_len = strlen(DM_MSG_INFO)+10+strlen(request->productCode)+strlen(request->deviceCode)+strlen(request->msgTypeStr)+1;
    req_info = malloc(req_info_len);
    if (req_info == NULL) {
 		free(payload);
        return MEMORY_NOT_ENOUGH;
    }
    memset(req_info, 0, req_info_len);
    snprintf(req_info, req_info_len, DM_MSG_INFO, request->msgTypeStr, request->productCode, request->deviceCode);
    memset(&lite, 0, sizeof(lite_cjson_t));
    res = lite_cjson_parse(payload, payload_len, &lite);
    if (res < SUCCESS_RETURN) {
        ERROR_PRINT("Wrong JSON Format, Payload: %s", payload);
        free(req_info);
        free(payload);
        return FAIL_RETURN;
    }
    memset(&lite, 0, sizeof(lite_cjson_t));
    res = lite_cjson_parse(req_info, req_info_len, &lite);
    if (res < SUCCESS_RETURN) {
        ERROR_PRINT("Wrong JSON Format, Payload: %s", req_info_len);
        free(req_info);
        free(payload);
        return FAIL_RETURN;
    }
    //if (type & DM_MSG_DEST_CLOUD) {
    // dm_client_publish(uri, (unsigned char *)payload, strlen(payload), request->callback);
     kk_sendData2app(req_info, payload);
    //}
    free(req_info);
    free(payload);
    return SUCCESS_RETURN;
 }
 const char DM_MSG_RESPONSE_WITH_DATA[] DM_READ_ONLY = "{\"msgId\":\"%.*s\",\"code\":%d,\"data\":%.*s}";
 int dm_msg_response(_IN_ kk_msg_request_payload_t *request, _IN_ kk_msg_response_t *response,
                    _IN_ char *data, _IN_ int data_len, _IN_ void *user_data)
 {
    int res = 0, payload_len = 0,res_info_len = 0;
    char *uri = NULL, *payload = NULL;
    lite_cjson_t lite;
 	char *res_info = NULL;
    if (request == NULL || response == NULL || data == NULL || data_len <= 0) {
        return INVALID_PARAMETER;
    }
    /* Response Payload */
    payload_len = strlen(DM_MSG_RESPONSE_WITH_DATA) + request->id.value_length + DM_UTILS_UINT32_STRLEN + data_len + 1;
    payload = malloc(payload_len);
    if (payload == NULL) {
        free(uri);
        return MEMORY_NOT_ENOUGH;
    }
    memset(payload, 0, payload_len);
    snprintf(payload, payload_len, DM_MSG_RESPONSE_WITH_DATA,
                 request->id.value_length, request->id.value, response->code, data_len, data);
 	 res_info_len = strlen(DM_MSG_INFO)+10+strlen(response->productCode)+strlen(response->deviceCode)+strlen(response->msgTypeStr)+1;
 	 res_info = malloc(res_info_len);
 	 if (res_info == NULL) {
 		 free(payload);
 		 return MEMORY_NOT_ENOUGH;
 	 }
 	 memset(res_info, 0, res_info_len);
 	 snprintf(res_info, res_info_len, DM_MSG_INFO, response->msgTypeStr,response->productCode, response->deviceCode);
    memset(&lite, 0, sizeof(lite_cjson_t));
    res = lite_cjson_parse(payload, payload_len, &lite);
    if (res < SUCCESS_RETURN) {
        ERROR_PRINT("Wrong JSON Format, URI: %s, Payload: %s", uri, payload);
        free(uri);
        free(payload);
        return FAIL_RETURN;
    }
    memset(&lite, 0, sizeof(lite_cjson_t));
    res = lite_cjson_parse(res_info, res_info_len, &lite);
    if (res < SUCCESS_RETURN) {
        ERROR_PRINT("Wrong JSON Format, Payload: %s", res_info_len);
        free(res_info);
        free(payload);
        return FAIL_RETURN;
    }
    //dm_client_publish(uri, (unsigned char *)payload, strlen(payload), NULL);
    kk_sendData2app(res_info, payload);
    free(res_info);
    free(payload);
    return SUCCESS_RETURN;
 }
 int dm_msg_response_parse(_IN_ char *payload, _IN_ int payload_len, _OU_ dm_msg_response_payload_t *response)
 {
    lite_cjson_t lite, lite_message;
    if (payload == NULL || payload_len <= 0 || response == NULL) {
        return INVALID_PARAMETER;
    }
    if (kk_utils_json_parse(payload, payload_len, cJSON_Invalid, &lite) != SUCCESS_RETURN ||
        kk_utils_json_object_item(&lite, DM_MSG_KEY_ID, strlen(DM_MSG_KEY_ID), cJSON_Invalid, &response->id) != SUCCESS_RETURN ||
        kk_utils_json_object_item(&lite, DM_MSG_KEY_CODE, strlen(DM_MSG_KEY_CODE), cJSON_Invalid,
                                  &response->code) != SUCCESS_RETURN ||
        kk_utils_json_object_item(&lite, DM_MSG_KEY_DATA, strlen(DM_MSG_KEY_DATA), cJSON_Invalid,
                                  &response->data) != SUCCESS_RETURN) {
        ERROR_PRINT("Current Request parse faild \n");                          
        return FAIL_RETURN;
    }
    INFO_PRINT("Current Request Message ID: %.*s", response->id.value_length, response->id.value);
    INFO_PRINT("Current Request Message Code: %d", response->code.value_int);
    INFO_PRINT("Current Request Message Data: %.*s", response->data.value_length, response->data.value);
    memset(&lite_message, 0, sizeof(lite_cjson_t));
    if (kk_utils_json_object_item(&lite, DM_MSG_KEY_MESSAGE, strlen(DM_MSG_KEY_MESSAGE), cJSON_Invalid,
                                  &response->message) == SUCCESS_RETURN) {
        INFO_PRINT("Current Request Message Desc: %.*s", response->message.value_length, response->message.value);
    }
    return SUCCESS_RETURN;
 }
 static int dm_msg_request_parse(_IN_ char *payload, _IN_ int payload_len, _OU_ kk_msg_request_payload_t *request)
 {
    lite_cjson_t lite;
    if (payload == NULL || payload_len <= 0 || request == NULL) {
        return INVALID_PARAMETER;
    }
    if (lite_cjson_parse(payload, payload_len, &lite) != SUCCESS_RETURN ||
        lite_cjson_object_item(&lite, KK_MSG_KEY_ID, strlen(KK_MSG_KEY_ID), &request->id) != SUCCESS_RETURN ||
        lite_cjson_object_item(&lite, KK_MSG_KEY_VERSION, strlen(KK_MSG_KEY_VERSION),
                                  &request->version) != SUCCESS_RETURN ||
        lite_cjson_object_item(&lite, KK_MSG_KEY_METHOD, strlen(KK_MSG_KEY_METHOD),
                                  &request->method) != SUCCESS_RETURN ||
        lite_cjson_object_item(&lite, KK_MSG_KEY_PARAMS, strlen(KK_MSG_KEY_PARAMS),
                                  &request->params) != SUCCESS_RETURN) {
        return FAIL_RETURN;
    }
    INFO_PRINT("Current Request Message ID: %.*s", request->id.value_length, request->id.value);
    INFO_PRINT("Current Request Message Version: %.*s", request->version.value_length, request->version.value);
    INFO_PRINT("Current Request Message Method: %.*s", request->method.value_length, request->method.value);
    INFO_PRINT("Current Request Message Params: %.*s", request->params.value_length, request->params.value);
    return SUCCESS_RETURN;
 }
 const char DM_URI_THING_SERVICE_PROPERTY_SET_REPLY[] = "/thing/service/property/set_reply";
 int dm_msg_thing_property_set_reply(char deviceCode[DEVICE_CODE_MAXLEN],char *payload, unsigned int payload_len,
        void *context){
    kk_msg_request_payload_t request;
    kk_msg_response_t response;
 	dm_mgr_dev_node_t *node = NULL;
    int res = 0, devid = 0;
    memset(&request, 0, sizeof(kk_msg_request_payload_t));
    memset(&response, 0, sizeof(kk_msg_response_t));
    res = dm_mgr_get_device_by_devicecode(deviceCode, &node);
    if (res < SUCCESS_RETURN) {
 		ERROR_PRINT("dm_mgr_search_device_by_pkdn failed");
        return res;
    }
    res = dm_msg_request_parse((char *)payload, payload_len, &request);
    if (res < SUCCESS_RETURN) {
 		ERROR_PRINT("dm_msg_request_parse failed");
        return res ;
    }
 	response.msgTypeStr = DM_URI_THING_SERVICE_PROPERTY_SET_REPLY;
    memcpy(response.productCode, node->productCode, strlen( node->productCode));	
    memcpy(response.deviceCode, node->deviceCode, strlen(node->deviceCode));
    response.code = (res == SUCCESS_RETURN) ? (IOTX_DM_ERR_CODE_SUCCESS) : (IOTX_DM_ERR_CODE_REQUEST_ERROR);
 	dm_msg_response(&request, &response, "{}", strlen("{}"), NULL);
 	return SUCCESS_RETURN;
 }
--- a/midware/midware/midware.c
+++ b/midware/midware/midware.c
@@ -180,7 +180,7 @@ void kk_platMsg_handle(void* data, char* chalMark){
        info = cJSON_GetObjectItem(json, "info");
 		payload = cJSON_GetObjectItem(json, "payload");
 		if (info == NULL || payload == NULL){
-            ERROR_PRINT("info or payload params is error\n");
+            ERROR_PRINT("info or payload params error\n");
            goto error;
 		}
@@ -194,6 +194,10 @@ void kk_platMsg_handle(void* data, char* chalMark){
            goto error;
 		}
+        if (chalMark != NULL){
+		    dm_mgr_update_timestamp_by_devicecode(chalMark,HAL_UptimeMs());
+		}
        dm_mgr_update_timestamp_by_devicecode(info_dcode->valuestring,HAL_UptimeMs());
        if (strcmp(msgType->valuestring, "/thing/topo/add")==0){