#include <stdio.h>
#include <unistd.h>
#include <getopt.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#include <regex.h>
#include <pthread.h>
#include <uthash/uthash.h>
#include <arpa/inet.h>
#include <time.h>
#include <sys/types.h>
#include <sys/stat.h>

#include "compile.h"
#include "log.h"
#include "object_manager.h"
#include "json_interface.h"
#include "regex_table.h"

#define MAX_OBJ             (300)

#define JS_FILE_ROOT        "/mnt/e/wsl"
#define ADD_JS_FILE         (JS_FILE_ROOT"/secogateway/Product/user/object_manager/json_test/add.json")
#define DEL_JS_FILE         (JS_FILE_ROOT"/secogateway/Product/user/object_manager/json_test/del.json")
#define MOD_JS_FILE         (JS_FILE_ROOT"/secogateway/Product/user/object_manager/json_test/mod.json")
#define QUERY_LIST_JS_FILE  (JS_FILE_ROOT"/secogateway/Product/user/object_manager/json_test/page_queue.json")
#define DETAIL_JS_FILE      (JS_FILE_ROOT"/secogateway/Product/user/object_manager/json_test/detail.json")

static PSPLIT_PAGE  g_pSplitPage = NULL;
static PCMHI_OBJECT g_pObject = NULL;
static OBJECT_K g_objItem[MAX_OBJ];
static pthread_mutex_t g_obj_lock = PTHREAD_MUTEX_INITIALIZER;

static void random_string(unsigned char *buf, int size)
{
    int i;
    const char *asc_char = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
    int max = strlen(asc_char);
    srand(time(NULL));

    for(i = 0; i < size && buf; i++) {
        buf[i] = asc_char[rand() % max];
    }

    LOG_EX(LOG_Debug, "random string(%d): %s\n", strlen(buf), (char *)buf);
}

static int split_params(char *pInput, char **pFirst, char **pSecond,
                        const char *split)
{
    char *pStr = (char *)pInput;
    char *p;

    if(!pInput || !pFirst || !pSecond) {
        LOG_EX(LOG_Error, "Input params error: %p, %p, %p\n", pInput, pFirst, pSecond);
        return -RET_INPUTERR;
    }

    p = strsep(&pStr, split);

    if(strlen(p) == 0) {
        *pFirst = pInput;
        *pSecond = NULL;
    } else {
        *pFirst = p;
        *pSecond = pStr;
    }

    return RET_OK;
}

static int get_free_pos(void)
{
    int i;

    for(i = 0; i < MAX_OBJ; i++) {
        if(strlen(g_objItem[i].memTag) == 0) {
            return i;
        }
    }

    return -1;
}

static void dump_object(void)
{
    int i;
    PCMHI_OBJECT pObj, pTmp;
    pthread_mutex_lock(&g_obj_lock);
    HASH_ITER(hh, g_pObject, pObj, pTmp) {
        LOG_EX(LOG_Info, "name:         %s\n", pObj->name);
        LOG_EX(LOG_Info, "desc:         %s\n", pObj->desc);
        LOG_EX(LOG_Info, "prio:         %d\n", pObj->prio);
        LOG_EX(LOG_Info, "Tags:         %s\n", g_objItem[pObj->obj_index].memTag);
        LOG_EX(LOG_Info, "type:         %d\n", g_objItem[pObj->obj_index].type);
        LOG_EX(LOG_Info, "items:        %d\n", g_objItem[pObj->obj_index].ctx_num);

        for(i = 0; i < g_objItem[pObj->obj_index].ctx_num; i++) {
            struct tm *pTm;
            char buf[256];
            time_t t;
            POBJECT_K pObjK = &g_objItem[pObj->obj_index];

            switch(pObjK->type / 10) {
                case OBJ_TYPE_SERVER:
                    LOG_EX(LOG_Info, "    porType:      %d\n", pObjK->objs.svr_obj[i].pro_type);
                    LOG_EX(LOG_Info, "    min Port:     %d\n", pObjK->objs.svr_obj[i].min_port);
                    LOG_EX(LOG_Info, "    min Port:     %d\n", pObjK->objs.svr_obj[i].max_port);
                    break;

                case OBJ_TYPE_ADDR:
                    LOG_EX(LOG_Info, "    ip_version:   %d\n", pObjK->objs.addr_obj[i].ip_version);
                    LOG_EX(LOG_Info, "    netmask:      %u\n", pObjK->objs.addr_obj[i].net_mask);

                    if(IP_V4 == pObjK->objs.addr_obj[i].ip_version) {
                        LOG_EX(LOG_Info, "    min addr:     %08X\n",
                               pObjK->objs.addr_obj[i].min_addr.addr_v4.ip4_addr);
                        LOG_EX(LOG_Info, "    max addr:     %08X\n",
                               pObjK->objs.addr_obj[i].max_addr.addr_v4.ip4_addr);
                    } else {
                        LOG_EX(LOG_Info,
                               "    min addr:     %04X:%04X:%04X:%04X:%04X:%04X:%04X:%04X:%04X\n",
                               pObjK->objs.addr_obj[i].min_addr.addr_v6.addr.addr16[0],
                               pObjK->objs.addr_obj[i].min_addr.addr_v6.addr.addr16[1],
                               pObjK->objs.addr_obj[i].min_addr.addr_v6.addr.addr16[2],
                               pObjK->objs.addr_obj[i].min_addr.addr_v6.addr.addr16[3],
                               pObjK->objs.addr_obj[i].min_addr.addr_v6.addr.addr16[4],
                               pObjK->objs.addr_obj[i].min_addr.addr_v6.addr.addr16[6],
                               pObjK->objs.addr_obj[i].min_addr.addr_v6.addr.addr16[7]);
                        LOG_EX(LOG_Info,
                               "    max addr:     %04X:%04X:%04X:%04X:%04X:%04X:%04X:%04X:%04X\n",
                               pObjK->objs.addr_obj[i].max_addr.addr_v6.addr.addr16[0],
                               pObjK->objs.addr_obj[i].max_addr.addr_v6.addr.addr16[1],
                               pObjK->objs.addr_obj[i].max_addr.addr_v6.addr.addr16[2],
                               pObjK->objs.addr_obj[i].max_addr.addr_v6.addr.addr16[3],
                               pObjK->objs.addr_obj[i].max_addr.addr_v6.addr.addr16[4],
                               pObjK->objs.addr_obj[i].max_addr.addr_v6.addr.addr16[5],
                               pObjK->objs.addr_obj[i].max_addr.addr_v6.addr.addr16[6],
                               pObjK->objs.addr_obj[i].max_addr.addr_v6.addr.addr16[7]);
                    }

                    break;

                case OBJ_TYPE_DATETIME:
                    LOG_EX(LOG_Info, "    repeat:       %d\n", pObjK->objs.dt_obj[i].rep_mode);
                    t = pObjK->objs.dt_obj[i].min_time;
                    pTm = localtime(&t);
                    memset(buf, 0, 256);
                    strftime(buf, sizeof(buf), "%Y/%m/%d %H:%M:%S", pTm);
                    LOG_EX(LOG_Info, "    min time:     %ld[%s]\n", pObjK->objs.dt_obj[i].min_time, buf);
                    t = pObjK->objs.dt_obj[i].max_time;
                    pTm = localtime(&t);
                    memset(buf, 0, 256);
                    strftime(buf, sizeof(buf), "%Y/%m/%d %H:%M:%S", pTm);
                    LOG_EX(LOG_Info, "    max time:     %ld[%s]\n", pObjK->objs.dt_obj[i].max_time, buf);
                    break;
            }
        }
    }
    pthread_mutex_unlock(&g_obj_lock);
}

int object_split_page(char *pSession, int type, char *outSession)
{
    PSPLIT_PAGE p;

    if(pSession == NULL || strlen(pSession) == 0) {
        PCMHI_OBJECT pObj, pTmp;
        int sess_type = OBJ_TYPE_MAX;
        PSPLIT_PAGE pNew = (PSPLIT_PAGE)malloc(sizeof(SPLIT_PAGE));

        if(!pNew) {
            LOG_EX(LOG_Error, "Malloc memory error\n");
            return -RET_NOMEM;
        }

        memset(pNew, 0, sizeof(SPLIT_PAGE));
        random_string(pNew->session, MAX_SESSION - 1);

        if(outSession) {
            strcpy(outSession, pNew->session);
        }

        HASH_ADD_STR(g_pSplitPage, session, pNew);

        if(type == 1) {
            sess_type = OBJ_TYPE_SERVER;
        } else if(type == 2) {
            sess_type = OBJ_TYPE_ADDR;
        } else if(type == 3) {
            sess_type = OBJ_TYPE_DATETIME;
        }

        pthread_mutex_lock(&g_obj_lock);
        HASH_ITER(hh, g_pObject, pObj, pTmp) {
            if(g_objItem[pObj->obj_index].type / 10 == sess_type
               || sess_type == OBJ_TYPE_MAX) {
                char *pStr = strdup(pObj->name);
                pNew->last_time = time(NULL);

                if(pNew->name_list == NULL) {
                    utarray_new(pNew->name_list, &ut_str_icd);
                }

                LOG_EX(LOG_Debug, "Add String: %s\n", pStr);
                utarray_push_back(pNew->name_list, &pStr);
            }
        }
        pthread_mutex_unlock(&g_obj_lock);
        return RET_OK;
    } else {
        LOG_EX(LOG_Error, "Input params error\n");
        return -RET_INPUTERR;
    }
}

int get_page_items(char *pSession, int type, int start, int end)
{
    int ret = RET_OK;
    PSPLIT_PAGE p;
    char **pStr;
    int i, iCount = 0;
    char session[MAX_SESSION];

    if(pSession == NULL || strlen(pSession) == 0) {
        memset(session, 0, MAX_SESSION);
        ret = object_split_page(pSession, type, session);

        if(ret != RET_OK) {
            return ret;
        }

        pSession = session;
    }

    HASH_FIND_STR(g_pSplitPage, pSession, p);

    if(p == NULL) {
        LOG_EX(LOG_Debug, "Can't found session: %s\n", pSession);
        return -RET_NOTFOUND;
    }

    for(i = start; i < end && iCount < MAX_PAGE_ITEMS && iCount < utarray_len(p->name_list); i++) {
        pStr = (char **)utarray_eltptr(p->name_list, i);
        LOG_EX(LOG_Debug, "%s[%03d]: %s\n", p->session, iCount++, *pStr);
    }
}

int object_add(PCMHI_OBJECT pObj, POBJECT_K pObjK)
{
    int i, pos;
    PCMHI_OBJECT p;

    if(!pObj || !pObjK) {
        LOG_EX(LOG_Error, "Input params error %p, %p\n", pObj, pObjK);
        return -RET_INPUTERR;
    }

    pthread_mutex_lock(&g_obj_lock);
    HASH_FIND_STR(g_pObject, pObj->name, p);
    pthread_mutex_unlock(&g_obj_lock);

    if(p != NULL) {
        LOG_EX(LOG_Error, "Item %s exists\n", pObj->name);
        return -RET_EXIST;
    }

    pos = get_free_pos();

    if(pos < 0) {
        LOG_EX(LOG_Error, "Share memory full\n");
        return -RET_NOMEM;
    }

    strcpy(pObjK->memTag, OBJ_MEM_TAG);

    for(i = 0; i < pObjK->ctx_num && i < MAX_OBJ_CONTENT; i++) {
        char         *pStart    = NULL, *pEnd    = NULL;
        char         *pSubStart = NULL, *pSubEnd = NULL;
        PSVR_OBJECT  pSvr       = &pObjK->objs.svr_obj[i];
        PADDR_OBJECT pAddr      = &pObjK->objs.addr_obj[i];
        PDT_OBJECT   pDt        = &pObjK->objs.dt_obj[i];
        struct tm tm;

        switch(pObjK->type / 10) {
            case OBJ_TYPE_SERVER:
                split_params((char *)pSvr->str_val, &pStart, &pEnd, "-");

                if(!pcre_match(REGEX_SVR_PORT, pStart)) {
                    LOG_EX(LOG_Error, "Input %s format error\n", pStart);
                    return -RET_INPUTERR;
                } else {
                    int first;
                    first = strtoul(pStart, NULL, 10);
                    pSvr->min_port = first;
                    pSvr->max_port = 0;
                }

                if(pEnd && strlen(pEnd) > 0) {
                    int last;

                    if(!pcre_match(REGEX_SVR_PORT, pEnd)) {
                        LOG_EX(LOG_Error, "Input %s format error\n", pEnd);
                        return -RET_INPUTERR;
                    }

                    //first = strtoul(pStart, NULL, 10);
                    last = strtoul(pEnd, NULL, 10);

                    if(pSvr->pro_type <= PORT_UDP) {
                        //pSvr->min_port = htonl(first) & 0xFFFF;
                        pSvr->max_port = last;
                    } else {
                        //ICMP , min_port --> type, max_port --> code
                        //pSvr->min_port = first;
                        pSvr->max_port = last;
                    }
                }

                break;

            case OBJ_TYPE_ADDR:
                split_params((char *)pAddr->str_val, &pStart, &pEnd, "-");

                if(!pcre_match(REGEX_IP_ADDR, pStart)) {
                    LOG_EX(LOG_Error, "Input %s format error\n", pStart);
                    return -RET_INPUTERR;
                }

                split_params((char *)pStart, &pSubStart, &pSubEnd, "/");

                if(pSubEnd && strlen(pSubEnd) > 0) {
                    pAddr->net_mask = strtoul(pSubEnd, NULL, 10);
                }

                // IPv4 格式
                if(strchr(pStart, ':') == NULL) {
                    if(inet_pton(AF_INET, pSubStart, &pAddr->min_addr.addr_v4.ip4_addr) != 1) {
                        LOG_EX(LOG_Error, "%s convert to ip address error\n", pStart);
                        return -RET_INPUTERR;
                    }

                    pAddr->ip_version = IP_V4;
                } else {
                    if(inet_pton(AF_INET6, pSubStart, &pAddr->min_addr.addr_v6.addr.addr8) != 1) {
                        LOG_EX(LOG_Error, "%s convert to ip address error\n", pStart);
                        return -RET_INPUTERR;
                    }

                    pAddr->ip_version = IP_V6;
                }

                if(pEnd && strlen(pEnd) > 0) {
                    if(!pcre_match(REGEX_IP_ADDR, pEnd)) {
                        LOG_EX(LOG_Error, "Input %s format error\n", pEnd);
                        return -RET_INPUTERR;
                    }

                    if(pAddr->ip_version == IP_V4) {
                        if(inet_pton(AF_INET, pEnd, &pAddr->max_addr.addr_v4.ip4_addr) != 1) {
                            LOG_EX(LOG_Error, "%s convert to ip address error\n", pEnd);
                            return -RET_INPUTERR;
                        }
                    } else {
                        if(inet_pton(AF_INET6, pEnd, &pAddr->max_addr.addr_v6.addr.addr8) != 1) {
                            LOG_EX(LOG_Error, "%s convert to ip address error\n", pEnd);
                            return -RET_INPUTERR;
                        }
                    }
                }

                //LOG_EX(LOG_Info, "    value:        %s\n", pObjK->objs.addr_obj[j].str_val);
                break;

            case OBJ_TYPE_DATETIME:
                split_params((char *)pDt->str_val, &pStart, &pEnd, "-");

                if(!pcre_match(REGEX_DT, pStart)) {
                    LOG_EX(LOG_Error, "Input %s format error\n", pStart);
                    return -RET_INPUTERR;
                } else {
                    memset(&tm, 0, sizeof(struct tm));

                    // YYYY/MM/DD HH:MM 格式
                    if(strlen(pStart) > strlen("00:00")) {
                        strptime(pStart, "%Y/%m/%d %H:%M", &tm);
                    } else {
                        strptime(pStart, "%H:%M", &tm);
                    }

                    if(tm.tm_year < 119) {
                        tm.tm_year = 119;
                    }

                    if(tm.tm_mday < 1) {
                        tm.tm_mday = 1;
                    }

                    pDt->min_time = mktime(&tm);
                    pDt->max_time = 0;
                }

                if(pEnd && strlen(pEnd) > 0) {
                    if(!pcre_match(REGEX_DT, pEnd)) {
                        LOG_EX(LOG_Error, "Input %s format error\n", pEnd);
                        return -RET_INPUTERR;
                    }

                    memset(&tm, 0, sizeof(struct tm));

                    if(strlen(pEnd) > strlen("00:00")) {
                        strptime(pEnd, "%Y/%m/%d %H:%M", &tm);
                    } else {
                        strptime(pEnd, "%H:%M", &tm);
                    }

                    if(tm.tm_year < 119) {
                        tm.tm_year = 119;
                    }

                    if(tm.tm_mday < 1) {
                        tm.tm_mday = 1;
                    }

                    pDt->max_time = mktime(&tm);
                }

                //LOG_EX(LOG_Info, "    repeat:       %d\n", pObjK->objs.dt_obj[j].rep_mode);
                //LOG_EX(LOG_Info, "    value:        %s\n", pObjK->objs.dt_obj[j].str_val);
                break;
        }
    }

    memcpy(&g_objItem[pos], pObjK, sizeof(OBJECT_K));
    pObj->obj_index = pos;
    pthread_mutex_init(&pObj->lock, NULL);
    pthread_mutex_lock(&g_obj_lock);
    HASH_ADD_STR(g_pObject, name, pObj);
    pthread_mutex_unlock(&g_obj_lock);
    return RET_OK;
}

int object_del(const char *pName)
{
    int i;
    PCMHI_OBJECT p, pTmp;

    if(!pName || strlen(pName) == 0) {
        return -RET_INPUTERR;
    }

    pthread_mutex_lock(&g_obj_lock);
    HASH_FIND_STR(g_pObject, pName, p);
    pthread_mutex_unlock(&g_obj_lock);

    if(p == NULL) {
        LOG_EX(LOG_Error, "Item %s not exists\n", pName);
        return -RET_NOTFOUND;
    }

    if(g_objItem[p->obj_index].ref_count > 0) {
        LOG_EX(LOG_Error, "Item %s used %d\n", p->name,
               g_objItem[p->obj_index].ref_count);
        return -RET_USED;
    }

    pthread_mutex_lock(&g_obj_lock);
    HASH_DEL(g_pObject, p);
    pthread_mutex_unlock(&g_obj_lock);

    for(i = 0; i < g_objItem[p->obj_index].ctx_num && i < MAX_OBJ_CONTENT; i++) {
        PSVR_OBJECT  pSvr       = &g_objItem[p->obj_index].objs.svr_obj[i];
        PADDR_OBJECT pAddr      = &g_objItem[p->obj_index].objs.addr_obj[i];
        PDT_OBJECT   pDt        = &g_objItem[p->obj_index].objs.dt_obj[i];

        switch(g_objItem[p->obj_index].type / 10) {
            case OBJ_TYPE_SERVER:
                if(pSvr->str_val) {
                    free(pSvr->str_val);
                }

                break;

            case OBJ_TYPE_ADDR:
                if(pAddr->str_val) {
                    free(pAddr->str_val);
                }

                break;

            case OBJ_TYPE_DATETIME:
                if(pDt->str_val) {
                    free(pDt->str_val);
                }

                break;
        }
    }

    memset(&g_objItem[p->obj_index], 0, sizeof(OBJECT_K));
    free(p);
    return RET_OK;
}

int object_mod(PCMHI_OBJECT pObj, POBJECT_K pObjK)
{
    int i;
    PCMHI_OBJECT p;

    if(!pObj || !pObjK) {
        LOG_EX(LOG_Error, "Input params error %p, %p\n", pObj, pObjK);
        return -RET_INPUTERR;
    }

    pthread_mutex_lock(&g_obj_lock);
    HASH_FIND_STR(g_pObject, pObj->name, p);
    pthread_mutex_unlock(&g_obj_lock);

    if(p == NULL) {
        LOG_EX(LOG_Error, "Item %s not exists\n", pObj->name);
        return -RET_EXIST;
    }

    memset(p->desc, 0, MAX_DESC);
    strncpy(p->desc, pObj->desc, MAX_DESC - 1);

    // 清理缓存的配置命令资源
    for(i = 0; i < g_objItem[p->obj_index].ctx_num && i < MAX_OBJ_CONTENT; i++) {
        PSVR_OBJECT  pSvr       = &g_objItem[p->obj_index].objs.svr_obj[i];
        PADDR_OBJECT pAddr      = &g_objItem[p->obj_index].objs.addr_obj[i];
        PDT_OBJECT   pDt        = &g_objItem[p->obj_index].objs.dt_obj[i];

        switch(g_objItem[p->obj_index].type / 10) {
            case OBJ_TYPE_SERVER:
                if(pSvr->str_val) {
                    free(pSvr->str_val);
                }

                break;

            case OBJ_TYPE_ADDR:
                if(pAddr->str_val) {
                    free(pAddr->str_val);
                }

                break;

            case OBJ_TYPE_DATETIME:
                if(pDt->str_val) {
                    free(pDt->str_val);
                }

                break;
        }
    }

    for(i = 0; i < pObjK->ctx_num && i < MAX_OBJ_CONTENT; i++) {
        char         *pStart    = NULL, *pEnd    = NULL;
        char         *pSubStart = NULL, *pSubEnd = NULL;
        PSVR_OBJECT  pSvr       = &pObjK->objs.svr_obj[i];
        PADDR_OBJECT pAddr      = &pObjK->objs.addr_obj[i];
        PDT_OBJECT   pDt        = &pObjK->objs.dt_obj[i];
        struct tm tm;

        switch(pObjK->type / 10) {
            case OBJ_TYPE_SERVER:
                split_params((char *)pSvr->str_val, &pStart, &pEnd, "-");

                if(!pcre_match(REGEX_SVR_PORT, pStart)) {
                    LOG_EX(LOG_Error, "Input %s format error\n", pStart);
                    return -RET_INPUTERR;
                } else {
                    int first;
                    first = strtoul(pStart, NULL, 10);
                    pSvr->min_port = first;
                    pSvr->max_port = 0;
                }

                if(pEnd && strlen(pEnd) > 0) {
                    int last;

                    if(!pcre_match(REGEX_SVR_PORT, pEnd)) {
                        LOG_EX(LOG_Error, "Input %s format error\n", pEnd);
                        return -RET_INPUTERR;
                    }

                    //first = strtoul(pStart, NULL, 10);
                    last = strtoul(pEnd, NULL, 10);

                    if(pSvr->pro_type <= PORT_UDP) {
                        //pSvr->min_port = htonl(first) & 0xFFFF;
                        pSvr->max_port = last;
                    } else {
                        //ICMP , min_port --> type, max_port --> code
                        //pSvr->min_port = first;
                        pSvr->max_port = last;
                    }
                }

                break;

            case OBJ_TYPE_ADDR:
                split_params((char *)pAddr->str_val, &pStart, &pEnd, "-");

                if(!pcre_match(REGEX_IP_ADDR, pStart)) {
                    LOG_EX(LOG_Error, "Input %s format error\n", pStart);
                    return -RET_INPUTERR;
                }

                split_params((char *)pStart, &pSubStart, &pSubEnd, "/");

                if(pSubEnd && strlen(pSubEnd) > 0) {
                    pAddr->net_mask = strtoul(pSubEnd, NULL, 10);
                }

                // IPv4 格式
                if(strchr(pStart, ':') == NULL) {
                    if(inet_pton(AF_INET, pSubStart, &pAddr->min_addr.addr_v4.ip4_addr) != 1) {
                        LOG_EX(LOG_Error, "%s convert to ip address error\n", pStart);
                        return -RET_INPUTERR;
                    }

                    pAddr->ip_version = IP_V4;
                } else {
                    if(inet_pton(AF_INET6, pSubStart, &pAddr->min_addr.addr_v6.addr.addr8) != 1) {
                        LOG_EX(LOG_Error, "%s convert to ip address error\n", pStart);
                        return -RET_INPUTERR;
                    }

                    pAddr->ip_version = IP_V6;
                }

                if(pEnd && strlen(pEnd) > 0) {
                    if(!pcre_match(REGEX_IP_ADDR, pEnd)) {
                        LOG_EX(LOG_Error, "Input %s format error\n", pEnd);
                        return -RET_INPUTERR;
                    }

                    if(pAddr->ip_version == IP_V4) {
                        if(inet_pton(AF_INET, pEnd, &pAddr->max_addr.addr_v4.ip4_addr) != 1) {
                            LOG_EX(LOG_Error, "%s convert to ip address error\n", pEnd);
                            return -RET_INPUTERR;
                        }
                    } else {
                        if(inet_pton(AF_INET6, pEnd, &pAddr->max_addr.addr_v6.addr.addr8) != 1) {
                            LOG_EX(LOG_Error, "%s convert to ip address error\n", pEnd);
                            return -RET_INPUTERR;
                        }
                    }
                }

                //LOG_EX(LOG_Info, "    value:        %s\n", pObjK->objs.addr_obj[j].str_val);
                break;

            case OBJ_TYPE_DATETIME:
                split_params((char *)pDt->str_val, &pStart, &pEnd, "-");

                if(!pcre_match(REGEX_DT, pStart)) {
                    LOG_EX(LOG_Error, "Input %s format error\n", pStart);
                    return -RET_INPUTERR;
                } else {
                    memset(&tm, 0, sizeof(struct tm));

                    // YYYY/MM/DD HH:MM 格式
                    if(strlen(pStart) > strlen("00:00")) {
                        strptime(pStart, "%Y/%m/%d %H:%M", &tm);
                    } else {
                        strptime(pStart, "%H:%M", &tm);
                    }

                    if(tm.tm_year < 119) {
                        tm.tm_year = 119;
                    }

                    if(tm.tm_mday < 1) {
                        tm.tm_mday = 1;
                    }

                    pDt->min_time = mktime(&tm);
                    pDt->max_time = 0;
                }

                if(pEnd && strlen(pEnd) > 0) {
                    if(!pcre_match(REGEX_DT, pEnd)) {
                        LOG_EX(LOG_Error, "Input %s format error\n", pEnd);
                        return -RET_INPUTERR;
                    }

                    memset(&tm, 0, sizeof(struct tm));

                    if(strlen(pEnd) > strlen("00:00")) {
                        strptime(pEnd, "%Y/%m/%d %H:%M", &tm);
                    } else {
                        strptime(pEnd, "%H:%M", &tm);
                    }

                    if(tm.tm_year < 119) {
                        tm.tm_year = 119;
                    }

                    if(tm.tm_mday < 1) {
                        tm.tm_mday = 1;
                    }

                    pDt->max_time = mktime(&tm);
                }

                //LOG_EX(LOG_Info, "    repeat:       %d\n", pObjK->objs.dt_obj[j].rep_mode);
                //LOG_EX(LOG_Info, "    value:        %s\n", pObjK->objs.dt_obj[j].str_val);
                break;
        }
    }

    p->prio                         = pObj->prio;
    g_objItem[p->obj_index].ctx_num = pObjK->ctx_num;
    g_objItem[p->obj_index].type    = pObjK->type;
    memcpy(&g_objItem[p->obj_index].objs, &pObjK->objs, sizeof(g_objItem[p->obj_index].objs));
    return RET_OK;
}

static const char *read_json_file(const char *pPath)
{
    FILE *pFile;
    unsigned char *pBuf;
    int f_size = 0;
    GET_FILE_SIZE(pPath, f_size);

    if(f_size <= 0) {
        LOG_EX(LOG_Error, "Get file %p size error: %d\n", pPath, f_size);
        return NULL;
    }

    pBuf = (unsigned char *)malloc(f_size + 1);

    if(!pBuf) {
        LOG_EX(LOG_Error, "Malloc %d bytes memory error: %d\n", f_size + 1);
        return NULL;
    }

    pFile = fopen(pPath, "r");

    if(!pFile) {
        LOG_EX(LOG_Error, "Open file %p size error\n", pPath);
        free(pBuf);
        return NULL;
    }

    fread(pBuf, 1, f_size, pFile);
    fclose(pFile);
    pBuf[f_size] = 0;
    return (const char *)pBuf;
}

static void test_del_object(void)
{
    int i, ret;
    const char *pRetJson;
    IFC_RET_MSG retCtx;
    PIFACE_DEL_OBJ  pDel        = NULL;
    PJSON_INTERFACE p           = NULL;
    const           char *pJson = read_json_file(DEL_JS_FILE);
    ret = Json2Struct(pJson, &p, JE_INTERFACE, FALSE);
    memset(&retCtx, 0, sizeof(IFC_RET_MSG));

    if(ret != RET_OK || p == NULL) {
        LOG_EX(LOG_Error, "Decode json error: %d\n", ret);
        free((void *)pJson);

        if(p) {
            if(p->msgContent) {
                free((void *)p->msgContent);
            }

            free(p);
        }

        retCtx.ret_code = -RET_JSONERR;
        retCtx.mesg = get_err_message(RET_JSONERR);
        retCtx.n_items = 0;
        pRetJson = Struct2Json(&retCtx, JE_OBJ_DEL, FALSE, &ret);

        if(!pRetJson || ret != RET_OK) {
            LOG_EX(LOG_Error, "Json format error: %d\n", ret);
            return;
        }

        LOG_EX(LOG_Debug, "Respons:\n%s\n", pRetJson);
        free((void *)pRetJson);
        return;
    }

    LOG_EX(LOG_Info, "cmdId:        %d\n", p->cmdId);
    LOG_EX(LOG_Info, "ver:          %d\n", p->ver);
    LOG_EX(LOG_Info, "cryptoType:   %d\n", p->cryptoType);
    LOG_EX(LOG_Info, "timeStamp:    %d\n", p->timeStamp);
    LOG_EX(LOG_Info, "msgContent:   %s\n", p->msgContent);
    ret = Json2Struct(p->msgContent, &pDel, JE_OBJ_DEL, FALSE);

    if(ret != RET_OK || pDel == NULL) {
        LOG_EX(LOG_Error, "Decode json error: %d\n", ret);

        if(pDel) {
            free(pDel);
        }

        if(p->msgContent) {
            free((void *)p->msgContent);
        }

        free(p);
        free((void *)pJson);
        retCtx.ret_code = -RET_JSONERR;
        retCtx.mesg = get_err_message(RET_JSONERR);
        retCtx.n_items = 0;
        pRetJson = Struct2Json(&retCtx, JE_OBJ_DEL, FALSE, &ret);

        if(!pRetJson || ret != RET_OK) {
            LOG_EX(LOG_Error, "Json format error: %d\n", ret);
            return;
        }

        LOG_EX(LOG_Debug, "Respons:\n%s\n", pRetJson);
        free((void *)pRetJson);
        return;
    } else {
        retCtx.n_items = pDel->n_obj;
    }

    for(i = 0; i < pDel->n_obj; i++) {
        ret = object_del(pDel->name[i]);

        if(ret != RET_OK && retCtx.ret_code == RET_OK) {
            retCtx.ret_code = ret;
        }

        retCtx.data[i].name = pDel->name[i];
        retCtx.data[i].ret_code = ret;
        retCtx.data[i].mesg = get_err_message(ret);
    }

    dump_object();
    retCtx.mesg = get_err_message(retCtx.ret_code);
    pRetJson = Struct2Json(&retCtx, JE_OBJ_DEL, FALSE, &ret);

    if(!pRetJson || ret != RET_OK) {
        LOG_EX(LOG_Error, "Json format error: %d\n", ret);

        if(pRetJson) {
            free((void *)pRetJson);
        }

        free(pDel);

        if(p->msgContent) {
            free((void *)p->msgContent);
        }

        free(p);
        free((void *)pJson);
        return;
    }

    LOG_EX(LOG_Debug, "Respons:\n%s\n", pRetJson);
    free((void *)pRetJson);
    free(pDel);

    if(p->msgContent) {
        free((void *)p->msgContent);
    }

    free(p);
    free((void *)pJson);
}

static void test_add_object(void)
{
    int i, ret;
    const char *pRetJson;
    IFC_RET_MSG retCtx;
    PJSON_INTERFACE p           = NULL;
    PIFACE_ADD_OBJ  pAdd        = NULL;
    const           char *pJson = read_json_file(ADD_JS_FILE);
    ret = Json2Struct(pJson, &p, JE_INTERFACE, FALSE);
    memset(&retCtx, 0, sizeof(IFC_RET_MSG));

    if(ret != RET_OK || p == NULL) {
        LOG_EX(LOG_Error, "Decode json error: %d\n", ret);
        free((void *)pJson);

        if(p) {
            if(p->msgContent) {
                free((void *)p->msgContent);
            }

            free(p);
        }

        retCtx.ret_code = -RET_JSONERR;
        retCtx.mesg = get_err_message(RET_JSONERR);
        retCtx.n_items = 0;
        pRetJson = Struct2Json(&retCtx, JE_OBJ_ADD, FALSE, &ret);

        if(!pRetJson || ret != RET_OK) {
            LOG_EX(LOG_Error, "Json format error: %d\n", ret);
            return;
        }

        LOG_EX(LOG_Debug, "Respons:\n%s\n", pRetJson);
        free((void *)pRetJson);
        return;
    }

    LOG_EX(LOG_Info, "cmdId:        %d\n", p->cmdId);
    LOG_EX(LOG_Info, "ver:          %d\n", p->ver);
    LOG_EX(LOG_Info, "cryptoType:   %d\n", p->cryptoType);
    LOG_EX(LOG_Info, "timeStamp:    %d\n", p->timeStamp);
    LOG_EX(LOG_Info, "msgContent:   %s\n", p->msgContent);
    ret = Json2Struct(p->msgContent, &pAdd, JE_OBJ_ADD, FALSE);

    if(ret != RET_OK || pAdd == NULL || pAdd->pCtx == NULL) {
        LOG_EX(LOG_Error, "Decode json error: %d\n", ret);

        if(pAdd) {
            if(pAdd->pCtx) {
                free(pAdd->pCtx);
            }

            free(pAdd);
        }

        if(p->msgContent) {
            free((void *)p->msgContent);
        }

        free(p);
        free((void *)pJson);
        retCtx.ret_code = -RET_JSONERR;
        retCtx.mesg = get_err_message(RET_JSONERR);
        retCtx.n_items = 0;
        pRetJson = Struct2Json(&retCtx, JE_OBJ_ADD, FALSE, &ret);

        if(!pRetJson || ret != RET_OK) {
            LOG_EX(LOG_Error, "Json format error: %d\n", ret);
            return;
        }

        LOG_EX(LOG_Debug, "Respons:\n%s\n", pRetJson);
        free((void *)pRetJson);
        return;
    } else {
        retCtx.n_items = pAdd->n_obj;
    }

    for(i = 0; i < pAdd->n_obj; i++) {
        LOG_EX(LOG_Debug, "%d: %s\n", i, pAdd->pCtx[i].pObj->name);
        ret = object_add(pAdd->pCtx[i].pObj, &pAdd->pCtx[i].objk);

        if(ret != RET_OK && retCtx.ret_code == RET_OK) {
            retCtx.ret_code = ret;
        }

        retCtx.data[i].name = pAdd->pCtx[i].pObj->name;
        retCtx.data[i].ret_code = ret;
        retCtx.data[i].mesg = get_err_message(ret);
    }

    for(i = 0; i < 100; i++) {
        PCMHI_OBJECT pObjItem = malloc(sizeof(CMHI_OBJECT));
        POBJECT_K pObjKItem = malloc(sizeof(OBJECT_K));

        if(pObjItem && pObjKItem) {
            memcpy(pObjItem, pAdd->pCtx[0].pObj, sizeof(CMHI_OBJECT));
            memcpy(pObjKItem, &pAdd->pCtx[i].objk, sizeof(OBJECT_K));
            sprintf(pObjItem->name, "%s_%02d", pAdd->pCtx[0].pObj->name, i);
            pObjKItem->type = 1;
            pObjKItem->ctx_num = 1;
            pObjKItem->objs.svr_obj[0].pro_type = 1;
            pObjKItem->objs.svr_obj[0].str_val = strdup("10010-10011");
            object_add(pObjItem, pObjKItem);
        }
    }

    //dump_object();
    retCtx.mesg = get_err_message(retCtx.ret_code);
    pRetJson = Struct2Json(&retCtx, JE_OBJ_ADD, FALSE, &ret);

    if(!pRetJson || ret != RET_OK) {
        LOG_EX(LOG_Error, "Json format error: %d\n", ret);

        if(pRetJson) {
            free((void *)pRetJson);
        }

        if(pAdd->pCtx) {
            free(pAdd->pCtx);
        }

        free(pAdd);

        if(p->msgContent) {
            free((void *)p->msgContent);
        }

        free(p);
        free((void *)pJson);
        return;
    }

    LOG_EX(LOG_Debug, "Respons:\n%s\n", pRetJson);
    free((void *)pRetJson);

    if(pAdd->pCtx) {
        free(pAdd->pCtx);
    }

    free(pAdd);

    if(p->msgContent) {
        free((void *)p->msgContent);
    }

    free(p);
    free((void *)pJson);
}

static void test_mod_object(void)
{
    int i, ret;
    const char *pRetJson;
    IFC_RET_MSG retCtx;
    PJSON_INTERFACE p           = NULL;
    PIFACE_ADD_OBJ  pAdd        = NULL;
    const           char *pJson = read_json_file(MOD_JS_FILE);
    ret = Json2Struct(pJson, &p, JE_INTERFACE, FALSE);
    memset(&retCtx, 0, sizeof(IFC_RET_MSG));

    if(ret != RET_OK || p == NULL) {
        LOG_EX(LOG_Error, "Decode json error: %d\n", ret);
        free((void *)pJson);

        if(p) {
            if(p->msgContent) {
                free((void *)p->msgContent);
            }

            free(p);
        }

        retCtx.ret_code = -RET_JSONERR;
        retCtx.mesg = get_err_message(RET_JSONERR);
        retCtx.n_items = 0;
        pRetJson = Struct2Json(&retCtx, JE_OBJ_MOD, FALSE, &ret);

        if(!pRetJson || ret != RET_OK) {
            LOG_EX(LOG_Error, "Json format error: %d\n", ret);
            return;
        }

        LOG_EX(LOG_Debug, "Respons:\n%s\n", pRetJson);
        free((void *)pRetJson);
        return;
    }

    LOG_EX(LOG_Info, "cmdId:        %d\n", p->cmdId);
    LOG_EX(LOG_Info, "ver:          %d\n", p->ver);
    LOG_EX(LOG_Info, "cryptoType:   %d\n", p->cryptoType);
    LOG_EX(LOG_Info, "timeStamp:    %d\n", p->timeStamp);
    LOG_EX(LOG_Info, "msgContent:   %s\n", p->msgContent);
    ret = Json2Struct(p->msgContent, &pAdd, JE_OBJ_MOD, FALSE);

    if(ret != RET_OK || pAdd == NULL || pAdd->pCtx == NULL) {
        LOG_EX(LOG_Error, "Decode json error: %d\n", ret);

        if(pAdd) {
            if(pAdd->pCtx) {
                free(pAdd->pCtx);
            }

            free(pAdd);
        }

        if(p->msgContent) {
            free((void *)p->msgContent);
        }

        free(p);
        free((void *)pJson);
        retCtx.ret_code = -RET_JSONERR;
        retCtx.mesg = get_err_message(RET_JSONERR);
        retCtx.n_items = 0;
        pRetJson = Struct2Json(&retCtx, JE_OBJ_MOD, FALSE, &ret);

        if(!pRetJson || ret != RET_OK) {
            LOG_EX(LOG_Error, "Json format error: %d\n", ret);
            return;
        }

        LOG_EX(LOG_Debug, "Respons:\n%s\n", pRetJson);
        free((void *)pRetJson);
        return;
    } else {
        retCtx.n_items = pAdd->n_obj;
    }

    for(i = 0; i < pAdd->n_obj; i++) {
        LOG_EX(LOG_Debug, "%d: %s\n", i, pAdd->pCtx[i].pObj->name);
        ret = object_mod(pAdd->pCtx[i].pObj, &pAdd->pCtx[i].objk);

        if(ret != RET_OK && retCtx.ret_code == RET_OK) {
            retCtx.ret_code = ret;
        }

        retCtx.data[i].name = pAdd->pCtx[i].pObj->name;
        retCtx.data[i].ret_code = ret;
        retCtx.data[i].mesg = get_err_message(ret);
    }

    dump_object();
    retCtx.mesg = get_err_message(retCtx.ret_code);
    pRetJson = Struct2Json(&retCtx, JE_OBJ_MOD, FALSE, &ret);

    if(!pRetJson || ret != RET_OK) {
        LOG_EX(LOG_Error, "Json format error: %d\n", ret);

        if(pRetJson) {
            free((void *)pRetJson);
        }

        if(pAdd->pCtx) {
            free(pAdd->pCtx);
        }

        free(pAdd);

        if(p->msgContent) {
            free((void *)p->msgContent);
        }

        free(p);
        free((void *)pJson);
        return;
    }

    LOG_EX(LOG_Debug, "Respons:\n%s\n", pRetJson);
    free((void *)pRetJson);

    if(pAdd->pCtx) {
        free(pAdd->pCtx);
    }

    free(pAdd);

    if(p->msgContent) {
        free((void *)p->msgContent);
    }

    free(p);
    free((void *)pJson);
}

static void test_strsep(char *pVal)
{
    char *pStart = NULL, *pEnd = NULL;
    split_params(pVal, &pStart, &pEnd, "-");

    if(pEnd) {
        LOG_EX(LOG_Debug, "[%s] Split to First = %s, Second = %s\n", pVal, pStart,
               pEnd);
    } else {
        LOG_EX(LOG_Debug, "[%s] Split to First = %s\n", pVal, pStart);
    }
}

static void test_regex(char *pVal)
{
    if(pcre_match(REGEX_IP_ADDR, pVal)) {
        LOG_EX(LOG_Debug, "[%s] ==> Match\n", pVal);
    } else {
        LOG_EX(LOG_Error, "[%s] ==> Not Match\n", pVal);
    }

    //LOG_EX(LOG_Debug, "Ret : [%s] ==> %d\n", pVal, pcre_match(REGEX_SVR_PORT, pVal));
}

static void test_ipaddr_format(char *pVal)
{
    int ret = 0;
    IP4_ADDR ip_v4;
    IP6_ADDR ip_v6;
    memset(&ip_v4, 0, sizeof(IP4_ADDR));
    memset(&ip_v6, 0, sizeof(IP6_ADDR));
    ret = pcre_match(REGEX_IP_ADDR, pVal);

    if(ret != TRUE) {
        LOG_EX(LOG_Error, "Verify ipadd format error\n");
    }

    if(strchr(pVal, ':') == NULL) {
        ret = inet_pton(AF_INET, pVal, &ip_v4.ip4_addr);
        print_hex_dump_bytes("IP", 0, &ip_v4, sizeof(IP4_ADDR));
    } else {
        ret = inet_pton(AF_INET6, pVal, ip_v6.addr.addr8);
        print_hex_dump_bytes("IP", 0, &ip_v6, sizeof(IP6_ADDR));
    }

    LOG_EX(LOG_Debug, "Convert %s to ip address ret: %d\n", pVal, ret);
}

static void test_str_time(char *pVal)
{
    struct tm tm;
    char buf[255];

    if(!pVal || strlen(pVal) == 0) {
        LOG_EX(LOG_Error, "Input params error\n");
        return;
    }

    memset(&tm, 0, sizeof(struct tm));
    strptime(pVal, "%H:%M", &tm);
    memset(buf, 0, sizeof(buf));
    LOG_EX(LOG_Debug, "year = %d, month = %d, day = %d\n", tm.tm_year, tm.tm_mon,
           tm.tm_mday);

    if(tm.tm_year < 119) {
        tm.tm_year = 119;
    }

    if(tm.tm_mday < 1) {
        tm.tm_mday = 1;
    }

    strftime(buf, sizeof(buf), "%Y/%m/%d %H:%M:%S", &tm);
    LOG_EX(LOG_Debug, "asctime: %s / %d\n", buf, mktime(&tm));
    memset(&tm, 0, sizeof(struct tm));
    strptime(pVal, "%Y/%m/%d %H:%M", &tm);
    memset(buf, 0, sizeof(buf));
    strftime(buf, sizeof(buf), "%Y/%m/%d %H:%M:%S", &tm);
    LOG_EX(LOG_Debug, "asctime: %s / %d\n", buf, mktime(&tm));
}

static void test_random_string(char *pVal)
{
    int first;
    unsigned char *pBuf;

    if(!pVal || strlen(pVal) == 0) {
        first = 64;
    } else {
        first = strtoul(pVal, NULL, 10);
    }

    pBuf = malloc(first + 1);
    LOG_EX(LOG_Debug, "Make %d bytes\n", first);

    if(pBuf) {
        memset(pBuf, 0, first + 1);
        random_string(pBuf, first);
        free(pBuf);
    }
}

static void test_page_object(char *pVal)
{
    int i, ret;
    char **pStr;
    PSPLIT_PAGE pPage;
    PCMHI_OBJECT pObj;
    const char *pRetJson;
    IFC_RET_PAGE_MSG retCtx;
    char session[MAX_SESSION];
    int iCount = 0;
    PIFACE_QUERY_LIST pQuery      = NULL;
    PJSON_INTERFACE   p           = NULL;
    const             char *pJson = read_json_file(QUERY_LIST_JS_FILE);
    ret = Json2Struct(pJson, &p, JE_INTERFACE, FALSE);
    memset(&retCtx, 0, sizeof(IFC_RET_PAGE_MSG));

    if(ret != RET_OK || p == NULL) {
        LOG_EX(LOG_Error, "Decode json error: %d\n", ret);
        free((void *)pJson);

        if(p) {
            if(p->msgContent) {
                free((void *)p->msgContent);
            }

            free(p);
        }

        retCtx.ret_code = -RET_JSONERR;
        retCtx.mesg = get_err_message(RET_JSONERR);
        retCtx.n_items = 0;
        pRetJson = Struct2Json(&retCtx, JE_OBJ_QUERYLIST, FALSE, &ret);

        if(!pRetJson || ret != RET_OK) {
            LOG_EX(LOG_Error, "Json format error: %d\n", ret);
            return;
        }

        LOG_EX(LOG_Debug, "Respons:\n%s\n", pRetJson);
        free((void *)pRetJson);
        return;
    }

    LOG_EX(LOG_Info, "cmdId:        %d\n", p->cmdId);
    LOG_EX(LOG_Info, "ver:          %d\n", p->ver);
    LOG_EX(LOG_Info, "cryptoType:   %d\n", p->cryptoType);
    LOG_EX(LOG_Info, "timeStamp:    %d\n", p->timeStamp);
    LOG_EX(LOG_Info, "msgContent:   %s\n", p->msgContent);
    ret = Json2Struct(p->msgContent, &pQuery, JE_OBJ_QUERYLIST, FALSE);

    if(ret != RET_OK || pQuery == NULL) {
        LOG_EX(LOG_Error, "Decode json error: %d\n", ret);

        if(pQuery) {
            free(pQuery);
        }

        if(p->msgContent) {
            free((void *)p->msgContent);
        }

        free(p);
        free((void *)pJson);
        retCtx.ret_code = -RET_JSONERR;
        retCtx.mesg = get_err_message(RET_JSONERR);
        retCtx.n_items = 0;
        pRetJson = Struct2Json(&retCtx, JE_OBJ_QUERYLIST, FALSE, &ret);

        if(!pRetJson || ret != RET_OK) {
            LOG_EX(LOG_Error, "Json format error: %d\n", ret);
            return;
        }

        LOG_EX(LOG_Debug, "Respons:\n%s\n", pRetJson);
        free((void *)pRetJson);
        return;
    }

    if(strlen(pQuery->session) == 0) {
        memset(pQuery->session, 0, MAX_SESSION);
        ret = object_split_page("", pQuery->type, pQuery->session);

        if(ret != RET_OK) {
            LOG_EX(LOG_Error, "object_split_page error: %d\n", ret);

            if(pQuery) {
                free(pQuery);
            }

            if(p->msgContent) {
                free((void *)p->msgContent);
            }

            free(p);
            free((void *)pJson);
            retCtx.ret_code = ret;
            retCtx.mesg = get_err_message(retCtx.ret_code);
            retCtx.n_items = 0;
            pRetJson = Struct2Json(&retCtx, JE_OBJ_QUERYLIST, FALSE, &ret);

            if(!pRetJson || ret != RET_OK) {
                LOG_EX(LOG_Error, "Json format error: %d\n", ret);
                return;
            }

            LOG_EX(LOG_Debug, "Respons:\n%s\n", pRetJson);
            free((void *)pRetJson);
            return;
        }
    }

    HASH_FIND_STR(g_pSplitPage, pQuery->session, pPage);

    if(pPage == NULL) {
        LOG_EX(LOG_Debug, "Can't found session: %s\n", pQuery->session);

        if(pQuery) {
            free(pQuery);
        }

        if(p->msgContent) {
            free((void *)p->msgContent);
        }

        free(p);
        free((void *)pJson);
        retCtx.ret_code = -RET_NOTFOUND;
        retCtx.mesg = get_err_message(retCtx.ret_code);
        retCtx.n_items = 0;
        pRetJson = Struct2Json(&retCtx, JE_OBJ_QUERYLIST, FALSE, &ret);

        if(!pRetJson || ret != RET_OK) {
            LOG_EX(LOG_Error, "Json format error: %d\n", ret);
            return;
        }

        LOG_EX(LOG_Debug, "Respons:\n%s\n", pRetJson);
        free((void *)pRetJson);
        return;
    }

    retCtx.ret_code = RET_OK;
    retCtx.mesg = get_err_message(retCtx.ret_code);
    retCtx.session = pQuery->session;
    retCtx.type = pQuery->type;

    if(pPage->name_list) {
        retCtx.tolItems = utarray_len(pPage->name_list);
    } else {
        retCtx.tolItems = 0;
    }

    if(pQuery->start > retCtx.tolItems) {
        retCtx.start = 0;
    } else {
        retCtx.start = pQuery->start;
    }

    retCtx.n_items = 0;

    for(i = retCtx.start; i < pQuery->end && iCount < MAX_PAGE_ITEMS && iCount < retCtx.tolItems; i++) {
        pStr = (char **)utarray_eltptr(pPage->name_list, i);
        pthread_mutex_lock(&g_obj_lock);
        HASH_FIND_STR(g_pObject, *pStr, pObj);
        pthread_mutex_unlock(&g_obj_lock);

        if(pObj) {
            retCtx.data[retCtx.n_items].name      = pObj->name;
            retCtx.data[retCtx.n_items].desc      = pObj->desc;
            retCtx.data[retCtx.n_items].ref_count = g_objItem[pObj->obj_index].ref_count;
            retCtx.data[retCtx.n_items].type      = g_objItem[pObj->obj_index].type;
            retCtx.n_items++;
        }

        LOG_EX(LOG_Debug, "%s[%03d]: %s\n", pQuery->session, iCount++, *pStr);
    }

    retCtx.end = retCtx.start + iCount - 1;

    pRetJson = Struct2Json(&retCtx, JE_OBJ_QUERYLIST, FALSE, &ret);

    if(!pRetJson || ret != RET_OK) {
        LOG_EX(LOG_Error, "Json format error: %d\n", ret);
        return;
    }

    LOG_EX(LOG_Debug, "Respons:\n%s\n", pRetJson);
    free((void *)pRetJson);

    /* char **pStr;
    int iCount = 0;
    PSPLIT_PAGE p, pTmp;
    test_add_object();
    get_page_items("", 1, 30, 100); */
    /* object_split_page("", 1);
    HASH_ITER(hh, g_pSplitPage, p, pTmp) {
        while((pStr = (char **)utarray_next(p->name_list, pStr))) {
            LOG_EX(LOG_Debug, "%s[%03d]: %s\n", p->session, iCount++, *pStr);
        }
    } */

    if(p->msgContent) {
        free((void *)p->msgContent);
    }

    free(p);
    free((void *)pJson);
}

static void test_detail_object(void)
{
    int i, ret;
    const char *pRetJson;
    IFC_RET_DETAIL_MSG retCtx;
    PIFACE_DETAIL_OBJ  pDetail        = NULL;
    PJSON_INTERFACE p           = NULL;
    const           char *pJson = read_json_file(DETAIL_JS_FILE);
    ret = Json2Struct(pJson, &p, JE_INTERFACE, FALSE);
    memset(&retCtx, 0, sizeof(IFC_RET_DETAIL_MSG));

    if(ret != RET_OK || p == NULL) {
        LOG_EX(LOG_Error, "Decode json error: %d\n", ret);
        free((void *)pJson);

        if(p) {
            if(p->msgContent) {
                free((void *)p->msgContent);
            }

            free(p);
        }

        retCtx.ret_code = -RET_JSONERR;
        retCtx.mesg = get_err_message(RET_JSONERR);
        retCtx.n_items = 0;
        pRetJson = Struct2Json(&retCtx, JE_OBJ_QUERYDETAIL, FALSE, &ret);

        if(!pRetJson || ret != RET_OK) {
            LOG_EX(LOG_Error, "Json format error: %d\n", ret);
            return;
        }

        LOG_EX(LOG_Debug, "Respons:\n%s\n", pRetJson);
        free((void *)pRetJson);
        return;
    }

    LOG_EX(LOG_Info, "cmdId:        %d\n", p->cmdId);
    LOG_EX(LOG_Info, "ver:          %d\n", p->ver);
    LOG_EX(LOG_Info, "cryptoType:   %d\n", p->cryptoType);
    LOG_EX(LOG_Info, "timeStamp:    %d\n", p->timeStamp);
    LOG_EX(LOG_Info, "msgContent:   %s\n", p->msgContent);
    ret = Json2Struct(p->msgContent, &pDetail, JE_OBJ_QUERYDETAIL, FALSE);

    if(ret != RET_OK || pDetail == NULL) {
        LOG_EX(LOG_Error, "Decode json error: %d\n", ret);

        if(pDetail) {
            free(pDetail);
        }

        if(p->msgContent) {
            free((void *)p->msgContent);
        }

        free(p);
        free((void *)pJson);
        retCtx.ret_code = -RET_JSONERR;
        retCtx.mesg = get_err_message(RET_JSONERR);
        retCtx.n_items = 0;
        pRetJson = Struct2Json(&retCtx, JE_OBJ_QUERYDETAIL, FALSE, &ret);

        if(!pRetJson || ret != RET_OK) {
            LOG_EX(LOG_Error, "Json format error: %d\n", ret);
            return;
        }

        LOG_EX(LOG_Debug, "Respons:\n%s\n", pRetJson);
        free((void *)pRetJson);
        return;
    } else {
        retCtx.n_items = pDetail->n_obj;
    }

    for(i = 0; i < pDetail->n_obj; i++) {
        ret = object_del(pDetail->name[i]);

        if(ret != RET_OK && retCtx.ret_code == RET_OK) {
            retCtx.ret_code = ret;
        }

        retCtx.data[i].name = pDetail->name[i];
        retCtx.data[i].ret_code = ret;
        retCtx.data[i].mesg = get_err_message(ret);
    }

    dump_object();
    retCtx.mesg = get_err_message(retCtx.ret_code);
    pRetJson = Struct2Json(&retCtx, JE_OBJ_DEL, FALSE, &ret);

    if(!pRetJson || ret != RET_OK) {
        LOG_EX(LOG_Error, "Json format error: %d\n", ret);

        if(pRetJson) {
            free((void *)pRetJson);
        }

        free(pDetail);

        if(p->msgContent) {
            free((void *)p->msgContent);
        }

        free(p);
        free((void *)pJson);
        return;
    }

    LOG_EX(LOG_Debug, "Respons:\n%s\n", pRetJson);
    free((void *)pRetJson);
    free(pDetail);

    if(p->msgContent) {
        free((void *)p->msgContent);
    }

    free(p);
    free((void *)pJson);
}

/**
 * @brief  应用程序主函数
 * @param  argc       输入参数个数
 * @param  argv       输入参数详细内容
 * @return 0
 */
int main(int argc, char **argv)
{
    int c, optidx = 0;
    static const struct option long_opts[] = {
        { "help",       no_argument,        NULL, 'h'},
        { "version",    no_argument,        NULL, 'v'},
        // TODO 添加其它需要处理的参数配置
        { "interface",  no_argument,        NULL, 'i'},
        { "regex",      required_argument,  NULL, 'r'},
        { "split_str",  required_argument,  NULL, 's'},
        { "ip_addr",    required_argument,  NULL, 'p'},
        { "str_time",   required_argument,  NULL, 't'},
        { "page_split", optional_argument,  NULL, 'a'},
        {NULL, 0, NULL, 0}
    };
    IHW_InitLOG("obj", NULL, TRUE);
    LOG_EX(LOG_Debug, "OBJECT_K = %u bytes\n", sizeof(OBJECT_K));
    LOG_EX(LOG_Debug, "DT_OBJECT = %u bytes\n", sizeof(DT_OBJECT));
    LOG_EX(LOG_Debug, "SVR_OBJECT = %u bytes\n", sizeof(SVR_OBJECT));
    LOG_EX(LOG_Debug, "ADDR_OBJECT = %u bytes\n", sizeof(ADDR_OBJECT));
    LOG_EX(LOG_Debug, "time_t = %u bytes\n", sizeof(time_t));
    LOG_EX(LOG_Debug, "g_objItem[0].objs = %u bytes\n", sizeof(g_objItem[0].objs));
    LOG_EX(LOG_Debug, "DT_OBJECT = %u bytes\n", sizeof(DT_OBJECT) * MAX_OBJ_CONTENT);
    LOG_EX(LOG_Debug, "SVR_OBJECT = %u bytes\n", sizeof(SVR_OBJECT) * MAX_OBJ_CONTENT);
    LOG_EX(LOG_Debug, "ADDR_OBJECT = %u bytes\n", sizeof(ADDR_OBJECT) * MAX_OBJ_CONTENT);

    while((c = getopt_long(argc, argv, "ir:s:p:t:a::hv", long_opts, &optidx)) != -1) {
        switch(c) {
            case 'v':
                LOG_EX(LOG_Info, "User demo version: %s(%s)\n", sGATE_GIT_TAGS, sGATE_GIT_VERS);
                break;

            case '?':
            case 'h':
                LOG_EX2(LOG_Info, "Usage: %s [-h] [-v] ...\n", argv[0]);
                LOG_EX2(LOG_Info, "options:\n");
                LOG_EX2(LOG_Info, "\t-v, --version show program version\n");
                LOG_EX2(LOG_Info, "\t-h, --help    print this message\n");
                LOG_EX2(LOG_Info, "\t-i, --interface    test object add interface\n");
                break;

            //TODO 添加其它必要处理参数过程
            case 'i':
                test_add_object();
                //test_del_object();
                //test_mod_object();
                break;

            case 's':
                test_strsep(optarg);
                break;

            case 'r':
                test_regex(optarg);
                break;

            case 'p':
                test_ipaddr_format(optarg);
                break;

            case 't':
                test_str_time(optarg);
                break;

            case 'a':
                test_add_object();
                test_page_object(optarg);
                break;
        }
    }

    while(TRUE) {
        sleep(1);
    }

    return 0;
}