#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/select.h>
#include <sys/stat.h>
#include <sys/syscall.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#include "cJSON.h"

#include "auxiliary.h"

// #define AUXILIARY_CFGFILE "auxiliary.json"

#define AUXILIARY_CFGFILE "/app/config/ems/auxiliary.json"
// #undef DEBUG
// #ifdef DEBUG
// #undef dy_syslog
// #define dy_syslog(xx, fmt, ...) printf("[%s:%d->%s]" fmt "\r\n", __FILE__, __LINE__, __func__, ##__VA_ARGS__)
// #else
// #endif

#define SERVICEUPCONT var->devNodeInfo.serviceupcont
#define SERVICEDOWNCONT var->devNodeInfo.servicedowncont
#define SERVICE_DOWN var->devNodeInfo.pserviceInfoDOWN
#define SERVICE_UP var->devNodeInfo.pserviceInfoUP
#define DI_UP var->auxiliaryInfo

#define SERVICEUPCONTSUB var->subdevNodeInfo.serviceupcont
#define SERVICEDOWNCONTSUB var->subdevNodeInfo.servicedowncont
#define SERVICE_DOWNSUB var->subdevNodeInfo.pserviceInfoDOWN
#define SERVICE_UPSUB var->subdevNodeInfo.pserviceInfoUP
#define SUB_DI_UP var->auxiliaryInfoall

#define PCS_MI 12323

static int auxiliary_cfg(auxiliary_var_t *var, const char *cfg_file)
{
    CHAR *pdata = NULL;
    cJSON *root = NULL;
    cJSON *nodes = NULL;
    cJSON *node = NULL;
    cJSON *tmp = NULL;
    int node_cnt = 0, i = 0;
    BYTE flag = E_TRUE;

    if (var == NULL || cfg_file == NULL)
    {
        dbg_syslog(LOG_ERR, "pcfg:%p cfg_file:%p", var, cfg_file);
        return -1;
    }
    pdata = read_file_data(cfg_file);

    if (pdata == NULL)
    {
        dbg_syslog(LOG_ERR, "read cfg file %s error", cfg_file);
        flag = E_FALSE;
        goto out;
    }
    root = cJSON_Parse(pdata);
    if (!root)
    {
        dbg_syslog(LOG_ERR, "parse cfg file %s error", cfg_file);
        flag = E_FALSE;
        goto out;
    }
    GET_JSON_VALUE_STRING_LOG(root, "devSn", var->vir_sn_str);
    GET_JSON_VALUE_STRING_LOG(root, "desSn", var->desSn);
    GET_JSON_VALUE_INT_LOG(root, "runMode", var->runMode);
    GET_JSON_VALUE_INT_LOG(root, "linkage", var->linkageflag);
    GET_JSON_VALUE_INT_LOG(root, "pcserr", var->pcserr);

    if (var->runMode != E_ONGW_MODE)
    {
        nodes = cJSON_GetObjectItemCaseSensitive(root, "mqtt_broker");
        if (!nodes)
        {
            dbg_syslog(LOG_ERR, "get mqtt_broker failed");
            flag = E_FALSE;
            goto out;
        }
        GET_JSON_VALUE_STRING_LOG(nodes, "host", var->mqttBroker.hostname);
        GET_JSON_VALUE_STRING_LOG(nodes, "user", var->mqttBroker.username);
        GET_JSON_VALUE_STRING_LOG(nodes, "passwd", var->mqttBroker.password);
        GET_JSON_VALUE_INT_LOG(nodes, "port", var->mqttBroker.port);
    }
    nodes = cJSON_GetObjectItemCaseSensitive(root, "node");

    if (!nodes)
    {
        dbg_syslog(LOG_ERR, "get node failed");
        flag = E_FALSE;
        goto out;
    }

    node_cnt = cJSON_GetArraySize(nodes);
    if (node_cnt != 0)
    {
        var->devNodeInfo.pdevnodecfg = (DEV_NODE_CFG_T *)malloc(node_cnt * sizeof(DEV_NODE_CFG_T));
        var->auxiliaryInfo.precodeinfo = (DI_RECODE_INFO_T *)malloc(node_cnt * sizeof(DI_RECODE_INFO_T));
            if (var->devNodeInfo.pdevnodecfg == NULL || var->auxiliaryInfo.precodeinfo == NULL)
        {
            dbg_syslog(LOG_ERR, "malloc pdevnodcfg failed,node_cnt:%d", node_cnt);
            flag = E_FALSE;
            goto out;
        }
        memset(var->devNodeInfo.pdevnodecfg, 0, node_cnt * sizeof(DEV_NODE_CFG_T));
        var->devNodeInfo.devcont = node_cnt;
        for (i = 0; i < node_cnt; i++)
        {
            node = cJSON_GetArrayItem(nodes, i);
            GET_JSON_VALUE_STRING_LOG(node, "devSn", var->devNodeInfo.pdevnodecfg[i].devSn);
            GET_JSON_VALUE_STRING_LOG(node, "devGwSn", var->devNodeInfo.pdevnodecfg[i].devGwSn);
            GET_JSON_VALUE_STRING_LOG(node, "devOut", var->devNodeInfo.pdevnodecfg[i].devOut);
            GET_JSON_VALUE_STRING_LOG(node, "rmGwSn", var->devNodeInfo.pdevnodecfg[i].rmGwSn);
            GET_JSON_VALUE_STRING_LOG(node, "type", var->devNodeInfo.pdevnodecfg[i].type);
        }
    }
    nodes = cJSON_GetObjectItemCaseSensitive(root, "service_down");
    if (!nodes)
    {
        dbg_syslog(LOG_ERR, "get service_down failed");
        flag = E_FALSE;
        goto out;
    }
    node_cnt = cJSON_GetArraySize(nodes);
    if (node_cnt != 0)
    {
        var->devNodeInfo.pserviceInfoDOWN = (SERVICE_INFO_T *)malloc(node_cnt * sizeof(SERVICE_INFO_T));
        if (var->devNodeInfo.pserviceInfoDOWN == NULL)
        {
            dbg_syslog(LOG_ERR, "malloc pserviceInfoDOWN failed,node_cnt:%d", node_cnt);
            flag = E_FALSE;
            goto out;
        }
        var->devNodeInfo.servicedowncont = node_cnt;
        for (i = 0; i < node_cnt; i++)
        {
            node = cJSON_GetArrayItem(nodes, i);
            GET_JSON_VALUE_STRING_LOG(node, "identifier", var->devNodeInfo.pserviceInfoDOWN[i].identifier);
            GET_JSON_VALUE_STRING_LOG(node, "name", var->devNodeInfo.pserviceInfoDOWN[i].name);
        }
        // for (i = 0; i < node_cnt; i++)
        // {
        // dbg_syslog(LOG_ERR, "i:%d identifier:%s name:%s",i,SERVICE_DOWN[i].identifier,SERVICE_DOWN[i].name);
        // }
    }
    nodes = cJSON_GetObjectItemCaseSensitive(root, "service_up");
    if (!nodes)
    {
        dbg_syslog(LOG_ERR, "get service_up failed");
        flag = E_FALSE;
        goto out;
    }
    node_cnt = cJSON_GetArraySize(nodes);
    if (node_cnt != 0)
    {
        var->devNodeInfo.pserviceInfoUP = (SERVICE_INFO_T *)malloc(node_cnt * sizeof(SERVICE_INFO_T));
        if (var->devNodeInfo.pserviceInfoUP == NULL)
        {
            dbg_syslog(LOG_ERR, "malloc pserviceInfoDOWN failed,node_cnt:%d", node_cnt);
            flag = E_FALSE;
            goto out;
        }
        var->devNodeInfo.serviceupcont = node_cnt;
        memset(var->devNodeInfo.pserviceInfoUP, 0, node_cnt * sizeof(SERVICE_INFO_T));
        for (i = 0; i < node_cnt; i++)
        {
            node = cJSON_GetArrayItem(nodes, i);
            GET_JSON_VALUE_STRING_LOG(node, "identifier", var->devNodeInfo.pserviceInfoUP[i].identifier);
            GET_JSON_VALUE_STRING_LOG(node, "inidentifier", var->devNodeInfo.pserviceInfoUP[i].inidentifier);
            GET_JSON_VALUE_STRING_LOG(node, "name", var->devNodeInfo.pserviceInfoUP[i].name);
            {
                int j, tagcon = 0;
                cJSON *tagnodes = NULL;
                cJSON *tagnode = NULL;
                tagnodes = cJSON_GetObjectItemCaseSensitive(node, "tagnode");
                if (!tagnode)
                {
                    // todo 是否需要判断加载失败退出
                    tagcon = cJSON_GetArraySize(tagnodes);
                    dbg_syslog(LOG_ERR, "tagcon:%d", tagcon);
                    var->devNodeInfo.pserviceInfoUP[i].tagNode.ptagNode = (TAG_NODE_T *)malloc(tagcon * sizeof(TAG_NODE_T));
                    if (var->devNodeInfo.pserviceInfoUP[i].tagNode.ptagNode == NULL)
                    {
                        flag = E_FALSE;
                        goto out;
                    }
                    var->devNodeInfo.pserviceInfoUP[i].tagNode.nodecont = tagcon;
                    for (j = 0; j < tagcon; j++)
                    {
                        tagnode = cJSON_GetArrayItem(tagnodes, j);
                        GET_JSON_VALUE_STRING_LOG(tagnode, "tag", var->devNodeInfo.pserviceInfoUP[i].tagNode.ptagNode[j].tag);
                        GET_JSON_VALUE_STRING_LOG(tagnode, "name", var->devNodeInfo.pserviceInfoUP[i].tagNode.ptagNode[j].name);
                        
                        // {
                        //     int j, tagcon = 0;
                        //     cJSON *tagnodes = NULL;
                        //     cJSON *tagnode = NULL;
                        //     tagnodes = cJSON_GetObjectItemCaseSensitive(node, "tagnode");
                        //     if (!tagnode)
                        //     {
                        //         // todo 是否需要判断加载失败退出
                        //         tagcon = cJSON_GetArraySize(tagnodes);
                        //         dbg_syslog(LOG_ERR, "tagcon:%d", tagcon);
                        //         var->devNodeInfo.pserviceInfoUP[i].tagNode.ptagNode = (TAG_NODE_T *)malloc(tagcon * sizeof(TAG_NODE_T));
                        //         if (var->devNodeInfo.pserviceInfoUP[i].tagNode.ptagNode == NULL)
                        //         {
                        //             flag = E_FALSE;
                        //             goto out;
                        //         }
                        //         var->devNodeInfo.pserviceInfoUP[i].tagNode.nodecont = tagcon;
                        //         for (j = 0; j < tagcon; j++)
                        //         {
                        //             tagnode = cJSON_GetArrayItem(tagnodes, j);
                        //             GET_JSON_VALUE_STRING_LOG(tagnode, "tag", var->devNodeInfo.pserviceInfoUP[i].tagNode.ptagNode[j].tag);
                        //             GET_JSON_VALUE_STRING_LOG(tagnode, "name", var->devNodeInfo.pserviceInfoUP[i].tagNode.ptagNode[j].name);
                        //             GET_JSON_VALUE_STRING_LOG(tagnode, "type", var->devNodeInfo.pserviceInfoUP[i].tagNode.ptagNode[j].type);
                        //         }
                        //     }
                        // }
                    }
                }
            }
        }
        //
        if (var->linkageflag)
        {
            nodes = cJSON_GetObjectItemCaseSensitive(root, "service_todev");
            if (!nodes)
            {
                dbg_syslog(LOG_ERR, "get service_todev failed");
                flag = E_FALSE;
                goto out;
            }
            node_cnt = cJSON_GetArraySize(nodes);
            if (node_cnt != 0)
            {
                var->devNodeInfo.pserviceInfoTodev = (SERVICE_INFO_T *)malloc(node_cnt * sizeof(SERVICE_INFO_T));
                if (var->devNodeInfo.pserviceInfoTodev == NULL)
                {
                    dbg_syslog(LOG_ERR, "malloc pserviceInfoDOWN failed,node_cnt:%d", node_cnt);
                    flag = E_FALSE;
                    goto out;
                }
                var->devNodeInfo.servicetodevcont = node_cnt;

                for (i = 0; i < node_cnt; i++)
                {
                    node = cJSON_GetArrayItem(nodes, i);
                    GET_JSON_VALUE_STRING_LOG(node, "identifier", var->devNodeInfo.pserviceInfoTodev[i].identifier);
                    GET_JSON_VALUE_STRING_LOG(node, "name", var->devNodeInfo.pserviceInfoTodev[i].name);
                    {
                        int j, tagcon = 0;
                        cJSON *tagnodes = NULL;
                        cJSON *tagnode = NULL;
                        tagnodes = cJSON_GetObjectItemCaseSensitive(node, "tagnode");
                        if (!tagnode)
                        {
                            // todo 是否需要判断加载失败退出
                            tagcon = cJSON_GetArraySize(tagnodes);
                            dbg_syslog(LOG_ERR, "tagcon:%d", tagcon);
                            var->devNodeInfo.pserviceInfoTodev[i].tagNode.ptagNode = (TAG_NODE_T *)malloc(tagcon * sizeof(TAG_NODE_T));
                            if (var->devNodeInfo.pserviceInfoTodev[i].tagNode.ptagNode == NULL)
                            {
                                flag = E_FALSE;
                                goto out;
                            }
                            var->devNodeInfo.pserviceInfoTodev[i].tagNode.nodecont = tagcon;
                            for (j = 0; j < tagcon; j++)
                            {
                                tagnode = cJSON_GetArrayItem(tagnodes, j);
                                GET_JSON_VALUE_STRING_LOG(tagnode, "tag", var->devNodeInfo.pserviceInfoTodev[i].tagNode.ptagNode[j].tag);
                                GET_JSON_VALUE_STRING_LOG(tagnode, "name", var->devNodeInfo.pserviceInfoTodev[i].tagNode.ptagNode[j].name);
                            }
                        }
                    }
                }
            }
        }
    }
    // sub
    if (var->runMode == E_ONIOTBOX_MODE)
    {

        nodes = cJSON_GetObjectItemCaseSensitive(root, "subnode");

        if (!nodes)
        {
            dbg_syslog(LOG_ERR, "get subnode failed");
            // flag = E_FALSE;
            goto out;
        }

        node_cnt = cJSON_GetArraySize(nodes);
        if (node_cnt != 0)
        {
            var->subdevNodeInfo.pdevnodecfg = (DEV_NODE_CFG_T *)malloc(node_cnt * sizeof(DEV_NODE_CFG_T));
            var->auxiliaryInfoall.precodeinfo = (DI_RECODE_INFO_T *)malloc(node_cnt * sizeof(DI_RECODE_INFO_T));

            if (var->subdevNodeInfo.pdevnodecfg == NULL || var->auxiliaryInfoall.precodeinfo == NULL)
            {
                dbg_syslog(LOG_ERR, "malloc pdevnodcfg failed,node_cnt:%d", node_cnt);
                flag = E_FALSE;
                goto out;
            }
            memset(var->subdevNodeInfo.pdevnodecfg, 0, node_cnt * sizeof(DEV_NODE_CFG_T));
            var->subdevNodeInfo.devcont = node_cnt;
            for (i = 0; i < node_cnt; i++)
            {
                node = cJSON_GetArrayItem(nodes, i);
                GET_JSON_VALUE_STRING_LOG(node, "devSn", var->subdevNodeInfo.pdevnodecfg[i].devSn);
                GET_JSON_VALUE_STRING_LOG(node, "devGwSn", var->subdevNodeInfo.pdevnodecfg[i].devGwSn);
                GET_JSON_VALUE_STRING_LOG(node, "rmGwSn", var->subdevNodeInfo.pdevnodecfg[i].rmGwSn);
                GET_JSON_VALUE_STRING_LOG(node, "type", var->subdevNodeInfo.pdevnodecfg[i].type);
            }
        }
        nodes = cJSON_GetObjectItemCaseSensitive(root, "service_down");
        if (!nodes)
        {
            dbg_syslog(LOG_ERR, "get service_down failed");
            flag = E_FALSE;
            goto out;
        }
        node_cnt = cJSON_GetArraySize(nodes);
        if (node_cnt != 0)
        {
            var->subdevNodeInfo.pserviceInfoDOWN = (SERVICE_INFO_T *)malloc(node_cnt * sizeof(SERVICE_INFO_T));
            if (var->devNodeInfo.pserviceInfoDOWN == NULL)
            {
                dbg_syslog(LOG_ERR, "malloc pserviceInfoDOWN failed,node_cnt:%d", node_cnt);
                flag = E_FALSE;
                goto out;
            }
            var->subdevNodeInfo.servicedowncont = node_cnt;
            for (i = 0; i < node_cnt; i++)
            {
                node = cJSON_GetArrayItem(nodes, i);
                GET_JSON_VALUE_STRING_LOG(node, "identifier", var->subdevNodeInfo.pserviceInfoDOWN[i].identifier);
                GET_JSON_VALUE_STRING_LOG(node, "name", var->subdevNodeInfo.pserviceInfoDOWN[i].name);
            }
            // for (i = 0; i < node_cnt; i++)
            // {
            // dbg_syslog(LOG_ERR, "i:%d identifier:%s name:%s",i,SERVICE_DOWN[i].identifier,SERVICE_DOWN[i].name);
            // }
        }
        nodes = cJSON_GetObjectItemCaseSensitive(root, "subservice_up");
        if (!nodes)
        {
            dbg_syslog(LOG_ERR, "get service_up failed");
            flag = E_FALSE;
            goto out;
        }
        node_cnt = cJSON_GetArraySize(nodes);
        if (node_cnt != 0)
        {
            var->subdevNodeInfo.pserviceInfoUP = (SERVICE_INFO_T *)malloc(node_cnt * sizeof(SERVICE_INFO_T));
            if (var->subdevNodeInfo.pserviceInfoUP == NULL)
            {
                dbg_syslog(LOG_ERR, "malloc pserviceInfoDOWN failed,node_cnt:%d", node_cnt);
                flag = E_FALSE;
                goto out;
            }
            var->subdevNodeInfo.serviceupcont = node_cnt;
            memset(var->subdevNodeInfo.pserviceInfoUP, 0, node_cnt * sizeof(SERVICE_INFO_T));
            for (i = 0; i < node_cnt; i++)
            {
                node = cJSON_GetArrayItem(nodes, i);
                GET_JSON_VALUE_STRING_LOG(node, "identifier", var->subdevNodeInfo.pserviceInfoUP[i].identifier);
                GET_JSON_VALUE_STRING_LOG(node, "inidentifier", var->subdevNodeInfo.pserviceInfoUP[i].inidentifier);
                GET_JSON_VALUE_STRING_LOG(node, "name", var->subdevNodeInfo.pserviceInfoUP[i].name);
                {
                    int j, tagcon = 0;
                    cJSON *tagnodes = NULL;
                    cJSON *tagnode = NULL;
                    tagnodes = cJSON_GetObjectItemCaseSensitive(node, "tagnode");
                    if (!tagnode)
                    {
                        // todo 是否需要判断加载失败退出
                        tagcon = cJSON_GetArraySize(tagnodes);
                        dbg_syslog(LOG_ERR, "tagcon:%d", tagcon);
                        var->subdevNodeInfo.pserviceInfoUP[i].tagNode.ptagNode = (TAG_NODE_T *)malloc(tagcon * sizeof(TAG_NODE_T));
                        if (var->subdevNodeInfo.pserviceInfoUP[i].tagNode.ptagNode == NULL)
                        {
                            flag = E_FALSE;
                            goto out;
                        }
                        var->subdevNodeInfo.pserviceInfoUP[i].tagNode.nodecont = tagcon;
                        for (j = 0; j < tagcon; j++)
                        {
                            tagnode = cJSON_GetArrayItem(tagnodes, j);
                            GET_JSON_VALUE_STRING_LOG(tagnode, "tag", var->subdevNodeInfo.pserviceInfoUP[i].tagNode.ptagNode[j].tag);
                            GET_JSON_VALUE_STRING_LOG(tagnode, "name", var->subdevNodeInfo.pserviceInfoUP[i].tagNode.ptagNode[j].name);
                            {
                                int j, tagcon = 0;
                                cJSON *tagnodes = NULL;
                                cJSON *tagnode = NULL;
                                tagnodes = cJSON_GetObjectItemCaseSensitive(node, "tagnode");
                                if (!tagnode)
                                {
                                    // todo 是否需要判断加载失败退出
                                    tagcon = cJSON_GetArraySize(tagnodes);
                                    dbg_syslog(LOG_ERR, "tagcon:%d", tagcon);
                                    var->subdevNodeInfo.pserviceInfoUP[i].tagNode.ptagNode = (TAG_NODE_T *)malloc(tagcon * sizeof(TAG_NODE_T));
                                    if (var->subdevNodeInfo.pserviceInfoUP[i].tagNode.ptagNode == NULL)
                                    {
                                        flag = E_FALSE;
                                        goto out;
                                    }
                                    var->subdevNodeInfo.pserviceInfoUP[i].tagNode.nodecont = tagcon;
                                    for (j = 0; j < tagcon; j++)
                                    {
                                        tagnode = cJSON_GetArrayItem(tagnodes, j);
                                        GET_JSON_VALUE_STRING_LOG(tagnode, "tag", var->subdevNodeInfo.pserviceInfoUP[i].tagNode.ptagNode[j].tag);
                                        GET_JSON_VALUE_STRING_LOG(tagnode, "name", var->subdevNodeInfo.pserviceInfoUP[i].tagNode.ptagNode[j].name);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }

out:
    cJSON_Delete(root);
    if (pdata != NULL)
    {
        free(pdata);
    }
    if (flag == E_FALSE)
    {
        if (var->devNodeInfo.pdevnodecfg != NULL)
        {
            free(var->devNodeInfo.pdevnodecfg);
        }
        if (var->devNodeInfo.pserviceInfoDOWN != NULL)
        {
            free(var->devNodeInfo.pserviceInfoDOWN);
        }
        if (var->subdevNodeInfo.pdevnodecfg != NULL)
        {
            free(var->subdevNodeInfo.pdevnodecfg);
        }
        if (var->subdevNodeInfo.pserviceInfoDOWN != NULL)
        {
            free(var->subdevNodeInfo.pserviceInfoDOWN);
        }
    }
    return 0;
}
static void auxiliary_exsubscribe_all(auxiliary_var_t *var, ipc_session_t *psession)
{
    CHAR topic[TOPIC_MAX_LEN] = {0};
    int i, j;
    for (i = 0; i < var->devNodeInfo.devcont; i++)
    {
        // snprintf(topic, TOPIC_MAX_LEN, "/ems/%s/service", var->devNodeInfo.pdevnodecfg[i].devSn);  --test
        snprintf(topic, TOPIC_MAX_LEN, "/ems/%s/service", var->devNodeInfo.pdevnodecfg[i].rmGwSn);
        dbg_syslog(LOG_INFO, "topic:%s TOPIC_MAX_LEN:%d len:%d", topic, TOPIC_MAX_LEN, strlen(topic));
        ipc_session_subscribe(psession, topic);
    }
    for (i = 0; i < var->subdevNodeInfo.devcont; i++)
    {
        for (j = 0; j < var->subdevNodeInfo.serviceupcont; j++)
        {
            snprintf(topic, TOPIC_MAX_LEN, "/ems/%s/service", var->subdevNodeInfo.pdevnodecfg[i].rmGwSn);
            dbg_syslog(LOG_INFO, "topic:%s TOPIC_MAX_LEN:%d len:%d", topic, TOPIC_MAX_LEN, strlen(topic));
            ipc_session_subscribe(psession, topic);
        }
    }
}

static void auxiliary_subscribe_all(auxiliary_var_t *var, ipc_session_t *psession)
{
    CHAR topic[TOPIC_MAX_LEN] = {0};
    int i, j;
    snprintf(topic, TOPIC_MAX_LEN, "ipc/%s/+/device/%s/data/set_rglt_raw", var->sn_str, var->vir_sn_str);
    dbg_syslog(LOG_INFO, "topic:%s\r\n", topic);
    ipc_session_subscribe(psession, topic);
    if (var->runMode == E_ONGW_MODE)
    {
        for (i = 0; i < var->devNodeInfo.devcont; i++)
        {
            for (j = 0; j < var->devNodeInfo.serviceupcont; j++)
            {
                snprintf(topic, TOPIC_MAX_LEN, "ipc/%s/+/device/%s/data/service/%s", var->sn_str, var->devNodeInfo.pdevnodecfg[i].devSn, var->devNodeInfo.pserviceInfoUP[j].identifier);
                dbg_syslog(LOG_INFO, "topic:%s\r\n", topic);
                ipc_session_subscribe(psession, topic);
            }
        }
    }
}

static int publish_auxi_data(ipc_session_t *session, char *sn, unsigned char *data, int len, char *desSn, CHAR *identifier)
{
    char topic[TOPIC_MAX_LEN] = {0};
    // ipc/%s/+/device/+/data/set_rglt_raw
    snprintf(topic, TOPIC_MAX_LEN, "ipc/%s/%s/device/%s/data/service/%s", sn, "aaa", desSn, identifier);
    dbg_syslog(LOG_DEBUG, "topic:%s", topic);
    ipc_session_publish(session, topic, data, len);
    return 0;
}

static int publish_auxi_data_tobox(ipc_session_t *session, char *sn, unsigned char *data, int len, char *desSn, CHAR *identifier)
{
    char topic[TOPIC_MAX_LEN] = {0};
    // ipc/%s/+/device/+/data/set_rglt_raw
    snprintf(topic, TOPIC_MAX_LEN, "/sys/%s/device/%s/data/service/%s", sn, desSn, identifier);
    dbg_syslog(LOG_DEBUG, "topic:%s", topic);
    ipc_session_publish(session, topic, data, len);
    return 0;
}

static int auxiliary_sub_report(auxiliary_var_t *var, CHAR *identifier)
{
    CHAR *data_tmp = NULL;
    int i;
    double power = 0;
    cJSON *sub = NULL;
    CHAR tagNode[64] = {0};
    cJSON *tag_data = cJSON_CreateObject();

    cJSON_AddStringToObject(tag_data, "sn", var->sn_str);
    cJSON_AddNumberToObject(tag_data, "timestamp", time(NULL));
    cJSON_AddStringToObject(tag_data, "identifier", identifier);
    cJSON_AddNumberToObject(tag_data, "mi", PCS_MI);
    if (var->pcserr)
    {
        sprintf(tagNode, "{\"fire\":%d,\"smog\":%d,\"warterIm\":%d,\"pcsalarm\":%d}",
                var->auxiliaryInfoall.fire, var->auxiliaryInfoall.smog, var->auxiliaryInfoall.waterImmersion, var->auxiliaryInfo.pcserr);
    }
    else
    {
        sprintf(tagNode, "{\"fire\":%d,\"smog\":%d,\"warterIm\":%d}",
                var->auxiliaryInfoall.fire, var->auxiliaryInfoall.smog, var->auxiliaryInfoall.waterImmersion);
    }

    cJSON_AddStringToObject(tag_data, "tag_node", tagNode);
    // sub = cJSON_CreateObject();
    // cJSON_AddItemToObject(tag_data, "tags", sub);
    // cJSON_AddNumberToObject(sub, "p3", power);
    data_tmp = cJSON_Print(tag_data);
    if (var->runMode == E_ONGW_MODE) //本地收发，发送到本地
    {
        publish_auxi_data(var->session, var->sn_str, data_tmp, strlen(data_tmp), var->desSn, identifier);
    }
    else if (var->runMode == E_ONIOTBOX_MODE)
    {
        publish_auxi_data(var->insession, var->sn_str, data_tmp, strlen(data_tmp), var->desSn, identifier);
    }

    free(data_tmp);
    cJSON_Delete(tag_data);
}

static int auxiliary_report(auxiliary_var_t *var, CHAR *identifier)
{
    CHAR *data_tmp = NULL;
    int i;
    double power = 0;
    cJSON *sub = NULL;
    CHAR tagNode[256] = {0};
    cJSON *tag_data = cJSON_CreateObject();

    cJSON_AddStringToObject(tag_data, "sn", var->sn_str);
    cJSON_AddNumberToObject(tag_data, "timestamp", time(NULL));
    cJSON_AddStringToObject(tag_data, "identifier", identifier);
    cJSON_AddNumberToObject(tag_data, "mi", PCS_MI);
    sprintf(tagNode, "{\"fire\":%d,\"smog\":%d,\"warterIm\":%d,\"surgein\":%d,\"surgestation\":%d,\"door\":%d,\"loadio\":%d,\"gridio\":%d,\"transio\":%d,\"tiaoji\":%d,\"temp\":%d,\"gas\":%d,\"emerstop\":%d,\"pcserr\":%d}",
            var->auxiliaryInfo.fire, var->auxiliaryInfo.smog, var->auxiliaryInfo.waterImmersion, var->auxiliaryInfo.surgeIn,
            var->auxiliaryInfo.surgeSatation, var->auxiliaryInfo.doorState, var->auxiliaryInfo.cutoutLoad, var->auxiliaryInfo.cutoutGrid,
            var->auxiliaryInfo.cutoutTrans, var->auxiliaryInfo.tiaoji, var->auxiliaryInfo.tempSen,
            var->auxiliaryInfo.gasSen, var->auxiliaryInfo.emerStop, var->auxiliaryInfo.pcserr);
    cJSON_AddStringToObject(tag_data, "tag_node", tagNode);
    // sub = cJSON_CreateObject();
    // cJSON_AddItemToObject(tag_data, "tags", sub);
    // cJSON_AddNumberToObject(sub, "p3", power);
    data_tmp = cJSON_Print(tag_data);
    if (var->runMode == E_ONGW_MODE) //本地收发，发送到本地
    {
        publish_auxi_data(var->session, var->sn_str, data_tmp, strlen(data_tmp), var->desSn, identifier);
    }
    else if (var->runMode == E_ONIOTBOX_MODE)
    {
        publish_auxi_data(var->insession, var->sn_str, data_tmp, strlen(data_tmp), var->desSn, identifier);
    }
    free(data_tmp);
    cJSON_Delete(tag_data);
    return 0;
}

static void service_analy_proc(auxiliary_var_t *var, cJSON *sub)
{
    int i, j, n, tmp;
    if (sub)
    {
        for (i = 0; i < SERVICEUPCONT; i++)
        {
            dbg_syslog(LOG_DEBUG, "i:%d identifier:%s name:%s", i, SERVICE_UP[i].identifier, SERVICE_UP[i].name);
            if (strcmp(SERVICE_UP[i].identifier, var->servInfo.identifier) == 0)
            {
                for (j = 0; j < var->devNodeInfo.devcont; j++)
                {
                    dbg_syslog(LOG_DEBUG, "sn%d:%s", j, var->devNodeInfo.pdevnodecfg[j].devSn);
                    if (strcmp(var->devNodeInfo.pdevnodecfg[j].devSn, var->servInfo.devSn) == 0)
                    {
                        if (SERVICE_UP[i].tagNode.nodecont > 0)
                        {
                            for (n = 0; n < SERVICE_UP[i].tagNode.nodecont; n++)
                            {
                                tmp = -1;
                                GET_JSON_VALUE_INT_LOG(sub, SERVICE_UP[i].tagNode.ptagNode[n].tag, tmp);
                                // GET_JSON_VALUE_DOUBLE_LOG(sub, SERVICE_UP[i].tagNode.ptagNode[n].tag, tmp);
                                if (tmp != -1)
                                {
                                    if (strcmp(SERVICE_UP[i].tagNode.ptagNode[n].name, "fire") == 0)
                                    {
                                        DI_UP.precodeinfo[j].fire[DI_UP.recodeindex] = tmp;
                                        // var->auxiliaryInfo.fire = tmp;
                                    }
                                    if (strcmp(SERVICE_UP[i].tagNode.ptagNode[n].name, "smog") == 0)
                                    {
                                        DI_UP.precodeinfo[j].smog[DI_UP.recodeindex] = tmp;
                                        // var->auxiliaryInfo.smog = tmp;
                                    }
                                    if (strcmp(SERVICE_UP[i].tagNode.ptagNode[n].name, "warterIm") == 0)
                                    {
                                        var->auxiliaryInfo.waterImmersion = tmp;
                                    }
                                    if (strcmp(SERVICE_UP[i].tagNode.ptagNode[n].name, "surgein") == 0)
                                    {
                                        var->auxiliaryInfo.surgeIn = tmp;
                                    }
                                    if (strcmp(SERVICE_UP[i].tagNode.ptagNode[n].name, "surgestation") == 0)
                                    {
                                        var->auxiliaryInfo.surgeSatation = tmp;
                                    }
                                    if (strcmp(SERVICE_UP[i].tagNode.ptagNode[n].name, "door") == 0)
                                    {
                                        var->auxiliaryInfo.doorState = tmp;
                                    }
                                    if (strcmp(SERVICE_UP[i].tagNode.ptagNode[n].name, "loadio") == 0)
                                    {
                                        var->auxiliaryInfo.cutoutLoad = tmp;
                                    }
                                    if (strcmp(SERVICE_UP[i].tagNode.ptagNode[n].name, "gridio") == 0)
                                    {
                                        var->auxiliaryInfo.cutoutGrid = tmp;
                                    }
                                    if (strcmp(SERVICE_UP[i].tagNode.ptagNode[n].name, "transio") == 0)
                                    {
                                        var->auxiliaryInfo.cutoutTrans = tmp;
                                    }
                                    if (strcmp(SERVICE_UP[i].tagNode.ptagNode[n].name, "tiaoji") == 0)
                                    {
                                        var->auxiliaryInfo.tiaoji = tmp;
                                    }
                                    if (strcmp(SERVICE_UP[i].tagNode.ptagNode[n].name, "temp") == 0)
                                    {
                                        var->auxiliaryInfo.tempSen = tmp;
                                    }
                                    if (strcmp(SERVICE_UP[i].tagNode.ptagNode[n].name, "gas") == 0)
                                    {
                                        var->auxiliaryInfo.gasSen = tmp;
                                    }
                                    if (strcmp(SERVICE_UP[i].tagNode.ptagNode[n].name, "emerstop") == 0)
                                    {
                                        var->auxiliaryInfo.emerStop = tmp;
                                    }
                                    if (strcmp(SERVICE_UP[i].tagNode.ptagNode[n].name, "pcserr") == 0)
                                    {
                                        var->auxiliaryInfo.pcserr = tmp;
                                    }
                                }
                            }
                            auxiliary_report(var, SERVICE_UP[i].inidentifier);
                        }
                        break;
                    }
                }
            }
        }

        if (var->runMode == E_ONIOTBOX_MODE)
        {
            for (i = 0; i < SERVICEUPCONTSUB; i++)
            {
                dbg_syslog(LOG_INFO, "i:%d identifier:%s name:%s", i, SERVICE_UPSUB[i].identifier, SERVICE_UP[i].name);
                if (strcmp(SERVICE_UPSUB[i].identifier, var->servInfo.identifier) == 0)
                {
                    for (j = 0; j < var->subdevNodeInfo.devcont; j++)
                    {
                        dbg_syslog(LOG_INFO, "sn%d:%s", j, var->subdevNodeInfo.pdevnodecfg[j].devSn);
                        if (strcmp(var->subdevNodeInfo.pdevnodecfg[j].devSn, var->servInfo.devSn) == 0)
                        {
                            if (SERVICE_UPSUB[i].tagNode.nodecont > 0)
                            {
                                for (n = 0; n < SERVICE_UPSUB[i].tagNode.nodecont; n++)
                                {
                                    tmp = -1;
                                    GET_JSON_VALUE_INT_LOG(sub, SERVICE_UPSUB[i].tagNode.ptagNode[n].tag, tmp);
                                    // GET_JSON_VALUE_DOUBLE_LOG(sub, SERVICE_UP[i].tagNode.ptagNode[n].tag, tmp);
                                    if (tmp != -1)
                                    {
                                        if (strcmp(SERVICE_UPSUB[i].tagNode.ptagNode[n].name, "fire") == 0)
                                        {
                                            var->auxiliaryInfoall.fire = tmp;
                                        }
                                        if (strcmp(SERVICE_UPSUB[i].tagNode.ptagNode[n].name, "smog") == 0)
                                        {
                                            var->auxiliaryInfoall.smog = tmp;
                                        }
                                        if (strcmp(SERVICE_UPSUB[i].tagNode.ptagNode[n].name, "warterIm") == 0)
                                        {
                                            var->auxiliaryInfoall.waterImmersion = tmp;
                                        }
                                        if (strcmp(SERVICE_UPSUB[i].tagNode.ptagNode[n].name, "pcserr") == 0)
                                        {
                                            var->auxiliaryInfoall.pcserr = tmp;
                                        }
                                    }
                                }
                                auxiliary_sub_report(var, SERVICE_UP[i].inidentifier);
                            }
                            break;
                        }
                    }
                }
            }
        }
    }
}

static int publish_to_dev_data(ipc_session_t *session, char *sn, unsigned char *data, int len, char *desSn, char *porttype)
{
    char topic[TOPIC_MAX_LEN] = {0};
    // ipc/%s/+/device/+/data/set_rglt_raw
    snprintf(topic, TOPIC_MAX_LEN, "ipc/%s/%s/device/%s/data/Set_Rglt", sn, porttype, desSn);
    dbg_syslog(LOG_DEBUG, "topic:%s", topic);
    ipc_session_publish(session, topic, data, len);
    return 0;
}

static int publish_to_exdev_data(ipc_session_t *session, char *sn, unsigned char *data, int len, char *desSn, char *porttype)
{
    char topic[TOPIC_MAX_LEN] = {0};
    // ipc/%s/+/device/+/data/set_rglt_raw
    snprintf(topic, TOPIC_MAX_LEN, "/ems/%s/service/set", desSn);
    dbg_syslog(LOG_DEBUG, "topic:%s", topic);
    ipc_session_publish(session, topic, data, len);
    return 0;
}

static int auxiliary_linkage_option(auxiliary_var_t *var, CHAR *pidentifier, CHAR type)
{
    int i, j, n;
    CHAR *data_tmp = NULL;
    int err = 1, num = 0;
    cJSON *sub = NULL;
    cJSON *tag_data;
    CHAR tagNode[64] = {0};

    if (var->linkageflag)
    {
        for (i = 0; i < var->devNodeInfo.servicetodevcont; i++)
        {
            dbg_syslog(LOG_INFO, "identifier:%s->pid:%s", var->devNodeInfo.pserviceInfoTodev[i].identifier, pidentifier);

            if (strcmp(pidentifier, var->devNodeInfo.pserviceInfoTodev[i].identifier) == 0) 
            {
                for (n = 0; n < var->devNodeInfo.pserviceInfoTodev[i].tagNode.nodecont; n++)
                {
                    dbg_syslog(LOG_INFO, "name:%s", var->devNodeInfo.pserviceInfoTodev[i].tagNode.ptagNode[n].name);
                    for (j = 0; j < var->devNodeInfo.devcont; j++)
                    {
                        if (strcmp("DO", var->devNodeInfo.pdevnodecfg[j].devGwSn) != 0)
                            continue;
                        tag_data = cJSON_CreateObject();
                        // cJSON_AddStringToObject(tag_data, "sn", var->vir_sn_str);
                        cJSON_AddStringToObject(tag_data, "sn", var->devNodeInfo.pdevnodecfg[j].devOut);
                        cJSON_AddNumberToObject(tag_data, "timestamp", time(NULL));
                        cJSON_AddNumberToObject(tag_data, "mi", PCS_MI);
                        cJSON_AddStringToObject(tag_data, "identifier", var->devNodeInfo.pserviceInfoTodev[i].identifier);
                        if (type == 0)
                        {
                            cJSON_AddNumberToObject(tag_data, var->devNodeInfo.pserviceInfoTodev[i].tagNode.ptagNode[n].tag, DI_VALUE_OFF);
                        }
                        else
                        {
                            cJSON_AddNumberToObject(tag_data, var->devNodeInfo.pserviceInfoTodev[i].tagNode.ptagNode[n].tag, DI_VALUE_ON);
                        }

                        data_tmp = cJSON_Print(tag_data);
                        if (var->runMode == E_ONGW_MODE)
                        {
                            publish_to_dev_data(var->session, var->sn_str, data_tmp, strlen(data_tmp), var->devNodeInfo.pdevnodecfg[j].devOut, var->devNodeInfo.pdevnodecfg[j].type);
                        }
                        else
                        {
                            publish_to_exdev_data(var->session, var->sn_str, data_tmp, strlen(data_tmp), var->devNodeInfo.pdevnodecfg[j].devOut, var->devNodeInfo.pdevnodecfg[j].type);
                        }
                        free(data_tmp);
                        cJSON_Delete(tag_data);
                    }
                }
            }
        }
    }
}

static int auxiliary_mqtt_handle_recv_msg(void *obj, ipc_msg_t *mqtt_msg)
{
    cJSON *node = NULL;
    cJSON *sub = NULL;
    CHAR *tagNode = NULL;
    int i, n, j = 0;
    int tmp = 0;
    auxiliary_var_t *var = (auxiliary_var_t *)obj;
    dbg_syslog(LOG_DEBUG, "topic:%s", mqtt_msg->topic);

    if (strstr(mqtt_msg->topic, "data/service"))
    {
        node = cJSON_Parse(mqtt_msg->payload);
        if (!node)
        {
            return E_FALSE;
        }
        GET_JSON_VALUE_INT(node, "mi", var->servInfo.mi);
        GET_JSON_VALUE_INT(node, "timestamp", var->servInfo.timestamp);
        GET_JSON_VALUE_STRING(node, "identifier", var->servInfo.identifier);
        GET_JSON_VALUE_STRING(node, "sn", var->servInfo.devSn);
        GET_JSON_VALUE_DY_STRING(node, "tag_node", tagNode);
        dbg_syslog(LOG_DEBUG, "mi:%d timestamp:%d identifier:%s sn:%s SERVICEUPCONT:%d tagNode:%s\r\n", var->servInfo.mi,var->servInfo.timestamp,var->servInfo.identifier,var->servInfo.devSn,SERVICEUPCONT,tagNode);
        if (tagNode != NULL)
        {
            sub = cJSON_Parse(tagNode);
        }
        service_analy_proc(var, sub);
        // if (var->runMode != E_ONGW_TO_IOTBOX_MODE)
        // {
        //     // Io输出控制
        //     if (var->auxiliaryInfo.fire || var->auxiliaryInfo.smog || var->auxiliaryInfo.waterImmersion)
        //     {
        //         // publish 下行指令
        //         dbg_syslog(LOG_INFO, "publish :%s\r\n", "io local");
        //         // linkage
        //         auxiliary_linkage_option(var);
        //     }

        //     if (var->runMode == E_ONGW_MODE_MAIN)
        //     {
        //         if (var->auxiliaryInfoall.fire || var->auxiliaryInfoall.smog || var->auxiliaryInfoall.waterImmersion)
        //         {
        //             dbg_syslog(LOG_INFO, "publish :%s\r\n", "remote");
        //             auxiliary_linkage_option(var);
        //         }
        //     }
        // }
    }
    else if (strstr(mqtt_msg->topic, "data/set_rglt_raw"))
    {
        int onoff = -1;
        node = cJSON_Parse(mqtt_msg->payload);
        if (!node)
        {
            return E_FALSE;
        }
        GET_JSON_VALUE_INT_LOG(node, "mi", var->servInfo.mi);
        GET_JSON_VALUE_INT_LOG(node, "timestamp", var->servInfo.timestamp);
        GET_JSON_VALUE_STRING_LOG(node, "identifier", var->servInfo.identifier);
        GET_JSON_VALUE_STRING_LOG(node, "sn", var->servInfo.devSn);
        GET_JSON_VALUE_INT_LOG(node, "onoff", onoff);
        dbg_syslog(LOG_INFO, "SERVICEDOWNCONT:%d\r\n", SERVICEDOWNCONT);
        if (onoff != -1)
        {
            for (i = 0; i < SERVICEDOWNCONT; i++)
            {
                dbg_syslog(LOG_INFO, "i:%d identifier:%s name:%s", i, SERVICE_DOWN[i].identifier, SERVICE_DOWN[i].name);
                if (strcmp(SERVICE_DOWN[i].identifier, var->servInfo.identifier) == 0)
                {
                    dbg_syslog(LOG_INFO, "name:%s", SERVICE_DOWN[i].name);
                    auxiliary_linkage_option(var, SERVICE_DOWN[i].name, onoff);
                }
            }
        }
    }

    if (node)
    {
        cJSON_Delete(node);
    }
    if (var->runMode == E_ONGW_MODE)
    {
        if (sub)
        {
            cJSON_Delete(sub);
        }
    }
    if (tagNode)
    {
        free(tagNode);
    }
}

static int auxiliary_state_change(void *obj, int state)
{
    auxiliary_var_t *var = (auxiliary_var_t *)obj;
    char topic[TOPIC_MAX_LEN] = {0};

    switch (state)
    {
    case MQTT_CONNECTED:
        snprintf(topic, TOPIC_MAX_LEN, "ipc/%s/+/device/%s/start", var->sn_str, "ems_auxi");
        ipc_session_publish(var->session, topic, "", 0);
        break;
    }
    return E_TRUE;
}

static int auxiliary_exmqtt_handle_recv_msg(void *obj, ipc_msg_t *mqtt_msg)
{
    cJSON *node = NULL;
    cJSON *sub = NULL;
    CHAR *tagNode = NULL;
    int i, n, j = 0;
    int tmp = 0;
    auxiliary_var_t *var = (auxiliary_var_t *)obj;
    dbg_syslog(LOG_INFO, "topic:%s", mqtt_msg->topic);

    if (strstr(mqtt_msg->topic, "service"))
    {
        node = cJSON_Parse(mqtt_msg->payload);
        if (!node)
        {
            return E_FALSE;
        }
        GET_JSON_VALUE_INT_LOG(node, "mi", var->servInfo.mi);
        GET_JSON_VALUE_INT_LOG(node, "time", var->servInfo.timestamp);
        GET_JSON_VALUE_STRING_LOG(node, "identifier", var->servInfo.identifier);
        GET_JSON_VALUE_STRING_LOG(node, "sn", var->servInfo.devSn);
        dbg_syslog(LOG_INFO, "SERVICEUPCONT:%d\r\n", SERVICEUPCONT);

        sub = cJSON_GetObjectItemCaseSensitive(node, "tags");
        service_analy_proc(var, sub);
    }
    if (node)
    {
        cJSON_Delete(node);
    }
    if (var->runMode == E_ONGW_MODE)
    {
        if (sub)
        {
            cJSON_Delete(sub);
        }
    }
    if (tagNode)
    {
        free(tagNode);
    }
}

static int auxiliary_remote_state_change(void *obj, int state)
{
    auxiliary_var_t *var = (auxiliary_var_t *)obj;
    char topic[TOPIC_MAX_LEN] = {0};

    switch (state)
    {
    case MQTT_CONNECTED:
        snprintf(topic, TOPIC_MAX_LEN, "ipc/%s/+/device/%s/start", var->sn_str, "ems_auxi");
        ipc_session_publish(var->session, topic, "", 0);
        break;
    }
    return E_TRUE;
}

static int auxiliary_mqtt_client_init(auxiliary_var_t *var)
{
    char clientId[MAX_CLIENT_ID_LEN] = {0};

    snprintf(clientId, MAX_CLIENT_ID_LEN, "INT_auxiliary_%s", var->sn_str);
    if (var->runMode == E_ONGW_MODE) //本地接收，发送本地
    {
        var->session = ipc_session_new(clientId, (void *)var, IPC_DEFAULT);
        // var->session = ipc_session_new(clientId, (void *)var, IPC_NNG);
        if (var->session == NULL)
            return -1;
        ipc_session_set_callbacks(var->session, auxiliary_mqtt_handle_recv_msg, auxiliary_state_change);
        auxiliary_subscribe_all(var, var->session);
        ipc_session_start(var->session);
    }
    else if (var->runMode == E_ONIOTBOX_MODE)
    {
        var->insession = ipc_session_new(clientId, (void *)var, IPC_DEFAULT);
        if (var->insession == NULL)
            return -1;
        ipc_session_set_callbacks(var->insession, auxiliary_mqtt_handle_recv_msg, auxiliary_state_change);
        auxiliary_subscribe_all(var, var->insession);
        ipc_session_start(var->insession);

        var->session = ipc_session_new(clientId, (void *)var, IPC_DEFAULT);
        dbg_syslog(LOG_INFO, "hostname:%s port:%d username:%s password:%s", var->mqttBroker.hostname, var->mqttBroker.port, var->mqttBroker.username, var->mqttBroker.password);
        ipc_session_set_address(var->session, var->mqttBroker.hostname, var->mqttBroker.port, var->mqttBroker.username, var->mqttBroker.password);
        ipc_session_set_opts(var->session, MQTT_QOS_LEVLE0, KEEP_ALIVE_MAX);
        ipc_session_set_callbacks(var->session, auxiliary_exmqtt_handle_recv_msg, auxiliary_state_change);
        auxiliary_exsubscribe_all(var, var->session);
        ipc_session_start(var->session);
    }

    return E_TRUE;
}

static void auxiliary_init(void *obj)
{
    auxiliary_var_t *var = (auxiliary_var_t *)obj;
    auxiliary_cfg(var, AUXILIARY_CFGFILE);
    get_board_sn(var->sn_str); //所有表信息;meter  sn
    dbg_syslog(LOG_INFO, "board SN:%s", var->sn_str);
    auxiliary_mqtt_client_init(var);
}

static void auxiliary_entry(void *obj)
{
    int ret = -1, maxfd;
    fd_set rset;
    struct timeval timeout;

    while (1)
    {
        SELECT_INIT();
        // SELECT_ADD_FD(var->second_period_timer);
        timeout.tv_usec = 0;
        timeout.tv_sec = 5;
        ret = select(maxfd + 1, &rset, 0, 0, &timeout);
        if (ret < 0)
        {
            dbg_syslog(LOG_INFO, "errno %d\n", errno);

            if (errno == EINTR)
            {
                continue;
            }
            else
            {
                dbg_syslog(LOG_INFO, "errno---");
                break;
            }
        }
    }
}

void main()
{
    auxiliary_var_t auxiliary_var = {0};
    lnxall_loglevel_set(LNXALL_LOGNOTICE,1);
    auxiliary_init(&auxiliary_var);
    auxiliary_entry(&auxiliary_var);
}