/*
 * Copyright (C) 2015-2018 Alibaba Group Holding Limited
 */

#include "iotx_ota_internal.h"

#if (OTA_SIGNAL_CHANNEL) == 1
#include "ota_mqtt.c"
#elif (OTA_SIGNAL_CHANNEL) == 2
#include "ota_coap.c"
#else
#error "NOT support yet!"
#endif

/* check whether the progress state is valid or not */
/* return: true, valid progress state; false, invalid progress state. */
static int ota_check_progress(IOT_OTA_Progress_t progress)
{
    return ((progress >= IOT_OTAP_BURN_FAILED) && (progress <= IOT_OTAP_FETCH_PERCENTAGE_MAX));
}

static int ota_callback(void *pcontext, const char *msg, uint32_t msg_len, iotx_ota_topic_types_t type)
{
    const char *pvalue;
    uint32_t val_len;

    OTA_Struct_pt h_ota = (OTA_Struct_pt)pcontext;

    if (h_ota->state == IOT_OTAS_FETCHING)
    {
        OTA_LOG_INFO("In downloading state");
        return -1;
    }
    OTA_LOG_INFO("Call back In downloading state");
    switch (type)
    {
    case IOTX_OTA_TOPIC_TYPE_DEVICE_REQUEST:
    case IOTX_OTA_TOPIC_TYPE_DEVICE_UPGRATE:
    {
        pvalue = otalib_JsonValueOf(msg, msg_len, "message", &val_len);
        if (NULL == pvalue)
        {
            OTA_LOG_ERROR("invalid json doc of OTA ");
            return -1;
        }

        /* check whether is positive message */
        if (!((strlen("success") == val_len) && (0 == strncmp(pvalue, "success", val_len))))
        {
            OTA_LOG_ERROR("fail state of json doc of OTA");
            return -1;
        }

        /* get value of 'data' key */
        pvalue = otalib_JsonValueOf(msg, msg_len, "data", &val_len);
        if (NULL == pvalue)
        {
            OTA_LOG_ERROR("Not 'data' key in json doc of OTA");
            return -1;
        }

        if (0 != otalib_GetParams(pvalue, val_len, &h_ota->purl, &h_ota->version, h_ota->md5sum,
                                  &h_ota->size_file, &h_ota->module))
        {
            OTA_LOG_ERROR("Get config parameter failed");
            return -1;
        }

        h_ota->size_fetched_per_time = 256 * 8;	//1024*12
        if (NULL == (ofc_Init_new(h_ota)))
        {
            OTA_LOG_ERROR("Initialize fetch module failed");
            return -1;
        }

        h_ota->type = IOT_OTAT_FOTA;
        h_ota->state = IOT_OTAS_PUSHED;
        HAL_Printf("ota_callback(): 修改OTA类型为FOTA\n");
    }
    break;

    case IOTX_OTA_TOPIC_TYPE_CONFIG_GET:
    {
        pvalue = otalib_JsonValueOf(msg, msg_len, "code", &val_len);
        if (NULL == pvalue)
        {
            OTA_LOG_ERROR("invalid json doc of OTA ");
            return -1;
        }

        /* check whether is positive message */
        if (!((strlen("200") == val_len) && (0 == strncmp(pvalue, "200", val_len))))
        {
            OTA_LOG_ERROR("fail state of json doc of OTA");
            return -1;
        }

        /* get value of 'data' key */
        pvalue = otalib_JsonValueOf(msg, msg_len, "data", &val_len);
        if (NULL == pvalue)
        {
            OTA_LOG_ERROR("Not 'data' key in json doc of OTA");
            return -1;
        }

        if (0 != otalib_GetConfigParams(pvalue, val_len, &h_ota->configId, &h_ota->configSize,
                                        &h_ota->sign, &h_ota->signMethod, &h_ota->cota_url, &h_ota->getType))
        {
            OTA_LOG_ERROR("Get firmware parameter failed");
            return -1;
        }

        h_ota->size_file = h_ota->configSize;
        h_ota->size_fetched = 0;
        if (NULL != h_ota->md5)
        {
            otalib_MD5Deinit(h_ota->md5);
        }
        h_ota->md5 = otalib_MD5Init();

        if (NULL != h_ota->sha256)
        {
            otalib_Sha256Deinit(h_ota->sha256);
        }
        h_ota->sha256 = otalib_Sha256Init();

        if (NULL == (h_ota->ch_fetch = ofc_Init(h_ota->cota_url, h_ota->size_fetched)))
        {
            OTA_LOG_ERROR("Initialize fetch module failed");
            return -1;
        }

        h_ota->type = IOT_OTAT_COTA;
        h_ota->state = IOT_OTAS_PUSHED;
    }
    break;

    case IOTX_OTA_TOPIC_TYPE_CONFIG_PUSH:
    {
        /* get value of 'params' key */
        pvalue = otalib_JsonValueOf(msg, msg_len, "params", &val_len);
        if (NULL == pvalue)
        {
            OTA_LOG_ERROR("Not 'data' key in json doc of OTA");
            return -1;
        }

        if (0 != otalib_GetConfigParams(pvalue, val_len, &h_ota->configId, &h_ota->configSize,
                                        &h_ota->sign, &h_ota->signMethod, &h_ota->cota_url, &h_ota->getType))
        {
            OTA_LOG_ERROR("Get firmware parameter failed");
            return -1;
        }

        h_ota->size_file = h_ota->configSize;
        h_ota->size_fetched = 0;
        if (NULL != h_ota->md5)
        {
            otalib_MD5Deinit(h_ota->md5);
        }
        h_ota->md5 = otalib_MD5Init();

        if (NULL != h_ota->sha256)
        {
            otalib_Sha256Deinit(h_ota->sha256);
        }
        h_ota->sha256 = otalib_Sha256Init();

        if (NULL == (h_ota->ch_fetch = ofc_Init(h_ota->cota_url, h_ota->size_fetched)))
        {
            OTA_LOG_ERROR("Initialize fetch module failed");
            return -1;
        }

        h_ota->type = IOT_OTAT_COTA;
        h_ota->state = IOT_OTAS_PUSHED;
    }
    break;

    default:
        return -1;
        break;
    }

    if (h_ota->ota_event_cb != NULL)
    {
        h_ota->ota_event_cb(h_ota);
    }
    return 0;
}

static int g_ota_is_initialized = 0;

int IOT_OTA_SetOnPushedCallback(void *handle, int (*cb)(void *context))
{
    OTA_Struct_pt h_ota = (OTA_Struct_pt)handle;
    if (h_ota == NULL)
    {
        return -1;
    }

    h_ota->ota_event_cb = cb;
    return 0;
}
/* Initialize OTA module */
void *IOT_OTA_Init(const char *product_key, const char *device_name, void *ch_signal)
{
    OTA_Struct_pt h_ota = NULL;

    if (1 == g_ota_is_initialized)
    {
        OTA_LOG_ERROR("iot ota has been initialized");
        return NULL;
    }

    if ((NULL == product_key) || (NULL == device_name))
    {
        OTA_LOG_ERROR("one or more parameters is invalid");
        return NULL;
    }

    if (NULL == (h_ota = OTA_MALLOC(sizeof(OTA_Struct_t))))
    {
        OTA_LOG_ERROR("allocate failed");
        return NULL;
    }
    memset(h_ota, 0, sizeof(OTA_Struct_t));
    h_ota->type = IOT_OTAT_NONE;
    h_ota->state = IOT_OTAS_UNINITED;

    h_ota->ch_signal = osc_Init(product_key, device_name, ch_signal, ota_callback, h_ota);
    if (NULL == h_ota->ch_signal)
    {
        OTA_LOG_ERROR("initialize signal channel failed");
        goto do_exit;
    }

    h_ota->md5 = otalib_MD5Init();
    if (NULL == h_ota->md5)
    {
        OTA_LOG_ERROR("initialize md5 failed");
        goto do_exit;
    }
    h_ota->sha256 = otalib_Sha256Init();
    if (NULL == h_ota->sha256)
    {
        OTA_LOG_ERROR("initialize sha256 failed");
        goto do_exit;
    }

    h_ota->product_key = product_key;
    h_ota->device_name = device_name;
    h_ota->state = IOT_OTAS_INITED;
    g_ota_is_initialized = 1;
    return h_ota;

do_exit:

    if (NULL != h_ota->ch_signal)
    {
        osc_Deinit(h_ota->ch_signal);
    }

    if (NULL != h_ota->md5)
    {
        otalib_MD5Deinit(h_ota->md5);
    }

    if (NULL != h_ota->sha256)
    {
        otalib_Sha256Deinit(h_ota->sha256);
    }

    if (NULL != h_ota)
    {
        OTA_FREE(h_ota);
    }

    return NULL;

#undef AOM_INFO_MSG_LEN
}

/* deinitialize OTA module */
int IOT_OTA_Deinit(void *handle)
{
    OTA_Struct_pt h_ota = (OTA_Struct_pt)handle;

    if (NULL == h_ota)
    {
        OTA_LOG_ERROR("handle is NULL");
        return IOT_OTAE_INVALID_PARAM;
    }

    if (IOT_OTAS_UNINITED == h_ota->state)
    {
        OTA_LOG_ERROR("handle is uninitialized");
        h_ota->err = IOT_OTAE_INVALID_STATE;
        return -1;
    }

    g_ota_is_initialized = 0;

    if (NULL != h_ota->ch_signal)
    {
        osc_Deinit(h_ota->ch_signal);
    }

    if (NULL != h_ota->ch_fetch)
    {
        ofc_Deinit(&h_ota->ch_fetch);
    }

    if (NULL != h_ota->md5)
    {
        otalib_MD5Deinit(h_ota->md5);
    }

    if (NULL != h_ota->sha256)
    {
        otalib_Sha256Deinit(h_ota->sha256);
    }

    if (NULL != h_ota->purl)
    {
        OTA_FREE(h_ota->purl);
    }

    if (NULL != h_ota->version)
    {
        OTA_FREE(h_ota->version);
    }

    if (NULL != h_ota->configId)
    {
        OTA_FREE(h_ota->configId);
    }

    if (NULL != h_ota->sign)
    {
        OTA_FREE(h_ota->sign);
    }

    if (NULL != h_ota->signMethod)
    {
        OTA_FREE(h_ota->signMethod);
    }

    if (NULL != h_ota->cota_url)
    {
        OTA_FREE(h_ota->cota_url);
    }

    if (NULL != h_ota->getType)
    {
        OTA_FREE(h_ota->getType);
    }

    OTA_FREE(h_ota);
    return 0;
}

#define OTA_VERSION_STR_LEN_MIN (1)
#define OTA_VERSION_STR_LEN_MAX (32)

int IOT_OTA_ReportVersion(void *handle, const char *version)
{
#define MSG_INFORM_LEN (128)

    int ret, len;
    char *msg_informed;
    OTA_Struct_pt h_ota = (OTA_Struct_pt)handle;

    if ((NULL == h_ota) || (NULL == version))
    {
        OTA_LOG_ERROR("one or more invalid parameter");
        return IOT_OTAE_INVALID_PARAM;
    }

    len = strlen(version);
    if ((len < OTA_VERSION_STR_LEN_MIN) || (len > OTA_VERSION_STR_LEN_MAX))
    {
        OTA_LOG_ERROR("version string is invalid: must be [1, 32] chars");
        h_ota->err = IOT_OTAE_INVALID_PARAM;
        return -1;
    }

    if (IOT_OTAS_UNINITED == h_ota->state)
    {
        OTA_LOG_ERROR("handle is uninitialized");
        h_ota->err = IOT_OTAE_INVALID_STATE;
        return -1;
    }

    if (NULL == (msg_informed = OTA_MALLOC(MSG_INFORM_LEN)))
    {
        OTA_LOG_ERROR("allocate for msg_informed failed");
        h_ota->err = IOT_OTAE_NOMEM;
        return -1;
    }

    ret = otalib_GenInfoMsg(msg_informed, MSG_INFORM_LEN, h_ota->id, version);
    if (ret != 0)
    {
        OTA_LOG_ERROR("generate inform message failed");
        h_ota->err = ret;
        ret = -1;
        goto do_exit;
    }

    ret = osc_ReportVersion(h_ota->ch_signal, msg_informed);
    if (0 != ret)
    {
        OTA_LOG_ERROR("Report version failed");
        h_ota->err = ret;
        ret = -1;
        goto do_exit;
    }
    ret = 0;

do_exit:
    if (NULL != msg_informed)
    {
        OTA_FREE(msg_informed);
    }
    return ret;

#undef MSG_INFORM_LEN
}

int iotx_req_image(void *handle, const char *version)
{
#define MSG_REQUEST_LEN (128)

    int ret, len;
    char *msg_informed;
    OTA_Struct_pt h_ota = (OTA_Struct_pt)handle;

    if ((NULL == h_ota) || (NULL == version))
    {
        OTA_LOG_ERROR("one or more invalid parameter");
        return IOT_OTAE_INVALID_PARAM;
    }

    len = strlen(version);
    if ((len < OTA_VERSION_STR_LEN_MIN) || (len > OTA_VERSION_STR_LEN_MAX))
    {
        OTA_LOG_ERROR("version string is invalid: must be [1, 32] chars");
        h_ota->err = IOT_OTAE_INVALID_PARAM;
        return -1;
    }

    if (IOT_OTAS_UNINITED == h_ota->state)
    {
        OTA_LOG_ERROR("handle is uninitialized");
        h_ota->err = IOT_OTAE_INVALID_STATE;
        return -1;
    }

    if (IOT_OTAS_FETCHING == h_ota->state)
    {
        OTA_LOG_ERROR("ota is busying");
        h_ota->err = IOT_OTAE_INVALID_STATE;
        return -1;
    }

    if (NULL == (msg_informed = OTA_MALLOC(MSG_REQUEST_LEN)))
    {
        OTA_LOG_ERROR("allocate for msg_informed failed");
        h_ota->err = IOT_OTAE_NOMEM;
        return -1;
    }

    ret = otalib_GenInfoMsg(msg_informed, MSG_REQUEST_LEN, h_ota->id, version);
    if (ret != 0)
    {
        OTA_LOG_ERROR("generate request image message failed");
        h_ota->err = ret;
        ret = -1;
        goto do_exit;
    }

    ret = osc_RequestImage(h_ota->ch_signal, msg_informed);
    if (0 != ret)
    {
        OTA_LOG_ERROR("Request image failed");
        h_ota->err = ret;
        ret = -1;
        goto do_exit;
    }
    ret = 0;

do_exit:
    if (NULL != msg_informed)
    {
        OTA_FREE(msg_informed);
    }
    return ret;

#undef MSG_REQUEST_LEN
}

int IOT_OTA_ReportProgress(void *handle, IOT_OTA_Progress_t progress, const char *msg)
{
#define MSG_REPORT_LEN (256)

    int ret = -1;
    char *msg_reported;
    OTA_Struct_pt h_ota = (OTA_Struct_pt)handle;

    if (NULL == handle)
    {
        OTA_LOG_ERROR("handle is NULL");
        return IOT_OTAE_INVALID_PARAM;
    }

    if (IOT_OTAS_UNINITED == h_ota->state)
    {
        OTA_LOG_ERROR("handle is uninitialized");
        h_ota->err = IOT_OTAE_INVALID_STATE;
        return -1;
    }
    if (!ota_check_progress(progress))
    {
        OTA_LOG_ERROR("progress is a invalid parameter");
        h_ota->err = IOT_OTAE_INVALID_PARAM;
        return -1;
    }

    if (NULL == (msg_reported = OTA_MALLOC(MSG_REPORT_LEN)))
    {
        OTA_LOG_ERROR("allocate for msg_reported failed");
        h_ota->err = IOT_OTAE_NOMEM;
        return -1;
    }

    ret = otalib_GenReportMsg(msg_reported, MSG_REPORT_LEN, h_ota->id, progress, msg);
    if (0 != ret)
    {
        OTA_LOG_ERROR("generate reported message failed");
        h_ota->err = ret;
        goto do_exit;
    }

    ret = osc_ReportProgress(h_ota->ch_signal, msg_reported);
    if (0 != ret)
    {
        OTA_LOG_ERROR("Report progress failed");
        h_ota->err = ret;
        goto do_exit;
    }

    ret = 0;

do_exit:
    if (NULL != msg_reported)
    {
        OTA_FREE(msg_reported);
    }
    return ret;

#undef MSG_REPORT_LEN
}

int iotx_ota_get_config(void *handle, const char *configScope, const char *getType, const char *attributeKeys)
{
#define MSG_REPORT_LEN (256)

    int ret = -1;
    char *msg_get;
    char topic[OTA_MQTT_TOPIC_LEN] = {0};
    OTA_Struct_pt h_ota = (OTA_Struct_pt)handle;
    iotx_mqtt_topic_info_t topic_info;

    memset(&topic_info, 0, sizeof(iotx_mqtt_topic_info_t));

    if (NULL == handle)
    {
        OTA_LOG_ERROR("handle is NULL");
        return IOT_OTAE_INVALID_PARAM;
    }

    if (IOT_OTAS_UNINITED == h_ota->state)
    {
        OTA_LOG_ERROR("handle is uninitialized");
        h_ota->err = IOT_OTAE_INVALID_STATE;
        return -1;
    }

    if (IOT_OTAS_FETCHING == h_ota->state)
    {
        OTA_LOG_ERROR("ota is busying");
        h_ota->err = IOT_OTAE_INVALID_STATE;
        return -1;
    }

    if (NULL == (msg_get = OTA_MALLOC(MSG_REPORT_LEN)))
    {
        OTA_LOG_ERROR("allocate for msg_reported failed");
        h_ota->err = IOT_OTAE_NOMEM;
        return -1;
    }

    if (0 > HAL_Snprintf(topic,
                         OTA_MQTT_TOPIC_LEN,
                         "/sys/%s/%s/thing/config/get",
                         h_ota->product_key,
                         h_ota->device_name))
    {
        goto do_exit;
    };

    if (0 > HAL_Snprintf(msg_get,
                         MSG_REPORT_LEN,
                         "{\"id\" : %d,\"version\":\"1.0\",\"params\":{\"configScope\":\"%s\",\"getType\":\"%s\",\"attributeKeys\":\"%s\"},\"method\":\"thing.config.get\"}",
                         h_ota->id,
                         configScope,
                         getType,
                         attributeKeys))
    {
        goto do_exit;
    };
    OTA_LOG_INFO(msg_get);
    topic_info.qos = IOTX_MQTT_QOS0;
    topic_info.payload = (void *)msg_get;
    topic_info.payload_len = strlen(msg_get);

    ret = osc_RequestConfig(h_ota->ch_signal, topic, &topic_info);
    if (ret < 0)
    {
        OTA_LOG_ERROR("publish failed");
        return IOT_OTAE_OSC_FAILED;
    }

    ret = 0;

do_exit:
    if (NULL != msg_get)
    {
        OTA_FREE(msg_get);
    }
    return ret;

#undef MSG_REPORT_LEN
}

/* check whether is downloading */
int IOT_OTA_IsFetching(void *handle)
{
    OTA_Struct_pt h_ota = (OTA_Struct_pt)handle;

    if (NULL == handle)
    {
        OTA_LOG_ERROR("handle is NULL");
        return 0;
    }

    if (IOT_OTAS_UNINITED == h_ota->state)
    {
        OTA_LOG_ERROR("handle is uninitialized");
        h_ota->err = IOT_OTAE_INVALID_STATE;
        return 0;
    }

    return (IOT_OTAS_PUSHED == h_ota->state || IOT_OTAS_FETCHING == h_ota->state);
}

/* check whether fetch over */
int IOT_OTA_IsFetchFinish(void *handle)
{
    OTA_Struct_pt h_ota = (OTA_Struct_pt)handle;

    if (NULL == handle)
    {
        OTA_LOG_ERROR("handle is NULL");
        return 0;
    }

    if (IOT_OTAS_UNINITED == h_ota->state)
    {
        OTA_LOG_ERROR("handle is uninitialized");
        h_ota->err = IOT_OTAE_INVALID_STATE;
        return 0;
    }

    return (IOT_OTAS_FETCHED == h_ota->state);
}

int IOT_OTA_FetchYield(void *handle, char *buf, uint32_t buf_len, uint32_t timeout_s)
{
    int ret;
    OTA_Struct_pt h_ota = (OTA_Struct_pt)handle;

    if ((NULL == handle) || (NULL == buf) || (0 == buf_len))
    {
        OTA_LOG_ERROR("invalid parameter");
        return IOT_OTAE_INVALID_PARAM;
    }

    if (IOT_OTAS_PUSHED == h_ota->state)
    {
        h_ota->state = IOT_OTAS_FETCHING;
    }
    else if (IOT_OTAS_FETCHING != h_ota->state)
    {
        h_ota->err = IOT_OTAE_INVALID_STATE;
        return IOT_OTAE_INVALID_STATE;
    }

    if (h_ota->md5 == NULL)
    {
        h_ota->md5 = otalib_MD5Init();
        if (h_ota->md5 == NULL)
        {
            return FAIL_RETURN;
        }
    }
    if (h_ota->sha256 == NULL)
    {
        h_ota->sha256 = otalib_Sha256Init();
        if (h_ota->sha256 == NULL)
        {
            return FAIL_RETURN;
        }
    }

    if (h_ota->ch_fetch == NULL)
    {
        if (h_ota->type == IOT_OTAT_FOTA)
        {
            OTA_LOG_ERROR("h_ota->size_fetched: %d", h_ota->size_fetched);
            h_ota->size_fetched_per_time = buf_len;
            h_ota->ch_fetch = ofc_Init_new(h_ota);
        }
        else if (h_ota->type == IOT_OTAT_COTA)
        {
            h_ota->ch_fetch = ofc_Init(h_ota->cota_url, h_ota->size_fetched);
        }

        if (h_ota->ch_fetch == NULL)
        {
            OTA_LOG_ERROR("Re-Initialize HTTP handle failed");
            return FAIL_RETURN;
        }
    }
    else
    {
        if (h_ota->type == IOT_OTAT_FOTA)
        {
            OTA_LOG_ERROR("h_ota->size_fetched: %d", h_ota->size_fetched);
            h_ota->size_fetched_per_time = buf_len;
            h_ota->ch_fetch = ofc_Init_new(h_ota);
        }
    }

    ret = ofc_Fetch(h_ota->ch_fetch, buf, buf_len, timeout_s);
    if (ret < 0)
    {
        OTA_LOG_ERROR("OTA Internal Error: %d", ret);
        ofc_Deinit(&h_ota->ch_fetch);
        return ret;
    }
    else if (0 == h_ota->size_fetched)
    {
        otalib_MD5Deinit(h_ota->md5);
        h_ota->md5 = otalib_MD5Init();
        if (h_ota->md5 == NULL)
        {
            OTA_LOG_ERROR("md5 init failed");
            return -1;
        }

        otalib_Sha256Deinit(h_ota->sha256);
        h_ota->sha256 = otalib_Sha256Init();
        if (h_ota->sha256 == NULL)
        {
            OTA_LOG_ERROR("sha256 init failed");
            return -1;
        }
        /* force report status in the first */
        IOT_OTA_ReportProgress(h_ota, IOT_OTAP_FETCH_PERCENTAGE_MIN, "Enter in downloading state");
    }

    otalib_MD5Update(h_ota->md5, buf, ret);
    otalib_Sha256Update(h_ota->sha256, buf, ret);
    h_ota->size_last_fetched = ret;
    h_ota->size_fetched += ret;

    if (h_ota->size_fetched >= h_ota->size_file)
    {
        h_ota->type = IOT_OTAT_NONE;
        h_ota->state = IOT_OTAS_FETCHED;
    }

    return ret;
}

int IOT_OTA_Ioctl(void *handle, IOT_OTA_CmdType_t type, void *buf, int buf_len)
{
    OTA_Struct_pt h_ota = (OTA_Struct_pt)handle;

    if ((NULL == handle) || (NULL == buf) || (0 == buf_len))
    {
        OTA_LOG_ERROR("invalid parameter");
        return IOT_OTAE_INVALID_PARAM;
    }

    if (h_ota->state < IOT_OTAS_PUSHED)
    {
        h_ota->err = IOT_OTAE_INVALID_STATE;
        return IOT_OTAE_INVALID_STATE;
    }

    switch (type)
    {
    case IOT_OTAG_COTA_CONFIG_ID:
    {
        char **value = (char **)buf;
        if (value == NULL || *value != NULL || h_ota->configId == NULL)
        {
            OTA_LOG_ERROR("Invalid parameter");
            h_ota->err = IOT_OTAE_INVALID_PARAM;
            return -1;
        }
        else
        {
            *value = OTA_API_MALLOC(strlen(h_ota->configId) + 1);
            if (*value == NULL)
            {
                h_ota->err = IOT_OTAE_INVALID_PARAM;
                return -1;
            }
            memset(*value, 0, strlen(h_ota->configId) + 1);
            memcpy(*value, h_ota->configId, strlen(h_ota->configId));
            return 0;
        }
    }
    break;
    case IOT_OTAG_COTA_CONFIG_SIZE:
    {
        if ((4 != buf_len) || (0 != ((unsigned long)buf & 0x3)))
        {
            OTA_LOG_ERROR("Invalid parameter");
            h_ota->err = IOT_OTAE_INVALID_PARAM;
            return -1;
        }
        else
        {
            *((uint32_t *)buf) = h_ota->configSize;
            return 0;
        }
    }
    break;
    case IOT_OTAG_COTA_SIGN:
    {
        char **value = (char **)buf;
        if (value == NULL || *value != NULL || h_ota->sign == NULL)
        {
            OTA_LOG_ERROR("Invalid parameter");
            h_ota->err = IOT_OTAE_INVALID_PARAM;
            return -1;
        }
        else
        {
            *value = OTA_API_MALLOC(strlen(h_ota->sign) + 1);
            if (*value == NULL)
            {
                h_ota->err = IOT_OTAE_INVALID_PARAM;
                return -1;
            }
            memset(*value, 0, strlen(h_ota->sign) + 1);
            memcpy(*value, h_ota->sign, strlen(h_ota->sign));
            return 0;
        }
    }
    break;
    case IOT_OTAG_COTA_SIGN_METHOD:
    {
        char **value = (char **)buf;
        if (value == NULL || *value != NULL || h_ota->signMethod == NULL)
        {
            OTA_LOG_ERROR("Invalid parameter");
            h_ota->err = IOT_OTAE_INVALID_PARAM;
            return -1;
        }
        else
        {
            *value = OTA_API_MALLOC(strlen(h_ota->signMethod) + 1);
            if (*value == NULL)
            {
                h_ota->err = IOT_OTAE_INVALID_PARAM;
                return -1;
            }
            memset(*value, 0, strlen(h_ota->signMethod) + 1);
            memcpy(*value, h_ota->signMethod, strlen(h_ota->signMethod));
            return 0;
        }
    }
    break;
    case IOT_OTAG_COTA_URL:
    {
        char **value = (char **)buf;
        if (value == NULL || *value != NULL || h_ota->cota_url == NULL)
        {
            OTA_LOG_ERROR("Invalid parameter");
            h_ota->err = IOT_OTAE_INVALID_PARAM;
            return -1;
        }
        else
        {
            *value = OTA_API_MALLOC(strlen(h_ota->cota_url) + 1);
            if (*value == NULL)
            {
                h_ota->err = IOT_OTAE_INVALID_PARAM;
                return -1;
            }
            memset(*value, 0, strlen(h_ota->cota_url) + 1);
            memcpy(*value, h_ota->cota_url, strlen(h_ota->cota_url));
            return 0;
        }
    }
    break;
    case IOT_OTAG_COTA_GETTYPE:
    {
        char **value = (char **)buf;
        if (value == NULL || *value != NULL || h_ota->getType == NULL)
        {
            OTA_LOG_ERROR("Invalid parameter");
            h_ota->err = IOT_OTAE_INVALID_PARAM;
            return -1;
        }
        else
        {
            *value = OTA_API_MALLOC(strlen(h_ota->getType) + 1);
            if (*value == NULL)
            {
                h_ota->err = IOT_OTAE_INVALID_PARAM;
                return -1;
            }
            memset(*value, 0, strlen(h_ota->getType) + 1);
            memcpy(*value, h_ota->getType, strlen(h_ota->getType));
            return 0;
        }
    }
    break;
    case IOT_OTAG_OTA_TYPE:
    {
        if ((4 != buf_len) || (0 != ((unsigned long)buf & 0x3)))
        {
            OTA_LOG_ERROR("Invalid parameter");
            h_ota->err = IOT_OTAE_INVALID_PARAM;
            return -1;
        }
        else
        {
            *((uint32_t *)buf) = h_ota->type;
            return 0;
        }
    }
    break;
    case IOT_OTAG_FETCHED_SIZE:
        if ((4 != buf_len) || (0 != ((unsigned long)buf & 0x3)))
        {
            OTA_LOG_ERROR("Invalid parameter");
            h_ota->err = IOT_OTAE_INVALID_PARAM;
            return -1;
        }
        else
        {
            *((uint32_t *)buf) = h_ota->size_fetched;
            return 0;
        }

    case IOT_OTAG_FILE_SIZE:
        if ((4 != buf_len) || (0 != ((unsigned long)buf & 0x3)))
        {
            OTA_LOG_ERROR("Invalid parameter");
            h_ota->err = IOT_OTAE_INVALID_PARAM;
            return -1;
        }
        else
        {
            *((uint32_t *)buf) = h_ota->size_file;
            return 0;
        };

    case IOT_OTAG_VERSION:
    {
        strncpy(buf, h_ota->version, buf_len);
        ((char *)buf)[buf_len - 1] = '\0';
    }
    break;

    case IOT_OTAG_MODULE:
    {
        if (h_ota->module != NULL)
        {
            strncpy(buf, h_ota->module, buf_len);
            ((char *)buf)[buf_len - 1] = '\0';
        }
    }
    break;

    case IOT_OTAG_MD5SUM:
        strncpy(buf, h_ota->md5sum, buf_len);
        ((char *)buf)[buf_len - 1] = '\0';
        break;

    case IOT_OTAG_CHECK_FIRMWARE:
        if ((4 != buf_len) || (0 != ((unsigned long)buf & 0x3)))
        {
            OTA_LOG_ERROR("Invalid parameter");
            h_ota->err = IOT_OTAE_INVALID_PARAM;
            return -1;
        }
        else if (h_ota->state != IOT_OTAS_FETCHED)
        {
            h_ota->err = IOT_OTAE_INVALID_STATE;
            OTA_LOG_ERROR("Firmware can be checked in IOT_OTAS_FETCHED state only");
            return -1;
        }
        else
        {
            char md5_str[33];
            otalib_MD5Finalize(h_ota->md5, md5_str);
            otalib_MD5Deinit(h_ota->md5);
            h_ota->md5 = NULL;

            OTA_LOG_DEBUG("origin=%s, now=%s", h_ota->md5sum, md5_str);
            if (0 == strcmp(h_ota->md5sum, md5_str))
            {
                *((uint32_t *)buf) = 1;
            }
            else
            {
                *((uint32_t *)buf) = 0;
                IOT_OTA_ReportProgress(h_ota, IOT_OTAP_CHECK_FALIED, NULL);
                OTA_LOG_ERROR("image checksum compare failed");
            }
            return 0;
        }
    case IOT_OTAG_CHECK_CONFIG:
        if ((4 != buf_len) || (0 != ((unsigned long)buf & 0x3)))
        {
            OTA_LOG_ERROR("Invalid parameter");
            h_ota->err = IOT_OTAE_INVALID_PARAM;
            return -1;
        }
        else if (h_ota->state != IOT_OTAS_FETCHED)
        {
            h_ota->err = IOT_OTAE_INVALID_STATE;
            OTA_LOG_ERROR("Config can be checked in IOT_OTAS_FETCHED state only");
            return -1;
        }
        else
        {
            if (0 == strncmp(h_ota->signMethod, "Md5", strlen(h_ota->signMethod)))
            {
                char md5_str[33];
                otalib_MD5Finalize(h_ota->md5, md5_str);
                OTA_LOG_DEBUG("origin=%s, now=%s", h_ota->sign, md5_str);
                if (0 == strcmp(h_ota->sign, md5_str))
                {
                    *((uint32_t *)buf) = 1;
                }
                else
                {
                    *((uint32_t *)buf) = 0;
                }
            }
            if (0 == strncmp(h_ota->signMethod, "Sha256", strlen(h_ota->signMethod)))
            {
                char sha256_str[65];
                otalib_Sha256Finalize(h_ota->sha256, sha256_str);
                OTA_LOG_DEBUG("origin=%s, now=%s", h_ota->sign, sha256_str);
                if (0 == strcmp(h_ota->sign, sha256_str))
                {
                    *((uint32_t *)buf) = 1;
                }
                else
                {
                    *((uint32_t *)buf) = 0;
                }
            }
            return 0;
        }
    case IOT_OTAG_RESET_FETCHED_SIZE:
    {
        h_ota->size_fetched = 0;
        return 0;
    }
    case IOT_OTAG_RESET_STATE:
    {
        h_ota->type = IOT_OTAT_NONE;
        h_ota->state = IOT_OTAS_INITED;
        h_ota->size_fetched = 0;
        return 0;
    }
    default:
        OTA_LOG_ERROR("invalid cmd type");
        h_ota->err = IOT_OTAE_INVALID_PARAM;
        return -1;
    }

    return 0;
}

/* Get last error code */
int IOT_OTA_GetLastError(void *handle)
{
    OTA_Struct_pt h_ota = (OTA_Struct_pt)handle;

    if (NULL == handle)
    {
        OTA_LOG_ERROR("handle is NULL");
        return IOT_OTAE_INVALID_PARAM;
    }

    return h_ota->err;
}