static OCStackResult OCParsePlatformPayload(OCPayload** outPayload, CborValue* rootValue)
{
    if (!outPayload)
    {
        return OC_STACK_INVALID_PARAM;
    }

    bool err = false;

    if(cbor_value_is_map(rootValue))
    {
        OCPlatformInfo info = {0};

        CborValue repVal;
        size_t len;
        // Platform ID
        err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_PLATFORM_ID, &repVal);
        if(cbor_value_is_valid(&repVal))
        {
            err = err || cbor_value_dup_text_string(&repVal, &(info.platformID), &len, NULL);
        }

        // MFG Name
        err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_MFG_NAME, &repVal);
        if(cbor_value_is_valid(&repVal))
        {
            err = err || cbor_value_dup_text_string(&repVal, &(info.manufacturerName), &len, NULL);
        }

        // MFG URL
        err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_MFG_URL, &repVal);
        if(cbor_value_is_valid(&repVal))
        {
            err = err || cbor_value_dup_text_string(&repVal, &(info.manufacturerUrl), &len, NULL);
        }

        // Model Num
        err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_MODEL_NUM, &repVal);
        if(cbor_value_is_valid(&repVal))
        {
            err = err || cbor_value_dup_text_string(&repVal, &(info.modelNumber), &len, NULL);
        }

        // Date of Mfg
        err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_MFG_DATE, &repVal);
        if(cbor_value_is_valid(&repVal))
        {
            err = err || cbor_value_dup_text_string(&repVal, &(info.dateOfManufacture), &len,
                                                    NULL);
        }

        // Platform Version
        err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_PLATFORM_VERSION, &repVal);
        if(cbor_value_is_valid(&repVal))
        {
            err = err || cbor_value_dup_text_string(&repVal, &(info.platformVersion), &len, NULL);
        }

        // OS Version
        err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_OS_VERSION, &repVal);
        if(cbor_value_is_valid(&repVal))
        {
            err = err || cbor_value_dup_text_string(&repVal, &(info.operatingSystemVersion),
                                                    &len, NULL);
        }

        // Hardware Version
        err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_HARDWARE_VERSION, &repVal);
        if(cbor_value_is_valid(&repVal))
        {
            err = err || cbor_value_dup_text_string(&repVal, &(info.hardwareVersion), &len,
                                                    NULL);
        }

        // Firmware Version
        err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_FIRMWARE_VERSION, &repVal);
        if(cbor_value_is_valid(&repVal))
        {
            err = err || cbor_value_dup_text_string(&repVal, &(info.firmwareVersion), &len,
                                                    NULL);
        }

        // Support URL
        err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_SUPPORT_URL, &repVal);
        if(cbor_value_is_valid(&repVal))
        {
            err = err || cbor_value_dup_text_string(&repVal, &(info.supportUrl), &len, NULL);
        }

        // System Time
        err = err || cbor_value_map_find_value(rootValue, OC_RSRVD_SYSTEM_TIME, &repVal);
        if(cbor_value_is_valid(&repVal))
        {
            err = err || cbor_value_dup_text_string(&repVal, &(info.systemTime), &len, NULL);
        }

        err = err || cbor_value_advance(rootValue);

        if(err)
        {
            OICFree(info.dateOfManufacture);
            OICFree(info.firmwareVersion);
            OICFree(info.hardwareVersion);
            OICFree(info.manufacturerName);
            OICFree(info.manufacturerUrl);
            OICFree(info.modelNumber);
            OICFree(info.operatingSystemVersion);
            OICFree(info.platformID);
            OICFree(info.platformVersion);
            OICFree(info.supportUrl);
            OICFree(info.systemTime);
            OC_LOG(ERROR, TAG, "CBOR error In ParsePlatformPayload");
            return OC_STACK_MALFORMED_RESPONSE;
        }

        *outPayload = (OCPayload*)OCPlatformPayloadCreateAsOwner(&info);

        if(!*outPayload)
        {
            return OC_STACK_NO_MEMORY;
        }

        return OC_STACK_OK;
    }
    else
    {
        OC_LOG(ERROR, TAG, "Root device node was not a map");
        return OC_STACK_MALFORMED_RESPONSE;
    }
}
Beispiel #2
0
static OCStackResult OCParsePlatformPayload(OCPayload **outPayload, CborValue *rootValue)
{
    OCStackResult ret = OC_STACK_INVALID_PARAM;
    CborError err = CborNoError;
    OCPlatformInfo info = {0};

    VERIFY_PARAM_NON_NULL(TAG, outPayload, "Invalid Parameter outPayload");

    if (cbor_value_is_map(rootValue))
    {
        CborValue repVal;
        size_t len = 0;
        ret = OC_STACK_MALFORMED_RESPONSE;

        // Platform ID
        err = cbor_value_map_find_value(rootValue, OC_RSRVD_PLATFORM_ID, &repVal);
        if (cbor_value_is_valid(&repVal))
        {
            err = cbor_value_dup_text_string(&repVal, &(info.platformID), &len, NULL);
            VERIFY_CBOR_SUCCESS(TAG, err, "Failed to find platformID in the platform payload");
        }
         // MFG Name
        err = cbor_value_map_find_value(rootValue, OC_RSRVD_MFG_NAME, &repVal);
        if (cbor_value_is_valid(&repVal))
        {
            err = cbor_value_dup_text_string(&repVal, &(info.manufacturerName), &len, NULL);
            VERIFY_CBOR_SUCCESS(TAG, err, "Failed to find manufactureName in the platform payload");
        }
        // MFG URL
        err = cbor_value_map_find_value(rootValue, OC_RSRVD_MFG_URL, &repVal);
        if (cbor_value_is_valid(&repVal))
        {
            err = cbor_value_dup_text_string(&repVal, &(info.manufacturerUrl), &len, NULL);
            VERIFY_CBOR_SUCCESS(TAG, err, "Failed to find manufactureUrl in the platform payload");
        }
        // Model Num
        err = cbor_value_map_find_value(rootValue, OC_RSRVD_MODEL_NUM, &repVal);
        if (cbor_value_is_valid(&repVal))
        {
            err = cbor_value_dup_text_string(&repVal, &(info.modelNumber), &len, NULL);
            VERIFY_CBOR_SUCCESS(TAG, err, "Failed to find modelNumber in the platform payload");
        }
        // Date of Mfg
        err = cbor_value_map_find_value(rootValue, OC_RSRVD_MFG_DATE, &repVal);
        if (cbor_value_is_valid(&repVal))
        {
            err = cbor_value_dup_text_string(&repVal, &(info.dateOfManufacture), &len, NULL);
            VERIFY_CBOR_SUCCESS(TAG, err, "Failed to find dateOfManufacture in the platform payload");
        }
        // Platform Version
        err = cbor_value_map_find_value(rootValue, OC_RSRVD_PLATFORM_VERSION, &repVal);
        if (cbor_value_is_valid(&repVal))
        {
            err = cbor_value_dup_text_string(&repVal, &(info.platformVersion), &len, NULL);
            VERIFY_CBOR_SUCCESS(TAG, err, "Failed to find platformVersion in the platform payload");
        }
        // OS Version
        err = cbor_value_map_find_value(rootValue, OC_RSRVD_OS_VERSION, &repVal);
        if (cbor_value_is_valid(&repVal))
        {
            err = cbor_value_dup_text_string(&repVal, &(info.operatingSystemVersion), &len, NULL);
            VERIFY_CBOR_SUCCESS(TAG, err, "Failed to find OSVersion in the platform payload");
        }
        // Hardware Version
        err = cbor_value_map_find_value(rootValue, OC_RSRVD_HARDWARE_VERSION, &repVal);
        if(cbor_value_is_valid(&repVal))
        {
            err = cbor_value_dup_text_string(&repVal, &(info.hardwareVersion), &len, NULL);
            VERIFY_CBOR_SUCCESS(TAG, err, "Failed to find HWVersion in the platform payload");
        }
        // Firmware Version
        err = cbor_value_map_find_value(rootValue, OC_RSRVD_FIRMWARE_VERSION, &repVal);
        if(cbor_value_is_valid(&repVal))
        {
            err = cbor_value_dup_text_string(&repVal, &(info.firmwareVersion), &len, NULL);
            VERIFY_CBOR_SUCCESS(TAG, err, "Failed to find firmwareVersion in the platform payload");
        }
        // Support URL
        err = cbor_value_map_find_value(rootValue, OC_RSRVD_SUPPORT_URL, &repVal);
        if(cbor_value_is_valid(&repVal))
        {
            err = cbor_value_dup_text_string(&repVal, &(info.supportUrl), &len, NULL);
            VERIFY_CBOR_SUCCESS(TAG, err, "Failed to find supportUrl in the platform payload");
        }
        // System Time
        err = cbor_value_map_find_value(rootValue, OC_RSRVD_SYSTEM_TIME, &repVal);
        if(cbor_value_is_valid(&repVal))
        {
            err = cbor_value_dup_text_string(&repVal, &(info.systemTime), &len, NULL);
            VERIFY_CBOR_SUCCESS(TAG, err, "Failed to find systemTume in the platform payload");
        }

        err = cbor_value_advance(rootValue);
        VERIFY_CBOR_SUCCESS(TAG, err, "Failed to find supportUrl in the platform payload");

        *outPayload = (OCPayload *)OCPlatformPayloadCreateAsOwner(&info);
        return OC_STACK_OK;
    }

exit:
    OCPlatformInfoDestroy(&info);
    OIC_LOG(ERROR, TAG, "CBOR error In ParsePlatformPayload");
    return ret;
}