예제 #1
0
파일: ocpayload.c 프로젝트: rzr/iotivity-1
void OCPayloadDestroy(OCPayload* payload)
{
    if(!payload)
    {
        return;
    }

    switch(payload->type)
    {
        case PAYLOAD_TYPE_REPRESENTATION:
            OCRepPayloadDestroy((OCRepPayload*)payload);
            break;
        case PAYLOAD_TYPE_DISCOVERY:
            OCDiscoveryPayloadDestroy((OCDiscoveryPayload*)payload);
            break;
        case PAYLOAD_TYPE_DEVICE:
            OCDevicePayloadDestroy((OCDevicePayload*)payload);
            break;
        case PAYLOAD_TYPE_PLATFORM:
            OCPlatformPayloadDestroy((OCPlatformPayload*)payload);
            break;
        case PAYLOAD_TYPE_PRESENCE:
            OCPresencePayloadDestroy((OCPresencePayload*)payload);
            break;
        case PAYLOAD_TYPE_SECURITY:
            OCSecurityPayloadDestroy((OCSecurityPayload*)payload);
            break;
        default:
            OC_LOG_V(ERROR, TAG, "Unsupported payload type in destroy: %d", payload->type);
            OICFree(payload);
            break;
    }
}
예제 #2
0
static OCStackResult OCParseDevicePayload(OCPayload **outPayload, CborValue *rootValue)
{
    OCStackResult ret = OC_STACK_INVALID_PARAM;
    CborError err = CborNoError;
    OCDevicePayload *out = NULL;
    VERIFY_PARAM_NON_NULL(TAG, outPayload, "Invalid param outPayload");
    VERIFY_PARAM_NON_NULL(TAG, rootValue, "Invalid param rootValue");

    *outPayload = NULL;

    out = (OCDevicePayload *)OICCalloc(1, sizeof(OCDevicePayload));
    VERIFY_PARAM_NON_NULL(TAG, out, "Failed allocating device payload")
    out->base.type = PAYLOAD_TYPE_DEVICE;
    ret = OC_STACK_MALFORMED_RESPONSE;

    if (cbor_value_is_map(rootValue))
    {
        // Device ID
        size_t len = 0;
        CborValue curVal;
        err = cbor_value_map_find_value(rootValue, OC_RSRVD_DEVICE_ID, &curVal);
        if (cbor_value_is_valid(&curVal))
        {
            err = cbor_value_dup_byte_string(&curVal, &out->sid, &len, NULL);
            VERIFY_CBOR_SUCCESS(TAG, err, "to find device id in device payload");
        }
        // Device Name
        err = cbor_value_map_find_value(rootValue, OC_RSRVD_DEVICE_NAME, &curVal);
        if (cbor_value_is_valid(&curVal))
        {
            err = cbor_value_dup_text_string(&curVal, &out->deviceName, &len, NULL);
            VERIFY_CBOR_SUCCESS(TAG, err, "to find device name in device payload");
        }
        // Device Spec Version
        err = cbor_value_map_find_value(rootValue, OC_RSRVD_SPEC_VERSION, &curVal);
        if (cbor_value_is_valid(&curVal))
        {
            err = cbor_value_dup_text_string(&curVal, &out->specVersion, &len, NULL);
            VERIFY_CBOR_SUCCESS(TAG, err, "to find spec version in device payload");
        }
        // Data Model Version
        err = cbor_value_map_find_value(rootValue, OC_RSRVD_DATA_MODEL_VERSION, &curVal);
        if (cbor_value_is_valid(&curVal))
        {
            err = cbor_value_dup_text_string(&curVal, &out->dataModelVersion, &len, NULL);
            VERIFY_CBOR_SUCCESS(TAG, err, "to find data model version in device payload");
        }
        err = cbor_value_advance(rootValue);
        VERIFY_CBOR_SUCCESS(TAG, err, "to advance device payload");

        *outPayload = (OCPayload *)out;
        return OC_STACK_OK;
    }

exit:
    OCDevicePayloadDestroy(out);
    return ret;
}