STATUS deserializeSignalingCacheEntries()

in src/source/Signaling/FileCache.c [27:115]
75 lines of code
23 McCabe index (conditional complexity)

STATUS deserializeSignalingCacheEntries(PCHAR cachedFileContent, UINT64 fileSize, PSignalingFileCacheEntry pSignalingFileCacheEntryList,
                                        PUINT32 pEntryCount, PCHAR cacheFilePath)
{
    ENTERS();
    STATUS retStatus = STATUS_SUCCESS;
    UINT32 listSize = 0, entryCount = 0, tokenCount = 0, remainingSize, tokenSize = 0;
    PCHAR pCurrent = NULL, nextToken = NULL, nextLine = NULL;

    CHK(cachedFileContent != NULL && pSignalingFileCacheEntryList != NULL && pEntryCount != NULL && cacheFilePath != NULL, STATUS_NULL_ARG);
    listSize = *pEntryCount;

    pCurrent = cachedFileContent;
    remainingSize = (UINT32) fileSize;
    /* detect end of file */
    while (remainingSize > MAX_SIGNALING_CACHE_ENTRY_TIMESTAMP_STR_LEN) {
        nextLine = STRCHR(pCurrent, '\n');
        while ((nextToken = STRCHR(pCurrent, ',')) != NULL && nextToken < nextLine) {
            switch (tokenCount % 7) {
                case 0:
                    STRNCPY(pSignalingFileCacheEntryList[entryCount].channelName, pCurrent, nextToken - pCurrent);
                    break;
                case 1:
                    STRNCPY(pSignalingFileCacheEntryList[entryCount].region, pCurrent, nextToken - pCurrent);
                    if (STRNCMP(pCurrent, SIGNALING_FILE_CACHE_ROLE_TYPE_MASTER_STR, STRLEN(SIGNALING_FILE_CACHE_ROLE_TYPE_MASTER_STR)) == 0) {
                        pSignalingFileCacheEntryList[entryCount].role = SIGNALING_CHANNEL_ROLE_TYPE_MASTER;
                    } else if (STRNCMP(pCurrent, SIGNALING_FILE_CACHE_ROLE_TYPE_VIEWER_STR, STRLEN(SIGNALING_FILE_CACHE_ROLE_TYPE_VIEWER_STR)) == 0) {
                        pSignalingFileCacheEntryList[entryCount].role = SIGNALING_CHANNEL_ROLE_TYPE_VIEWER;
                    } else {
                        CHK_WARN(FALSE, STATUS_INVALID_ARG, "Unknown role type");
                    }
                    break;
                case 2:
                    STRNCPY(pSignalingFileCacheEntryList[entryCount].region, pCurrent, nextToken - pCurrent);
                    break;
                case 3:
                    STRNCPY(pSignalingFileCacheEntryList[entryCount].channelArn, pCurrent, nextToken - pCurrent);
                    break;
                case 4:
                    STRNCPY(pSignalingFileCacheEntryList[entryCount].httpsEndpoint, pCurrent, nextToken - pCurrent);
                    break;
                case 5:
                    STRNCPY(pSignalingFileCacheEntryList[entryCount].wssEndpoint, pCurrent, nextToken - pCurrent);
                    break;
                default:
                    break;
            }
            tokenCount++;
            tokenSize = (UINT32) (nextToken - pCurrent);
            pCurrent += tokenSize + 1;
            remainingSize -= tokenSize + 1;
        }

        /* time stamp element is always 10 characters */
        CHK_STATUS(STRTOUI64(pCurrent, pCurrent + MAX_SIGNALING_CACHE_ENTRY_TIMESTAMP_STR_LEN, 10,
                             &pSignalingFileCacheEntryList[entryCount].creationTsEpochSeconds));
        tokenCount++;
        pCurrent += MAX_SIGNALING_CACHE_ENTRY_TIMESTAMP_STR_LEN + 1;
        remainingSize -= MAX_SIGNALING_CACHE_ENTRY_TIMESTAMP_STR_LEN + 1;

        CHK(!IS_EMPTY_STRING(pSignalingFileCacheEntryList[entryCount].channelArn) &&
                !IS_EMPTY_STRING(pSignalingFileCacheEntryList[entryCount].channelName) &&
                !IS_EMPTY_STRING(pSignalingFileCacheEntryList[entryCount].region) &&
                !IS_EMPTY_STRING(pSignalingFileCacheEntryList[entryCount].httpsEndpoint) &&
                !IS_EMPTY_STRING(pSignalingFileCacheEntryList[entryCount].wssEndpoint),
            STATUS_INVALID_ARG);

        entryCount++;

        /* Stop parsing once we reach cache entry limit */
        if (entryCount == listSize) {
            break;
        }
    }

CleanUp:

    if (pEntryCount != NULL) {
        *pEntryCount = entryCount;
    }

    CHK_LOG_ERR(retStatus);

    if (STATUS_FAILED(retStatus) && cacheFilePath != NULL) {
        FREMOVE(cacheFilePath);
    }

    LEAVES();
    return retStatus;
}