Skip to content

K
k-sdk
Commit aab93033 authored by 黄振令's avatar 黄振令
Browse files
Options

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

【提交人】huang.zhenling
parent 87d2de68
Hide whitespace changes
Inline Side-by-side
Showing with 1485 additions and 1469 deletions
common/hal/HAL_OS_linux.c
View file @ aab93033
/*
* 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)
{
struct timeval tv;
struct tm tm;
int str_len = 0;
if (buf == NULL || len < 28) {
return NULL;
}
gettimeofday(&tv, NULL);
localtime_r(&tv.tv_sec, &tm);
strftime(buf, 28, "%m-%d %H:%M:%S", &tm);
str_len = strlen(buf);
if (str_len + 3 < len) {
snprintf(buf + str_len, len, ".%3.3d", (int)(tv.tv_usec) / 1000);
}
return buf;
}
void HAL_SleepMs(_IN_ uint32_t ms)
{
usleep(1000 * ms);
}
void HAL_Srandom(uint32_t seed)
{
srandom(seed);
}
uint32_t HAL_Random(uint32_t region)
{
return (region > 0) ? (random() % region) : 0;
}
int HAL_Snprintf(_IN_ char *str, const int len, const char *fmt, ...)
{
va_list args;
int rc;
va_start(args, fmt);
rc = vsnprintf(str, len, fmt, args);
va_end(args);
return rc;
}
int HAL_Vsnprintf(_IN_ char *str, _IN_ const int len, _IN_ const char *format, va_list ap)
{
return vsnprintf(str, len, format, ap);
}
void HAL_Printf(_IN_ const char *fmt, ...)
{
va_list args;
va_start(args, fmt);
vprintf(fmt, args);
va_end(args);
fflush(stdout);
}
int HAL_SetProduct_Type(_IN_ char *product_type)
{
int len = strlen(product_type);
if (len > PRODUCT_TYPE_LEN) {
return -1;
}
memset(g_product_type, 0x0, PRODUCT_TYPE_LEN);
strncpy(g_product_type, product_type, len);
return len;
}
int HAL_SetProduct_Code(_IN_ char *product_code)
{
int len = strlen(product_code);
if (len > PRODUCT_CODE_LEN) {
return -1;
}
memset(g_product_code, 0x0, PRODUCT_CODE_LEN);
strncpy(g_product_code, product_code, len);
return len;
}
int HAL_SetDevice_Code(_IN_ char *device_code)
{
int len = strlen(device_code);
if (len > DEVICE_CODE_LEN) {
return -1;
}
memset(g_device_code, 0x0, DEVICE_CODE_LEN);
strncpy(g_device_code, DEVICE_CODE_LEN, len);
return len;
}
int HAL_GetProduct_Type(_OU_ char *product_type)
{
int len = strlen(g_product_type);
memset(product_type, 0x0, PRODUCT_TYPE_LEN);
strncpy(product_type, g_product_type, len);
return len;
}
int HAL_GetProduct_Code(_OU_ char *product_code)
{
int len = strlen(g_product_code);
memset(product_code, 0x0, PRODUCT_CODE_LEN);
strncpy(product_code, g_product_code, len);
return len;
}
int HAL_GetDevice_Code(_OU_ char *device_code)
{
int len = strlen(g_device_code);
memset(device_code, 0x0, DEVICE_CODE_LEN);
//strncpy(device_code, g_device_code, len);
strncpy(device_code, "CCU_66666", strlen("CCU_66666"));
return len;
}
int HAL_GetVersion(_OU_ char *version)
{
char *ver = "test-1.0.0";
int len = strlen(ver);
memset(version, 0x0, VERSION_MAXLEN);
strncpy(version, ver, len);
version[len] = '\0';
return strlen(version);
}
/*
* This need to be same with app version as in uOTA module (ota_version.h)
#ifndef SYSINFO_APP_VERSION
#define SYSINFO_APP_VERSION "app-1.0.0-20180101.1000"
#endif
*
*/
int HAL_GetFirmwareVersion(_OU_ char *version)
{
char *ver = "app-1.0.0-20180101.1000";
int len = strlen(ver);
memset(version, 0x0, FIRMWARE_VERSION_MAXLEN);
strncpy(version, ver, len);
version[len] = '\0';
return strlen(version);
}
void *HAL_SemaphoreCreate(void)
{
sem_t *sem = (sem_t *)malloc(sizeof(sem_t));
if (NULL == sem) {
return NULL;
}
if (0 != sem_init(sem, 0, 0)) {
free(sem);
return NULL;
}
return sem;
}
void HAL_SemaphoreDestroy(_IN_ void *sem)
{
sem_destroy((sem_t *)sem);
free(sem);
}
void HAL_SemaphorePost(_IN_ void *sem)
{
sem_post((sem_t *)sem);
}
int HAL_SemaphoreWait(_IN_ void *sem, _IN_ uint32_t timeout_ms)
{
if (PLATFORM_WAIT_INFINITE == timeout_ms) {
sem_wait(sem);
return 0;
} else {
struct timespec ts;
int s;
/* Restart if interrupted by handler */
do {
if (clock_gettime(CLOCK_REALTIME, &ts) == -1) {
return -1;
}
s = 0;
ts.tv_nsec += (timeout_ms % 1000) * 1000000;
if (ts.tv_nsec >= 1000000000) {
ts.tv_nsec -= 1000000000;
s = 1;
}
ts.tv_sec += timeout_ms / 1000 + s;
} while (((s = sem_timedwait(sem, &ts)) != 0) && errno == EINTR);
return (s == 0) ? 0 : -1;
}
}
int HAL_ThreadCreate(
_OU_ void **thread_handle,
_IN_ void *(*work_routine)(void *),
_IN_ void *arg,
_OU_ int *stack_used)
{
int ret = -1;
ret = pthread_create((pthread_t *)thread_handle, NULL, work_routine, arg);
return ret;
}
void HAL_ThreadDetach(_IN_ void *thread_handle)
{
pthread_detach((pthread_t)thread_handle);
}
void HAL_ThreadDelete(_IN_ void *thread_handle)
{
if (NULL == thread_handle) {
pthread_exit(0);
} else {
/*main thread delete child thread*/
pthread_cancel((pthread_t)thread_handle);
pthread_join((pthread_t)thread_handle, 0);
}
}
#if 1
static FILE *fp;
#define otafilename "/tmp/kkota.bin"
#define __DEMO__
void HAL_Firmware_Persistence_Start(void* fileName)
{
#ifdef __DEMO__
char * file = NULL;
if (fileName == NULL){
file = otafilename;
}else{
file = fileName;
}
fp = fopen(file, "w");
// assert(fp);
#endif
return;
}
int HAL_Firmware_Persistence_Write(_IN_ char *buffer, _IN_ uint32_t length)
{
#ifdef __DEMO__
unsigned int written_len = 0;
written_len = fwrite(buffer, 1, length, fp);
if (written_len != length) {
return -1;
}
#endif
return 0;
}
int HAL_Firmware_Persistence_Stop(void)
{
#ifdef __DEMO__
if (fp != NULL) {
fclose(fp);
}
#endif
/* check file md5, and burning it to flash ... finally reboot system */
return 0;
}
int HAL_Config_Write(const char *buffer, int length)
{
FILE *fp;
size_t written_len;
char filepath[128] = {0};
if (!buffer || length <= 0) {
return -1;
}
snprintf(filepath, sizeof(filepath), "./%s", "alinkconf");
fp = fopen(filepath, "w");
if (!fp) {
return -1;
}
written_len = fwrite(buffer, 1, length, fp);
fclose(fp);
return ((written_len != length) ? -1 : 0);
}
int HAL_Config_Read(char *buffer, int length)
{
FILE *fp;
size_t read_len;
char filepath[128] = {0};
if (!buffer || length <= 0) {
return -1;
}
snprintf(filepath, sizeof(filepath), "./%s", "alinkconf");
fp = fopen(filepath, "r");
if (!fp) {
return -1;
}
read_len = fread(buffer, 1, length, fp);
fclose(fp);
return ((read_len != length) ? -1 : 0);
}
#define REBOOT_CMD "reboot"
void HAL_Reboot(void)
{
if (system(REBOOT_CMD)) {
perror("HAL_Reboot failed");
}
}
#endif
#define ROUTER_INFO_PATH "/proc/net/route"
#define ROUTER_RECORD_SIZE 256
static char *_get_default_routing_ifname(char *ifname, int ifname_size)
{
FILE *fp = NULL;
char line[ROUTER_RECORD_SIZE] = {0};
char iface[IFNAMSIZ] = {0};
char *result = NULL;
unsigned int destination, gateway, flags, mask;
unsigned int refCnt, use, metric, mtu, window, irtt;
fp = fopen(ROUTER_INFO_PATH, "r");
if (fp == NULL) {
perror("fopen");
return result;
}
char *buff = fgets(line, sizeof(line), fp);
if (buff == NULL) {
perror("fgets");
goto out;
}
while (fgets(line, sizeof(line), fp)) {
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)) {
perror("sscanf");
continue;
}
/*default route */
if ((destination == 0) && (mask == 0)) {
strncpy(ifname, iface, ifname_size - 1);
result = ifname;
break;
}
}
out:
if (fp) {
fclose(fp);
}
return result;
}
int HAL_Get_mac(char* mac)
{
struct ifreq tmp;
int sock_mac;
char mac_addr[30];
sock_mac = socket(AF_INET, SOCK_STREAM, 0);
if( sock_mac == -1){
perror("create socket fail\n");
return -1;
}
memset(&tmp,0,sizeof(tmp));
strncpy(tmp.ifr_name,"ens33",sizeof(tmp.ifr_name)-1 );
if( (ioctl( sock_mac, SIOCGIFHWADDR, &tmp)) < 0 ){
printf("mac ioctl error\n");
return -1;
}
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],
(unsigned char)tmp.ifr_hwaddr.sa_data[2],
(unsigned char)tmp.ifr_hwaddr.sa_data[3],
(unsigned char)tmp.ifr_hwaddr.sa_data[4],
(unsigned char)tmp.ifr_hwaddr.sa_data[5]
);
printf("local mac:%s\n", mac_addr);
close(sock_mac);
memcpy(mac,mac_addr,strlen(mac_addr));
return 0;
}
int HAL_Get_SN(char sn[SN_ADDR_LEN])
{
strncpy(sn,"15",SN_ADDR_LEN);
return 0;//just for test
}
int HAL_Get_port(void)
{
return 5555;//just for test
}
uint32_t HAL_Get_IP(char ip_str[NETWORK_ADDR_LEN], const char *ifname)
{
struct ifreq ifreq;
int sock = -1;
char ifname_buff[IFNAMSIZ] = {0};
if ((NULL == ifname || strlen(ifname) == 0) &&
NULL == (ifname = _get_default_routing_ifname(ifname_buff, sizeof(ifname_buff)))) {
perror("get default routeing ifname");
return -1;
}
if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
perror("socket");
return -1;
}
ifreq.ifr_addr.sa_family = AF_INET; //ipv4 address
strncpy(ifreq.ifr_name, ifname, IFNAMSIZ - 1);
if (ioctl(sock, SIOCGIFADDR, &ifreq) < 0) {
close(sock);
perror("ioctl");
return -1;
}
close(sock);
strncpy(ip_str,
inet_ntoa(((struct sockaddr_in *)&ifreq.ifr_addr)->sin_addr),
NETWORK_ADDR_LEN);
return ((struct sockaddr_in *)&ifreq.ifr_addr)->sin_addr.s_addr;
}
#if 0
static kv_file_t *kvfile = NULL;
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_set_blob(kvfile, (char *)key, (char *)val, len);
}
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_get_blob(kvfile, (char *)key, buffer, buffer_len);
}
int HAL_Kv_Del(const char *key)
{
if (!kvfile) {
kvfile = kv_open("/tmp/kvfile.db");
if (!kvfile) {
return -1;
}
}
return kv_del(kvfile, (char *)key);
}
static long long os_time_get(void)
{
struct timeval tv;
long long ms;
gettimeofday(&tv, NULL);
ms = tv.tv_sec * 1000LL + tv.tv_usec / 1000;
return ms;
}
static long long delta_time = 0;
void HAL_UTC_Set(long long ms)
{
delta_time = ms - os_time_get();
}
long long HAL_UTC_Get(void)
{
return delta_time + os_time_get();
}
void *HAL_Timer_Create(const char *name, void (*func)(void *), void *user_data)
{
timer_t *timer = NULL;
struct sigevent ent;
/* check parameter */
if (func == NULL) {
return NULL;
}
timer = (timer_t *)malloc(sizeof(time_t));
/* Init */
memset(&ent, 0x00, sizeof(struct sigevent));
/* create a timer */
ent.sigev_notify = SIGEV_THREAD;
ent.sigev_notify_function = (void (*)(union sigval))func;
ent.sigev_value.sival_ptr = user_data;
printf("HAL_Timer_Create\n");
if (timer_create(CLOCK_MONOTONIC, &ent, timer) != 0) {
free(timer);
return NULL;
}
return (void *)timer;
}
int HAL_Timer_Start(void *timer, int ms)
{
struct itimerspec ts;
/* check parameter */
if (timer == NULL) {
return -1;
}
/* it_interval=0: timer run only once */
ts.it_interval.tv_sec = 0;
ts.it_interval.tv_nsec = 0;
/* it_value=0: stop timer */
ts.it_value.tv_sec = ms / 1000;
ts.it_value.tv_nsec = (ms % 1000) * 1000;
return timer_settime(*(timer_t *)timer, 0, &ts, NULL);
}
int HAL_Timer_Stop(void *timer)
{
struct itimerspec ts;
/* check parameter */
if (timer == NULL) {
return -1;
}
/* it_interval=0: timer run only once */
ts.it_interval.tv_sec = 0;
ts.it_interval.tv_nsec = 0;
/* it_value=0: stop timer */
ts.it_value.tv_sec = 0;
ts.it_value.tv_nsec = 0;
return timer_settime(*(timer_t *)timer, 0, &ts, NULL);
}
int HAL_Timer_Delete(void *timer)
{
int ret = 0;
/* check parameter */
if (timer == NULL) {
return -1;
}
ret = timer_delete(*(timer_t *)timer);
free(timer);
return ret;
}
#endif
/*
* 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;
}
uint64_t HAL_GetTimeMs(void)
{
uint64_t time_ms;
struct timespec ts;
clock_gettime(CLOCK_REALTIME, &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)
{
struct timeval tv;
struct tm tm;
int str_len = 0;
if (buf == NULL || len < 28) {
return NULL;
}
gettimeofday(&tv, NULL);
localtime_r(&tv.tv_sec, &tm);
strftime(buf, 28, "%m-%d %H:%M:%S", &tm);
str_len = strlen(buf);
if (str_len + 3 < len) {
snprintf(buf + str_len, len, ".%3.3d", (int)(tv.tv_usec) / 1000);
}
return buf;
}
void HAL_SleepMs(_IN_ uint32_t ms)
{
usleep(1000 * ms);
}
void HAL_Srandom(uint32_t seed)
{
srandom(seed);
}
uint32_t HAL_Random(uint32_t region)
{
return (region > 0) ? (random() % region) : 0;
}
int HAL_Snprintf(_IN_ char *str, const int len, const char *fmt, ...)
{
va_list args;
int rc;
va_start(args, fmt);
rc = vsnprintf(str, len, fmt, args);
va_end(args);
return rc;
}
int HAL_Vsnprintf(_IN_ char *str, _IN_ const int len, _IN_ const char *format, va_list ap)
{
return vsnprintf(str, len, format, ap);
}
void HAL_Printf(_IN_ const char *fmt, ...)
{
va_list args;
va_start(args, fmt);
vprintf(fmt, args);
va_end(args);
fflush(stdout);
}
int HAL_SetProduct_Type(_IN_ char *product_type)
{
int len = strlen(product_type);
if (len > PRODUCT_TYPE_LEN) {
return -1;
}
memset(g_product_type, 0x0, PRODUCT_TYPE_LEN);
strncpy(g_product_type, product_type, len);
return len;
}
int HAL_SetProduct_Code(_IN_ char *product_code)
{
int len = strlen(product_code);
if (len > PRODUCT_CODE_LEN) {
return -1;
}
memset(g_product_code, 0x0, PRODUCT_CODE_LEN);
strncpy(g_product_code, product_code, len);
return len;
}
int HAL_SetDevice_Code(_IN_ char *device_code)
{
int len = strlen(device_code);
if (len > DEVICE_CODE_LEN) {
return -1;
}
memset(g_device_code, 0x0, DEVICE_CODE_LEN);
strncpy(g_device_code, DEVICE_CODE_LEN, len);
return len;
}
int HAL_GetProduct_Type(_OU_ char *product_type)
{
int len = strlen(g_product_type);
memset(product_type, 0x0, PRODUCT_TYPE_LEN);
strncpy(product_type, g_product_type, len);
return len;
}
int HAL_GetProduct_Code(_OU_ char *product_code)
{
int len = strlen(g_product_code);
memset(product_code, 0x0, PRODUCT_CODE_LEN);
strncpy(product_code, g_product_code, len);
return len;
}
int HAL_GetDevice_Code(_OU_ char *device_code)
{
int len = strlen(g_device_code);
memset(device_code, 0x0, DEVICE_CODE_LEN);
//strncpy(device_code, g_device_code, len);
strncpy(device_code, "CCU_66666", strlen("CCU_66666"));
return len;
}
int HAL_GetVersion(_OU_ char *version)
{
char *ver = "test-1.0.0";
int len = strlen(ver);
memset(version, 0x0, VERSION_MAXLEN);
strncpy(version, ver, len);
version[len] = '\0';
return strlen(version);
}
/*
* This need to be same with app version as in uOTA module (ota_version.h)
#ifndef SYSINFO_APP_VERSION
#define SYSINFO_APP_VERSION "app-1.0.0-20180101.1000"
#endif
*
*/
int HAL_GetFirmwareVersion(_OU_ char *version)
{
char *ver = "app-1.0.0-20180101.1000";
int len = strlen(ver);
memset(version, 0x0, FIRMWARE_VERSION_MAXLEN);
strncpy(version, ver, len);
version[len] = '\0';
return strlen(version);
}
void *HAL_SemaphoreCreate(void)
{
sem_t *sem = (sem_t *)malloc(sizeof(sem_t));
if (NULL == sem) {
return NULL;
}
if (0 != sem_init(sem, 0, 0)) {
free(sem);
return NULL;
}
return sem;
}
void HAL_SemaphoreDestroy(_IN_ void *sem)
{
sem_destroy((sem_t *)sem);
free(sem);
}
void HAL_SemaphorePost(_IN_ void *sem)
{
sem_post((sem_t *)sem);
}
int HAL_SemaphoreWait(_IN_ void *sem, _IN_ uint32_t timeout_ms)
{
if (PLATFORM_WAIT_INFINITE == timeout_ms) {
sem_wait(sem);
return 0;
} else {
struct timespec ts;
int s;
/* Restart if interrupted by handler */
do {
if (clock_gettime(CLOCK_REALTIME, &ts) == -1) {
return -1;
}
s = 0;
ts.tv_nsec += (timeout_ms % 1000) * 1000000;
if (ts.tv_nsec >= 1000000000) {
ts.tv_nsec -= 1000000000;
s = 1;
}
ts.tv_sec += timeout_ms / 1000 + s;
} while (((s = sem_timedwait(sem, &ts)) != 0) && errno == EINTR);
return (s == 0) ? 0 : -1;
}
}
int HAL_ThreadCreate(
_OU_ void **thread_handle,
_IN_ void *(*work_routine)(void *),
_IN_ void *arg,
_OU_ int *stack_used)
{
int ret = -1;
ret = pthread_create((pthread_t *)thread_handle, NULL, work_routine, arg);
return ret;
}
void HAL_ThreadDetach(_IN_ void *thread_handle)
{
pthread_detach((pthread_t)thread_handle);
}
void HAL_ThreadDelete(_IN_ void *thread_handle)
{
if (NULL == thread_handle) {
pthread_exit(0);
} else {
/*main thread delete child thread*/
pthread_cancel((pthread_t)thread_handle);
pthread_join((pthread_t)thread_handle, 0);
}
}
#if 1
static FILE *fp;
#define otafilename "/tmp/kkota.bin"
#define __DEMO__
void HAL_Firmware_Persistence_Start(void* fileName)
{
#ifdef __DEMO__
char * file = NULL;
if (fileName == NULL){
file = otafilename;
}else{
file = fileName;
}
fp = fopen(file, "w");
// assert(fp);
#endif
return;
}
int HAL_Firmware_Persistence_Write(_IN_ char *buffer, _IN_ uint32_t length)
{
#ifdef __DEMO__
unsigned int written_len = 0;
written_len = fwrite(buffer, 1, length, fp);
if (written_len != length) {
return -1;
}
#endif
return 0;
}
int HAL_Firmware_Persistence_Stop(void)
{
#ifdef __DEMO__
if (fp != NULL) {
fclose(fp);
}
#endif
/* check file md5, and burning it to flash ... finally reboot system */
return 0;
}
int HAL_Config_Write(const char *buffer, int length)
{
FILE *fp;
size_t written_len;
char filepath[128] = {0};
if (!buffer || length <= 0) {
return -1;
}
snprintf(filepath, sizeof(filepath), "./%s", "alinkconf");
fp = fopen(filepath, "w");
if (!fp) {
return -1;
}
written_len = fwrite(buffer, 1, length, fp);
fclose(fp);
return ((written_len != length) ? -1 : 0);
}
int HAL_Config_Read(char *buffer, int length)
{
FILE *fp;
size_t read_len;
char filepath[128] = {0};
if (!buffer || length <= 0) {
return -1;
}
snprintf(filepath, sizeof(filepath), "./%s", "alinkconf");
fp = fopen(filepath, "r");
if (!fp) {
return -1;
}
read_len = fread(buffer, 1, length, fp);
fclose(fp);
return ((read_len != length) ? -1 : 0);
}
#define REBOOT_CMD "reboot"
void HAL_Reboot(void)
{
if (system(REBOOT_CMD)) {
perror("HAL_Reboot failed");
}
}
#endif
#define ROUTER_INFO_PATH "/proc/net/route"
#define ROUTER_RECORD_SIZE 256
static char *_get_default_routing_ifname(char *ifname, int ifname_size)
{
FILE *fp = NULL;
char line[ROUTER_RECORD_SIZE] = {0};
char iface[IFNAMSIZ] = {0};
char *result = NULL;
unsigned int destination, gateway, flags, mask;
unsigned int refCnt, use, metric, mtu, window, irtt;
fp = fopen(ROUTER_INFO_PATH, "r");
if (fp == NULL) {
perror("fopen");
return result;
}
char *buff = fgets(line, sizeof(line), fp);
if (buff == NULL) {
perror("fgets");
goto out;
}
while (fgets(line, sizeof(line), fp)) {
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)) {
perror("sscanf");
continue;
}
/*default route */
if ((destination == 0) && (mask == 0)) {
strncpy(ifname, iface, ifname_size - 1);
result = ifname;
break;
}
}
out:
if (fp) {
fclose(fp);
}
return result;
}
int HAL_Get_mac(char* mac)
{
struct ifreq tmp;
int sock_mac;
char mac_addr[30];
sock_mac = socket(AF_INET, SOCK_STREAM, 0);
if( sock_mac == -1){
perror("create socket fail\n");
return -1;
}
memset(&tmp,0,sizeof(tmp));
strncpy(tmp.ifr_name,"ens33",sizeof(tmp.ifr_name)-1 );
if( (ioctl( sock_mac, SIOCGIFHWADDR, &tmp)) < 0 ){
printf("mac ioctl error\n");
return -1;
}
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],
(unsigned char)tmp.ifr_hwaddr.sa_data[2],
(unsigned char)tmp.ifr_hwaddr.sa_data[3],
(unsigned char)tmp.ifr_hwaddr.sa_data[4],
(unsigned char)tmp.ifr_hwaddr.sa_data[5]
);
printf("local mac:%s\n", mac_addr);
close(sock_mac);
memcpy(mac,mac_addr,strlen(mac_addr));
return 0;
}
int HAL_Get_SN(char sn[SN_ADDR_LEN])
{
strncpy(sn,"15",SN_ADDR_LEN);
return 0;//just for test
}
int HAL_Get_port(void)
{
return 5555;//just for test
}
uint32_t HAL_Get_IP(char ip_str[NETWORK_ADDR_LEN], const char *ifname)
{
struct ifreq ifreq;
int sock = -1;
char ifname_buff[IFNAMSIZ] = {0};
if ((NULL == ifname || strlen(ifname) == 0) &&
NULL == (ifname = _get_default_routing_ifname(ifname_buff, sizeof(ifname_buff)))) {
perror("get default routeing ifname");
return -1;
}
if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
perror("socket");
return -1;
}
ifreq.ifr_addr.sa_family = AF_INET; //ipv4 address
strncpy(ifreq.ifr_name, ifname, IFNAMSIZ - 1);
if (ioctl(sock, SIOCGIFADDR, &ifreq) < 0) {
close(sock);
perror("ioctl");
return -1;
}
close(sock);
strncpy(ip_str,
inet_ntoa(((struct sockaddr_in *)&ifreq.ifr_addr)->sin_addr),
NETWORK_ADDR_LEN);
return ((struct sockaddr_in *)&ifreq.ifr_addr)->sin_addr.s_addr;
}
#if 0
static kv_file_t *kvfile = NULL;
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_set_blob(kvfile, (char *)key, (char *)val, len);
}
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_get_blob(kvfile, (char *)key, buffer, buffer_len);
}
int HAL_Kv_Del(const char *key)
{
if (!kvfile) {
kvfile = kv_open("/tmp/kvfile.db");
if (!kvfile) {
return -1;
}
}
return kv_del(kvfile, (char *)key);
}
static long long os_time_get(void)
{
struct timeval tv;
long long ms;
gettimeofday(&tv, NULL);
ms = tv.tv_sec * 1000LL + tv.tv_usec / 1000;
return ms;
}
static long long delta_time = 0;
void HAL_UTC_Set(long long ms)
{
delta_time = ms - os_time_get();
}
long long HAL_UTC_Get(void)
{
return delta_time + os_time_get();
}
void *HAL_Timer_Create(const char *name, void (*func)(void *), void *user_data)
{
timer_t *timer = NULL;
struct sigevent ent;
/* check parameter */
if (func == NULL) {
return NULL;
}
timer = (timer_t *)malloc(sizeof(time_t));
/* Init */
memset(&ent, 0x00, sizeof(struct sigevent));
/* create a timer */
ent.sigev_notify = SIGEV_THREAD;
ent.sigev_notify_function = (void (*)(union sigval))func;
ent.sigev_value.sival_ptr = user_data;
printf("HAL_Timer_Create\n");
if (timer_create(CLOCK_MONOTONIC, &ent, timer) != 0) {
free(timer);
return NULL;
}
return (void *)timer;
}
int HAL_Timer_Start(void *timer, int ms)
{
struct itimerspec ts;
/* check parameter */
if (timer == NULL) {
return -1;
}
/* it_interval=0: timer run only once */
ts.it_interval.tv_sec = 0;
ts.it_interval.tv_nsec = 0;
/* it_value=0: stop timer */
ts.it_value.tv_sec = ms / 1000;
ts.it_value.tv_nsec = (ms % 1000) * 1000;
return timer_settime(*(timer_t *)timer, 0, &ts, NULL);
}
int HAL_Timer_Stop(void *timer)
{
struct itimerspec ts;
/* check parameter */
if (timer == NULL) {
return -1;
}
/* it_interval=0: timer run only once */
ts.it_interval.tv_sec = 0;
ts.it_interval.tv_nsec = 0;
/* it_value=0: stop timer */
ts.it_value.tv_sec = 0;
ts.it_value.tv_nsec = 0;
return timer_settime(*(timer_t *)timer, 0, &ts, NULL);
}
int HAL_Timer_Delete(void *timer)
{
int ret = 0;
/* check parameter */
if (timer == NULL) {
return -1;
}
ret = timer_delete(*(timer_t *)timer);
free(timer);
return ret;
}
#endif
midware/midware/dm/kk_dm_msg.c
View file @ aab93033
#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());
/* 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());
/* 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());
/* 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);
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;
}
#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_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_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_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_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;
}
midware/midware/midware.c
View file @ aab93033
......@@ -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){
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment