更新硬件SDK

sdk/合宙/air780e/csdk/luatos-soc-2022/thirdparty/linksdk/components/dynreg/README.md

@@ -0,0 +1,3 @@
+Name: 动态注册
+DYNREG Component for Link SDK V4.0.0
+

sdk/合宙/air780e/csdk/luatos-soc-2022/thirdparty/linksdk/components/dynreg/aiot_dynreg_api.c

@@ -0,0 +1,522 @@
+/**
+ * @file aiot_dynreg_api.c
+ * @brief dynreg模块的API接口实现, 提供获取设备信息的能力
+ *
+ * @copyright Copyright (C) 2015-2020 Alibaba Group Holding Limited
+ *
+ */
+#include "dynreg_private.h"
+
+#include "core_string.h"
+#include "core_log.h"
+#include "core_auth.h"
+
+static void _dynreg_exec_inc(dynreg_handle_t *dynreg_handle)
+{
+    dynreg_handle->sysdep->core_sysdep_mutex_lock(dynreg_handle->data_mutex);
+    dynreg_handle->exec_count++;
+    dynreg_handle->sysdep->core_sysdep_mutex_unlock(dynreg_handle->data_mutex);
+}
+
+static void _dynreg_exec_dec(dynreg_handle_t *dynreg_handle)
+{
+    dynreg_handle->sysdep->core_sysdep_mutex_lock(dynreg_handle->data_mutex);
+    dynreg_handle->exec_count--;
+    dynreg_handle->sysdep->core_sysdep_mutex_unlock(dynreg_handle->data_mutex);
+}
+
+static int32_t _dynreg_sign(dynreg_handle_t *dynreg_handle, char *random, char sign_str[65])
+{
+    int32_t res = STATE_SUCCESS;
+    uint8_t sign_hex[32] = {0};
+    char *src_fmt = "deviceName%sproductKey%srandom%s";
+    char *src[] = {dynreg_handle->device_name, dynreg_handle->product_key, random};
+    char *plain_text = NULL;
+
+    res = core_sprintf(dynreg_handle->sysdep, &plain_text, src_fmt, src, sizeof(src) / sizeof(char *), DYNREG_MODULE_NAME);
+    if (res < STATE_SUCCESS) {
+        return res;
+    }
+
+    core_hmac_sha256((const uint8_t *)plain_text, (uint32_t)strlen(plain_text),
+                     (const uint8_t *)dynreg_handle->product_secret, (uint32_t)strlen(dynreg_handle->product_secret), sign_hex);
+    core_hex2str(sign_hex, 32, sign_str, 0);
+
+    dynreg_handle->sysdep->core_sysdep_free(plain_text);
+
+    return STATE_SUCCESS;
+}
+
+static void _dynreg_recv_handler(void *handle, const aiot_http_recv_t *packet, void *userdata)
+{
+    dynreg_handle_t *dynreg_handle = (dynreg_handle_t *)userdata;
+
+    if (dynreg_handle->recv_handler == NULL) {
+        return;
+    }
+
+    switch (packet->type) {
+        case AIOT_HTTPRECV_STATUS_CODE: {
+            dynreg_handle->response.code = packet->data.status_code.code;
+        }
+        break;
+        case AIOT_HTTPRECV_HEADER: {
+            if ((strlen(packet->data.header.key) == strlen("Content-Length")) &&
+                (memcmp(packet->data.header.key, "Content-Length", strlen(packet->data.header.key)) == 0)) {
+                core_str2uint(packet->data.header.value, (uint8_t)strlen(packet->data.header.value),
+                              &dynreg_handle->response.content_total_len);
+            }
+        }
+        break;
+        case AIOT_HTTPRECV_BODY: {
+            uint8_t *content = dynreg_handle->sysdep->core_sysdep_malloc(dynreg_handle->response.content_len + packet->data.body.len
+                               + 1,
+                               CORE_HTTP_MODULE_NAME);
+            if (content == NULL) {
+                return;
+            }
+            memset(content, 0, dynreg_handle->response.content_len + packet->data.body.len + 1);
+            if (content != NULL) {
+                memcpy(content, dynreg_handle->response.content, dynreg_handle->response.content_len);
+                dynreg_handle->sysdep->core_sysdep_free(dynreg_handle->response.content);
+            }
+            memcpy(content + dynreg_handle->response.content_len, packet->data.body.buffer, packet->data.body.len);
+            dynreg_handle->response.content = content;
+            dynreg_handle->response.content_len = dynreg_handle->response.content_len + packet->data.body.len;
+        }
+        break;
+        default: {
+
+        }
+        break;
+    }
+}
+
+static int32_t _dynreg_device_info(dynreg_handle_t *dynreg_handle, char **device_secret)
+{
+    int32_t res = STATE_SUCCESS;
+    char *tmp_ds = NULL, *ds_key = "deviceSecret";
+    char *ds_value = NULL;
+    uint32_t ds_value_len = 0;
+
+    if (dynreg_handle->response.code != 200) {
+        return STATE_DYNREG_INVALID_STATUS_CODE;
+    }
+
+    if ((res = core_json_value((char *)dynreg_handle->response.content, dynreg_handle->response.content_len, ds_key,
+                               strlen(ds_key), &ds_value, &ds_value_len)) < STATE_SUCCESS) {
+        return STATE_DYNREG_INVALID_DEVICE_SECRET;
+    }
+
+    tmp_ds = dynreg_handle->sysdep->core_sysdep_malloc(ds_value_len + 1, DYNREG_MODULE_NAME);
+    if (tmp_ds == NULL) {
+        return STATE_SYS_DEPEND_MALLOC_FAILED;
+    }
+    memset(tmp_ds, 0, ds_value_len + 1);
+    memcpy(tmp_ds, ds_value, ds_value_len);
+
+    *device_secret = tmp_ds;
+
+    return STATE_SUCCESS;
+}
+
+void *aiot_dynreg_init(void)
+{
+    dynreg_handle_t *dynreg_handle = NULL;
+    aiot_sysdep_portfile_t *sysdep = NULL;
+
+    sysdep = aiot_sysdep_get_portfile();
+    if (sysdep == NULL) {
+        return NULL;
+    }
+
+    dynreg_handle = sysdep->core_sysdep_malloc(sizeof(dynreg_handle_t), DYNREG_MODULE_NAME);
+    if (dynreg_handle == NULL) {
+        return NULL;
+    }
+    memset(dynreg_handle, 0, sizeof(dynreg_handle_t));
+
+    dynreg_handle->sysdep = sysdep;
+    dynreg_handle->response_body_len = DYNREG_RESPONSE_BODY_LEN;
+    dynreg_handle->timeout_ms = DYNREG_DEFAULT_TIMEOUT_MS;
+    dynreg_handle->deinit_timeout_ms = DYNREG_DEFAULT_DEINIT_TIMEOUT_MS;
+    dynreg_handle->send_timeout_ms = DYNREG_DEFAULT_SEND_TIMEOUT;
+    dynreg_handle->recv_timeout_ms = DYNREG_DEFAULT_RECV_TIMEOUT;
+    dynreg_handle->data_mutex = dynreg_handle->sysdep->core_sysdep_mutex_init();
+
+    dynreg_handle->exec_enabled = 1;
+
+    return dynreg_handle;
+}
+
+int32_t aiot_dynreg_setopt(void *handle, aiot_dynreg_option_t option, void *data)
+{
+    int32_t res = STATE_SUCCESS;
+    dynreg_handle_t *dynreg_handle = (dynreg_handle_t *)handle;
+
+    if (dynreg_handle == NULL || data == NULL) {
+        return STATE_USER_INPUT_NULL_POINTER;
+    }
+
+    if (option >= AIOT_DYNREGOPT_MAX) {
+        return STATE_USER_INPUT_OUT_RANGE;
+    }
+
+    if (dynreg_handle->exec_enabled == 0) {
+        return STATE_USER_INPUT_EXEC_DISABLED;
+    }
+
+    _dynreg_exec_inc(dynreg_handle);
+
+    dynreg_handle->sysdep->core_sysdep_mutex_lock(dynreg_handle->data_mutex);
+    switch (option) {
+        case AIOT_DYNREGOPT_NETWORK_CRED: {
+            if (dynreg_handle->cred != NULL) {
+                dynreg_handle->sysdep->core_sysdep_free(dynreg_handle->cred);
+                dynreg_handle->cred = NULL;
+            }
+            dynreg_handle->cred = dynreg_handle->sysdep->core_sysdep_malloc(sizeof(aiot_sysdep_network_cred_t), DYNREG_MODULE_NAME);
+            if (dynreg_handle->cred != NULL) {
+                memset(dynreg_handle->cred, 0, sizeof(aiot_sysdep_network_cred_t));
+                memcpy(dynreg_handle->cred, data, sizeof(aiot_sysdep_network_cred_t));
+            } else {
+                res = STATE_SYS_DEPEND_MALLOC_FAILED;
+            }
+        }
+        break;
+        case AIOT_DYNREGOPT_HOST: {
+            res = core_strdup(dynreg_handle->sysdep, &dynreg_handle->host, data, DYNREG_MODULE_NAME);
+        }
+        break;
+        case AIOT_DYNREGOPT_PORT: {
+            dynreg_handle->port = *(uint16_t *)data;
+        }
+        break;
+        case AIOT_DYNREGOPT_PRODUCT_KEY: {
+            res = core_strdup(dynreg_handle->sysdep, &dynreg_handle->product_key, data, DYNREG_MODULE_NAME);
+        }
+        break;
+        case AIOT_DYNREGOPT_PRODUCT_SECRET: {
+            res = core_strdup(dynreg_handle->sysdep, &dynreg_handle->product_secret, data, DYNREG_MODULE_NAME);
+        }
+        break;
+        case AIOT_DYNREGOPT_DEVICE_NAME: {
+            res = core_strdup(dynreg_handle->sysdep, &dynreg_handle->device_name, data, DYNREG_MODULE_NAME);
+        }
+        break;
+        case AIOT_DYNREGOPT_SEND_TIMEOUT_MS: {
+            dynreg_handle->send_timeout_ms = *(uint32_t *)data;
+        }
+        break;
+        case AIOT_DYNREGOPT_RECV_TIMEOUT_MS: {
+            dynreg_handle->recv_timeout_ms = *(uint32_t *)data;
+        }
+        break;
+        case AIOT_DYNREGOPT_RECV_HANDLER: {
+            dynreg_handle->recv_handler = (aiot_dynreg_recv_handler_t)data;
+        }
+        break;
+        case AIOT_DYNREGOPT_USERDATA: {
+            dynreg_handle->userdata = data;
+        }
+        break;
+        case AIOT_DYNREGOPT_TIMEOUT_MS: {
+            dynreg_handle->timeout_ms = *(uint32_t *)data;
+        }
+        break;
+        case AIOT_DYNREGOPT_DEINIT_TIMEOUT_MS: {
+            dynreg_handle->deinit_timeout_ms = *(uint32_t *)data;
+        }
+        break;
+        default: {
+            res = STATE_USER_INPUT_UNKNOWN_OPTION;
+        }
+        break;
+    }
+    dynreg_handle->sysdep->core_sysdep_mutex_unlock(dynreg_handle->data_mutex);
+
+    _dynreg_exec_dec(dynreg_handle);
+
+    return res;
+}
+
+int32_t aiot_dynreg_deinit(void **handle)
+{
+    uint64_t deinit_timestart = 0;
+    dynreg_handle_t *dynreg_handle = NULL;
+    aiot_sysdep_portfile_t *sysdep = NULL;
+
+    if (handle == NULL || *handle == NULL) {
+        return STATE_USER_INPUT_NULL_POINTER;
+    }
+
+    dynreg_handle = *(dynreg_handle_t **)handle;
+    sysdep = dynreg_handle->sysdep;
+
+    if (dynreg_handle->exec_enabled == 0) {
+        return STATE_USER_INPUT_EXEC_DISABLED;
+    }
+
+    dynreg_handle->exec_enabled = 0;
+    deinit_timestart = dynreg_handle->sysdep->core_sysdep_time();
+    do {
+        if (dynreg_handle->exec_count == 0) {
+            break;
+        }
+        dynreg_handle->sysdep->core_sysdep_sleep(DYNREG_DEINIT_INTERVAL_MS);
+    } while ((dynreg_handle->sysdep->core_sysdep_time() - deinit_timestart) < dynreg_handle->deinit_timeout_ms);
+
+    if (dynreg_handle->exec_count != 0) {
+        return STATE_DYNREG_DEINIT_TIMEOUT;
+    }
+
+    *handle = NULL;
+
+    if (dynreg_handle->response.content != NULL) {
+        sysdep->core_sysdep_free(dynreg_handle->response.content);
+    }
+    memset(&dynreg_handle->response, 0, sizeof(core_http_response_t));
+
+    if (dynreg_handle->http_handle != NULL) {
+        core_http_deinit(&dynreg_handle->http_handle);
+    }
+
+    if (dynreg_handle->host != NULL) {
+        sysdep->core_sysdep_free(dynreg_handle->host);
+    }
+
+    if (dynreg_handle->product_key != NULL) {
+        sysdep->core_sysdep_free(dynreg_handle->product_key);
+    }
+
+    if (dynreg_handle->product_secret != NULL) {
+        sysdep->core_sysdep_free(dynreg_handle->product_secret);
+    }
+
+    if (dynreg_handle->device_name != NULL) {
+        sysdep->core_sysdep_free(dynreg_handle->device_name);
+    }
+
+    if (dynreg_handle->cred != NULL) {
+        sysdep->core_sysdep_free(dynreg_handle->cred);
+    }
+
+    sysdep->core_sysdep_mutex_deinit(&dynreg_handle->data_mutex);
+
+    sysdep->core_sysdep_free(dynreg_handle);
+
+    return STATE_SUCCESS;
+}
+
+int32_t aiot_dynreg_send_request(void *handle)
+{
+    int32_t res = STATE_SUCCESS;
+    dynreg_handle_t *dynreg_handle = (dynreg_handle_t *)handle;
+
+    if (dynreg_handle == NULL) {
+        return STATE_USER_INPUT_NULL_POINTER;
+    }
+
+    if (dynreg_handle->host == NULL) {
+        return STATE_USER_INPUT_MISSING_HOST;
+    }
+
+    if (dynreg_handle->product_key == NULL) {
+        return STATE_USER_INPUT_MISSING_PRODUCT_KEY;
+    }
+
+    if (dynreg_handle->product_secret == NULL) {
+        return STATE_USER_INPUT_MISSING_PRODUCT_SECRET;
+    }
+
+    if (dynreg_handle->device_name == NULL) {
+        return STATE_USER_INPUT_MISSING_DEVICE_NAME;
+    }
+
+    if (dynreg_handle->exec_enabled == 0) {
+        return STATE_USER_INPUT_EXEC_DISABLED;
+    }
+
+    _dynreg_exec_inc(dynreg_handle);
+
+    dynreg_handle->sysdep->core_sysdep_mutex_lock(dynreg_handle->data_mutex);
+    if (dynreg_handle->response.content != NULL) {
+        dynreg_handle->sysdep->core_sysdep_free(dynreg_handle->response.content);
+    }
+    memset(&dynreg_handle->response, 0, sizeof(core_http_response_t));
+
+    if (dynreg_handle->http_handle != NULL) {
+        core_http_deinit(&dynreg_handle->http_handle);
+    }
+
+    dynreg_handle->http_handle = core_http_init();
+    if (dynreg_handle->http_handle == NULL) {
+        dynreg_handle->sysdep->core_sysdep_mutex_unlock(dynreg_handle->data_mutex);
+        _dynreg_exec_dec(dynreg_handle);
+        return STATE_SYS_DEPEND_MALLOC_FAILED;
+    }
+
+    if (((res = core_http_setopt(dynreg_handle->http_handle, CORE_HTTPOPT_HOST,
+                                 (void *)dynreg_handle->host)) < STATE_SUCCESS) ||
+        ((res = core_http_setopt(dynreg_handle->http_handle, CORE_HTTPOPT_PORT, (void *)&dynreg_handle->port)) < STATE_SUCCESS)
+        ||
+        ((res = core_http_setopt(dynreg_handle->http_handle, CORE_HTTPOPT_NETWORK_CRED,
+                                 (void *)dynreg_handle->cred)) < STATE_SUCCESS) ||
+        ((res = core_http_setopt(dynreg_handle->http_handle, CORE_HTTPOPT_SEND_TIMEOUT_MS,
+                                 (void *)&dynreg_handle->send_timeout_ms)) < STATE_SUCCESS) ||
+        ((res = core_http_setopt(dynreg_handle->http_handle, CORE_HTTPOPT_RECV_TIMEOUT_MS,
+                                 (void *)&dynreg_handle->recv_timeout_ms)) < STATE_SUCCESS) ||
+        ((res = core_http_setopt(dynreg_handle->http_handle, CORE_HTTPOPT_BODY_BUFFER_MAX_LEN,
+                                 (void *)&dynreg_handle->response_body_len)) < STATE_SUCCESS) ||
+        ((res = core_http_setopt(dynreg_handle->http_handle, CORE_HTTPOPT_RECV_HANDLER,
+                                 (void *)_dynreg_recv_handler)) < STATE_SUCCESS) ||
+        ((res = core_http_setopt(dynreg_handle->http_handle, CORE_HTTPOPT_USERDATA, (void *)dynreg_handle)) < STATE_SUCCESS)) {
+        core_http_deinit(&dynreg_handle->http_handle);
+        dynreg_handle->sysdep->core_sysdep_mutex_unlock(dynreg_handle->data_mutex);
+        _dynreg_exec_dec(dynreg_handle);
+        return res;
+    }
+
+    res = core_http_connect(dynreg_handle->http_handle);
+    if (res < STATE_SUCCESS) {
+        core_http_deinit(&dynreg_handle->http_handle);
+        dynreg_handle->sysdep->core_sysdep_mutex_unlock(dynreg_handle->data_mutex);
+        _dynreg_exec_dec(dynreg_handle);
+        return res;
+    }
+
+    {
+        uint32_t random_num = 0;
+        char random[11] = {0};
+        char sign_str[65] = {0};
+        char *content = NULL;
+        char *content_fmt = "productKey=%s&deviceName=%s&random=%s&sign=%s&signMethod=hmacsha256";
+        char *content_src[] = { dynreg_handle->product_key, dynreg_handle->device_name, (char *)random, sign_str };
+        core_http_request_t request;
+
+        dynreg_handle->sysdep->core_sysdep_rand((uint8_t *)&random_num, 4);
+        core_uint2str(random_num, random, NULL);
+
+        res = _dynreg_sign(dynreg_handle, (char *)random, sign_str);
+        if (res < STATE_SUCCESS) {
+            core_http_deinit(&dynreg_handle->http_handle);
+            dynreg_handle->sysdep->core_sysdep_mutex_unlock(dynreg_handle->data_mutex);
+            _dynreg_exec_dec(dynreg_handle);
+            return res;
+        }
+
+
+        memset(&request, 0, sizeof(core_http_request_t));
+        res = core_sprintf(dynreg_handle->sysdep, &content, content_fmt, content_src, sizeof(content_src) / sizeof(char *),
+                           DYNREG_MODULE_NAME);
+        if (res < STATE_SUCCESS) {
+            core_http_deinit(&dynreg_handle->http_handle);
+            dynreg_handle->sysdep->core_sysdep_mutex_unlock(dynreg_handle->data_mutex);
+            _dynreg_exec_dec(dynreg_handle);
+            return res;
+        }
+        request.method = "POST";
+        request.path = DYNREG_PATH;
+        request.header = "Accept: text/xml,text/javascript,text/html,application/json\r\n" \
+                         "Content-Type: application/x-www-form-urlencoded\r\n";
+        request.content = (uint8_t *)content;
+        request.content_len = (uint32_t)strlen(content);
+
+        res = core_http_send(dynreg_handle->http_handle, &request);
+        dynreg_handle->sysdep->core_sysdep_free(content);
+        if (res < STATE_SUCCESS) {
+            core_http_deinit(&dynreg_handle->http_handle);
+            dynreg_handle->sysdep->core_sysdep_mutex_unlock(dynreg_handle->data_mutex);
+            _dynreg_exec_dec(dynreg_handle);
+            return res;
+        }
+    }
+    dynreg_handle->sysdep->core_sysdep_mutex_unlock(dynreg_handle->data_mutex);
+    _dynreg_exec_dec(dynreg_handle);
+
+    return res;
+}
+
+int32_t aiot_dynreg_recv(void *handle)
+{
+    int32_t res = STATE_SUCCESS;
+    uint64_t timenow_ms = 0;
+    dynreg_handle_t *dynreg_handle = (dynreg_handle_t *)handle;
+    char *device_secret = NULL;
+    aiot_dynreg_recv_t packet;
+
+    if (dynreg_handle == NULL) {
+        return STATE_USER_INPUT_NULL_POINTER;
+    }
+
+    if (dynreg_handle->http_handle == NULL) {
+        return STATE_DYNREG_NEED_SEND_REQUEST;
+    }
+
+    if (dynreg_handle->exec_enabled == 0) {
+        return STATE_USER_INPUT_EXEC_DISABLED;
+    }
+
+    _dynreg_exec_inc(dynreg_handle);
+
+    dynreg_handle->sysdep->core_sysdep_mutex_lock(dynreg_handle->data_mutex);
+    timenow_ms = dynreg_handle->sysdep->core_sysdep_time();
+    while (1) {
+        if (timenow_ms >= dynreg_handle->sysdep->core_sysdep_time()) {
+            timenow_ms = dynreg_handle->sysdep->core_sysdep_time();
+        }
+        if (dynreg_handle->sysdep->core_sysdep_time() - timenow_ms >= dynreg_handle->timeout_ms) {
+            break;
+        }
+
+        res = core_http_recv(dynreg_handle->http_handle);
+        if (res < STATE_SUCCESS) {
+            break;
+        }
+    }
+
+    if (res < STATE_SUCCESS) {
+        if (res != STATE_HTTP_READ_BODY_FINISHED) {
+            if (dynreg_handle->response.content != NULL) {
+                dynreg_handle->sysdep->core_sysdep_free(dynreg_handle->response.content);
+                memset(&dynreg_handle->response, 0, sizeof(core_http_response_t));
+            }
+            dynreg_handle->sysdep->core_sysdep_mutex_unlock(dynreg_handle->data_mutex);
+            _dynreg_exec_dec(dynreg_handle);
+            return res;
+        } else {
+            res = STATE_SUCCESS;
+        }
+    } else {
+        dynreg_handle->sysdep->core_sysdep_mutex_unlock(dynreg_handle->data_mutex);
+        _dynreg_exec_dec(dynreg_handle);
+        return STATE_HTTP_RECV_NOT_FINISHED;
+    }
+
+    if (dynreg_handle->recv_handler != NULL) {
+        packet.type = AIOT_DYNREGRECV_STATUS_CODE;
+        packet.data.status_code.code = dynreg_handle->response.code;
+
+        dynreg_handle->recv_handler(dynreg_handle, &packet, dynreg_handle->userdata);
+    }
+
+    res = _dynreg_device_info(dynreg_handle, &device_secret);
+    dynreg_handle->sysdep->core_sysdep_mutex_unlock(dynreg_handle->data_mutex);
+    if (res < STATE_SUCCESS) {
+        _dynreg_exec_dec(dynreg_handle);
+        return res;
+    }
+
+    memset(&packet, 0, sizeof(aiot_dynreg_recv_t));
+    if (dynreg_handle->recv_handler != NULL) {
+        packet.type = AIOT_DYNREGRECV_DEVICE_INFO;
+        packet.data.device_info.device_secret = device_secret;
+
+        dynreg_handle->recv_handler(dynreg_handle, &packet, dynreg_handle->userdata);
+    }
+    dynreg_handle->sysdep->core_sysdep_free(device_secret);
+
+    _dynreg_exec_dec(dynreg_handle);
+    return STATE_SUCCESS;
+}
+

sdk/合宙/air780e/csdk/luatos-soc-2022/thirdparty/linksdk/components/dynreg/aiot_dynreg_api.h

@@ -0,0 +1,302 @@
+/**
+ * @file aiot_dynreg_api.h
+ * @brief dynreg模块头文件, 提供获取设备信息的能力
+ *
+ * @copyright Copyright (C) 2015-2020 Alibaba Group Holding Limited
+ *
+ */
+#ifndef __AIOT_DYNREG_API_H__
+#define __AIOT_DYNREG_API_H__
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+/**
+ * @brief -0x0600~-0x06FF表达SDK在dynreg模块内的状态码
+ */
+#define STATE_DYNREG_BASE                                             (-0x0600)
+
+/**
+ * @brief 执行@ref aiot_dynreg_deinit 时, 等待其他API执行结束的超过设定的超时时间, MQTT实例销毁失败
+ */
+#define STATE_DYNREG_DEINIT_TIMEOUT                                   (-0x0601)
+
+/**
+ * @brief 需要首先执行@ref aiot_dynreg_send_request 发送dynreg请求
+ */
+#define STATE_DYNREG_NEED_SEND_REQUEST                                (-0x0602)
+
+/**
+ * @brief dynreg模块返回了错误的http status code
+ */
+#define STATE_DYNREG_INVALID_STATUS_CODE                              (-0x0603)
+
+/**
+ * @brief 收到非法的device secret
+ */
+#define STATE_DYNREG_INVALID_DEVICE_SECRET                            (-0x0604)
+
+/**
+ * @brief dynreg模块收到从网络上来的报文时, 通知用户的报文类型
+ */
+typedef enum {
+    /**
+     * @brief dynreg模块返回的http status code
+     */
+    AIOT_DYNREGRECV_STATUS_CODE,
+    /**
+     * @brief dynreg模块返回的设备信息
+     */
+    AIOT_DYNREGRECV_DEVICE_INFO,
+} aiot_dynreg_recv_type_t;
+
+/**
+ * @brief dynreg模块收到从网络上来的报文时, 通知用户的报文内容
+ */
+typedef struct {
+    /**
+     * @brief 报文内容所对应的报文类型, 更多信息请参考@ref aiot_dynreg_recv_type_t
+     */
+    aiot_dynreg_recv_type_t  type;
+    union {
+        /**
+         * @brief dynreg模块返回的http status code
+         */
+        struct {
+            uint32_t code;
+        } status_code;
+        /**
+         * @brief dynreg模块返回的设备信息
+         */
+        struct {
+            char *device_secret;
+        } device_info;
+    } data;
+} aiot_dynreg_recv_t;
+
+/**
+ * @brief dynreg模块收到从网络上来的报文时, 通知用户所调用的数据回调函数
+ *
+ * @param[in] handle dynreg会话句柄
+ * @param[in] packet dynreg消息结构体, 存放收到的dynreg报文内容
+ * @param[in] userdata 用户上下文
+ *
+ * @return void
+ */
+typedef void (* aiot_dynreg_recv_handler_t)(void *handle,
+        const aiot_dynreg_recv_t *packet, void *userdata);
+
+/**
+ * @brief @ref aiot_dynreg_setopt 接口的option参数可选值.
+ *
+ * @details 下文每个选项中的数据类型, 指的是@ref aiot_dynreg_setopt 中, data参数的数据类型
+ *
+ * 1. data的数据类型是char *时, 以配置@ref AIOT_DYNREGOPT_HOST 为例:
+ *
+ *    char *host = "xxx";
+ *    aiot_dynreg_setopt(dynreg_handle, AIOT_DYNREGOPT_HOST, host);
+ *
+ * 2. data的数据类型是其他数据类型时, 以配置@ref AIOT_DYNREGOPT_PORT 为例:
+ *
+ *    uint16_t port = 443;
+ *    aiot_mqtt_setopt(dynreg_handle, AIOT_DYNREGOPT_PORT, (void *)&port);
+ */
+typedef enum {
+    /**
+     * @brief http动态注册 服务器建联时, 网络使用的安全凭据
+     *
+     * @details
+     *
+     * 该配置项用于为底层网络配置@ref aiot_sysdep_network_cred_t 安全凭据数据
+     *
+     * 应当把 @ref aiot_sysdep_network_cred_t 中option配置为@ref AIOT_SYSDEP_NETWORK_CRED_SVRCERT_CA , 以tls方式建联
+     *
+     * 数据类型: (aiot_sysdep_network_cred_t *)
+     */
+    AIOT_DYNREGOPT_NETWORK_CRED,
+
+    /**
+     * @brief http动态注册 服务器的域名地址或者ip地址
+     *
+     * @details
+     *
+     * 阿里云物联网平台 http动态注册 服务器域名地址列表:
+     *
+     * | 域名地址                                        | 区域    | 端口号
+     * |-------------------------------------------------|---------|---------
+     * | iot-auth.cn-shanghai.aliyuncs.com               | 国内    | 443
+     * | iot-auth.ap-southeast-1.aliyuncs.com            | 海外    | 443
+     *
+     * 数据类型: (char *)
+     */
+    AIOT_DYNREGOPT_HOST,
+
+    /**
+     * @brief http动态注册 服务器的端口号
+     *
+     * @details
+     *
+     * 连接阿里云物联网平台 http动态注册 服务器时:
+     *
+     * 必须使用tls方式建联, 端口号设置为443
+     *
+     * 数据类型: (uint16_t *)
+     */
+    AIOT_DYNREGOPT_PORT,
+
+    /**
+     * @brief 设备的productKey, 可从<a href="http://iot.console.aliyun.com/">阿里云物联网平台控制台</a>获取
+     *
+     * @details
+     *
+     * 数据类型: (char *)
+     */
+    AIOT_DYNREGOPT_PRODUCT_KEY,
+
+    /**
+     * @brief 设备的productSecret, 可从<a href="http://iot.console.aliyun.com/">阿里云物联网平台控制台</a>获取
+     *
+     * @details
+     *
+     * 数据类型: (char *)
+     */
+    AIOT_DYNREGOPT_PRODUCT_SECRET,
+
+    /**
+     * @brief 设备的deviceName, 可从<a href="http://iot.console.aliyun.com/">阿里云物联网平台控制台</a>获取
+     *
+     * @details
+     *
+     * 数据类型: (char *)
+     */
+    AIOT_DYNREGOPT_DEVICE_NAME,
+
+    /**
+     * @brief dynreg会话发送消息时可消费的最长时间间隔
+     *
+     * @details
+     *
+     * 数据类型: (uint32_t) 默认值: (5 * 1000) ms
+     */
+    AIOT_DYNREGOPT_SEND_TIMEOUT_MS,
+
+    /**
+     * @brief dynreg会话接收消息时可消费的最长时间间隔
+     *
+     * @details
+     *
+     * 数据类型: (uint32_t) 默认值: (5 * 1000) ms
+     */
+    AIOT_DYNREGOPT_RECV_TIMEOUT_MS,
+
+    /**
+     * @brief 设置回调, 它在SDK收到网络报文的时候被调用, 告知用户
+     *
+     * @details
+     *
+     * 数据类型: (aiot_dynreg_http_recv_handler_t)
+     */
+    AIOT_DYNREGOPT_RECV_HANDLER,
+
+    /**
+     * @brief 用户需要SDK暂存的上下文
+     *
+     * @details
+     *
+     * 这个上下文指针会在 AIOT_DYNREGOPT_RECV_HANDLER 和 AIOT_DYNREGOPT_EVENT_HANDLER 设置的回调被调用时, 由SDK传给用户
+     *
+     * 数据类型: (void *)
+     */
+    AIOT_DYNREGOPT_USERDATA,
+
+    /**
+     * @brief dynreg模块接收消息的超时时间
+     *
+     * @details
+     *
+     * 数据类型: (uint32_t) 默认值: (5 * 1000) ms
+     */
+    AIOT_DYNREGOPT_TIMEOUT_MS,
+
+    /**
+     * @brief 销毁dynreg实例时, 等待其他api执行完毕的时间
+     *
+     * @details
+     *
+     * 当调用@ref aiot_dynreg_deinit 销毁MQTT实例时, 若继续调用其他aiot_dynreg_xxx API, API会返回@ref STATE_USER_INPUT_EXEC_DISABLED 错误
+     *
+     * 此时, 用户应该停止调用其他aiot_dynreg_xxx API
+     *
+     * 数据类型: (uint32_t *) 默认值: (2 * 1000) ms
+     */
+    AIOT_DYNREGOPT_DEINIT_TIMEOUT_MS,
+    AIOT_DYNREGOPT_MAX
+} aiot_dynreg_option_t;
+
+/**
+ * @brief 创建dynreg会话实例, 并以默认值配置会话参数
+ *
+ * @return void *
+ * @retval 非NULL dynreg实例的句柄
+ * @retval NULL   初始化失败, 一般是内存分配失败导致
+ *
+ */
+void *aiot_dynreg_init(void);
+
+/**
+ * @brief 配置dynreg会话
+ *
+ * @param[in] handle dynreg会话句柄
+ * @param[in] option 配置选项, 更多信息请参考@ref aiot_dynreg_option_t
+ * @param[in] data   配置选项数据, 更多信息请参考@ref aiot_dynreg_option_t
+ *
+ * @return int32_t
+ * @retval <STATE_SUCCESS  参数配置失败
+ * @retval >=STATE_SUCCESS 参数配置成功
+ *
+ */
+int32_t aiot_dynreg_setopt(void *handle, aiot_dynreg_option_t option, void *data);
+
+/**
+ * @brief 结束dynreg会话, 销毁实例并回收资源
+ *
+ * @param[in] handle 指向dynreg会话句柄的指针
+ *
+ * @return int32_t
+ * @retval <STATE_SUCCESS  执行失败
+ * @retval >=STATE_SUCCESS 执行成功
+ *
+ */
+int32_t aiot_dynreg_deinit(void **handle);
+
+/**
+ * @brief 向dynreg服务器发送dynreg消息请求
+ *
+ * @param handle dynreg会话句柄
+ *
+ * @return int32_t
+ * @retval <STATE_SUCCESS  请求发送失败
+ * @retval >=STATE_SUCCESS 请求发送成功
+ */
+int32_t aiot_dynreg_send_request(void *handle);
+
+/**
+ * @brief 从网络上收取dynreg消息
+ *
+ * @param handle dynreg会话句柄
+ *
+ * @return int32_t
+ * @retval <STATE_SUCCESS  数据接收失败
+ * @retval >=STATE_SUCCESS 数据接收成功
+ */
+int32_t aiot_dynreg_recv(void *handle);
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif  /* __AIOT_DYNREG_API_H__ */
+

sdk/合宙/air780e/csdk/luatos-soc-2022/thirdparty/linksdk/components/dynreg/dynreg_private.h

@@ -0,0 +1,73 @@
+/**
+ * @file dynreg_private.h
+ * @brief dynreg模块内部的宏定义和数据结构声明, 不面向其它模块, 更不面向用户
+ *
+ * @copyright Copyright (C) 2015-2020 Alibaba Group Holding Limited
+ *
+ */
+#ifndef __DYNREG_PRIVATE_H__
+#define __DYNREG_PRIVATE_H__
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+/* 用这种方式包含标准C库的头文件 */
+#include "core_stdinc.h"
+
+/* TODO: 这一段列出需要包含SDK其它模块头文件, 与上一段落以1个空行隔开 */
+#include "aiot_state_api.h"
+#include "aiot_sysdep_api.h"
+#include "core_http.h"
+#include "aiot_dynreg_api.h"      /* 内部头文件是用户可见头文件的超集 */
+
+/* TODO: 定义dynreg模块内部的会话句柄结构体, SDK用户不可见, 只能得到void *handle类型的指针 */
+typedef struct {
+
+    aiot_sysdep_portfile_t     *sysdep;             /* 底层依赖回调合集的引用指针 */
+    aiot_sysdep_network_cred_t *cred;               /* 指向当前连接使用的安全凭据 */
+
+    char       *host;                               /* 会话目标服务器域名 */
+    uint16_t    port;                               /* 会话目标服务器端口 */
+    char       *product_key;
+    char       *product_secret;
+    char       *device_name;
+
+    aiot_dynreg_recv_handler_t    recv_handler;       /* 组件从协议栈读到内容时, 通知用户的回调 */
+    void *userdata;                                /* 组件调用以上2个 dynreg_handler 时的入参之一 */
+
+    uint32_t    recv_timeout_ms;                       /* 从协议栈收包时最长等待时间 */
+    uint32_t    send_timeout_ms;                       /* 向协议栈写入时最长花费时间 */
+    uint32_t    timeout_ms;
+    uint32_t    deinit_timeout_ms;
+
+    /*---- 以上都是用户在API可配 ----*/
+
+    /*---- 以下都是DYNREG在内部使用, 用户无感知 ----*/
+    void *http_handle;
+    core_http_response_t response;
+    uint32_t    response_body_len;
+    uint8_t     exec_enabled;
+    uint32_t    exec_count;
+
+    void       *data_mutex;     /* 保护本地的数据结构 */
+
+} dynreg_handle_t;
+
+#define DYNREG_MODULE_NAME                      "dynreg"  /* 用于内存统计的模块名字符串 */
+
+#define DYNREG_DEFAULT_TIMEOUT_MS               (5 * 1000)
+#define DYNREG_DEFAULT_DEINIT_TIMEOUT_MS        (2 * 1000)
+#define DYNREG_DEFAULT_RECV_TIMEOUT             (5 * 1000)
+#define DYNREG_DEFAULT_SEND_TIMEOUT             (5 * 1000)
+
+#define DYNREG_PATH                             "/auth/register/device"
+
+#define DYNREG_DEINIT_INTERVAL_MS               (100)
+#define DYNREG_RESPONSE_BODY_LEN                (192)
+
+#if defined(__cplusplus)
+}
+#endif
+#endif  /* __DYNREG_PRIVATE_H__ */
+