Skip to content

K
k-sdk
Commit a706052d authored by 尹佳钦's avatar 尹佳钦
Browse files
Options

Merge branch 'master' of http://172.17.3.10:17001/chenweican/k-sdk

parents 64166551 890c7106
Hide whitespace changes
Inline Side-by-side
Showing with 112966 additions and 234408 deletions
application/kcloud/iot.mk
View file @ a706052d
LIBA_TARGET := libiot_kcloud.a
SRCS_kcloud := kcloud_main.c
$(call Append_Conditional, LIB_SRCS_EXCLUDE, kcloud_main.c)
$(call Append_Conditional, SRCS_kcloud, kcloud_main.c)
$(call Append_Conditional, TARGET, kcloud)
......
common/api/tcp_channel.c
View file @ a706052d
......@@ -6,6 +6,10 @@
#include <fcntl.h>
#include <errno.h>
#include <unistd.h>
#include <sys/select.h>
#include <sys/time.h>
#include <sys/types.h>
#include "com_api.h"
#define CCU_TCP_PORT 16565
......@@ -554,14 +558,14 @@ typedef struct {
char ip[MAX_IP_LEN];
int port;
ipc_cb* cb;
int retry;
} kk_tcp_client_t;
static kk_tcp_client_t g_client_ctrl = {NULL, -1, 0,{0},0, NULL};
static kk_tcp_client_t g_client_ctrl = {NULL, -1, 0,{0},0, NULL,0};
static int _init_client(){
memset(&g_client_ctrl, 0 ,sizeof(kk_tcp_client_t));
/* Create Mutex */
g_client_ctrl.mutex = _MutexCreate();
if (g_client_ctrl.mutex == NULL) {
return -1;
......@@ -601,14 +605,14 @@ static int client_socket_init(int *sd, char *ipaddr, uint16_t port)
}
//连接
int retry = 0;
for(;retry < 10; retry++){
for(;retry < 3; retry++){
if(-1 != connect(sock, (struct sockaddr *)&addr, sizeof(addr))){
break;
}
printf("==================connect retry=%d \n", retry);
//printf("==================connect retry=%d \n", retry);
sleep(1);
}
if (retry >= 10){
if (retry >= 3){
printf("==================connect failed \n");
goto err2;
}
......@@ -626,28 +630,56 @@ static void loop_tcp_client_thread(void *arg){
printf("loop_tcp_client_thread start!\r\n");
char buf[1024]= {0};
int ret = 0;
fd_set fds;
struct timeval timeout={0,200}; //select等待3秒，3秒轮询，要非阻塞就置0
while(1){
if(-1 == client_socket_init(&g_client_ctrl.sd,g_client_ctrl.ip, g_client_ctrl.port)){
printf("connect failed \n");
sleep(1);
g_client_ctrl.retry++;
continue;
}
g_client_ctrl.isConnect = 1;
g_client_ctrl.retry = 0;
while(g_client_ctrl.isConnect){
_MutexLock(g_client_ctrl.mutex);
ret = read(g_client_ctrl.sd, buf, sizeof(buf));
_MutexUnlock(g_client_ctrl.mutex);
if(-1== ret){
//printf("=================read error \n");
//break ;
}else if(ret > 0){
printf("buf = %s\n",buf);
if (g_client_ctrl.cb != NULL){
g_client_ctrl.cb(buf,ret,"");
FD_ZERO(&fds); //每次循环都要清空集合，否则不能检测描述符变化
FD_SET(g_client_ctrl.sd,&fds); //添加描述符
switch(select(g_client_ctrl.sd + 1,&fds,NULL,NULL,&timeout)) //select使用
{
case -1:
g_client_ctrl.isConnect = 0;
printf(" [%s] select error ret=%d \n", __FUNCTION__, ret);
break; //select错误 退出循环
case 0:
break; //再次轮询
default:
if(FD_ISSET(g_client_ctrl.sd,&fds)) //测试sock是否可读，即是否网络上有数据
{
//接受网络数据
_MutexLock(g_client_ctrl.mutex);
ret = read(g_client_ctrl.sd, buf, sizeof(buf));
_MutexUnlock(g_client_ctrl.mutex);
if( ret <= 0){
printf("=================read error ret=%d \n",ret);
if (errno != EINTR){
g_client_ctrl.isConnect = 0;
printf("read error reconnect!! \n");
break;
}
}else if(ret > 0){
printf("buf = %s\n",buf);
if (g_client_ctrl.cb != NULL){
g_client_ctrl.cb(buf,ret,"");
}
}
}
}
usleep(100000);
break;
}// end switch
//usleep(100000);
}
printf("network error, try connect again! \n");
......@@ -658,6 +690,14 @@ static void loop_tcp_client_thread(void *arg){
}
int kk_get_retry_num(){
return g_client_ctrl.retry;
}
int kk_reset_retry_num(){
return g_client_ctrl.retry = 0;
}
int kk_tcp_client_send(char* data, int len){
int ret = 0;
int cnt = 0;
......@@ -698,6 +738,7 @@ int kk_tcp_client_init(char ip[MAX_IP_LEN], int port, ipc_cb cb)
kk_tcp_client_deinit(){
if (g_client_ctrl.sd > -1){
close(g_client_ctrl.sd);
g_client_ctrl.sd = -1;
}
_MutexDestroy(g_client_ctrl.mutex);
}
......
common/hal/HAL_OS_linux.c
View file @ a706052d
/*
* 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
common/sqlite/shell.c deleted 100644 → 0
View file @ 64166551
This source diff could not be displayed because it is too large. You can view the blob instead.
common/sqlite/sqlite3.c
View file @ a706052d
This source diff could not be displayed because it is too large. You can view the blob instead.
common/sqlite/sqlite3.h
View file @ a706052d
This source diff could not be displayed because it is too large. You can view the blob instead.
common/sqlite/sqlite3ext.h deleted 100644 → 0
View file @ 64166551
/*
** 2006 June 7
**
** The author disclaims copyright to this source code. In place of
** a legal notice, here is a blessing:
**
** May you do good and not evil.
** May you find forgiveness for yourself and forgive others.
** May you share freely, never taking more than you give.
**
*************************************************************************
** This header file defines the SQLite interface for use by
** shared libraries that want to be imported as extensions into
** an SQLite instance. Shared libraries that intend to be loaded
** as extensions by SQLite should #include this file instead of
** sqlite3.h.
*/
#ifndef SQLITE3EXT_H
#define SQLITE3EXT_H
#include "sqlite3.h"
/*
** The following structure holds pointers to all of the SQLite API
** routines.
**
** WARNING: In order to maintain backwards compatibility, add new
** interfaces to the end of this structure only. If you insert new
** interfaces in the middle of this structure, then older different
** versions of SQLite will not be able to load each other's shared
** libraries!
*/
struct sqlite3_api_routines {
void * (*aggregate_context)(sqlite3_context*,int nBytes);
int (*aggregate_count)(sqlite3_context*);
int (*bind_blob)(sqlite3_stmt*,int,const void*,int n,void(*)(void*));
int (*bind_double)(sqlite3_stmt*,int,double);
int (*bind_int)(sqlite3_stmt*,int,int);
int (*bind_int64)(sqlite3_stmt*,int,sqlite_int64);
int (*bind_null)(sqlite3_stmt*,int);
int (*bind_parameter_count)(sqlite3_stmt*);
int (*bind_parameter_index)(sqlite3_stmt*,const char*zName);
const char * (*bind_parameter_name)(sqlite3_stmt*,int);
int (*bind_text)(sqlite3_stmt*,int,const char*,int n,void(*)(void*));
int (*bind_text16)(sqlite3_stmt*,int,const void*,int,void(*)(void*));
int (*bind_value)(sqlite3_stmt*,int,const sqlite3_value*);
int (*busy_handler)(sqlite3*,int(*)(void*,int),void*);
int (*busy_timeout)(sqlite3*,int ms);
int (*changes)(sqlite3*);
int (*close)(sqlite3*);
int (*collation_needed)(sqlite3*,void*,void(*)(void*,sqlite3*,
int eTextRep,const char*));
int (*collation_needed16)(sqlite3*,void*,void(*)(void*,sqlite3*,
int eTextRep,const void*));
const void * (*column_blob)(sqlite3_stmt*,int iCol);
int (*column_bytes)(sqlite3_stmt*,int iCol);
int (*column_bytes16)(sqlite3_stmt*,int iCol);
int (*column_count)(sqlite3_stmt*pStmt);
const char * (*column_database_name)(sqlite3_stmt*,int);
const void * (*column_database_name16)(sqlite3_stmt*,int);
const char * (*column_decltype)(sqlite3_stmt*,int i);
const void * (*column_decltype16)(sqlite3_stmt*,int);
double (*column_double)(sqlite3_stmt*,int iCol);
int (*column_int)(sqlite3_stmt*,int iCol);
sqlite_int64 (*column_int64)(sqlite3_stmt*,int iCol);
const char * (*column_name)(sqlite3_stmt*,int);
const void * (*column_name16)(sqlite3_stmt*,int);
const char * (*column_origin_name)(sqlite3_stmt*,int);
const void * (*column_origin_name16)(sqlite3_stmt*,int);
const char * (*column_table_name)(sqlite3_stmt*,int);
const void * (*column_table_name16)(sqlite3_stmt*,int);
const unsigned char * (*column_text)(sqlite3_stmt*,int iCol);
const void * (*column_text16)(sqlite3_stmt*,int iCol);
int (*column_type)(sqlite3_stmt*,int iCol);
sqlite3_value* (*column_value)(sqlite3_stmt*,int iCol);
void * (*commit_hook)(sqlite3*,int(*)(void*),void*);
int (*complete)(const char*sql);
int (*complete16)(const void*sql);
int (*create_collation)(sqlite3*,const char*,int,void*,
int(*)(void*,int,const void*,int,const void*));
int (*create_collation16)(sqlite3*,const void*,int,void*,
int(*)(void*,int,const void*,int,const void*));
int (*create_function)(sqlite3*,const char*,int,int,void*,
void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
void (*xStep)(sqlite3_context*,int,sqlite3_value**),
void (*xFinal)(sqlite3_context*));
int (*create_function16)(sqlite3*,const void*,int,int,void*,
void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
void (*xStep)(sqlite3_context*,int,sqlite3_value**),
void (*xFinal)(sqlite3_context*));
int (*create_module)(sqlite3*,const char*,const sqlite3_module*,void*);
int (*data_count)(sqlite3_stmt*pStmt);
sqlite3 * (*db_handle)(sqlite3_stmt*);
int (*declare_vtab)(sqlite3*,const char*);
int (*enable_shared_cache)(int);
int (*errcode)(sqlite3*db);
const char * (*errmsg)(sqlite3*);
const void * (*errmsg16)(sqlite3*);
int (*exec)(sqlite3*,const char*,sqlite3_callback,void*,char**);
int (*expired)(sqlite3_stmt*);
int (*finalize)(sqlite3_stmt*pStmt);
void (*free)(void*);
void (*free_table)(char**result);
int (*get_autocommit)(sqlite3*);
void * (*get_auxdata)(sqlite3_context*,int);
int (*get_table)(sqlite3*,const char*,char***,int*,int*,char**);
int (*global_recover)(void);
void (*interruptx)(sqlite3*);
sqlite_int64 (*last_insert_rowid)(sqlite3*);
const char * (*libversion)(void);
int (*libversion_number)(void);
void *(*malloc)(int);
char * (*mprintf)(const char*,...);
int (*open)(const char*,sqlite3**);
int (*open16)(const void*,sqlite3**);
int (*prepare)(sqlite3*,const char*,int,sqlite3_stmt**,const char**);
int (*prepare16)(sqlite3*,const void*,int,sqlite3_stmt**,const void**);
void * (*profile)(sqlite3*,void(*)(void*,const char*,sqlite_uint64),void*);
void (*progress_handler)(sqlite3*,int,int(*)(void*),void*);
void *(*realloc)(void*,int);
int (*reset)(sqlite3_stmt*pStmt);
void (*result_blob)(sqlite3_context*,const void*,int,void(*)(void*));
void (*result_double)(sqlite3_context*,double);
void (*result_error)(sqlite3_context*,const char*,int);
void (*result_error16)(sqlite3_context*,const void*,int);
void (*result_int)(sqlite3_context*,int);
void (*result_int64)(sqlite3_context*,sqlite_int64);
void (*result_null)(sqlite3_context*);
void (*result_text)(sqlite3_context*,const char*,int,void(*)(void*));
void (*result_text16)(sqlite3_context*,const void*,int,void(*)(void*));
void (*result_text16be)(sqlite3_context*,const void*,int,void(*)(void*));
void (*result_text16le)(sqlite3_context*,const void*,int,void(*)(void*));
void (*result_value)(sqlite3_context*,sqlite3_value*);
void * (*rollback_hook)(sqlite3*,void(*)(void*),void*);
int (*set_authorizer)(sqlite3*,int(*)(void*,int,const char*,const char*,
const char*,const char*),void*);
void (*set_auxdata)(sqlite3_context*,int,void*,void (*)(void*));
char * (*xsnprintf)(int,char*,const char*,...);
int (*step)(sqlite3_stmt*);
int (*table_column_metadata)(sqlite3*,const char*,const char*,const char*,
char const**,char const**,int*,int*,int*);
void (*thread_cleanup)(void);
int (*total_changes)(sqlite3*);
void * (*trace)(sqlite3*,void(*xTrace)(void*,const char*),void*);
int (*transfer_bindings)(sqlite3_stmt*,sqlite3_stmt*);
void * (*update_hook)(sqlite3*,void(*)(void*,int ,char const*,char const*,
sqlite_int64),void*);
void * (*user_data)(sqlite3_context*);
const void * (*value_blob)(sqlite3_value*);
int (*value_bytes)(sqlite3_value*);
int (*value_bytes16)(sqlite3_value*);
double (*value_double)(sqlite3_value*);
int (*value_int)(sqlite3_value*);
sqlite_int64 (*value_int64)(sqlite3_value*);
int (*value_numeric_type)(sqlite3_value*);
const unsigned char * (*value_text)(sqlite3_value*);
const void * (*value_text16)(sqlite3_value*);
const void * (*value_text16be)(sqlite3_value*);
const void * (*value_text16le)(sqlite3_value*);
int (*value_type)(sqlite3_value*);
char *(*vmprintf)(const char*,va_list);
/* Added ??? */
int (*overload_function)(sqlite3*, const char *zFuncName, int nArg);
/* Added by 3.3.13 */
int (*prepare_v2)(sqlite3*,const char*,int,sqlite3_stmt**,const char**);
int (*prepare16_v2)(sqlite3*,const void*,int,sqlite3_stmt**,const void**);
int (*clear_bindings)(sqlite3_stmt*);
/* Added by 3.4.1 */
int (*create_module_v2)(sqlite3*,const char*,const sqlite3_module*,void*,
void (*xDestroy)(void *));
/* Added by 3.5.0 */
int (*bind_zeroblob)(sqlite3_stmt*,int,int);
int (*blob_bytes)(sqlite3_blob*);
int (*blob_close)(sqlite3_blob*);
int (*blob_open)(sqlite3*,const char*,const char*,const char*,sqlite3_int64,
int,sqlite3_blob**);
int (*blob_read)(sqlite3_blob*,void*,int,int);
int (*blob_write)(sqlite3_blob*,const void*,int,int);
int (*create_collation_v2)(sqlite3*,const char*,int,void*,
int(*)(void*,int,const void*,int,const void*),
void(*)(void*));
int (*file_control)(sqlite3*,const char*,int,void*);
sqlite3_int64 (*memory_highwater)(int);
sqlite3_int64 (*memory_used)(void);
sqlite3_mutex *(*mutex_alloc)(int);
void (*mutex_enter)(sqlite3_mutex*);
void (*mutex_free)(sqlite3_mutex*);
void (*mutex_leave)(sqlite3_mutex*);
int (*mutex_try)(sqlite3_mutex*);
int (*open_v2)(const char*,sqlite3**,int,const char*);
int (*release_memory)(int);
void (*result_error_nomem)(sqlite3_context*);
void (*result_error_toobig)(sqlite3_context*);
int (*sleep)(int);
void (*soft_heap_limit)(int);
sqlite3_vfs *(*vfs_find)(const char*);
int (*vfs_register)(sqlite3_vfs*,int);
int (*vfs_unregister)(sqlite3_vfs*);
int (*xthreadsafe)(void);
void (*result_zeroblob)(sqlite3_context*,int);
void (*result_error_code)(sqlite3_context*,int);
int (*test_control)(int, ...);
void (*randomness)(int,void*);
sqlite3 *(*context_db_handle)(sqlite3_context*);
int (*extended_result_codes)(sqlite3*,int);
int (*limit)(sqlite3*,int,int);
sqlite3_stmt *(*next_stmt)(sqlite3*,sqlite3_stmt*);
const char *(*sql)(sqlite3_stmt*);
int (*status)(int,int*,int*,int);
int (*backup_finish)(sqlite3_backup*);
sqlite3_backup *(*backup_init)(sqlite3*,const char*,sqlite3*,const char*);
int (*backup_pagecount)(sqlite3_backup*);
int (*backup_remaining)(sqlite3_backup*);
int (*backup_step)(sqlite3_backup*,int);
const char *(*compileoption_get)(int);
int (*compileoption_used)(const char*);
int (*create_function_v2)(sqlite3*,const char*,int,int,void*,
void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
void (*xStep)(sqlite3_context*,int,sqlite3_value**),
void (*xFinal)(sqlite3_context*),
void(*xDestroy)(void*));
int (*db_config)(sqlite3*,int,...);
sqlite3_mutex *(*db_mutex)(sqlite3*);
int (*db_status)(sqlite3*,int,int*,int*,int);
int (*extended_errcode)(sqlite3*);
void (*log)(int,const char*,...);
sqlite3_int64 (*soft_heap_limit64)(sqlite3_int64);
const char *(*sourceid)(void);
int (*stmt_status)(sqlite3_stmt*,int,int);
int (*strnicmp)(const char*,const char*,int);
int (*unlock_notify)(sqlite3*,void(*)(void**,int),void*);
int (*wal_autocheckpoint)(sqlite3*,int);
int (*wal_checkpoint)(sqlite3*,const char*);
void *(*wal_hook)(sqlite3*,int(*)(void*,sqlite3*,const char*,int),void*);
int (*blob_reopen)(sqlite3_blob*,sqlite3_int64);
int (*vtab_config)(sqlite3*,int op,...);
int (*vtab_on_conflict)(sqlite3*);
/* Version 3.7.16 and later */
int (*close_v2)(sqlite3*);
const char *(*db_filename)(sqlite3*,const char*);
int (*db_readonly)(sqlite3*,const char*);
int (*db_release_memory)(sqlite3*);
const char *(*errstr)(int);
int (*stmt_busy)(sqlite3_stmt*);
int (*stmt_readonly)(sqlite3_stmt*);
int (*stricmp)(const char*,const char*);
int (*uri_boolean)(const char*,const char*,int);
sqlite3_int64 (*uri_int64)(const char*,const char*,sqlite3_int64);
const char *(*uri_parameter)(const char*,const char*);
char *(*xvsnprintf)(int,char*,const char*,va_list);
int (*wal_checkpoint_v2)(sqlite3*,const char*,int,int*,int*);
/* Version 3.8.7 and later */
int (*auto_extension)(void(*)(void));
int (*bind_blob64)(sqlite3_stmt*,int,const void*,sqlite3_uint64,
void(*)(void*));
int (*bind_text64)(sqlite3_stmt*,int,const char*,sqlite3_uint64,
void(*)(void*),unsigned char);
int (*cancel_auto_extension)(void(*)(void));
int (*load_extension)(sqlite3*,const char*,const char*,char**);
void *(*malloc64)(sqlite3_uint64);
sqlite3_uint64 (*msize)(void*);
void *(*realloc64)(void*,sqlite3_uint64);
void (*reset_auto_extension)(void);
void (*result_blob64)(sqlite3_context*,const void*,sqlite3_uint64,
void(*)(void*));
void (*result_text64)(sqlite3_context*,const char*,sqlite3_uint64,
void(*)(void*), unsigned char);
int (*strglob)(const char*,const char*);
/* Version 3.8.11 and later */
sqlite3_value *(*value_dup)(const sqlite3_value*);
void (*value_free)(sqlite3_value*);
int (*result_zeroblob64)(sqlite3_context*,sqlite3_uint64);
int (*bind_zeroblob64)(sqlite3_stmt*, int, sqlite3_uint64);
/* Version 3.9.0 and later */
unsigned int (*value_subtype)(sqlite3_value*);
void (*result_subtype)(sqlite3_context*,unsigned int);
/* Version 3.10.0 and later */
int (*status64)(int,sqlite3_int64*,sqlite3_int64*,int);
int (*strlike)(const char*,const char*,unsigned int);
int (*db_cacheflush)(sqlite3*);
/* Version 3.12.0 and later */
int (*system_errno)(sqlite3*);
/* Version 3.14.0 and later */
int (*trace_v2)(sqlite3*,unsigned,int(*)(unsigned,void*,void*,void*),void*);
char *(*expanded_sql)(sqlite3_stmt*);
/* Version 3.18.0 and later */
void (*set_last_insert_rowid)(sqlite3*,sqlite3_int64);
/* Version 3.20.0 and later */
int (*prepare_v3)(sqlite3*,const char*,int,unsigned int,
sqlite3_stmt**,const char**);
int (*prepare16_v3)(sqlite3*,const void*,int,unsigned int,
sqlite3_stmt**,const void**);
int (*bind_pointer)(sqlite3_stmt*,int,void*,const char*,void(*)(void*));
void (*result_pointer)(sqlite3_context*,void*,const char*,void(*)(void*));
void *(*value_pointer)(sqlite3_value*,const char*);
int (*vtab_nochange)(sqlite3_context*);
int (*value_nochange)(sqlite3_value*);
const char *(*vtab_collation)(sqlite3_index_info*,int);
/* Version 3.24.0 and later */
int (*keyword_count)(void);
int (*keyword_name)(int,const char**,int*);
int (*keyword_check)(const char*,int);
sqlite3_str *(*str_new)(sqlite3*);
char *(*str_finish)(sqlite3_str*);
void (*str_appendf)(sqlite3_str*, const char *zFormat, ...);
void (*str_vappendf)(sqlite3_str*, const char *zFormat, va_list);
void (*str_append)(sqlite3_str*, const char *zIn, int N);
void (*str_appendall)(sqlite3_str*, const char *zIn);
void (*str_appendchar)(sqlite3_str*, int N, char C);
void (*str_reset)(sqlite3_str*);
int (*str_errcode)(sqlite3_str*);
int (*str_length)(sqlite3_str*);
char *(*str_value)(sqlite3_str*);
/* Version 3.25.0 and later */
int (*create_window_function)(sqlite3*,const char*,int,int,void*,
void (*xStep)(sqlite3_context*,int,sqlite3_value**),
void (*xFinal)(sqlite3_context*),
void (*xValue)(sqlite3_context*),
void (*xInv)(sqlite3_context*,int,sqlite3_value**),
void(*xDestroy)(void*));
/* Version 3.26.0 and later */
const char *(*normalized_sql)(sqlite3_stmt*);
/* Version 3.28.0 and later */
int (*stmt_isexplain)(sqlite3_stmt*);
int (*value_frombind)(sqlite3_value*);
/* Version 3.30.0 and later */
int (*drop_modules)(sqlite3*,const char**);
/* Version 3.31.0 and later */
sqlite3_int64 (*hard_heap_limit64)(sqlite3_int64);
const char *(*uri_key)(const char*,int);
const char *(*filename_database)(const char*);
const char *(*filename_journal)(const char*);
const char *(*filename_wal)(const char*);
/* Version 3.32.0 and later */
char *(*create_filename)(const char*,const char*,const char*,
int,const char**);
void (*free_filename)(char*);
sqlite3_file *(*database_file_object)(const char*);
};
/*
** This is the function signature used for all extension entry points. It
** is also defined in the file "loadext.c".
*/
typedef int (*sqlite3_loadext_entry)(
sqlite3 *db, /* Handle to the database. */
char **pzErrMsg, /* Used to set error string on failure. */
const sqlite3_api_routines *pThunk /* Extension API function pointers. */
);
/*
** The following macros redefine the API routines so that they are
** redirected through the global sqlite3_api structure.
**
** This header file is also used by the loadext.c source file
** (part of the main SQLite library - not an extension) so that
** it can get access to the sqlite3_api_routines structure
** definition. But the main library does not want to redefine
** the API. So the redefinition macros are only valid if the
** SQLITE_CORE macros is undefined.
*/
#if !defined(SQLITE_CORE) && !defined(SQLITE_OMIT_LOAD_EXTENSION)
#define sqlite3_aggregate_context sqlite3_api->aggregate_context
#ifndef SQLITE_OMIT_DEPRECATED
#define sqlite3_aggregate_count sqlite3_api->aggregate_count
#endif
#define sqlite3_bind_blob sqlite3_api->bind_blob
#define sqlite3_bind_double sqlite3_api->bind_double
#define sqlite3_bind_int sqlite3_api->bind_int
#define sqlite3_bind_int64 sqlite3_api->bind_int64
#define sqlite3_bind_null sqlite3_api->bind_null
#define sqlite3_bind_parameter_count sqlite3_api->bind_parameter_count
#define sqlite3_bind_parameter_index sqlite3_api->bind_parameter_index
#define sqlite3_bind_parameter_name sqlite3_api->bind_parameter_name
#define sqlite3_bind_text sqlite3_api->bind_text
#define sqlite3_bind_text16 sqlite3_api->bind_text16
#define sqlite3_bind_value sqlite3_api->bind_value
#define sqlite3_busy_handler sqlite3_api->busy_handler
#define sqlite3_busy_timeout sqlite3_api->busy_timeout
#define sqlite3_changes sqlite3_api->changes
#define sqlite3_close sqlite3_api->close
#define sqlite3_collation_needed sqlite3_api->collation_needed
#define sqlite3_collation_needed16 sqlite3_api->collation_needed16
#define sqlite3_column_blob sqlite3_api->column_blob
#define sqlite3_column_bytes sqlite3_api->column_bytes
#define sqlite3_column_bytes16 sqlite3_api->column_bytes16
#define sqlite3_column_count sqlite3_api->column_count
#define sqlite3_column_database_name sqlite3_api->column_database_name
#define sqlite3_column_database_name16 sqlite3_api->column_database_name16
#define sqlite3_column_decltype sqlite3_api->column_decltype
#define sqlite3_column_decltype16 sqlite3_api->column_decltype16
#define sqlite3_column_double sqlite3_api->column_double
#define sqlite3_column_int sqlite3_api->column_int
#define sqlite3_column_int64 sqlite3_api->column_int64
#define sqlite3_column_name sqlite3_api->column_name
#define sqlite3_column_name16 sqlite3_api->column_name16
#define sqlite3_column_origin_name sqlite3_api->column_origin_name
#define sqlite3_column_origin_name16 sqlite3_api->column_origin_name16
#define sqlite3_column_table_name sqlite3_api->column_table_name
#define sqlite3_column_table_name16 sqlite3_api->column_table_name16
#define sqlite3_column_text sqlite3_api->column_text
#define sqlite3_column_text16 sqlite3_api->column_text16
#define sqlite3_column_type sqlite3_api->column_type
#define sqlite3_column_value sqlite3_api->column_value
#define sqlite3_commit_hook sqlite3_api->commit_hook
#define sqlite3_complete sqlite3_api->complete
#define sqlite3_complete16 sqlite3_api->complete16
#define sqlite3_create_collation sqlite3_api->create_collation
#define sqlite3_create_collation16 sqlite3_api->create_collation16
#define sqlite3_create_function sqlite3_api->create_function
#define sqlite3_create_function16 sqlite3_api->create_function16
#define sqlite3_create_module sqlite3_api->create_module
#define sqlite3_create_module_v2 sqlite3_api->create_module_v2
#define sqlite3_data_count sqlite3_api->data_count
#define sqlite3_db_handle sqlite3_api->db_handle
#define sqlite3_declare_vtab sqlite3_api->declare_vtab
#define sqlite3_enable_shared_cache sqlite3_api->enable_shared_cache
#define sqlite3_errcode sqlite3_api->errcode
#define sqlite3_errmsg sqlite3_api->errmsg
#define sqlite3_errmsg16 sqlite3_api->errmsg16
#define sqlite3_exec sqlite3_api->exec
#ifndef SQLITE_OMIT_DEPRECATED
#define sqlite3_expired sqlite3_api->expired
#endif
#define sqlite3_finalize sqlite3_api->finalize
#define sqlite3_free sqlite3_api->free
#define sqlite3_free_table sqlite3_api->free_table
#define sqlite3_get_autocommit sqlite3_api->get_autocommit
#define sqlite3_get_auxdata sqlite3_api->get_auxdata
#define sqlite3_get_table sqlite3_api->get_table
#ifndef SQLITE_OMIT_DEPRECATED
#define sqlite3_global_recover sqlite3_api->global_recover
#endif
#define sqlite3_interrupt sqlite3_api->interruptx
#define sqlite3_last_insert_rowid sqlite3_api->last_insert_rowid
#define sqlite3_libversion sqlite3_api->libversion
#define sqlite3_libversion_number sqlite3_api->libversion_number
#define sqlite3_malloc sqlite3_api->malloc
#define sqlite3_mprintf sqlite3_api->mprintf
#define sqlite3_open sqlite3_api->open
#define sqlite3_open16 sqlite3_api->open16
#define sqlite3_prepare sqlite3_api->prepare
#define sqlite3_prepare16 sqlite3_api->prepare16
#define sqlite3_prepare_v2 sqlite3_api->prepare_v2
#define sqlite3_prepare16_v2 sqlite3_api->prepare16_v2
#define sqlite3_profile sqlite3_api->profile
#define sqlite3_progress_handler sqlite3_api->progress_handler
#define sqlite3_realloc sqlite3_api->realloc
#define sqlite3_reset sqlite3_api->reset
#define sqlite3_result_blob sqlite3_api->result_blob
#define sqlite3_result_double sqlite3_api->result_double
#define sqlite3_result_error sqlite3_api->result_error
#define sqlite3_result_error16 sqlite3_api->result_error16
#define sqlite3_result_int sqlite3_api->result_int
#define sqlite3_result_int64 sqlite3_api->result_int64
#define sqlite3_result_null sqlite3_api->result_null
#define sqlite3_result_text sqlite3_api->result_text
#define sqlite3_result_text16 sqlite3_api->result_text16
#define sqlite3_result_text16be sqlite3_api->result_text16be
#define sqlite3_result_text16le sqlite3_api->result_text16le
#define sqlite3_result_value sqlite3_api->result_value
#define sqlite3_rollback_hook sqlite3_api->rollback_hook
#define sqlite3_set_authorizer sqlite3_api->set_authorizer
#define sqlite3_set_auxdata sqlite3_api->set_auxdata
#define sqlite3_snprintf sqlite3_api->xsnprintf
#define sqlite3_step sqlite3_api->step
#define sqlite3_table_column_metadata sqlite3_api->table_column_metadata
#define sqlite3_thread_cleanup sqlite3_api->thread_cleanup
#define sqlite3_total_changes sqlite3_api->total_changes
#define sqlite3_trace sqlite3_api->trace
#ifndef SQLITE_OMIT_DEPRECATED
#define sqlite3_transfer_bindings sqlite3_api->transfer_bindings
#endif
#define sqlite3_update_hook sqlite3_api->update_hook
#define sqlite3_user_data sqlite3_api->user_data
#define sqlite3_value_blob sqlite3_api->value_blob
#define sqlite3_value_bytes sqlite3_api->value_bytes
#define sqlite3_value_bytes16 sqlite3_api->value_bytes16
#define sqlite3_value_double sqlite3_api->value_double
#define sqlite3_value_int sqlite3_api->value_int
#define sqlite3_value_int64 sqlite3_api->value_int64
#define sqlite3_value_numeric_type sqlite3_api->value_numeric_type
#define sqlite3_value_text sqlite3_api->value_text
#define sqlite3_value_text16 sqlite3_api->value_text16
#define sqlite3_value_text16be sqlite3_api->value_text16be
#define sqlite3_value_text16le sqlite3_api->value_text16le
#define sqlite3_value_type sqlite3_api->value_type
#define sqlite3_vmprintf sqlite3_api->vmprintf
#define sqlite3_vsnprintf sqlite3_api->xvsnprintf
#define sqlite3_overload_function sqlite3_api->overload_function
#define sqlite3_prepare_v2 sqlite3_api->prepare_v2
#define sqlite3_prepare16_v2 sqlite3_api->prepare16_v2
#define sqlite3_clear_bindings sqlite3_api->clear_bindings
#define sqlite3_bind_zeroblob sqlite3_api->bind_zeroblob
#define sqlite3_blob_bytes sqlite3_api->blob_bytes
#define sqlite3_blob_close sqlite3_api->blob_close
#define sqlite3_blob_open sqlite3_api->blob_open
#define sqlite3_blob_read sqlite3_api->blob_read
#define sqlite3_blob_write sqlite3_api->blob_write
#define sqlite3_create_collation_v2 sqlite3_api->create_collation_v2
#define sqlite3_file_control sqlite3_api->file_control
#define sqlite3_memory_highwater sqlite3_api->memory_highwater
#define sqlite3_memory_used sqlite3_api->memory_used
#define sqlite3_mutex_alloc sqlite3_api->mutex_alloc
#define sqlite3_mutex_enter sqlite3_api->mutex_enter
#define sqlite3_mutex_free sqlite3_api->mutex_free
#define sqlite3_mutex_leave sqlite3_api->mutex_leave
#define sqlite3_mutex_try sqlite3_api->mutex_try
#define sqlite3_open_v2 sqlite3_api->open_v2
#define sqlite3_release_memory sqlite3_api->release_memory
#define sqlite3_result_error_nomem sqlite3_api->result_error_nomem
#define sqlite3_result_error_toobig sqlite3_api->result_error_toobig
#define sqlite3_sleep sqlite3_api->sleep
#define sqlite3_soft_heap_limit sqlite3_api->soft_heap_limit
#define sqlite3_vfs_find sqlite3_api->vfs_find
#define sqlite3_vfs_register sqlite3_api->vfs_register
#define sqlite3_vfs_unregister sqlite3_api->vfs_unregister
#define sqlite3_threadsafe sqlite3_api->xthreadsafe
#define sqlite3_result_zeroblob sqlite3_api->result_zeroblob
#define sqlite3_result_error_code sqlite3_api->result_error_code
#define sqlite3_test_control sqlite3_api->test_control
#define sqlite3_randomness sqlite3_api->randomness
#define sqlite3_context_db_handle sqlite3_api->context_db_handle
#define sqlite3_extended_result_codes sqlite3_api->extended_result_codes
#define sqlite3_limit sqlite3_api->limit
#define sqlite3_next_stmt sqlite3_api->next_stmt
#define sqlite3_sql sqlite3_api->sql
#define sqlite3_status sqlite3_api->status
#define sqlite3_backup_finish sqlite3_api->backup_finish
#define sqlite3_backup_init sqlite3_api->backup_init
#define sqlite3_backup_pagecount sqlite3_api->backup_pagecount
#define sqlite3_backup_remaining sqlite3_api->backup_remaining
#define sqlite3_backup_step sqlite3_api->backup_step
#define sqlite3_compileoption_get sqlite3_api->compileoption_get
#define sqlite3_compileoption_used sqlite3_api->compileoption_used
#define sqlite3_create_function_v2 sqlite3_api->create_function_v2
#define sqlite3_db_config sqlite3_api->db_config
#define sqlite3_db_mutex sqlite3_api->db_mutex
#define sqlite3_db_status sqlite3_api->db_status
#define sqlite3_extended_errcode sqlite3_api->extended_errcode
#define sqlite3_log sqlite3_api->log
#define sqlite3_soft_heap_limit64 sqlite3_api->soft_heap_limit64
#define sqlite3_sourceid sqlite3_api->sourceid
#define sqlite3_stmt_status sqlite3_api->stmt_status
#define sqlite3_strnicmp sqlite3_api->strnicmp
#define sqlite3_unlock_notify sqlite3_api->unlock_notify
#define sqlite3_wal_autocheckpoint sqlite3_api->wal_autocheckpoint
#define sqlite3_wal_checkpoint sqlite3_api->wal_checkpoint
#define sqlite3_wal_hook sqlite3_api->wal_hook
#define sqlite3_blob_reopen sqlite3_api->blob_reopen
#define sqlite3_vtab_config sqlite3_api->vtab_config
#define sqlite3_vtab_on_conflict sqlite3_api->vtab_on_conflict
/* Version 3.7.16 and later */
#define sqlite3_close_v2 sqlite3_api->close_v2
#define sqlite3_db_filename sqlite3_api->db_filename
#define sqlite3_db_readonly sqlite3_api->db_readonly
#define sqlite3_db_release_memory sqlite3_api->db_release_memory
#define sqlite3_errstr sqlite3_api->errstr
#define sqlite3_stmt_busy sqlite3_api->stmt_busy
#define sqlite3_stmt_readonly sqlite3_api->stmt_readonly
#define sqlite3_stricmp sqlite3_api->stricmp
#define sqlite3_uri_boolean sqlite3_api->uri_boolean
#define sqlite3_uri_int64 sqlite3_api->uri_int64
#define sqlite3_uri_parameter sqlite3_api->uri_parameter
#define sqlite3_uri_vsnprintf sqlite3_api->xvsnprintf
#define sqlite3_wal_checkpoint_v2 sqlite3_api->wal_checkpoint_v2
/* Version 3.8.7 and later */
#define sqlite3_auto_extension sqlite3_api->auto_extension
#define sqlite3_bind_blob64 sqlite3_api->bind_blob64
#define sqlite3_bind_text64 sqlite3_api->bind_text64
#define sqlite3_cancel_auto_extension sqlite3_api->cancel_auto_extension
#define sqlite3_load_extension sqlite3_api->load_extension
#define sqlite3_malloc64 sqlite3_api->malloc64
#define sqlite3_msize sqlite3_api->msize
#define sqlite3_realloc64 sqlite3_api->realloc64
#define sqlite3_reset_auto_extension sqlite3_api->reset_auto_extension
#define sqlite3_result_blob64 sqlite3_api->result_blob64
#define sqlite3_result_text64 sqlite3_api->result_text64
#define sqlite3_strglob sqlite3_api->strglob
/* Version 3.8.11 and later */
#define sqlite3_value_dup sqlite3_api->value_dup
#define sqlite3_value_free sqlite3_api->value_free
#define sqlite3_result_zeroblob64 sqlite3_api->result_zeroblob64
#define sqlite3_bind_zeroblob64 sqlite3_api->bind_zeroblob64
/* Version 3.9.0 and later */
#define sqlite3_value_subtype sqlite3_api->value_subtype
#define sqlite3_result_subtype sqlite3_api->result_subtype
/* Version 3.10.0 and later */
#define sqlite3_status64 sqlite3_api->status64
#define sqlite3_strlike sqlite3_api->strlike
#define sqlite3_db_cacheflush sqlite3_api->db_cacheflush
/* Version 3.12.0 and later */
#define sqlite3_system_errno sqlite3_api->system_errno
/* Version 3.14.0 and later */
#define sqlite3_trace_v2 sqlite3_api->trace_v2
#define sqlite3_expanded_sql sqlite3_api->expanded_sql
/* Version 3.18.0 and later */
#define sqlite3_set_last_insert_rowid sqlite3_api->set_last_insert_rowid
/* Version 3.20.0 and later */
#define sqlite3_prepare_v3 sqlite3_api->prepare_v3
#define sqlite3_prepare16_v3 sqlite3_api->prepare16_v3
#define sqlite3_bind_pointer sqlite3_api->bind_pointer
#define sqlite3_result_pointer sqlite3_api->result_pointer
#define sqlite3_value_pointer sqlite3_api->value_pointer
/* Version 3.22.0 and later */
#define sqlite3_vtab_nochange sqlite3_api->vtab_nochange
#define sqlite3_value_nochange sqlite3_api->value_nochange
#define sqlite3_vtab_collation sqlite3_api->vtab_collation
/* Version 3.24.0 and later */
#define sqlite3_keyword_count sqlite3_api->keyword_count
#define sqlite3_keyword_name sqlite3_api->keyword_name
#define sqlite3_keyword_check sqlite3_api->keyword_check
#define sqlite3_str_new sqlite3_api->str_new
#define sqlite3_str_finish sqlite3_api->str_finish
#define sqlite3_str_appendf sqlite3_api->str_appendf
#define sqlite3_str_vappendf sqlite3_api->str_vappendf
#define sqlite3_str_append sqlite3_api->str_append
#define sqlite3_str_appendall sqlite3_api->str_appendall
#define sqlite3_str_appendchar sqlite3_api->str_appendchar
#define sqlite3_str_reset sqlite3_api->str_reset
#define sqlite3_str_errcode sqlite3_api->str_errcode
#define sqlite3_str_length sqlite3_api->str_length
#define sqlite3_str_value sqlite3_api->str_value
/* Version 3.25.0 and later */
#define sqlite3_create_window_function sqlite3_api->create_window_function
/* Version 3.26.0 and later */
#define sqlite3_normalized_sql sqlite3_api->normalized_sql
/* Version 3.28.0 and later */
#define sqlite3_stmt_isexplain sqlite3_api->stmt_isexplain
#define sqlite3_value_frombind sqlite3_api->value_frombind
/* Version 3.30.0 and later */
#define sqlite3_drop_modules sqlite3_api->drop_modules
/* Version 3.31.0 and later */
#define sqlite3_hard_heap_limit64 sqlite3_api->hard_heap_limit64
#define sqlite3_uri_key sqlite3_api->uri_key
#define sqlite3_filename_database sqlite3_api->filename_database
#define sqlite3_filename_journal sqlite3_api->filename_journal
#define sqlite3_filename_wal sqlite3_api->filename_wal
/* Version 3.32.0 and later */
#define sqlite3_create_filename sqlite3_api->create_filename
#define sqlite3_free_filename sqlite3_api->free_filename
#define sqlite3_database_file_object sqlite3_api->database_file_object
#endif /* !defined(SQLITE_CORE) && !defined(SQLITE_OMIT_LOAD_EXTENSION) */
#if !defined(SQLITE_CORE) && !defined(SQLITE_OMIT_LOAD_EXTENSION)
/* This case when the file really is being compiled as a loadable
** extension */
# define SQLITE_EXTENSION_INIT1 const sqlite3_api_routines *sqlite3_api=0;
# define SQLITE_EXTENSION_INIT2(v) sqlite3_api=v;
# define SQLITE_EXTENSION_INIT3 \
extern const sqlite3_api_routines *sqlite3_api;
#else
/* This case when the file is being statically linked into the
** application */
# define SQLITE_EXTENSION_INIT1 /*no-op*/
# define SQLITE_EXTENSION_INIT2(v) (void)v; /* unused parameter */
# define SQLITE_EXTENSION_INIT3 /*no-op*/
#endif
#endif /* SQLITE3EXT_H */
midware/midware/dm/kk_dm_mng.c
View file @ a706052d
......@@ -502,7 +502,7 @@ int iotx_report_id(void)
return g_report_id++;
}
int dm_mgr_upstream_thing_property_post(_IN_ int devid, _IN_ char *payload, _IN_ int payload_len)
int dm_mgr_upstream_thing_property_post(_IN_ int devid, _IN_ char *payload, _IN_ int payload_len,_IN_ int isAsync)
{
int res = 0;
dm_msg_request_t request;
......@@ -522,7 +522,7 @@ int dm_mgr_upstream_thing_property_post(_IN_ int devid, _IN_ char *payload, _IN_
//request.callback = dm_client_thing_event_post_reply;
/* Send Message To Cloud */
res = dm_msg_request(&request);
res = dm_msg_request(&request,isAsync);
free(request.msgTypeStr);
free(request.params);
return res;
......@@ -549,7 +549,7 @@ int dm_mgr_upstream_thing_event_post(_IN_ int devid, _IN_ char *identifier, _IN_
//request.callback = dm_client_thing_event_post_reply;
/* Send Message To Cloud */
res = dm_msg_request(&request);
res = dm_msg_request(&request,0);
free(request.msgTypeStr);
free(request.params);
return res;
......@@ -669,7 +669,7 @@ int dm_mgr_upstream_thing_sub_register(_IN_ int devid)
//request.callback = dm_client_thing_sub_register_reply;
/* Send Message To Cloud */
res = dm_msg_request(&request);
res = dm_msg_request(&request,0);
if (res == SUCCESS_RETURN) {
res = request.msgid;
}
......@@ -723,7 +723,7 @@ int dm_mgr_upstream_thing_sub_unregister(_IN_ int devid)
/* Send Message To Cloud */
res = dm_msg_request(&request);
res = dm_msg_request(&request,0);
if (res == SUCCESS_RETURN) {
res = request.msgid;
......@@ -781,7 +781,7 @@ int dm_mgr_upstream_thing_topo_add(_IN_ int devid)
/* Send Message To Cloud */
res = dm_msg_request(&request);
res = dm_msg_request(&request,0);
if (res == SUCCESS_RETURN) {
res = request.msgid;
......@@ -838,7 +838,7 @@ int dm_mgr_upstream_thing_topo_delete(_IN_ int devid)
/* Send Message To Cloud */
res = dm_msg_request(&request);
res = dm_msg_request(&request,0);
if (res == SUCCESS_RETURN) {
res = request.msgid;
......@@ -882,7 +882,7 @@ int dm_mgr_upstream_thing_topo_get(void)
//request.callback = dm_client_thing_topo_get_reply;
/* Send Message To Cloud */
res = dm_msg_request(&request);
res = dm_msg_request(&request,0);
if (res == SUCCESS_RETURN) {
res = request.msgid;
}
......@@ -935,7 +935,7 @@ int dm_mgr_upstream_thing_list_found(_IN_ int devid)
//request.callback = dm_client_thing_list_found_reply;
/* Send Message To Cloud */
res = dm_msg_request(&request);
res = dm_msg_request(&request,0);
if (res == SUCCESS_RETURN) {
res = request.msgid;
}
......@@ -986,7 +986,7 @@ int dm_mgr_ccu_status_cloud(_IN_ int devid)
/* Send Message To Cloud */
res = dm_msg_request(&request);
res = dm_msg_request(&request,0);
if (res == SUCCESS_RETURN) {
res = request.msgid;
......@@ -1049,7 +1049,7 @@ int dm_mgr_upstream_status_online(_IN_ int devid)
/* Send Message To Cloud */
res = dm_msg_request(&request);
res = dm_msg_request(&request,0);
if (res == SUCCESS_RETURN) {
res = request.msgid;
......@@ -1109,7 +1109,7 @@ int dm_mgr_upstream_status_offline(_IN_ int devid)
/* Send Message To Cloud */
res = dm_msg_request(&request);
res = dm_msg_request(&request,0);
if (res == SUCCESS_RETURN) {
res = request.msgid;
......@@ -1165,7 +1165,7 @@ int dm_mgr_upstream_combine_login(_IN_ int devid)
/* Send Message To Cloud */
res = dm_msg_request(&request);
res = dm_msg_request(&request,0);
if (res == SUCCESS_RETURN) {
res = request.msgid;
......@@ -1220,7 +1220,7 @@ int dm_mgr_upstream_combine_logout(_IN_ int devid)
/* Send Message To Cloud */
/* Send Message To Cloud */
res = dm_msg_request(&request);
res = dm_msg_request(&request,0);
if (res == SUCCESS_RETURN) {
res = request.msgid;
......@@ -1273,7 +1273,7 @@ int dm_mgr_ota_report_version(_IN_ int devid, char *version)
/* Send Message To Cloud */
/* Send Message To Cloud */
res = dm_msg_request(&request);
res = dm_msg_request(&request,0);
if (res == SUCCESS_RETURN) {
res = request.msgid;
......@@ -1304,12 +1304,18 @@ int dm_mgr_subdev_delete(_IN_ char deviceCode[DEVICE_CODE_MAXLEN])
dm_mgr_dev_node_t *node = NULL;
INFO_PRINT("dm_mgr_subdev_delete deviceCode:%s\n",deviceCode);
res = kk_subDev_delete_by_dcode(deviceCode);//delete db data
res = kk_subDev_delete_by_dcode(deviceCode);//delete sub db data
if (res != SUCCESS_RETURN) {
ERROR_PRINT("ERROR [%s][%d] res:%d\n",__FUNCTION__,__LINE__,res);
return FAIL_RETURN;
}
res = kk_property_delete_by_dcode(deviceCode);//delete properties db data
if (res != SUCCESS_RETURN) {
ERROR_PRINT("ERROR [%s][%d] res:%d\n",__FUNCTION__,__LINE__,res);
return FAIL_RETURN;
}
res = dm_mgr_get_device_by_devicecode(deviceCode,&node);
if (res != SUCCESS_RETURN) {
ERROR_PRINT("ERROR [%s][%d] res:%d\n",__FUNCTION__,__LINE__,res);
......
midware/midware/dm/kk_dm_msg.c
View file @ a706052d
#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,int isAsync){
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);
if(isAsync){
dm_queue_msg_insert4(buf);
}else{
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,_IN_ int isAsync)
{
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,isAsync);
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,0);
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;
}
int dm_msg_thing_property_post_all(char *deviceCode)
{
int res = 0;
int nums = 0;
int idx = 0;
dm_mgr_dev_node_t *node = NULL;
if(deviceCode == NULL){
return FAIL_RETURN;
}
res = dm_mgr_get_device_by_devicecode(deviceCode, &node);
if (res != SUCCESS_RETURN) {
return FAIL_RETURN;
}
kk_tsl_post_property(node->devid,NULL,1);//here need async post
return SUCCESS_RETURN;
}
int dm_msg_thing_property_post_by_identify(char *deviceCode,cJSON *params)
{
int res = 0;
int nums = 0;
int idx = 0;
dm_mgr_dev_node_t *node = NULL;
kk_tsl_data_t *property = NULL;
cJSON *propertyItem = NULL;
if(params == NULL || deviceCode == NULL){
return FAIL_RETURN;
}
res = dm_mgr_get_device_by_devicecode(deviceCode, &node);
if (res != SUCCESS_RETURN) {
return FAIL_RETURN;
}
nums = node->dev_shadow->property_number;
for(idx = 0; idx < nums; idx++){
property = (kk_tsl_data_t *)(node->dev_shadow->properties + idx);
if(property == NULL){
continue;
}
propertyItem = cJSON_GetObjectItem(params, property->identifier);
if(propertyItem != NULL){
kk_tsl_post_property(node->devid,property->identifier,0);
}
}
return SUCCESS_RETURN;
}
midware/midware/dm/kk_linkkit.c
View file @ a706052d
......@@ -319,7 +319,7 @@ static void _iotx_linkkit_event_callback(iotx_dm_event_types_t type, char *data)
if(s_CloudStatus){
iotx_dm_dev_online(0);//first online,report the online status
usleep(200000);
kk_tsl_post_property(0,NULL);
kk_tsl_post_property(0,NULL,0);
}
}else if (strstr(typeJson->valuestring,KK_THING_OTA_DEVICE_UPGRADE)){
INFO_PRINT("ota upgrade... \n");
......
midware/midware/dm/kk_property_db.c
View file @ a706052d
......@@ -379,6 +379,29 @@ int kk_property_sync_values(const char *deviceCode)
return SUCCESS_RETURN;
}
int kk_property_delete_by_dcode(char deviceCode[DEVICE_CODE_MAXLEN])
{
const char *deleteCmd = "delete from PropertiesInfo where deviceCode = '%s';";
char *sqlCmd = NULL;
int rc = 0;
char *zErrMsg = 0;
kk_property_db_ctx_t *ctx = _kk_property_db_get_ctx();
_kk_property_db_lock();
sqlCmd = sqlite3_mprintf(deleteCmd,deviceCode);
INFO_PRINT("Table delete data sqlCmd:%s\n",sqlCmd);
rc = sqlite3_exec(ctx->pDb, sqlCmd, NULL, NULL, &zErrMsg);
if( rc != SQLITE_OK ){
ERROR_PRINT("SQL error: %s\n", zErrMsg);
sqlite3_free(zErrMsg);
}else{
INFO_PRINT("Table delete data successfully\n");
}
sqlite3_free(sqlCmd);
_kk_property_db_unlock();
return SUCCESS_RETURN;
}
......
midware/midware/dm/kk_sub_db.c
View file @ a706052d
......@@ -115,15 +115,16 @@ static int _kk_load_subDevice(void)
ctx->subDevNum++;
}
usleep(100000);
//如果为认证，需要认证
//再上线
// send the topc info
iotx_dm_subscribe(devId);
if(sqlite3_column_int(stmt, DB_DEVTYPE) == KK_DM_DEVICE_SUBDEV){
kk_property_sync_values(sqlite3_column_text(stmt, DB_DEVICECODE));
}
//sync the data from property db
kk_property_sync_values(sqlite3_column_text(stmt, DB_DEVICECODE));
kk_dm_ota_report_version(devId,sqlite3_column_text(stmt, DB_VERSION));//version
usleep(100000);
//post the property to cloud
dm_msg_thing_property_post_all(sqlite3_column_text(stmt, DB_DEVICECODE));
//kk_dm_ota_report_version(devId,sqlite3_column_text(stmt, DB_VERSION));//post version
//usleep(100000);
}
sqlite3_finalize(stmt);
......
midware/midware/midware.c
View file @ a706052d
......@@ -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){
......@@ -218,6 +222,7 @@ void kk_platMsg_handle(void* data, char* chalMark){
INFO_PRINT("save property and send to cloud \n");
char* outstr = cJSON_Print(payload);
kk_tsl_property_set_by_devicecode(info_dcode->valuestring, outstr, strlen(outstr)+1);
dm_msg_thing_property_post_by_identify(info_dcode->valuestring,jsonPay);
kk_property_db_update(info_dcode->valuestring);
free(outstr);
......@@ -458,7 +463,7 @@ void *udp_dispatch_yield(void *args){
memset(host_ip, 0, sizeof(host_ip));
memset(mac, 0, sizeof(mac));
memset(szOut, 0, sizeof(szOut));
HAL_Get_IP(host_ip,"ens33");
HAL_Get_IP(host_ip,NULL);
HAL_GetDevice_Code(device_code);
sprintf(szOut,"search_kk_ccu_ack|deviceCode=%s;ip=%s;port=%d",device_code,host_ip,16565);
......@@ -598,7 +603,7 @@ void *ccu_property_monitor(void *args)
}
if(needReport&&(kk_get_cloudstatus() == 1)){
needReport = 0;
kk_tsl_post_property(0,NULL);
kk_tsl_post_property(0,NULL,0);
}
sleep(time_second);
}
......
midware/tsl/tsl_handle/kk_tsl_api.c
View file @ a706052d
......@@ -1260,7 +1260,7 @@ int kk_tsl_property_set_by_devicecode(const char deviceCode[DEVICE_CODE_MAXLEN],
res = _kk_msg_property_set(devid, &request);
/* Response */
kk_tsl_post_property(devid,NULL);
//kk_tsl_post_property(devid,NULL);
#if 0
#define EVENT_ERROR_IDENTIFIER "Error"
......@@ -1317,7 +1317,7 @@ int kk_tsl_service_property_set(const char *topic, const char *payload, unsigned
res = _kk_msg_property_set(devid, &request);
/* Response */
kk_tsl_post_property(devid,NULL);
kk_tsl_post_property(devid,NULL,0);
#if 0
#define EVENT_ERROR_IDENTIFIER "Error"
......@@ -1468,7 +1468,7 @@ int kk_tsl_post_property_add(_IN_ void *handle, _IN_ char *identifier, _IN_ int
}
return ret;
}
static int kk_tsl_post_property_end(_IN_ void *handle)
static int kk_tsl_post_property_end(_IN_ void *handle,_IN_ int isAsync)
{
int res = 0;
char *payload = NULL;
......@@ -1485,7 +1485,7 @@ static int kk_tsl_post_property_end(_IN_ void *handle)
return MEMORY_NOT_ENOUGH;
}
INFO_PRINT("Post Payload, Length: %d, Payload: %s\n", strlen(payload), payload);
res = dm_mgr_upstream_thing_property_post(dapi_property->devid, payload, strlen(payload));
res = dm_mgr_upstream_thing_property_post(dapi_property->devid, payload, strlen(payload),isAsync);
lite_cjson_delete(dapi_property->lite);
free(dapi_property);
free(payload);
......@@ -1493,7 +1493,7 @@ static int kk_tsl_post_property_end(_IN_ void *handle)
return res;
}
int kk_tsl_post_property(int devId, const char *property_identifier)
int kk_tsl_post_property(int devId, const char *property_identifier,int isAsync)
{
int res = 0, msgid = 0, property_identifier_len = 0, post_property_reply = 0;
void *property_handle = NULL;
......@@ -1508,11 +1508,11 @@ int kk_tsl_post_property(int devId, const char *property_identifier)
property_identifier_len = (property_identifier) ? (strlen((char *)property_identifier)) : (0);
res = kk_tsl_post_property_add(property_handle, (char *)property_identifier, property_identifier_len);
if (res != SUCCESS_RETURN) {
kk_tsl_post_property_end(property_handle);
kk_tsl_post_property_end(property_handle,isAsync);
_kk_tsl_api_unlock();
return FAIL_RETURN;
}
res = kk_tsl_post_property_end(property_handle);
res = kk_tsl_post_property_end(property_handle,isAsync);
if (res < SUCCESS_RETURN) {
_kk_tsl_api_unlock();
return FAIL_RETURN;
......
midware/tsl/tsl_handle/kk_tsl_api.h
View file @ a706052d
......@@ -81,7 +81,7 @@ extern int kk_msg_uri_parse_pkdn(_IN_ char *uri, _IN_ int uri_len, _IN_ int star
_OU_ char productType[PRODUCT_TYPE_MAXLEN], _OU_ char deviceCode[DEVICE_CODE_MAXLEN]);
extern int kk_tsl_service_property_set(const char *topic, const char *payload, unsigned int payload_len,
void *context);
extern int kk_tsl_post_property(int devId, const char *property_identifier);
extern int kk_tsl_post_property(int devId, const char *property_identifier,int isAsync);
extern int kk_tsl_post_event(int devId, const char *event_identifier);
extern int kk_tsl_post_service(int devId, const char *service_identifier, int response_id,int code);
#endif
platform/zigbee/app/builder/Z3GatewayHost/rpc_api/src/rpc_interface_parse.c
View file @ a706052d
......@@ -349,6 +349,7 @@ int search_ccu(char devcode[33], char ip[16], int* port){
return -1;
}
printf("[%s] start search ccu!! \n", __FUNCTION__);
while (1)
{
if ((iSendbytes = sendto(sock, sendMessage, strlen(sendMessage)+1, 0, (struct sockaddr*)&Addrto, sizeof(struct sockaddr))) == -1)
......@@ -456,7 +457,6 @@ void* _msg_event_property_post(char ip[16], int port){
}
void ipcHandle(void)
{
char deviceCode[33] = {0};
......@@ -477,6 +477,8 @@ void ipcHandle(void)
jrpc_register_procedure(&my_server, rpc_table[i].func, rpc_table[i].name, NULL );
}
//send add gw to ccu
char* outbuf = _msg_topo_add();
if (strcmp(GW2CCU_PROTOCOL, "tcp") != 0){
......@@ -497,11 +499,32 @@ void ipcHandle(void)
kk_sendData2CCU(postmsg, strlen(postmsg));
free(postmsg);
}
if (kk_get_retry_num() > 20){
//discover ccu
search_ccu(deviceCode, ip, &port);
if(strcmp(GW2CCU_PROTOCOL, "tcp") == 0){
kk_tcp_client_init(ip, port, _cb);
}else{
//kk_ipc_init(IPC_PLAT2MID, _cb, macString/*GW_DEVICE_CODE*/, ip);
}
//send add gw to ccu
outbuf = _msg_topo_add();
if (outbuf == NULL){
printf("[%s] topo add msg failed, exit\n",__FUNCTION__);
return;
}
kk_sendData2CCU(outbuf, strlen(outbuf));
free(outbuf);
cnt = 0;
kk_reset_retry_num();
}
}
//jrpc_server_run(&my_server);
//jrpc_server_destroy(&my_server);
}
......
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