lixian
/
doubao_chat
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
doubao_chat/lib/net/libduer-device/modules/connagent/lightduer_ca.c

1459 lines
40 KiB
C
Raw Blame History

/**
* Copyright (2017) Baidu Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
// Author: Su Hao (suhao@baidu.com)
//
// Description: Provide the API for external applications.
#include "lightduer_ca.h"
#include "lightduer_timestamp.h"
#include "lightduer_lib.h"
#include "lightduer_coap_trace.h"
#include "lightduer_coap.h"
#include "lightduer_ca_conf.h"
#include "lightduer_mutex.h"
#include "lightduer_memory.h"
#include "lightduer_log.h"
#include "lightduer_ds_log_ca.h"
#include "lightduer_timestamp.h"
#include "baidu_json.h"
#define DUER_CONF_KEY_UUID "uuid"
#define DUER_CONF_KEY_TOKEN "token"
#define DUER_CONF_KEY_BINDTOKEN "bindToken"
#define DUER_CONF_KEY_HOST "serverAddr"
#define DUER_CONF_KEY_PORT_REG "lwm2mPort"
#define DUER_CONF_KEY_PORT_RPT "coapPort"
#define DUER_CONF_KEY_CERT "rsaCaCrt"
#define DUER_CONF_KEY_CUID "cuid"
#define DUER_CONF_KEY_BDUSS "bduss"
#define DUER_CONF_KEY_CLIENT_ID "clientId"
#define DUER_CONF_KEY_USER_AGENT "userAgent"
#define DUER_COAP_LIFETIME "3600"
#define DUER_SR_REG_PATH "reg_for_control"
#define DUER_REPORT_PATH "v1/device/data"
#define DUER_RPT_QUERY_UUID "deviceUuid="
#define DUER_RPT_QUERY_TOKEN "token="
#define SR_TAG_UUID "deviceUUID"
#define SR_TAG_TOKEN "token"
#define SR_TAG_CUID "cuid"
#define SR_TAG_BDUSS "bduss"
#define SR_TAG_CLIENT_ID "clientId"
#define SR_TAG_USER_AGENT "userAgent"
#if defined(DUER_UDP_REPORTER)
#define SR_HOST "117.185.17.43"
#define SR_PORT 8899
#endif
#define DUER_READ_TIMEOUT (0)
#define DUER_RES_INC_COUNT (5)
typedef enum _baidu_ca_start_state_enum {
DUER_ST_STOPED,
DUER_ST_UNREGISTERED,
DUER_ST_REGISTER_CONNECTED,
DUER_ST_REGISTERED,
DUER_ST_SR_CONNECTING,
DUER_ST_SR_DATA_SENDING,
DUER_ST_SR_DATA_RECEIVING,
DUER_ST_SR_INITIALIZED,
DUER_ST_RPT_CONNECTED,
DUER_ST_RPT_INITIALIZED,
DUER_ST_STARTED,
DUER_ST_REPORTING,
DUER_ST_REPORTED,
DUER_ST_REGISTER_FAIL
} duer_state_e;
typedef struct _baidu_ca_s {
// Start state
volatile duer_u8_t state;
// register message id
#if defined(DUER_LWM2M_REGISTER)
duer_u16_t msg_id_reg;
duer_u16_t msg_id_unreg;
#endif
// Configuation
duer_conf_handler conf;
// mutex
duer_mutex_t mutex;
// Configuration
char *uuid;
char *token;
char *bindToken;
// If cuid is not null, deviceUuid will be binded to cuid on IoT cloud
char *cuid;
// If bduss is not null, auth by bduss on IoT cloud
char *bduss;
char *client_id;
char *user_agent;
char *serverAddr;
char *report_query;
duer_size_t report_query_len;
const char *cert;
duer_size_t cert_length;
// Token generator
duer_u16_t gen_token;
// Coap handler
#if defined(DUER_LWM2M_REGISTER)
duer_coap_handler reg;
#endif
duer_coap_handler sr;
#if defined(DUER_UDP_REPORTER)
duer_coap_handler rpt;
#endif
// Resource list
duer_res_t *res_list;
duer_u32_t res_size;
duer_u32_t res_capa;
// Response callback
duer_notify_f f_response;
duer_context ctx_response;
// Response callback
duer_transmit_f f_transmit;
// Socket context
duer_transevt_func ctx_socket;
// Remote address
#if defined(DUER_LWM2M_REGISTER)
duer_addr_t addr_reg;
#endif
duer_addr_t addr_sr;
#if defined(DUER_UDP_REPORTER)
duer_addr_t addr_rpt;
#endif
duer_u32_t start_connect_time;
} baidu_ca_t;
static volatile duer_u32_t s_max_connect_time_ms = 0;
static volatile duer_u32_t s_count_connect = 0;
static volatile duer_u32_t s_total_connect_time_ms = 0;
void baidu_ca_get_statistic(duer_u32_t *connect_avg_time,
duer_u32_t *max_connect_time,
duer_u32_t *count_connect)
{
*max_connect_time = s_max_connect_time_ms / 1000; // unit is ms
*count_connect = s_count_connect;
if (s_count_connect > 0) {
*connect_avg_time =
(s_total_connect_time_ms * 0.001) / s_count_connect; // unit is ms
} else {
*connect_avg_time = 0;
}
}
DUER_EXT_IMPL const char *baidu_ca_get_uuid(duer_handler hdlr)
{
baidu_ca_t *ctx = (baidu_ca_t *)hdlr;
if (ctx) {
return (char *)ctx->uuid;
}
return NULL;
}
DUER_EXT_IMPL const char *baidu_ca_get_client_id(duer_handler hdlr)
{
baidu_ca_t *ctx = (baidu_ca_t *)hdlr;
if (ctx) {
return (char *)ctx->client_id;
}
return NULL;
}
DUER_EXT_IMPL const char *baidu_ca_get_bduss(duer_handler hdlr)
{
baidu_ca_t *ctx = (baidu_ca_t *)hdlr;
if (ctx) {
return (char *)ctx->bduss;
}
return NULL;
}
DUER_EXT_IMPL const char *baidu_ca_get_user_agent(duer_handler hdlr)
{
baidu_ca_t *ctx = (baidu_ca_t *)hdlr;
if (ctx) {
return (char *)ctx->user_agent;
}
return NULL;
}
DUER_EXT_IMPL const char *baidu_ca_get_bind_token(duer_handler hdlr)
{
baidu_ca_t *ctx = (baidu_ca_t *)hdlr;
if (ctx) {
return ctx->bindToken;
}
return NULL;
}
DUER_EXT_IMPL const char *baidu_ca_get_rsa_cacrt(duer_handler hdlr)
{
baidu_ca_t *ctx = (baidu_ca_t *)hdlr;
if (ctx) {
return ctx->cert;
}
return NULL;
}
DUER_LOC_IMPL duer_status_t duer_engine_coap_handler(duer_context ctx,
duer_coap_handler coap,
const duer_msg_t *msg,
const duer_addr_t *addr)
{
duer_status_t rs = DUER_ERR_FAILED;
baidu_ca_t *ptr = (baidu_ca_t *)ctx;
if (ptr && msg && addr) {
rs = DUER_OK;
DUER_LOGV("==> duer_engine_coap_handler: state = %d", ptr->state);
#if defined(DUER_LWM2M_REGISTER)
if (ptr->reg == coap) {
if (ptr->state == DUER_ST_REGISTER_CONNECTED && ptr->msg_id_reg == msg->msg_id) {
ptr->msg_id_reg = 0;
if (msg->msg_code == DUER_MSG_RSP_CREATED) {
ptr->state = DUER_ST_REGISTERED;
}
} else if (ptr->state == DUER_ST_STOPED && ptr->msg_id_unreg == msg->msg_id) {
ptr->msg_id_unreg = 0;
}
} else
#endif
if (ptr->sr == coap) {
if (ptr->state == DUER_ST_SR_DATA_RECEIVING) {
if (msg->msg_code == DUER_MSG_RSP_CONTENT) {
DUER_LOGD("ca status: DUER_ST_SR_INITIALIZED");
ptr->state = DUER_ST_SR_INITIALIZED;
duer_ds_log_ca_start_state_change(DUER_ST_SR_DATA_RECEIVING, DUER_ST_SR_INITIALIZED);
// for debug
// char *payload = (char *)DUER_MALLOC(msg->payload_len + 1);
// DUER_MEMCPY(payload, msg->payload, msg->payload_len);
// payload[msg->payload_len] = '\0';
// DUER_LOGI("register ack payload: %s", payload);
// DUER_LOGI("register ack msg_id: %d", msg->msg_id);
} else {
ptr->state = DUER_ST_REGISTER_FAIL;
duer_ds_log_ca_start_state_change(DUER_ST_SR_DATA_RECEIVING, DUER_ST_REGISTER_FAIL);
DUER_LOGE("register fail, code: %d", msg->msg_code);
duer_ds_log_ca_cache_error(DUER_DS_LOG_CA_START_STATE_REG_FAIL);
}
}
if (ptr->f_response) {
ptr->f_response(ptr->ctx_response, (duer_msg_t *)msg, NULL);
}
}
#if defined(DUER_UDP_REPORTER)
else if (ptr->rpt == coap) {
if (ptr->f_response) {
ptr->f_response(ptr->ctx_response, (duer_msg_t *)msg, NULL);
}
}
#endif
DUER_LOGV("<== duer_engine_coap_handler: rs = %d", rs);
}
return rs;
}
#if defined(DUER_UDP_REPORTER) || defined(DUER_LWM2M_REGISTER)
DUER_LOC_IMPL duer_bool baidu_ca_match_address(const duer_addr_t *l,
const duer_addr_t *r)
{
if (l) {
DUER_LOGV("baidu_ca_match_address: l = {ip:%s, port:%d, type:%d, length:%d}",
l->host, l->port, l->type, l->host_size);
}
if (r) {
DUER_LOGV("baidu_ca_match_address: r = {ip:%s, port:%d, type:%d, length:%d}",
r->host, r->port, r->type, r->host_size);
}
if (l == r || (l && r && l->port == r->port && l->type == r->type
&& l->host_size == r->host_size
&& DUER_MEMCMP(r->host, l->host, r->host_size) == 0)) {
return DUER_TRUE;
}
return DUER_FALSE;
}
#endif
#if defined(DUER_LWM2M_REGISTER)
DUER_LOC_IMPL duer_status_t baidu_ca_register(baidu_ca_t *ctx)
{
duer_status_t rs = DUER_ERR_FAILED;
duer_coap_ep_t ep;
DUER_LOGV("==> baidu_ca_register");
if (!ctx) {
goto exit;
}
if (!ctx->reg) {
if (!(ctx->reg = duer_coap_acquire(duer_engine_coap_handler, ctx,
ctx->ctx_socket, ctx->uuid))) {
goto exit;
}
duer_coap_set_tx_callback(ctx->reg, ctx->f_transmit);
}
if (ctx->state == DUER_ST_UNREGISTERED) {
rs = duer_coap_connect(ctx->reg, &ctx->addr_reg, ctx->cert, ctx->cert_length);
if (rs == DUER_OK) {
ctx->state = DUER_ST_REGISTER_CONNECTED;
}
}
if (ctx->state != DUER_ST_REGISTER_CONNECTED) {
goto exit;
}
// Send register message
if (ctx->msg_id_reg == 0) {
DUER_MEMSET(&ep, 0, sizeof(ep));
ep.name_ptr = (char *)ctx->uuid;
ep.name_len = DUER_STRLEN(ctx->uuid);
ep.type_ptr = (char *)ctx->token;
ep.type_len = DUER_STRLEN(ctx->token);
ep.lifetime_ptr = DUER_COAP_LIFETIME;
ep.lifetime_len = DUER_STRLEN(DUER_COAP_LIFETIME);
rs = duer_coap_register(ctx->reg, &ep);
if (rs == 0) {
rs = DUER_ERR_FAILED;
}
if (rs > 0) {
ctx->msg_id_reg = (duer_u16_t)rs;
} else {
goto exit;
}
}
rs = duer_coap_data_available(ctx->reg);
exit:
DUER_LOGV("<== baidu_ca_register: rs = %d", rs);
return rs;
}
#endif
DUER_LOC_IMPL char *baidu_ca_get_service_router_payload(
const char *uuid, const char *token, const char *cuid,
const char *bduss, const char *client_id, const char *user_agent)
{
char *rs = NULL;
baidu_json *item = baidu_json_CreateObject();
if (item) {
baidu_json_AddStringToObject(item, SR_TAG_UUID, uuid);
baidu_json_AddStringToObject(item, SR_TAG_TOKEN, token);
if (cuid != NULL) {
baidu_json_AddStringToObject(item, SR_TAG_CUID, cuid);
}
if (bduss != NULL) {
baidu_json_AddStringToObject(item, SR_TAG_BDUSS, bduss);
}
if (client_id != NULL) {
baidu_json_AddStringToObject(item, SR_TAG_CLIENT_ID, client_id);
}
if (user_agent != NULL) {
baidu_json_AddStringToObject(item, SR_TAG_USER_AGENT, user_agent);
}
rs = baidu_json_PrintUnformatted(item);
baidu_json_Delete(item);
}
return rs;
}
DUER_LOC_IMPL duer_status_t baidu_ca_create_service_router(baidu_ca_t *ctx)
{
duer_status_t rs = DUER_ERR_FAILED;
duer_msg_t msg_reg;
DUER_LOGV("==> baidu_ca_create_service_router");
if (!ctx) {
goto exit;
}
if (!ctx->sr) {
ctx->sr = duer_coap_acquire(duer_engine_coap_handler, ctx, ctx->ctx_socket, ctx->uuid);
if (!ctx->sr) {
goto exit;
}
duer_coap_set_tx_callback(ctx->sr, ctx->f_transmit);
}
if (ctx->state == DUER_ST_SR_CONNECTING) {
//record the start connect time
if (ctx->start_connect_time == 0) {
ctx->start_connect_time = duer_timestamp();
}
duer_ds_log_ca_start_connect(ctx->addr_sr.host, ctx->addr_sr.port);
#ifndef NET_TRANS_ENCRYPTED_BY_AES_CBC
rs = duer_coap_connect(ctx->sr, &ctx->addr_sr, ctx->cert, ctx->cert_length);
#else
// bindToken is the key for AES encryption
rs = duer_coap_connect(ctx->sr, &ctx->addr_sr, ctx->bindToken, DUER_STRLEN(ctx->bindToken));
#endif // NET_TRANS_ENCRYPTED_BY_AES_CBC
// baidu_ca_unload_configuration(ctx); //release the bjson format of the profile to save memory
DUER_LOGD("ca state: DUER_ST_SR_CONNECTING, rs:%d", rs);
if (rs == DUER_OK) {
ctx->state = DUER_ST_SR_DATA_SENDING;
//after success connect, calculate the connect time
int time_end = duer_timestamp();
int time_cost = time_end - ctx->start_connect_time;
if (time_cost > s_max_connect_time_ms) {
s_max_connect_time_ms = time_cost;
}
++s_count_connect;
s_total_connect_time_ms += time_cost;
ctx->start_connect_time = 0;
}
}
if (ctx->state == DUER_ST_SR_DATA_SENDING) {
DUER_MEMSET(&msg_reg, 0, sizeof(msg_reg));
msg_reg.msg_type = DUER_MSG_TYPE_CONFIRMABLE;
msg_reg.msg_code = DUER_MSG_REQ_POST;
msg_reg.path = (duer_u8_t *)DUER_SR_REG_PATH;
msg_reg.path_len = DUER_STRLEN(DUER_SR_REG_PATH);
msg_reg.payload = (duer_u8_t *)baidu_ca_get_service_router_payload(
ctx->uuid, ctx->token, ctx->cuid, ctx->bduss, ctx->client_id, ctx->user_agent);
msg_reg.payload_len = DUER_STRLEN((char *)msg_reg.payload);
rs = duer_coap_send(ctx->sr, &msg_reg);
baidu_json_release(msg_reg.payload);
DUER_LOGD("ca state: DUER_ST_SR_DATA_SENDING, rs:%d", rs);
if (rs < DUER_OK) {
goto exit;
}
ctx->state = DUER_ST_SR_DATA_RECEIVING;
duer_ds_log_ca_start_state_change(DUER_ST_SR_DATA_SENDING, DUER_ST_SR_DATA_RECEIVING);
}
if (ctx->state == DUER_ST_SR_DATA_RECEIVING) {
rs = duer_coap_data_available(ctx->sr);
DUER_LOGD("ca state: DUER_ST_SR_DATA_RECEIVING, rs:%d", rs);
if (rs < DUER_OK) {
goto exit;
}
}
if (ctx->state == DUER_ST_SR_INITIALIZED) {
DUER_LOGD("ca state: DUER_ST_SR_INITIALIZED");
baidu_ca_add_resources(ctx, ctx->res_list, ctx->res_size);
if (ctx->res_list) {
DUER_FREE(ctx->res_list);
ctx->res_list = NULL;
ctx->res_size = 0;
ctx->res_capa = 0;
}
}
if (ctx->state == DUER_ST_REGISTER_FAIL) {
rs = DUER_ERR_REG_FAIL;
}
exit:
DUER_LOGV("<== baidu_ca_create_service_router: rs = %d", rs);
return rs;
}
#if defined(DUER_UDP_REPORTER)
DUER_LOC_IMPL duer_status_t baidu_ca_create_reporter(baidu_ca_t *ctx)
{
duer_status_t rs = DUER_ERR_FAILED;
DUER_LOGV("==> baidu_ca_create_reporter");
if (!ctx) {
goto exit;
}
if (!ctx->rpt) {
ctx->rpt = duer_coap_acquire(duer_engine_coap_handler, ctx, ctx->ctx_socket, ctx->uuid);
if (!ctx->rpt) {
goto exit;
}
duer_coap_set_tx_callback(ctx->rpt, ctx->f_transmit);
}
if (ctx->state == DUER_ST_SR_INITIALIZED) {
rs = duer_coap_connect(ctx->rpt, &ctx->addr_rpt, ctx->cert, ctx->cert_length);
if (rs == DUER_OK) {
ctx->state = DUER_ST_RPT_CONNECTED;
}
}
if (ctx->state == DUER_ST_RPT_CONNECTED) {
#if defined(DUER_READ_TIMEOUT) && (DUER_READ_TIMEOUT > 0)
duer_coap_set_read_timeout(ctx->rpt, DUER_READ_TIMEOUT);
#endif
ctx->state = DUER_ST_RPT_INITIALIZED;
rs = DUER_OK;
}
exit:
DUER_LOGV("<== baidu_ca_create_reporter: rs = %d", rs);
return rs;
}
#endif
DUER_LOC_IMPL duer_status_t baidu_ca_run(baidu_ca_t *ctx)
{
duer_status_t rs = DUER_ERR_FAILED;
if (!ctx) {
goto exit;
}
DUER_LOGV("==> baidu_ca_run: ctx = %p, state = %d", ctx, ctx->state);
switch (ctx->state) {
case DUER_ST_UNREGISTERED:
DUER_LOGD("ca status: %d", ctx->state);
ctx->state = DUER_ST_REGISTER_CONNECTED;
rs = DUER_OK;
break;
case DUER_ST_REGISTER_CONNECTED:
#if defined(DUER_LWM2M_REGISTER)
rs = baidu_ca_register(ctx);
break;
#else
DUER_LOGD("ca status: %d", ctx->state);
ctx->state = DUER_ST_REGISTERED;
rs = DUER_OK;
break;
#endif
case DUER_ST_REGISTERED:
DUER_LOGD("ca status: %d", ctx->state);
ctx->state = DUER_ST_SR_CONNECTING;
rs = DUER_OK;
break;
case DUER_ST_SR_CONNECTING:
case DUER_ST_SR_DATA_SENDING:
case DUER_ST_SR_DATA_RECEIVING:
DUER_LOGD("ca status: %d", ctx->state);
rs = baidu_ca_create_service_router(ctx);
break;
case DUER_ST_SR_INITIALIZED:
#if defined(DUER_UDP_REPORTER)
rs = baidu_ca_create_reporter(ctx);
break;
#endif
case DUER_ST_RPT_INITIALIZED:
DUER_LOGD("ca status: DUER_ST_RPT_INITIALIZED -> DUER_ST_STARTED");
ctx->state = DUER_ST_STARTED;
duer_ds_log_ca_start_state_change(DUER_ST_RPT_INITIALIZED, DUER_ST_STARTED);
rs = DUER_OK;
break;
case DUER_ST_STOPED:
rs = DUER_ERR_FAILED;
break;
case DUER_ST_STARTED:
rs = DUER_OK;
break;
default:
// do noting
break;
}
DUER_LOGV("<== baidu_ca_run: rs = %d", rs);
exit:
return rs;
}
DUER_EXT_IMPL duer_handler baidu_ca_acquire(duer_transevt_func soc_ctx)
{
baidu_ca_t *hdlr = NULL;
DUER_LOGV("==> baidu_ca_acquire");
DUER_MEMDBG_USAGE();
hdlr = DUER_MALLOC(sizeof(baidu_ca_t));
if (!hdlr) {
DUER_LOGE("alloc failed...");
DUER_DS_LOG_CA_MEMORY_OVERFLOW();
baidu_ca_release(hdlr);
return NULL;
}
duer_coap_trace_enable();
DUER_MEMSET(hdlr, 0, sizeof(baidu_ca_t));
hdlr->state = DUER_ST_STOPED;
hdlr->mutex = duer_mutex_create();
hdlr->gen_token = 0xC000;
hdlr->ctx_socket = soc_ctx;
DUER_LOGV("<== baidu_ca_acquire: hdlr = %p", hdlr);
return hdlr;
}
DUER_EXT duer_status_t baidu_ca_add_resources(duer_handler hdlr,
const duer_res_t list_res[], duer_size_t list_res_size)
{
baidu_ca_t *ctx = (baidu_ca_t *)hdlr;
duer_status_t rs = DUER_ERR_FAILED;
if (ctx->state >= DUER_ST_SR_INITIALIZED) {
duer_u8_t i = 0;
while (i < list_res_size) {
duer_coap_resource_add(ctx->sr, list_res + i);
i++;
}
rs = DUER_OK;
goto exit;
}
//Note: if exccute here, the path/static data should be something with long-time life
// e.g. static chars; or try to add resource after the CA started.
DUER_LOGW("add_resource at CA not started, all the content(static_data, path)should be static!");
if (ctx->res_list == NULL) {
ctx->res_capa = (list_res_size / DUER_RES_INC_COUNT + 1) * DUER_RES_INC_COUNT;
ctx->res_list = DUER_MALLOC(sizeof(duer_res_t) * ctx->res_capa);
ctx->res_size = 0;
} else if (ctx->res_capa < ctx->res_size + list_res_size) {
ctx->res_capa =
((ctx->res_size + list_res_size) / DUER_RES_INC_COUNT + 1) * DUER_RES_INC_COUNT;
ctx->res_list = (duer_res_t *)DUER_REALLOC(ctx->res_list,
sizeof(duer_res_t) * ctx->res_capa);
}
if (ctx->res_list == NULL) {
DUER_LOGE(" stored the resource failed...");
DUER_DS_LOG_CA_MEMORY_OVERFLOW();
goto exit;
}
DUER_MEMCPY(ctx->res_list + ctx->res_size, list_res,
sizeof(duer_res_t) * list_res_size);
ctx->res_size += list_res_size;
rs = DUER_OK;
exit:
return rs;
}
duer_status_t baidu_ca_unload_configuration(duer_handler hdlr)
{
baidu_ca_t *ctx = (baidu_ca_t *)hdlr;
ctx->cert = NULL;
ctx->cert_length = 0;
if (ctx->conf) {
duer_conf_destroy(ctx->conf);
ctx->conf = NULL;
}
return DUER_OK;
}
DUER_EXT_IMPL duer_status_t baidu_ca_load_configuration(duer_handler hdlr, const void *data, duer_size_t size)
{
baidu_ca_t *ctx = (baidu_ca_t *)hdlr;
duer_status_t rs = DUER_ERR_FAILED;
const char *string_addr = NULL;
if (!ctx) {
DUER_LOGE("invalid handler with null");
goto error;
}
if (ctx->conf) {
duer_conf_destroy(ctx->conf);
ctx->conf = NULL;
}
ctx->conf = duer_conf_create(data, size);
if (!ctx->conf) {
DUER_LOGE(" create the configuation failed...");
goto error;
}
string_addr = duer_conf_get_string(ctx->conf, DUER_CONF_KEY_UUID);
if (ctx->uuid) {
DUER_FREE(ctx->uuid);
ctx->uuid = NULL;
}
if (string_addr) {
ctx->uuid = DUER_MALLOC(DUER_STRLEN(string_addr) + 1);
}
if (!string_addr || !ctx->uuid) {
DUER_LOGE(" obtain the uuid failed...");
goto error;
} else {
DUER_MEMCPY(ctx->uuid, string_addr, DUER_STRLEN(string_addr) + 1);
}
string_addr = duer_conf_get_string(ctx->conf, DUER_CONF_KEY_TOKEN);
if (ctx->token) {
DUER_FREE(ctx->token);
ctx->token = NULL;
}
if (string_addr) {
ctx->token = DUER_MALLOC(DUER_STRLEN(string_addr) + 1);
}
if (!string_addr || !ctx->token) {
DUER_LOGE(" obtain the token failed...");
goto error;
} else {
DUER_MEMCPY(ctx->token, string_addr, DUER_STRLEN(string_addr) + 1);
}
string_addr = duer_conf_get_string(ctx->conf, DUER_CONF_KEY_BINDTOKEN);
if (ctx->bindToken) {
DUER_FREE(ctx->bindToken);
ctx->bindToken = NULL;
}
if (string_addr) {
ctx->bindToken = DUER_MALLOC(DUER_STRLEN(string_addr) + 1);
}
if (!string_addr || !ctx->bindToken) {
// DUER_LOGE(" obtain the bindToken failed...");
// goto error;
} else {
DUER_MEMCPY(ctx->bindToken, string_addr, DUER_STRLEN(string_addr) + 1);
}
ctx->cert = duer_conf_get_string(ctx->conf, DUER_CONF_KEY_CERT);
if (!ctx->cert) {
DUER_LOGE(" obtain the cert failed...");
goto error;
}
ctx->cert_length = DUER_STRLEN(ctx->cert) + 1;
string_addr = duer_conf_get_string(ctx->conf, DUER_CONF_KEY_HOST);
if (ctx->serverAddr) {
DUER_FREE(ctx->serverAddr);
ctx->serverAddr = NULL;
}
if (string_addr) {
ctx->serverAddr = DUER_MALLOC(DUER_STRLEN(string_addr) + 1);
}
if (!string_addr || !ctx->serverAddr) {
DUER_LOGE(" obtain the hostname failed...");
goto error;
} else {
DUER_MEMCPY(ctx->serverAddr, string_addr, DUER_STRLEN(string_addr) + 1);
}
// cuid may be not exist
string_addr = (char *)duer_conf_get_string(ctx->conf, DUER_CONF_KEY_CUID);
if (ctx->cuid) {
DUER_FREE(ctx->cuid);
ctx->cuid = NULL;
}
if (string_addr) {
ctx->cuid = DUER_MALLOC(DUER_STRLEN(string_addr) + 1);
}
if (string_addr && !ctx->cuid) {
DUER_LOGE(" malloc the cuid failed...");
goto error;
} else {
if (ctx->cuid) {
DUER_MEMCPY(ctx->cuid, string_addr, DUER_STRLEN(string_addr) + 1);
DUER_LOGI("profile include cuid:%s", ctx->cuid);
}
}
// bduss may be not exist
string_addr = (char *)duer_conf_get_string(ctx->conf, DUER_CONF_KEY_BDUSS);
if (ctx->bduss) {
DUER_FREE(ctx->bduss);
ctx->bduss = NULL;
}
if (string_addr) {
ctx->bduss = DUER_MALLOC(DUER_STRLEN(string_addr) + 1);
}
if (string_addr && !ctx->bduss) {
DUER_LOGE(" malloc the bduss failed...");
goto error;
} else {
if (ctx->bduss) {
DUER_MEMCPY(ctx->bduss, string_addr, DUER_STRLEN(string_addr) + 1);
DUER_LOGI("profile include bduss:%s", ctx->bduss);
}
}
// client_id may be not exist
string_addr = (char *)duer_conf_get_string(ctx->conf, DUER_CONF_KEY_CLIENT_ID);
if (ctx->client_id) {
DUER_FREE(ctx->client_id);
ctx->client_id = NULL;
}
if (string_addr) {
ctx->client_id = DUER_MALLOC(DUER_STRLEN(string_addr) + 1);
}
if (string_addr && !ctx->client_id) {
DUER_LOGE(" malloc the client_id failed...");
goto error;
} else {
if (ctx->client_id) {
DUER_MEMCPY(ctx->client_id, string_addr, DUER_STRLEN(string_addr) + 1);
DUER_LOGI("profile include client_id:%s", ctx->client_id);
}
}
// user_agent may be not exist
string_addr = (char *)duer_conf_get_string(ctx->conf, DUER_CONF_KEY_USER_AGENT);
if (ctx->user_agent) {
DUER_FREE(ctx->user_agent);
ctx->user_agent = NULL;
}
if (string_addr) {
ctx->user_agent = DUER_MALLOC(DUER_STRLEN(string_addr) + 1);
}
if (string_addr && !ctx->user_agent) {
DUER_LOGE(" malloc the user_agent failed...");
goto error;
} else {
if (ctx->user_agent) {
DUER_MEMCPY(ctx->user_agent, string_addr, DUER_STRLEN(string_addr) + 1);
DUER_LOGI("profile include user_agent:%s", ctx->user_agent);
}
}
#if defined(DUER_LWM2M_REGISTER)
ctx->addr_reg.host = ctx->serverAddr;
ctx->addr_reg.host_size = DUER_STRLEN(ctx->serverAddr);
ctx->addr_reg.port = duer_conf_get_ushort(ctx->conf, DUER_CONF_KEY_PORT_REG);
ctx->addr_reg.type = DUER_PROTO_UDP;
#endif
#if defined(DUER_UDP_REPORTER)
ctx->addr_sr.host = SR_HOST;
ctx->addr_sr.host_size = DUER_STRLEN(SR_HOST);
ctx->addr_sr.port = SR_PORT;
#else
ctx->addr_sr.host = ctx->serverAddr;
ctx->addr_sr.host_size = DUER_STRLEN(ctx->serverAddr);
ctx->addr_sr.port = duer_conf_get_ushort(ctx->conf, DUER_CONF_KEY_PORT_RPT);
#endif
ctx->addr_sr.type = DUER_PROTO_TCP;
#if defined(DUER_UDP_REPORTER)
ctx->addr_rpt.host = ctx->serverAddr;
ctx->addr_rpt.host_size = DUER_STRLEN(ctx->serverAddr);
ctx->addr_rpt.port = duer_conf_get_ushort(ctx->conf, DUER_CONF_KEY_PORT_RPT);
ctx->addr_rpt.type = DUER_PROTO_UDP;
#endif
if (ctx->report_query) {
DUER_FREE(ctx->report_query);
ctx->report_query = NULL;
}
ctx->report_query_len = DUER_STRLEN(DUER_RPT_QUERY_UUID)
+ DUER_STRLEN(ctx->uuid)
+ 1 // '&'
+ DUER_STRLEN(DUER_RPT_QUERY_TOKEN)
+ DUER_STRLEN(ctx->token);
ctx->report_query = DUER_MALLOC(ctx->report_query_len + 1);
if (!ctx->report_query) {
DUER_DS_LOG_CA_MEMORY_OVERFLOW();
goto error;
}
DUER_SNPRINTF(
ctx->report_query,
ctx->report_query_len + 1,
DUER_RPT_QUERY_UUID"%s&"DUER_RPT_QUERY_TOKEN"%s",
ctx->uuid,
ctx->token);
rs = DUER_OK;
error:
return rs;
}
DUER_EXT_IMPL duer_status_t baidu_ca_do_start(duer_handler hdlr)
{
baidu_ca_t *ctx = (baidu_ca_t *)hdlr;
duer_status_t rs = DUER_ERR_FAILED;
DUER_LOGV("==> baidu_ca_do_start");
if (!ctx) {
goto exit;
}
duer_mutex_lock(ctx->mutex);
rs = DUER_OK;
while (ctx->state != DUER_ST_STARTED && rs == DUER_OK) {
DUER_LOGD("ca status: %d", ctx->state);
rs = baidu_ca_run(ctx);
}
duer_mutex_unlock(ctx->mutex);
exit:
DUER_LOGV("<== baidu_ca_do_start: rs = %d", rs);
return rs;
}
DUER_EXT_IMPL duer_status_t baidu_ca_start(duer_handler hdlr)
{
baidu_ca_t *ctx = (baidu_ca_t *)hdlr;
duer_status_t rs = DUER_ERR_FAILED;
DUER_LOGV("==> baidu_ca_start");
if (!ctx) {
goto exit;
}
if (ctx->state == DUER_ST_STOPED) {
DUER_LOGD("ca status: DUER_ST_STOPED -> DUER_ST_UNREGISTERED");
ctx->state = DUER_ST_UNREGISTERED;
}
if (ctx->state == DUER_ST_REGISTER_FAIL) {
rs = DUER_ERR_REG_FAIL;
} else {
rs = baidu_ca_do_start(hdlr);
}
exit:
DUER_LOGV("<== baidu_ca_start: rs = %d", rs);
return rs;
}
DUER_EXT_IMPL duer_bool baidu_ca_is_started(duer_handler hdlr)
{
baidu_ca_t *ctx = (baidu_ca_t *)hdlr;
return (ctx != NULL && ctx->state == DUER_ST_STARTED) ? DUER_TRUE : DUER_FALSE;
}
DUER_EXT_IMPL duer_bool baidu_ca_is_stopped(duer_handler hdlr)
{
baidu_ca_t *ctx = (baidu_ca_t *)hdlr;
return (ctx == NULL || ctx->state == DUER_ST_STOPED) ? DUER_TRUE : DUER_FALSE;
}
DUER_EXT_IMPL duer_status_t baidu_ca_report_set_response_callback(
duer_handler hdlr, duer_notify_f f_response, duer_context context)
{
baidu_ca_t *ctx = (baidu_ca_t *)hdlr;
if (ctx) {
ctx->f_response = f_response;
ctx->ctx_response = context;
return DUER_OK;
}
return DUER_ERR_FAILED;
}
DUER_EXT duer_status_t baidu_ca_report_set_data_tx_callback(duer_handler hdlr, duer_transmit_f f_transmit)
{
baidu_ca_t *ctx = (baidu_ca_t *)hdlr;
if (ctx) {
ctx->f_transmit = f_transmit;
return DUER_OK;
}
return DUER_ERR_FAILED;
}
static duer_msg_t *baidu_ca_build_coap_message()
{
duer_msg_t *msg = DUER_MALLOC(sizeof(duer_msg_t)); // ~= 36
if (msg) {
DUER_MEMSET(msg, 0, sizeof(duer_msg_t));
msg->create_timestamp = duer_timestamp();
}
return msg;
}
DUER_EXT duer_msg_t *baidu_ca_build_report_message(duer_handler hdlr,
duer_bool confirmable)
{
baidu_ca_t *ctx = (baidu_ca_t *)hdlr;
duer_msg_t *msg = NULL;
do {
if (!ctx) {
break;
}
msg = baidu_ca_build_coap_message();
if (!msg) {
DUER_DS_LOG_CA_MEMORY_OVERFLOW();
break;
}
msg->msg_type =
confirmable == DUER_FALSE ? DUER_MSG_TYPE_NON_CONFIRMABLE : DUER_MSG_TYPE_CONFIRMABLE;
msg->msg_code = DUER_MSG_REQ_POST;
msg->path = (duer_u8_t *)DUER_REPORT_PATH;
msg->path_len = DUER_STRLEN(DUER_REPORT_PATH);
msg->query = (duer_u8_t *)ctx->report_query;
msg->query_len = ctx->report_query_len;
msg->token_len = sizeof(ctx->gen_token);
msg->token = DUER_MALLOC(msg->token_len);
if (msg->token) {
DUER_MEMCPY(msg->token, &ctx->gen_token, msg->token_len);
} else {
DUER_DS_LOG_CA_MEMORY_OVERFLOW();
}
ctx->gen_token++;
} while (0);
return msg;
}
DUER_EXT duer_msg_t *baidu_ca_build_response_message(duer_handler hdlr,
const duer_msg_t *msg, duer_u8_t msg_code)
{
baidu_ca_t *ctx = (baidu_ca_t *)hdlr;
duer_msg_t *rs = NULL;
const char *token = NULL;
do {
if (!ctx || !msg) {
DUER_LOGE("paramter error: ctx = %p, msg = %p", ctx, msg);
break;
}
if (msg_code != DUER_MSG_EMPTY_MESSAGE) { // empty message don't need token
if (msg->token_len > 0 && msg->token) {
token = DUER_MALLOC(msg->token_len);
if (!token) {
DUER_DS_LOG_CA_MEMORY_OVERFLOW();
break;
}
}
}
rs = baidu_ca_build_coap_message();
if (!rs) {
DUER_DS_LOG_CA_MEMORY_OVERFLOW();
break;
}
if (msg->msg_type == DUER_MSG_TYPE_CONFIRMABLE) {
rs->msg_type = DUER_MSG_TYPE_ACKNOWLEDGEMENT;
rs->msg_id = msg->msg_id;
} else {
rs->msg_type = msg->msg_type;
}
// DUER_MSG_RSP_INVALID means a seperate response
if (msg_code != DUER_MSG_RSP_INVALID) {
rs->msg_code = msg_code;
if (token) {
rs->token_len = msg->token_len;
rs->token = (duer_u8_t *)token;
DUER_MEMCPY(rs->token, msg->token, rs->token_len);
}
}
} while (0);
if (!rs) {
if (token) {
DUER_FREE((char *)token);
token = NULL;
}
}
return rs;
}
DUER_EXT duer_msg_t *baidu_ca_build_seperate_response_message(duer_handler hdlr,
const char *ptoken,
duer_size_t token_len,
int msg_code,
duer_bool confirmable)
{
baidu_ca_t *ctx = (baidu_ca_t *)hdlr;
duer_msg_t *rs = NULL;
const char *token = NULL;
do {
if (!ctx) {
DUER_LOGE("paramter error: ctx = %p", ctx);
break;
}
if (token_len > 0 && ptoken) {
token = DUER_MALLOC(token_len);
if (!token) {
DUER_DS_LOG_CA_MEMORY_OVERFLOW();
break;
}
} else {
DUER_LOGI("token should not be null!!");
break;
}
rs = baidu_ca_build_coap_message();
if (!rs) {
DUER_DS_LOG_CA_MEMORY_OVERFLOW();
break;
}
rs->msg_type =
confirmable == DUER_FALSE ? DUER_MSG_TYPE_NON_CONFIRMABLE : DUER_MSG_TYPE_CONFIRMABLE;
rs->msg_code = msg_code;
if (token) {
rs->token_len = token_len;
rs->token = (duer_u8_t *)token;
DUER_MEMCPY(rs->token, ptoken, rs->token_len);
}
} while (0);
if (!rs) {
if (token) {
DUER_FREE((char *)token);
token = NULL;
}
}
return rs;
}
/*
* Release the message that generated by baidu_ca_build_XXXX_message.
*
* @Param hdlr, in, the handler will be operated
* @Param msg, in, the message that remote requested
*/
DUER_EXT void baidu_ca_release_message(duer_handler hdlr, duer_msg_t *msg)
{
if (msg) {
if (msg->token) {
DUER_FREE(msg->token);
msg->token = NULL;
}
DUER_FREE(msg);
}
}
DUER_EXT duer_status_t baidu_ca_send_data(duer_handler hdlr, const duer_msg_t *msg,
const duer_addr_t *addr)
{
baidu_ca_t *ctx = (baidu_ca_t *)hdlr;
duer_status_t rs = DUER_ERR_FAILED;
DUER_LOGV("==> baidu_ca_send_data");
#if defined(DUER_UDP_REPORTER)
if (ctx->state >= DUER_ST_SR_INITIALIZED
&& baidu_ca_match_address(&(ctx->addr_sr), addr))
#endif
{
DUER_LOGV(" ctx->sr matched: %p", addr);
rs = duer_coap_send(ctx->sr, msg);
goto exit;
}
#if defined(DUER_UDP_REPORTER)
if (ctx->state >= DUER_ST_RPT_INITIALIZED
&& (!addr || baidu_ca_match_address(&(ctx->addr_rpt), addr))) {
duer_mutex_lock(ctx->mutex);
DUER_LOGV(" ctx->rpt matched: %p", addr);
rs = duer_coap_send(ctx->rpt, msg);
duer_mutex_unlock(ctx->mutex);
goto exit;
}
rs = baidu_ca_do_start(hdlr);
if (rs < DUER_OK) {
DUER_LOGD(" start failed...");
goto exit;
}
#endif
exit:
DUER_LOGV("<== baidu_ca_send_data: rs = %d", rs);
DUER_MEMDBG_USAGE();
return rs;
}
DUER_EXT duer_status_t baidu_ca_send_data_directly(duer_handler hdlr, const void *data,
duer_size_t size, const duer_addr_t *addr)
{
baidu_ca_t *ctx = (baidu_ca_t *)hdlr;
duer_status_t rs = DUER_ERR_FAILED;
DUER_LOGV("==> baidu_ca_send_data");
#if defined(DUER_UDP_REPORTER)
if (ctx->state >= DUER_ST_SR_INITIALIZED
&& baidu_ca_match_address(&(ctx->addr_sr), addr))
#endif
{
DUER_LOGV(" ctx->sr matched: %p", addr);
rs = duer_coap_send_data(ctx->sr, data, size);
goto exit;
}
#if defined(DUER_UDP_REPORTER)
if (ctx->state >= DUER_ST_RPT_INITIALIZED
&& (!addr || baidu_ca_match_address(&(ctx->addr_rpt), addr))) {
duer_mutex_lock(ctx->mutex);
DUER_LOGV(" ctx->rpt matched: %p", addr);
rs = duer_coap_send_data(ctx->rpt, data, size);
duer_mutex_unlock(ctx->mutex);
goto exit;
}
rs = baidu_ca_do_start(hdlr);
if (rs < DUER_OK) {
DUER_LOGD(" start failed...");
goto exit;
}
#endif
exit:
DUER_LOGV("<== baidu_ca_send_data: rs = %d", rs);
//DUER_MEMDBG_USAGE();
return rs;
}
DUER_EXT_IMPL duer_status_t baidu_ca_data_available(duer_handler hdlr,
const duer_addr_t *addr)
{
baidu_ca_t *ctx = (baidu_ca_t *)hdlr;
duer_status_t rs = DUER_ERR_FAILED;
DUER_LOGV("==> baidu_ca_data_available");
if (ctx->state >= DUER_ST_SR_INITIALIZED
#if defined(DUER_UDP_REPORTER)
&& baidu_ca_match_address(&(ctx->addr_sr), addr)
#endif
) {
DUER_LOGV(" ctx->sr matched: %p", addr);
rs = duer_coap_data_available(ctx->sr);
}
#if defined(DUER_UDP_REPORTER)
if (ctx->state >= DUER_ST_RPT_INITIALIZED && (!addr
|| baidu_ca_match_address(&(ctx->addr_rpt), addr))) {
duer_mutex_lock(ctx->mutex);
DUER_LOGV(" ctx->rpt matched: %p", addr);
rs = duer_coap_data_available(ctx->rpt);
duer_mutex_unlock(ctx->mutex);
}
#endif
if (ctx->state < DUER_ST_STARTED) {
rs = baidu_ca_do_start(hdlr);
if (rs < DUER_OK && rs != DUER_ERR_TRANS_WOULD_BLOCK) {
DUER_LOGW(" start failed...");
}
}
DUER_LOGV("<== baidu_ca_data_available: rs = %d", rs);
return rs;
}
DUER_EXT duer_status_t baidu_ca_exec(duer_handler hdlr)
{
baidu_ca_t *ctx = (baidu_ca_t *)hdlr;
duer_status_t rs = DUER_OK;
duer_u32_t timestamp = duer_timestamp() / 1000;
DUER_LOGV("==> baidu_ca_exec");
if (ctx) {
#if defined(DUER_LWM2M_REGISTER)
duer_coap_exec(ctx->reg, timestamp);
#endif
#if defined(DUER_UDP_REPORTER)
duer_coap_exec(ctx->rpt, timestamp);
#endif
duer_coap_exec(ctx->sr, timestamp);
}
DUER_LOGV("<== baidu_ca_exec: rs = %d", rs);
return rs;
}
DUER_EXT_IMPL duer_status_t baidu_ca_stop(duer_handler hdlr)
{
baidu_ca_t *ctx = (baidu_ca_t *)hdlr;
duer_status_t rs = DUER_OK;
DUER_LOGV("==> baidu_ca_stop");
if (ctx->state > DUER_ST_STOPED) {
ctx->state = DUER_ST_STOPED;
if (ctx->sr) {
duer_coap_release(ctx->sr);
ctx->sr = NULL;
}
#if defined(DUER_UDP_REPORTER)
if (ctx->rpt) {
duer_coap_release(ctx->rpt);
ctx->rpt = NULL;
}
#endif
#if defined(DUER_LWM2M_REGISTER)
if (ctx->reg) {
duer_coap_unregister(ctx->reg);
duer_coap_release(ctx->reg);
ctx->reg = NULL;
}
#endif
}
DUER_LOGV("<== baidu_ca_stop: rs = %d", rs);
return rs;
}
DUER_EXT_IMPL duer_status_t baidu_ca_release(duer_handler hdlr)
{
baidu_ca_t *ctx = (baidu_ca_t *)hdlr;
DUER_LOGV("==> baidu_ca_release");
if (ctx) {
if (ctx->conf) {
duer_conf_destroy(ctx->conf);
ctx->conf = NULL;
}
baidu_ca_stop(ctx);
if (ctx->report_query) {
DUER_FREE(ctx->report_query);
ctx->report_query = NULL;
}
if (ctx->uuid) {
DUER_FREE(ctx->uuid);
ctx->uuid = NULL;
}
if (ctx->token) {
DUER_FREE(ctx->token);
ctx->token = NULL;
}
if (ctx->bindToken) {
DUER_FREE(ctx->bindToken);
ctx->bindToken = NULL;
}
if (ctx->cuid) {
DUER_FREE(ctx->cuid);
ctx->cuid = NULL;
}
if (ctx->bduss) {
DUER_FREE(ctx->bduss);
ctx->bduss = NULL;
}
if (ctx->client_id) {
DUER_FREE(ctx->client_id);
ctx->client_id = NULL;
}
if (ctx->user_agent) {
DUER_FREE(ctx->user_agent);
ctx->user_agent = NULL;
}
if (ctx->serverAddr) {
DUER_FREE(ctx->serverAddr);
ctx->serverAddr = NULL;
}
if (ctx->res_list) {
DUER_FREE(ctx->res_list);
ctx->res_list = NULL;
}
duer_coap_trace_disable();
duer_mutex_destroy(ctx->mutex);
ctx->mutex = NULL;
DUER_FREE(ctx);
}
DUER_MEMDBG_USAGE();
DUER_LOGV("<== baidu_ca_release");
return DUER_OK;
}
Reference in New Issue View Git Blame Copy Permalink