OTA

Functions
int16_t	OTA_init (OTA_runningMode runningMode, OTA_memBlock *pMemBlock, OTA_eventHandler eventHandler)
	Initialize the OTA application. More...
int16_t	OTA_run ()
	Run the OTA App state machine. More...
int16_t	OTA_set (OTA_option option, int32_t optionLen, uint8_t *pOptionVal, int32_t flags)
	Set OTA command/parameter. More...
int16_t	OTA_get (OTA_option option, int32_t *pOptionLen, uint8_t *pOptionVal)
	Get the current OTA status. More...

Variables
uint8_t	Buff [OTA_BLOCK_SIZE]
uint32_t	IpAddress
uint32_t	SecuredConnection
uint8_t	ServerName [MAX_SERVER_NAME]
uint8_t	VendorToken [MAX_VENDOR_TOKEN_SIZE]
uint8_t	CurrentVersion [VERSION_STR_SIZE+1]
uint8_t	NewVersion [VERSION_STR_SIZE+1]

Detailed Description

Function Documentation

OTA_get()

int16_t OTA_get	(	OTA_option	option,
		int32_t *	pOptionLen,
		uint8_t *	pOptionVal
	)

Get the current OTA status.

Parameters

[in]	pOtaLib	OTA control block pointer
[in]	Option	Selects the option
[in]	OptionLen	option structure length
[in]	pOptionVal	pointer to the option structure

This function gets the current OTA of active or Idle. The parameter option, could be one of the following:

EXTLIB_OTA_GET_OPT_IS_ACTIVE - Check if OTA process is active or idle
EXTLIB_OTA_GET_OPT_VERSIONS - return the current OTA version and the new update version for the user to compare
EXTLIB_OTA_GET_OPT_IS_PENDING_COMMIT - Check if the new image is in the state BUNDLE_STATE_WAITING_FOR_COMMIT
Value at pOptionVal will be set to 1 if OTA process is active, 0 if Idle

Returns

Return 0 on success, -1 otherwise.

See also

Note

Warning

Example:

For example: check if pending commit   

int32_t isPendingCommit;
int32_t isPendingCommit_len;
int32_t Status;

Status = Ota_get(EXTLIB_OTA_GET_OPT_IS_PENDING_COMMIT, &isPendingCommit_len, (uint8_t *)&isPendingCommit);

Definition at line 176 of file OtaLib.c.

{
    Ota_optVersionsInfo *pVersionsInfo;
    int16_t Status = OTA_STATUS_OK;

    switch (option)
    {
        case EXTLIB_OTA_GET_OPT_IS_ACTIVE:
            *(int32_t *)pOptionVal = (pOtaLib->State != OTA_STATE_IDLE);
            *pOptionLen = sizeof(int32_t);
            break;

        case EXTLIB_OTA_GET_OPT_VERSIONS:
        
            pVersionsInfo = (Ota_optVersionsInfo *)pOptionVal;
            /* get the current version from ota.dat file */
            OtaArchive_getCurrentVersion(pVersionsInfo->CurrentVersion);
            /* extract the new version from OtaFileName if exists */
            if(pOtaLib->pOtaFileName == NULL)
            {
                /* can be if the OTA not in the right state and still didn't read the file name */
                /* OTA file not exists (no upadte or state before reading the ota new update */
                memset(pVersionsInfo->NewVersion, '0', VERSION_STR_SIZE);
            }
            else
            {
                uint8_t *pVersionFileName = _ExtractFileVersion(pOtaLib->pOtaFileName, MAX_CDN_FILE_NAME_SIZE);
                /* extract version from file */
                memcpy(pVersionsInfo->NewVersion, pVersionFileName, VERSION_STR_SIZE);
            }
            pVersionsInfo->NewVersion[VERSION_STR_SIZE] = 0; /* null terminated string */
            break;

        case EXTLIB_OTA_GET_OPT_IS_PENDING_COMMIT:

            *(int32_t *)pOptionVal = OtaArchive_getPendingCommit();
            break;

        default:
            _SlOtaLibTrace(("OTA_get: option %ld is not implemented\r\n", option));
            Status = OTA_OPT_ERROR_OPTION_CODE;
    }

    return Status;
}

OTA_init()

int16_t OTA_init	(	OTA_runningMode	runningMode,
		OTA_memBlock *	pMemBlock,
		OTA_eventHandler	eventHandler
	)

Initialize the OTA application.

Parameters

[in]	runningMode	Supported only OTA_RUN_NON_BLOCKING
[in]	pMemBlock	Is the OTA library control block allocated by the application
[in]	eventHandler	Callback to the app, currently not supported, need to be NULL

This function initializes the OTA application and modules. The size of the control block parameter should be enough for OTA init (currently 7800 bytes) otherwize the init will failed

Returns

Return zero ot -ve otherwise.

-OTA_INIT_ERROR - when the size of the OTA control block OtaCB_t is not enough for the OTA lib

See also

Warning

Example:

For example: To initialize OTA from host invoke

OTA_memBlock otaMemBlock;
int16_t Status;
Status = OTA_init(OTA_RUN_NON_BLOCKING, &otaMemBlock, NULL);

Definition at line 45 of file OtaLib.c.

{
    _SlOtaLibTrace(("OTA_init: sizeof CdnClient=%d, sizeof OtaArchive=%d\r\n", sizeof(pOtaLib->CdnClient), sizeof(pOtaLib->OtaArchive)));
    _SlOtaLibTrace(("OTA_init: sizeof OtaLib_t=%d, sizeof OTA_memBlock=%d\r\n", sizeof(OtaLib_t), sizeof(OTA_memBlock)));
    if (sizeof(OtaLib_t) > sizeof(OTA_memBlock))
    {
        _SlOtaLibTrace(("OTA_init: ERROR buffer size OtaLib_t=%d < OTA_memBlock=%d\r\n", sizeof(OtaLib_t), sizeof(OTA_memBlock)));
        return OTA_INIT_ERROR;
    }
    pOtaLib = (OtaLib_t *)pMemBlock;

    memset(pOtaLib, 0, sizeof(OtaLib_t));
    pOtaLib->State = OTA_STATE_IDLE;

    _SlOtaLibTrace(("OTA_init: OTA lib version = %s\r\n", OTA_LIB_VERSION));

    CdnClient_Init(&pOtaLib->CdnClient, pOtaLib->NetBuf);
    OtaArchive_init(&pOtaLib->OtaArchive);

    /* init statistics */
    return OTA_STATUS_OK;
}

OTA_run()

int16_t OTA_run

(

)

Run the OTA App state machine.

Parameters

[in]

pOtaLib

Pointer to OTA application pointer

Run one step from the OTA application state machine. Host should repeat calling this function and examine the return value in order to check if OTA completed or got error or just need to be continued. This pattern is useful in host with NON-OS. In host with OS, host should start OTA task and continuously calling this function till OTA completed.

Returns

Return zero or +ve bitmap number on success, -ve otherwise.

-OTA_RUN_STATUS_CONTINUE - Host should continue calling sl_OtaRun
-OTA_RUN_STATUS_CONTINUE_WARNING_... - group of OTA WARNINGS, actually those are errors but the OTA will retry the process 5 times so user should continue run the OTA
-OTA_RUN_STATUS_NO_UPDATES - No updates for now, host can retry after another period of time
-OTA_RUN_STATUS_CHECK_NEWER_VERSION - OTA found newer update version, user can accept the new version by calling sl_OtaSet with option _ ACCEPT_UPDATE , or just continue running, or do another check before continue
-OTA_RUN_STATUS_CHECK_OLDER_VERSION - OTA found older update version, user can stop the OTA by calling sl_OtaSet with option _DECLINE_UPDATE , or continue running, or do another check before continue
-OTA_RUN_STATUS_DOWNLOAD_DONE - Current OTA update completed, host should move the image to BUNDLE_STATE_TESTING by calling sl_Stop and then ro reset the MCU
-OTA_RUN_ERROR_... - group of OTA ERRORS, user should stop the OTA process -OTA_RUN_ERROR_CONSECUTIVE_OTA_ERRORS - OTA process failed 5 consecutive times -OTA_RUN_ERROR_NO_SERVER_NO_VENDOR - user didn't call sl_OtaSet with EXTLIB_OTA_OPT_VENDOR_ID and EXTLIB_OTA_OPT_SERVER_INFO before running the OTA -OTA_RUN_ERROR_SECURITY_ALERT - security alert from file system, user must stop trying downloading current OTA update -OTA_RUN_ERROR_UNEXPECTED_STATE - OTA state error, must init the OTA before continue

See also

Note

Warning

Example:

For example: Run OTA from host   

Status = Ota_run();

Definition at line 249 of file OtaLib.c.

{
    CdnClient_t *pCdnClient = (CdnClient_t *)&pOtaLib->CdnClient;
    int16_t Status;
    int16_t ProcessedBytes;

    switch (pOtaLib->State)
    {
        case OTA_STATE_IDLE:
#if OTA_SERVER_TYPE == OTA_FILE_DOWNLOAD
            /* File Server URL must be initialized before running OTA */
            if(pOtaLib->FileUrlBuf[0] == 0)
            {
                return OTA_RUN_ERROR_NO_SERVER_NO_VENDOR;
            }
            pOtaLib->State = OTA_STATE_CONNECT_FILE_SERVER;
#else
            /* serverInfo and vendorDir must be init before running OTA */
            if /*(*/(pOtaLib->OtaServerInfo.ServerName[0] == 0) /*|| (pOtaLib->VendorDir[0] == 0))*/
            {
                return OTA_RUN_ERROR_NO_SERVER_NO_VENDOR;
            }

            pOtaLib->State = OTA_STATE_CONNECT_SERVER;
#endif
            break;
#if OTA_SERVER_TYPE != OTA_FILE_DOWNLOAD
        case OTA_STATE_CONNECT_SERVER:
            _SlOtaLibTrace(("OTA_run: call CdnClient_ConnectServer OTA server=%s\r\n", pOtaLib->OtaServerInfo.ServerName));
            Status = CdnClient_ConnectServer(pCdnClient, &pOtaLib->OtaServerInfo);
            if( Status < 0)
            {
                _SlOtaLibTrace(("OTA_run: ERROR CdnClient_ConnectServer, Status=%ld\r\n", Status));
                Status = _OtaCheckConsecutiveErrors(pOtaLib, OTA_RUN_STATUS_CONTINUE_WARNING_FAILED_CONNECT_FILE_SERVER, BACK_TO_IDLE);
                return Status;
            }
            pOtaLib->State = OTA_STATE_REQ_OTA_DIR;
            break;

        case OTA_STATE_REQ_OTA_DIR:
        {
            int32_t NumDirFiles;
            _SlOtaLibTrace(("OTA_run: CdnClient_ReqOtaDir, VendorDir=%s\r\n", pOtaLib->VendorDir));
            NumDirFiles = CdnClient_ReqOtaDir(pCdnClient, pOtaLib->VendorDir);
            if (NumDirFiles < 0)
            {
                _SlOtaLibTrace(("OTA_run: ERROR CdnClient_ReqOtaDir, Status=%d\r\n", NumDirFiles));
                Status = _OtaCheckConsecutiveErrors(pOtaLib, OTA_RUN_STATUS_CONTINUE_WARNING_FAILED_REQ_OTA_DIR, BACK_TO_IDLE);
                return Status;
            }
            if (NumDirFiles == 0)
            {
                _SlOtaLibTrace(("OTA_run: ERROR CdnClient_ReqOtaDir - no updates\r\n"));
                pOtaLib->ConsecutiveOtaErrors = 0;
                pOtaLib->State = OTA_STATE_IDLE;
                _OtaCleanToIdle(pOtaLib);
                return OTA_RUN_STATUS_NO_UPDATES;
            }
            _SlOtaLibTrace(("OTA_run: CdnClient_ReqOtaDir, NumDirFiles=%ld\r\n", NumDirFiles));
            pOtaLib->State = OTA_STATE_CHECK_ARCHIVE_NEW_UPDATE;
        }
        break;

        case OTA_STATE_CHECK_ARCHIVE_NEW_UPDATE:
        {
            uint8_t *pVersionFileName;
            _SlOtaLibTrace(("OTA_run: CdnClient_GetNextDirFile\r\n"));
            pOtaLib->pOtaFileName = CdnClient_GetNextDirFile(pCdnClient, &pOtaLib->OtaFileSize);

            /* check if last file in the list, still without tar file */
            if( pOtaLib->pOtaFileName == NULL)
            {
                /* tar file not found, return no updates */
                _SlOtaLibTrace(("OTA_run: ERROR CdnClient_ReqOtaDir - tar not found, no updates\r\n"));
                pOtaLib->ConsecutiveOtaErrors = 0;
                pOtaLib->State = OTA_STATE_IDLE;
                _OtaCleanToIdle(pOtaLib);
                return OTA_RUN_STATUS_NO_UPDATES;
            }

            _SlOtaLibTrace(("OTA_run: CdnClient_GetNextDirFile: file=%s, size=%ld\r\n", pOtaLib->pOtaFileName, pOtaLib->OtaFileSize));

            if (strstr((const char *)pOtaLib->pOtaFileName, ".tar") == NULL) 
            {
                _SlOtaLibTrace(("OTA_run: WARNING, not a tar file, filename=%s\r\n", pOtaLib->pOtaFileName));
                /* Stay on state, check next file version */
                pOtaLib->State = OTA_STATE_CHECK_ARCHIVE_NEW_UPDATE;
                return OTA_RUN_STATUS_CONTINUE;
            }

            /* continue anyway, user app can override this decision */
            pOtaLib->State = OTA_STATE_REQ_FILE_URL;


            /* Init the Tar parser module */
            OtaArchive_init(&pOtaLib->OtaArchive);

            /* host should check the version */
            pVersionFileName = _ExtractFileVersion(pOtaLib->pOtaFileName, MAX_CDN_FILE_NAME_SIZE);
            if (OtaArchive_checkVersion(&pOtaLib->OtaArchive, pVersionFileName))
            {
                return OTA_RUN_STATUS_CHECK_NEWER_VERSION;
            }
            else
            {
                return OTA_RUN_STATUS_CHECK_OLDER_VERSION;
            }
        }

        case OTA_STATE_REQ_FILE_URL:

            _SlOtaLibTrace(("OTA_run: Call CdnClient_ReqFileUrl, filename = %s\r\n", pOtaLib->pOtaFileName));
            Status = CdnClient_ReqFileUrl(pCdnClient, pOtaLib->pOtaFileName, pOtaLib->FileUrlBuf, sizeof(pOtaLib->FileUrlBuf));
            if( Status < 0)
            {
                _SlOtaLibTrace(("OTA_run: ERROR CdnClient_ReqFileUrl, Status=%d\r\n", Status));
                Status = _OtaCheckConsecutiveErrors(pOtaLib, OTA_RUN_STATUS_CONTINUE_WARNING_FAILED_REQ_FILE_URL, BACK_TO_IDLE);
                return Status;
            }

            /* In this stage the CDN server can be closed */
            CdnClient_CloseServer(&pOtaLib->CdnClient);

            pOtaLib->State = OTA_STATE_CONNECT_FILE_SERVER;
            break;
#endif
        case OTA_STATE_CONNECT_FILE_SERVER:

            _SlOtaLibTrace(("OTA_run: Call CdnClient_ConnectFileServer, url = %s\r\n", pOtaLib->FileUrlBuf));
            Status = CdnClient_ConnectFileServer(&pOtaLib->CdnClient, pOtaLib->FileUrlBuf, pOtaLib->OtaServerInfo.SecuredConnection);
            if( Status < 0)
            {
                /* stay on this state for another retry */
                _SlOtaLibTrace(("OTA_run: ERROR CdnClient_ConnectFileServer, Status=%d\r\n", Status));
                Status = _OtaCheckConsecutiveErrors(pOtaLib, OTA_RUN_STATUS_CONTINUE_WARNING_FAILED_CONNECT_FILE_SERVER, BACK_TO_IDLE);
                return Status;
            }
            pOtaLib->State = OTA_STATE_REQ_FILE_CONTENT;
            break;

        case OTA_STATE_REQ_FILE_CONTENT:

            _SlOtaLibTrace(("OTA_run: Call CdnClient_ReqFileContent, url = %s\r\n", pOtaLib->FileUrlBuf));
            Status = CdnClient_ReqFileContent(&pOtaLib->CdnClient, pOtaLib->FileUrlBuf);
            if( Status < 0)
            {
                _SlOtaLibTrace(("OTA_run: ERROR CdnClient_ReqFileContent, Status=%d\r\n", Status));
                Status = _OtaCheckConsecutiveErrors(pOtaLib, OTA_RUN_STATUS_CONTINUE_WARNING_FAILED_REQ_FILE_CONTENT, BACK_TO_IDLE);
                return Status;
            }

            pOtaLib->State = OTA_STATE_PREPARE_DOWNLOAD;
            break;

        case OTA_STATE_PREPARE_DOWNLOAD:

            /* prepare receive buffer */
            pOtaLib->pRecvChunk = pOtaLib->NetBuf;
            pOtaLib->RecvChunkOffset = 0;
            pOtaLib->RecvChunkForceReadMode = 0;

            pOtaLib->RecvChunkSize = CdnClient_RecvSkipHdr(pCdnClient->FileSockId, pOtaLib->pRecvChunk, NET_BUF_SIZE);
            if (0 >= pOtaLib->RecvChunkSize)
            {
                _SlOtaLibTrace(("OTA_run: ERROR downloading, CdnClient_RecvSkipHdr Status=%ld\r\n", pOtaLib->RecvChunkSize));
                /* Stop the parsing of the archive file */
                OtaArchive_abort(&pOtaLib->OtaArchive);
                Status = _OtaCheckConsecutiveErrors(pOtaLib, OTA_RUN_STATUS_CONTINUE_WARNING_FAILED_FILE_HDR, BACK_TO_IDLE);
                return Status;
            }

            pOtaLib->State = OTA_STATE_DOWNLOADING; 
            break;

        case OTA_STATE_DOWNLOADING:

            /* Check if to read more chunk */
            if ((pOtaLib->RecvChunkOffset != 0) || (pOtaLib->RecvChunkSize == 0) || pOtaLib->RecvChunkForceReadMode)
            {
                int16_t UnprocessedSize = pOtaLib->RecvChunkSize-pOtaLib->RecvChunkOffset;
                int16_t Len;

                if (UnprocessedSize >= TAR_HDR_SIZE)
                {
                    /* No need to read more, enough unprocessed bytes to decode next TAR file header */
                    memcpy(&pOtaLib->pRecvChunk[0], &pOtaLib->pRecvChunk[pOtaLib->RecvChunkOffset], UnprocessedSize);
                    Len = UnprocessedSize;
                }
                else
                {
                    Len = CdnClient_RecvAppend(pCdnClient->FileSockId, pOtaLib->pRecvChunk, NET_BUF_SIZE, pOtaLib->RecvChunkSize, pOtaLib->RecvChunkOffset);
                }
                if (0 >= Len)
                {
                    _SlOtaLibTrace(("OTA_run: ERROR downloading, CdnClient_RecvAppend Status=%ld\r\n", Len));
                    /* Stop the parsing of the archive file */  
                    OtaArchive_abort(&pOtaLib->OtaArchive);
                    Status = _OtaCheckConsecutiveErrors(pOtaLib, OTA_RUN_STATUS_CONTINUE_WARNING_FAILED_RECV_APPEND, BACK_TO_IDLE);
                    return Status;
                }
                pOtaLib->RecvChunkOffset = 0;
                pOtaLib->RecvChunkSize = Len;
                pOtaLib->RecvChunkForceReadMode = 0;
            }

            Status = OtaArchive_process(&pOtaLib->OtaArchive, pOtaLib->pRecvChunk, pOtaLib->RecvChunkSize, &ProcessedBytes);
            pOtaLib->RecvChunkForceReadMode = (Status == ARCHIVE_STATUS_FORCE_READ_MORE);
            pOtaLib->RecvChunkOffset += ProcessedBytes;
            if( Status < 0)
            {
                if (Status == ARCHIVE_STATUS_ERROR_SECURITY_ALERT)
                {
                    _SlOtaLibTrace(("OTA_run: SECURITY ALERT OtaArchive_RunParse, Status=%d\r\n", Status));
                    /* On SECURITY ALERT, stop all, no consecutive errors check */
                    pOtaLib->State = OTA_STATE_IDLE;
                    _OtaCleanToIdle(pOtaLib);
                    Status = OTA_RUN_ERROR_SECURITY_ALERT;
                }
                else
                {
                    _SlOtaLibTrace(("OTA_run: ERROR OtaArchive_RunParse, Status=%d\r\n", Status));
                    Status = _OtaCheckConsecutiveErrors(pOtaLib, OTA_RUN_STATUS_CONTINUE_WARNING_FAILED_DOWNLOAD_AND_SAVE, BACK_TO_IDLE);
                }
                return Status;
            }
            else if (Status == ARCHIVE_STATUS_DOWNLOAD_DONE)
            {
                _SlOtaLibTrace(("OTA_run: ---- Download file completed %s\r\n", pOtaLib->pOtaFileName));
                CdnClient_CloseFileServer(&pOtaLib->CdnClient);
                pOtaLib->State = OTA_STATE_WAIT_CONFIRM; /* not real state, cannot go to idle, user app should reset */
                pOtaLib->ConsecutiveOtaErrors = 0;

                return OTA_RUN_STATUS_DOWNLOAD_DONE;
            }
            break;

        case OTA_STATE_WAIT_CONFIRM:
            /* not real state, cannot go to idle, user app should reset */
            _SlOtaLibTrace(("sl_OtaRun ERROR: unexpected state %d\r\n", pOtaLib->State));
            return OTA_RUN_STATUS_DOWNLOAD_DONE;

        default:
            _SlOtaLibTrace(("sl_OtaRun ERROR: unexpected state %d\r\n", pOtaLib->State));
            return OTA_RUN_ERROR_UNEXPECTED_STATE;

    }

    return OTA_RUN_STATUS_CONTINUE;
}

OTA_set()

int16_t OTA_set	(	OTA_option	option,
		int32_t	optionLen,
		uint8_t *	pOptionVal,
		int32_t	flags
	)

Set OTA command/parameter.

Parameters

[in]	pOtaLib	OTA control block pointer
[in]	Option	Select the option
[in]	OptionLen	Option structure length
[in]	pOptionVal	pointer to the option structure

This function sets OTA command/parameter. The parameter Option can be one of the following:

EXTLIB_OTA_SET_OPT_SERVER_INFO - Set the Server information
EXTLIB_OTA_SET_OPT_VENDOR_ID - Set the Vendor DIR string
EXTLIB_OTA_SET_OPT_ACCEPT_UPDATE - Accept the new image
EXTLIB_OTA_SET_OPT_DECLINE_UPDATE - Decline the new image
EXTLIB_OTA_SET_OPT_IMAGE_COMMIT - Commit the currnet image in testing mode
EXTLIB_OTA_SET_OPT_IMAGE_ROLLBACK - decline the currnet image in testing mode and rollback to the previous image

Returns

On success, zero is returned. On error, -1 is returned

See also

Note

Warning

Example:

For example: Set OTA server info from host   

Ota_optServerInfo g_otaOptServerInfo;

g_otaOptServerInfo.IpAddress         = OTA_SERVER_IP_ADDRESS;
g_otaOptServerInfo.SecuredConnection = OTA_SERVER_SECURED;
strcpy((char *)g_otaOptServerInfo.ServerName,  OTA_SERVER_NAME);
strcpy((char *)g_otaOptServerInfo.VendorToken, OTA_VENDOR_TOKEN);
Status = Ota_set(EXTLIB_OTA_SET_OPT_SERVER_INFO, sizeof(g_otaOptServerInfo), (uint8_t *)&g_otaOptServerInfo);

Ota_set(EXTLIB_OTA_SET_OPT_SERVER_INFO, sizeof(g_otaOptServerInfo), (uint8_t *)&g_otaOptServerInfo, 0);

Definition at line 99 of file OtaLib.c.

{
    int16_t Status = OTA_STATUS_OK;

    switch (option)
    {
        case EXTLIB_OTA_SET_OPT_SERVER_INFO:
            memcpy(&pOtaLib->OtaServerInfo, pOptionVal, sizeof(Ota_optServerInfo));
            break;

        case EXTLIB_OTA_SET_OPT_FILE_SERVER_URL:
             strcpy((char *)pOtaLib->FileUrlBuf, (char *)pOptionVal);
             pOtaLib->OtaServerInfo.SecuredConnection = OTA_SERVER_SECURED;
             break;

        case EXTLIB_OTA_SET_OPT_VENDOR_ID:
            if (strlen((const char *)pOptionVal) >= MAX_VENDIR_DIR_SIZE)
            {
                return OTA_OPT_ERROR_VENDOR_DIR_SIZE;
            }
            strcpy((char *)pOtaLib->VendorDir, (const char *)pOptionVal);
            break;

        case EXTLIB_OTA_SET_OPT_ACCEPT_UPDATE:
            /* do nothing, the OTA is already on process and not in IDLE state */
            break;

        case EXTLIB_OTA_SET_OPT_DECLINE_UPDATE:

            /* check if after OTA_STATE_CHECK_ARCHIVE_NEW_UPDATE state */
            if (pOtaLib->State != OTA_STATE_REQ_FILE_URL)
            {
                _SlOtaLibTrace(("OTA_set: ERROR EXTLIB_OTA_SET_OPT_DECLINE_UPDATE in wrong state = %d\r\n", pOtaLib->State));
                return OTA_OPT_ERROR_WRONG_STATE;
            }

            /* close all connection from last OTA updates and back to IDLE */
            pOtaLib->ConsecutiveOtaErrors = 0;
            _OtaCleanToIdle(pOtaLib);
            break;

        case EXTLIB_OTA_SET_OPT_IMAGE_COMMIT:

            Status = OtaArchive_commit();
            if (Status < 0)
            {
                _SlOtaLibTrace(("OTA_set: ERROR OtaArchive_Commit, status=%d\r\n", Status));
                return OTA_OPT_ERROR_COMMIT;
            }


            break;

        case EXTLIB_OTA_SET_OPT_IMAGE_ROLLBACK:

            Status = OtaArchive_rollback();
            if (Status < 0)
            {
                if (Status == SL_ERROR_FS_BUNDLE_NOT_IN_CORRECT_STATE)
                {
                    _SlOtaLibTrace(("OTA_set: ERROR OtaArchive_Rollback, status=%d - ignored SL_ERROR_FS_BUNDLE_NOT_IN_CORRECT_STATE\r\n", Status));
                    /* Ignore error calling rollback in the incorrect state */
                    return OTA_STATUS_OK;
                }
                _SlOtaLibTrace(("OTA_set: ERROR OtaArchive_Rollback, status=%d\r\n", Status));
                return OTA_OPT_ERROR_ROLLBACK;
            }
            break;

        default:
            _SlOtaLibTrace(("OTA_set: option %ld is not implemented\r\n", option));
            return OTA_OPT_ERROR_OPTION_CODE;
    }

    return Status;
}

Variable Documentation

Buff

uint8_t Buff[OTA_BLOCK_SIZE]

Definition at line 56 of file ota.h.

CurrentVersion

uint8_t CurrentVersion[VERSION_STR_SIZE+1]

Definition at line 83 of file ota.h.

IpAddress

uint32_t IpAddress

Definition at line 75 of file ota.h.

NewVersion

uint8_t NewVersion[VERSION_STR_SIZE+1]

Definition at line 84 of file ota.h.

SecuredConnection

uint32_t SecuredConnection

Definition at line 76 of file ota.h.

ServerName

uint8_t ServerName[MAX_SERVER_NAME]

Definition at line 77 of file ota.h.

VendorToken

uint8_t VendorToken[MAX_VENDOR_TOKEN_SIZE]

Definition at line 78 of file ota.h.