#include "payload_logging.h"
#include "ocstack.h"
#include "ocrandom.h"
+#include "base64.h"
#include "ocserverrequest.h"
#include "oic_malloc.h"
#include "ocpayload.h"
/** Default cbor payload size. This value is increased in case of CborErrorOutOfMemory.
* The value of payload size is increased until reaching belox max cbor size. */
-static const uint8_t CBOR_SIZE = 255;
+static const uint16_t CBOR_SIZE = 2048;
/** Max cbor size payload. */
static const uint16_t CBOR_MAX_SIZE = 4400;
-/** CRED Map size - Number of mandatory items. */
-static const uint8_t CRED_MAP_SIZE = 4;
+/** CRED size - Number of mandatory items. */
+static const uint8_t CRED_ROOT_MAP_SIZE = 2;
+static const uint8_t CRED_MAP_SIZE = 3;
+
static OicSecCred_t *gCred = NULL;
static OCResourceHandle gCredHandle = NULL;
#endif
//Clean PublicData
+#ifdef __WITH_X509__
OICFree(cred->publicData.data);
+#endif
//Clean PrivateData
OICFree(cred->privateData.data);
//Clean Period
OICFree(cred->period);
- //Clean Owners
- OICFree(cred->owners);
-
//Clean Cred node itself
OICFree(cred);
}
}
OCStackResult ret = OC_STACK_ERROR;
- size_t cborLen = *cborSize;
- if (0 == cborLen)
- {
- cborLen = CBOR_SIZE;
- }
+ CborError cborEncoderResult = CborNoError;
+ uint8_t *outPayload = NULL;
+ size_t cborLen = *cborSize;
*cborSize = 0;
*cborPayload = NULL;
-
- CborEncoder encoder = { {.ptr = NULL }, .end = 0 };
- CborEncoder credArray = { {.ptr = NULL }, .end = 0 };
- CborError cborEncoderResult = CborNoError;
-
const OicSecCred_t *cred = credS;
- size_t mapSize = CRED_MAP_SIZE;
- if (cred->period)
- {
- mapSize++;
- }
- if (cred->publicData.data)
- {
- mapSize++;
- }
- if (cred->privateData.data)
- {
- mapSize++;
- }
- if (cred->period)
+ CborEncoder encoder;
+ CborEncoder credArray;
+ CborEncoder credRootMap;
+
+ if (0 == cborLen)
{
- mapSize++;
+ cborLen = CBOR_SIZE;
}
- uint8_t *outPayload = (uint8_t *)OICCalloc(1, cborLen);
+
+ outPayload = (uint8_t *)OICCalloc(1, cborLen);
VERIFY_NON_NULL(TAG, outPayload, ERROR);
cbor_encoder_init(&encoder, outPayload, cborLen, 0);
- // Create CRED Array
- cborEncoderResult = cbor_encoder_create_array(&encoder, &credArray, OicSecCredCount(cred));
- VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding0 Cred Array.");
+ // Create CRED Root Map (creds, rownerid)
+ cborEncoderResult = cbor_encoder_create_map(&encoder, &credRootMap, CRED_ROOT_MAP_SIZE);
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding Cred Root Map");
+
+ // creds
+ cborEncoderResult = cbor_encode_text_string(&credRootMap, OIC_JSON_CREDS_NAME,
+ strlen(OIC_JSON_CREDS_NAME));
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding creds Name Tag.");
+
+ // creds array
+ cborEncoderResult = cbor_encoder_create_array(&credRootMap, &credArray, OicSecCredCount(cred));
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding Cred Array.");
while (cred)
{
- CborEncoder credMap = { {.ptr = NULL }, .end = 0 };
+ CborEncoder credMap;
+ size_t mapSize = CRED_MAP_SIZE;
+ char *subject = NULL;
+ if (cred->period)
+ {
+ mapSize++;
+ }
+#ifdef __WITH_X509__
+ if (SIGNED_ASYMMETRIC_KEY == cred->credType && cred->publicData.data)
+ {
+ mapSize++;
+ }
+#endif /* __WITH_X509__ */
+ if (cred->privateData.data)
+ {
+ mapSize++;
+ }
cborEncoderResult = cbor_encoder_create_map(&credArray, &credMap, mapSize);
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding Cred Map");
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding Cred Id Value.");
//Subject -- Mandatory
- cborEncoderResult = cbor_encode_text_string(&credMap, OIC_JSON_SUBJECT_NAME,
- strlen(OIC_JSON_SUBJECT_NAME));
+ cborEncoderResult = cbor_encode_text_string(&credMap, OIC_JSON_SUBJECTID_NAME,
+ strlen(OIC_JSON_SUBJECTID_NAME));
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding Subject Tag.");
- cborEncoderResult = cbor_encode_byte_string(&credMap, cred->subject.id,
- sizeof(cred->subject.id));
- VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding Subject Value.");
+ ret = ConvertUuidToStr(&cred->subject, &subject);
+ VERIFY_SUCCESS(TAG, ret == OC_STACK_OK, ERROR);
+ cborEncoderResult = cbor_encode_text_string(&credMap, subject, strlen(subject));
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Addding Subject Id Value.");
+ OICFree(subject);
//CredType -- Mandatory
cborEncoderResult = cbor_encode_text_string(&credMap, OIC_JSON_CREDTYPE_NAME,
#ifdef __WITH_X509__
//PublicData -- Not Mandatory
- if (cred->publicData.data)
+ if (SIGNED_ASYMMETRIC_KEY == cred->credType && cred->publicData.data)
{
- cborEncoderResult = cbor_encode_text_string(&credMap,
- OIC_JSON_PUBLICDATA_NAME, strlen(OIC_JSON_PUBLICDATA_NAME));
- VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding Public Data Tag.");
- cborEncoderResult = cbor_encode_byte_string(&credMap, cred->publicData.data,
- sizeof(cred->publicData.data));
- VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding Public Tag Value.");
+ CborEncoder publicMap;
+ const size_t publicMapSize = 2;
+
+ cborEncoderResult = cbor_encode_text_string(&credMap, OIC_JSON_PUBLICDATA_NAME,
+ strlen(OIC_JSON_PUBLICDATA_NAME));
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding PublicData Tag.");
+
+ cborEncoderResult = cbor_encoder_create_map(&credMap, &publicMap, publicMapSize);
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding PublicData Map");
+
+ cborEncoderResult = cbor_encode_text_string(&publicMap, OIC_JSON_DATA_NAME,
+ strlen(OIC_JSON_DATA_NAME));
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding Pub Data Tag.");
+ cborEncoderResult = cbor_encode_byte_string(&publicMap, cred->publicData.data,
+ cred->publicData.len);
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding Pub Value.");
+
+ // TODO: Need to data strucure modification for OicSecCert_t.
+ cborEncoderResult = cbor_encode_text_string(&publicMap, OIC_JSON_ENCODING_NAME,
+ strlen(OIC_JSON_ENCODING_NAME));
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding Public Encoding Tag.");
+ cborEncoderResult = cbor_encode_text_string(&publicMap, OIC_SEC_ENCODING_RAW,
+ strlen(OIC_SEC_ENCODING_RAW));
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding Public Encoding Value.");
+
+ cborEncoderResult = cbor_encoder_close_container(&credMap, &publicMap);
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Closing PublicData Map.");
}
#endif /*__WITH_X509__*/
//PrivateData -- Not Mandatory
if(cred->privateData.data)
{
- cborEncoderResult = cbor_encode_text_string(&credMap,
- OIC_JSON_PRIVATEDATA_NAME, strlen(OIC_JSON_PRIVATEDATA_NAME));
- VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding Private Data Tag");
- cborEncoderResult = cbor_encode_byte_string(&credMap, cred->privateData.data,
- sizeof(cred->privateData.data));
- VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding Private Data Value.");
+ CborEncoder privateMap;
+ const size_t privateMapSize = 2;
+
+ cborEncoderResult = cbor_encode_text_string(&credMap, OIC_JSON_PRIVATEDATA_NAME,
+ strlen(OIC_JSON_PRIVATEDATA_NAME));
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding PrivateData Tag.");
+
+ cborEncoderResult = cbor_encoder_create_map(&credMap, &privateMap, privateMapSize);
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding PrivateData Map");
+
+ cborEncoderResult = cbor_encode_text_string(&privateMap, OIC_JSON_DATA_NAME,
+ strlen(OIC_JSON_DATA_NAME));
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding Priv Tag.");
+ cborEncoderResult = cbor_encode_byte_string(&privateMap, cred->privateData.data,
+ cred->privateData.len);
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding Priv Value.");
+
+ // TODO: Need to data strucure modification for OicSecKey_t.
+ cborEncoderResult = cbor_encode_text_string(&privateMap, OIC_JSON_ENCODING_NAME,
+ strlen(OIC_JSON_ENCODING_NAME));
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding Private Encoding Tag.");
+ cborEncoderResult = cbor_encode_text_string(&privateMap, OIC_SEC_ENCODING_RAW,
+ strlen(OIC_SEC_ENCODING_RAW));
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding Private Encoding Value.");
+
+ cborEncoderResult = cbor_encoder_close_container(&credMap, &privateMap);
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Closing PrivateData Map.");
}
//Period -- Not Mandatory
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding Period Name Value.");
}
- //Owners -- Mandatory
- {
- cborEncoderResult = cbor_encode_text_string(&credMap, OIC_JSON_OWNERS_NAME,
- strlen(OIC_JSON_OWNERS_NAME));
- VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding Owners Name Tag.");
- CborEncoder owners = { {.ptr = NULL }, .end = 0 };
- cborEncoderResult = cbor_encoder_create_array(&credMap, &owners, cred->ownersLen);
- VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding Owners Name Array.");
- for (size_t i = 0; i < cred->ownersLen; i++)
- {
- cborEncoderResult = cbor_encode_byte_string(&owners,
- (uint8_t *)cred->owners[i].id,
- sizeof(cred->owners[i].id));
- VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding Owners Array Value.");
- }
- cborEncoderResult = cbor_encoder_close_container(&credMap, &owners);
- VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Closing Owners Name Array.");
- }
+
cborEncoderResult = cbor_encoder_close_container(&credArray, &credMap);
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Closing Cred Map.");
cred = cred->next;
- }
- cborEncoderResult = cbor_encoder_close_container(&encoder, &credArray);
- VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Closing Cred Array.");
-
- if (CborNoError == cborEncoderResult)
- {
- *cborPayload = outPayload;
- *cborSize = encoder.ptr - outPayload;
- ret = OC_STACK_OK;
}
+ cborEncoderResult = cbor_encoder_close_container(&credRootMap, &credArray);
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Closing Cred Array.");
+
+ cred = credS;
+
+ // Rownerid
+ {
+ char *rowner = NULL;
+ cborEncoderResult = cbor_encode_text_string(&credRootMap, OIC_JSON_ROWNERID_NAME,
+ strlen(OIC_JSON_ROWNERID_NAME));
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding rownerid Name.");
+ ret = ConvertUuidToStr(&cred->rownerID, &rowner);
+ VERIFY_SUCCESS(TAG, ret == OC_STACK_OK, ERROR);
+ cborEncoderResult = cbor_encode_text_string(&credRootMap, rowner, strlen(rowner));
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Addding rownerid Value.");
+ OICFree(rowner);
+ }
+
+ // Close CRED Root Map
+ cborEncoderResult = cbor_encoder_close_container(&encoder, &credRootMap);
+ VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Closing CRED Root Map.");
+ if (CborNoError == cborEncoderResult)
+ {
+ OIC_LOG(DEBUG, TAG, "CredToCBORPayload Successed");
+ *cborPayload = outPayload;
+ *cborSize = encoder.ptr - outPayload;
+ ret = OC_STACK_OK;
+ }
+ OIC_LOG(DEBUG, TAG, "CredToCBORPayload OUT");
exit:
- if ((CborErrorOutOfMemory == cborEncoderResult) && (cborLen < CBOR_MAX_SIZE))
+ if (CborErrorOutOfMemory == cborEncoderResult)
{
- // reallocate and try again!
- OICFree(outPayload);
- outPayload = NULL;
- // Since the allocated initial memory failed, double the memory.
- cborLen += encoder.ptr - encoder.end;
- cborEncoderResult = CborNoError;
- ret = CredToCBORPayload(credS, cborPayload, &cborLen);
- if (CborNoError == cborEncoderResult)
- {
- *cborSize = cborLen;
- ret = OC_STACK_OK;
- }
+ OIC_LOG(DEBUG, TAG, "CredToCBORPayload:CborErrorOutOfMemory : retry with more memory");
+ // reallocate and try again!
+ OICFree(outPayload);
+ // Since the allocated initial memory failed, double the memory.
+ cborLen += encoder.ptr - encoder.end;
+ cborEncoderResult = CborNoError;
+ ret = CredToCBORPayload(credS, cborPayload, &cborLen);
+ *cborSize = cborLen;
}
if (CborNoError != cborEncoderResult)
{
- OICFree(outPayload);
- outPayload = NULL;
- *cborSize = 0;
- *cborPayload = NULL;
- ret = OC_STACK_ERROR;
+ OIC_LOG(ERROR, TAG, "Failed to CredToCBORPayload");
+ OICFree(outPayload);
+ outPayload = NULL;
+ *cborSize = 0;
+ *cborPayload = NULL;
+ ret = OC_STACK_ERROR;
}
return ret;
OCStackResult CBORPayloadToCred(const uint8_t *cborPayload, size_t size,
OicSecCred_t **secCred)
{
- if (NULL == cborPayload || NULL == secCred || NULL != *secCred)
+ if (NULL == cborPayload || NULL == secCred || NULL != *secCred || 0 == size)
{
return OC_STACK_INVALID_PARAM;
}
- *secCred = NULL;
-
OCStackResult ret = OC_STACK_ERROR;
-
CborValue credCbor = { .parser = NULL };
CborParser parser = { .end = NULL };
CborError cborFindResult = CborNoError;
- OicSecCred_t *cred = NULL;
- char *name = NULL;
+ cbor_parser_init(cborPayload, size, 0, &parser, &credCbor);
- int cborLen = size;
- if (0 == size)
- {
- cborLen = CBOR_SIZE;
- }
- cbor_parser_init(cborPayload, cborLen, 0, &parser, &credCbor);
-
- OicSecCred_t *headCred = NULL;
+ OicSecCred_t *headCred = (OicSecCred_t *) OICCalloc(1, sizeof(OicSecCred_t));
- CborValue credArray = { .parser = NULL };
- cborFindResult = cbor_value_enter_container(&credCbor, &credArray);
- VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding Cred Array.");
+ // Enter CRED Root Map
+ CborValue CredRootMap = { .parser = NULL, .ptr = NULL, .remaining = 0, .extra = 0, .type = 0, .flags = 0 };
+ cborFindResult = cbor_value_enter_container(&credCbor, &CredRootMap);
+ VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Entering CRED Root Map.");
- while (cbor_value_is_valid(&credArray))
+ while (cbor_value_is_valid(&CredRootMap))
{
- CborValue credMap = { .parser = NULL };
- cborFindResult = cbor_value_enter_container(&credArray, &credMap);
- VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding Cred Map.");
+ char* tagName = NULL;
+ size_t len = 0;
+ CborType type = cbor_value_get_type(&CredRootMap);
+ if (type == CborTextStringType)
+ {
+ cborFindResult = cbor_value_dup_text_string(&CredRootMap, &tagName, &len, NULL);
+ VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding Name in CRED Root Map.");
+ cborFindResult = cbor_value_advance(&CredRootMap);
+ VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Advancing Value in CRED Root Map.");
+ }
+ if(tagName)
+ {
+ if (strcmp(tagName, OIC_JSON_CREDS_NAME) == 0)
+ {
+ // Enter CREDS Array
+ size_t len = 0;
+ int credCount = 0;
+ CborValue credArray = { .parser = NULL, .ptr = NULL, .remaining = 0, .extra = 0, .type = 0, .flags = 0 };
+ cborFindResult = cbor_value_enter_container(&CredRootMap, &credArray);
+ VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding Cred Array.");
+
+ while (cbor_value_is_valid(&credArray))
+ {
+ credCount++;
+ //CredId -- Mandatory
+ CborValue credMap = { .parser = NULL, .ptr = NULL, .remaining = 0, .extra = 0, .type = 0, .flags = 0 };
+ cborFindResult = cbor_value_enter_container(&credArray, &credMap);
+ VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding Cred Map.");
+ OicSecCred_t *cred = NULL;
+
+ if(1 == credCount)
+ {
+ cred = headCred;
+ }
+ else
+ {
+ cred = (OicSecCred_t *) OICCalloc(1, sizeof(OicSecCred_t));
+ OicSecCred_t *temp = headCred;
+ while (temp->next)
+ {
+ temp = temp->next;
+ }
+ temp->next = cred;
+ }
- cred = (OicSecCred_t *) OICCalloc(1, sizeof(*cred));
- VERIFY_NON_NULL(TAG, cred, ERROR);
+ VERIFY_NON_NULL(TAG, cred, ERROR);
- while (cbor_value_is_valid(&credMap))
- {
- size_t len = 0;
- cborFindResult = cbor_value_dup_text_string(&credMap, &name, &len, NULL);
- VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding Cred Name.");
- cborFindResult = cbor_value_advance(&credMap);
- VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Advancing Cred Name. ");
+ while(cbor_value_is_valid(&credMap))
+ {
+ char* name = NULL;
+ CborType type = cbor_value_get_type(&credMap);
+ if (type == CborTextStringType)
+ {
+ cborFindResult = cbor_value_dup_text_string(&credMap, &name, &len, NULL);
+ VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding Name in CRED Map.");
+ cborFindResult = cbor_value_advance(&credMap);
+ VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Advancing Value in CRED Map.");
+ }
+ if(name)
+ {
+ //credid
+ if (strcmp(name, OIC_JSON_CREDID_NAME) == 0)
+ {
+ cborFindResult = cbor_value_get_uint64(&credMap, (uint64_t *) &cred->credId);
+ VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding CredId.");
+ }
+ // subjectid
+ if (strcmp(name, OIC_JSON_SUBJECTID_NAME) == 0)
+ {
+ char *subjectid = NULL;
+ cborFindResult = cbor_value_dup_text_string(&credMap, &subjectid, &len, NULL);
+ VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding subjectid Value.");
+ ret = ConvertStrToUuid(subjectid, &cred->subject);
+ VERIFY_SUCCESS(TAG, ret == OC_STACK_OK, ERROR);
+ OICFree(subjectid);
+ }
+ // credtype
+ if (strcmp(name, OIC_JSON_CREDTYPE_NAME) == 0)
+ {
+ cborFindResult = cbor_value_get_uint64(&credMap, (uint64_t *) &cred->credType);
+ VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding CredType.");
+ }
+ // privatedata
+ if (strcmp(name, OIC_JSON_PRIVATEDATA_NAME) == 0)
+ {
+ CborValue privateMap = { .parser = NULL };
+ cborFindResult = cbor_value_enter_container(&credMap, &privateMap);
+
+ while (cbor_value_is_valid(&privateMap))
+ {
+ char* privname = NULL;
+ CborType type = cbor_value_get_type(&privateMap);
+ if (type == CborTextStringType)
+ {
+ cborFindResult = cbor_value_dup_text_string(&privateMap, &privname,
+ &len, NULL);
+ VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed to get text");
+ cborFindResult = cbor_value_advance(&privateMap);
+ VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed to advance value");
+ }
+ if (privname)
+ {
+ // PrivateData::privdata -- Mandatory
+ if (strcmp(privname, OIC_JSON_DATA_NAME) == 0)
+ {
+ cborFindResult = cbor_value_dup_byte_string(&privateMap, &cred->privateData.data,
+ &cred->privateData.len, NULL);
+ VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding PrivateData.");
+ }
+ // PrivateData::encoding -- Mandatory
+ if (strcmp(privname, OIC_JSON_ENCODING_NAME) == 0)
+ {
+ // TODO: Need to update data structure, just ignore encoding value now.
+ }
+ }
+ if (cbor_value_is_valid(&privateMap))
+ {
+ cborFindResult = cbor_value_advance(&privateMap);
+ VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Advancing privatedata Map.");
+ }
+ OICFree(privname);
+ }
- CborType type = cbor_value_get_type(&credMap);
+ }
+#ifdef __WITH_X509__
+ if (strcmp(name, OIC_JSON_PUBLICDATA_NAME) == 0)
+ {
+ CborValue pubMap = { .parser = NULL };
+ cborFindResult = cbor_value_enter_container(&credMap, &pubMap);
+
+ while (cbor_value_is_valid(&pubMap))
+ {
+ char* pubname = NULL;
+ CborType type = cbor_value_get_type(&pubMap);
+ if (type == CborTextStringType)
+ {
+ cborFindResult = cbor_value_dup_text_string(&pubMap, &pubname,
+ &len, NULL);
+ VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed to get text");
+ cborFindResult = cbor_value_advance(&pubMap);
+ VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed to advance value");
+ }
+ if (pubname)
+ {
+ // PrivateData::privdata -- Mandatory
+ if (strcmp(pubname, OIC_JSON_DATA_NAME) == 0)
+ {
+ cborFindResult = cbor_value_dup_byte_string(&pubMap, &cred->publicData.data,
+ &cred->publicData.len, NULL);
+ VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding PubData.");
+ }
+ // PublicData::encoding -- Mandatory
+ if (strcmp(pubname, OIC_JSON_ENCODING_NAME) == 0)
+ {
+ // TODO: Need to update data structure, just ignore encoding value now.
+ }
+ }
+ if (cbor_value_is_valid(&pubMap))
+ {
+ cborFindResult = cbor_value_advance(&pubMap);
+ VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Advancing publicdata Map.");
+ }
+ OICFree(pubname);
+ }
+ }
+#endif //__WITH_X509__
- //CredId -- Mandatory
- if (0 == strcmp(OIC_JSON_CREDID_NAME, name))
- {
- cborFindResult = cbor_value_get_int(&credMap, (int *) &cred->credId);
- VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding Cred Id Value.");
- }
- //subject -- Mandatory
- if (0 == strcmp(OIC_JSON_SUBJECT_NAME, name))
- {
- uint8_t *id = NULL;
- cborFindResult = cbor_value_dup_byte_string(&credMap, &id, &len, NULL);
- VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding Subject Name Value.");
- memcpy(cred->subject.id, id, len);
- OICFree(id);
- }
- //CredType -- Mandatory
- if (0 == strcmp(OIC_JSON_CREDTYPE_NAME, name))
- {
- cborFindResult = cbor_value_get_int(&credMap, (int *) &cred->credType);
- VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding Cred Type Value.");
- }
- //Owners -- Mandatory
- if (0 == strcmp(OIC_JSON_OWNERS_NAME, name))
- {
- CborValue owners = { .parser = NULL };
- cborFindResult = cbor_value_get_array_length(&credMap, &cred->ownersLen);
- VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding Owners Name Array Len.");
- cborFindResult = cbor_value_enter_container(&credMap, &owners);
- VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding Owners Name.");
- int i = 0;
- cred->owners = (OicUuid_t *)OICCalloc(cred->ownersLen, sizeof(*cred->owners));
- VERIFY_NON_NULL(TAG, cred->owners, ERROR);
- while (cbor_value_is_valid(&owners))
- {
- uint8_t *owner = NULL;
- cborFindResult = cbor_value_dup_byte_string(&owners, &owner, &len, NULL);
- VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding Owner Value.");
- memcpy(cred->owners[i].id, owner, len);
- OICFree(owner);
- cborFindResult = cbor_value_advance(&owners);
- VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Advancing Owner Value.");
- }
- }
- //PrivateData is mandatory for some of the credential types listed below.
- if (0 == strcmp(OIC_JSON_PRIVATEDATA_NAME, name))
- {
- if ((cred->credType & SYMMETRIC_PAIR_WISE_KEY) ||
- (cred->credType & SYMMETRIC_GROUP_KEY) ||
- (cred->credType & PIN_PASSWORD))
- {
- cborFindResult = cbor_value_dup_byte_string(&credMap,
- &cred->privateData.data, &len, NULL);
- VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding Private Data Value.");
- }
- }
- else
- {
- cred->privateData.data = NULL;
- }
+ if (0 == strcmp(OIC_JSON_PERIOD_NAME, name))
+ {
+ cborFindResult = cbor_value_dup_text_string(&credMap, &cred->period, &len, NULL);
+ VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding Period.");
+ }
- //PublicData is mandatory only for SIGNED_ASYMMETRIC_KEY credentials type.
- if (0 == strcmp(OIC_JSON_PUBLICDATA_NAME, name))
- {
- if (cred->credType & SIGNED_ASYMMETRIC_KEY)
- {
- cborFindResult = cbor_value_dup_byte_string(&credMap,
- &cred->publicData.data, &len, NULL);
- VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding ");
+ if (cbor_value_is_valid(&credMap))
+ {
+ cborFindResult = cbor_value_advance(&credMap);
+ VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Advancing CRED Map.");
+ }
+ OICFree(name);
+ }
+ }
+ cred->next = NULL;
+ if (cbor_value_is_valid(&credArray))
+ {
+ cborFindResult = cbor_value_advance(&credArray);
+ VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Advancing CRED Array.");
+ }
}
}
- //Period -- Not Mandatory
- if (0 == strcmp(OIC_JSON_PERIOD_NAME, name))
- {
- cborFindResult = cbor_value_dup_text_string(&credMap,
- &cred->period, &len, NULL);
- VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding Period Name Value.");
- }
- if (CborMapType != type && cbor_value_is_valid(&credMap))
- {
- cborFindResult = cbor_value_advance(&credMap);
- VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Advancing Cred Map.");
- }
- OICFree(name);
- name = NULL;
- }
- cred->next = NULL;
- if (NULL == headCred)
- {
- headCred = cred;
- }
- else
- {
- OicSecCred_t *temp = headCred;
- while (temp->next)
+ //ROwner -- Mandatory
+ if (strcmp(tagName, OIC_JSON_ROWNERID_NAME) == 0)
{
- temp = temp->next;
+ char *stRowner = NULL;
+ cborFindResult = cbor_value_dup_text_string(&CredRootMap, &stRowner, &len, NULL);
+ VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding Rownerid Value.");
+
+ ret = ConvertStrToUuid(stRowner, &headCred->rownerID);
+ VERIFY_SUCCESS(TAG, ret == OC_STACK_OK, ERROR);
+ OICFree(stRowner);
}
- temp->next = cred;
+ OICFree(tagName);
}
- if (cbor_value_is_valid(&credArray))
+ if (cbor_value_is_valid(&CredRootMap))
{
- cborFindResult = cbor_value_advance(&credArray);
- VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Advancing Cred Array. ");
+ cborFindResult = cbor_value_advance(&CredRootMap);
+ VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Advancing CRED Root Map.");
}
}
+
*secCred = headCred;
ret = OC_STACK_OK;
+
exit:
if (CborNoError != cborFindResult)
{
DeleteCredList(headCred);
headCred = NULL;
+ *secCred = NULL;
ret = OC_STACK_ERROR;
}
- if (cred)
- {
- DeleteCredList(cred);
- }
- if (name)
- {
- OICFree(name);
- }
+
return ret;
}
OicSecCred_t * GenerateCredential(const OicUuid_t * subject, OicSecCredType_t credType,
- const uint8_t * publicData, const uint8_t* privateData,
- size_t ownersLen, const OicUuid_t * owners)
+ const OicSecCert_t * publicData, const OicSecKey_t* privateData,
+ const OicUuid_t * rownerID)
{
(void)publicData;
OCStackResult ret = OC_STACK_ERROR;
cred->credType = credType;
#ifdef __WITH_X509__
- if (publicData)
+ if (publicData && publicData->data)
{
- cred->publicData.data = (uint8_t *)OICCalloc(1, PUBLIC_KEY_SIZE);
+ cred->publicData.data = (uint8_t *)OICCalloc(1, publicData->len);
VERIFY_NON_NULL(TAG, cred->publicData.data, ERROR);
- memcpy(cred->publicData.data, publicData, PUBLIC_KEY_SIZE);
+ memcpy(cred->publicData.data, publicData->data, publicData->len);
+ cred->publicData.len = publicData->len;
}
#endif // __WITH_X509__
- if (privateData)
+ if (privateData && privateData->data)
{
-#ifdef __WITH_X509__
- cred->privateData.data = (uint8_t *)OICCalloc(1, PRIVATE_KEY_SIZE);
+ cred->privateData.data = (uint8_t *)OICCalloc(1, privateData->len);
VERIFY_NON_NULL(TAG, cred->privateData.data, ERROR);
- memcpy(cred->privateData.data, privateData, PRIVATE_KEY_SIZE);
-#endif // __WITH_X509__
+ memcpy(cred->privateData.data, privateData->data, privateData->len);
+ cred->privateData.len = privateData->len;
}
- VERIFY_SUCCESS(TAG, ownersLen > 0, ERROR);
- cred->ownersLen = ownersLen;
-
- cred->owners = (OicUuid_t *)OICCalloc(cred->ownersLen, sizeof(*cred->owners));
- VERIFY_NON_NULL(TAG, cred->owners, ERROR);
- for (size_t i = 0; i < cred->ownersLen; i++)
- {
- memcpy(cred->owners[i].id, owners[i].id, sizeof(cred->owners[i].id));
- }
+ VERIFY_NON_NULL(TAG, rownerID, ERROR);
+ memcpy(&cred->rownerID, rownerID, sizeof(OicUuid_t));
ret = OC_STACK_OK;
exit:
bool ret = false;
// Convert Cred data into JSON for update to persistent storage
- uint8_t *payload = NULL;
- size_t size = 0;
- OCStackResult res = CredToCBORPayload(cred, &payload, &size);
- if ((OC_STACK_OK == res) && payload)
+ if (cred)
{
- if (OC_STACK_OK == UpdateSecureResourceInPS(OIC_JSON_CRED_NAME, payload, size))
+ uint8_t *payload = NULL;
+ size_t size = 0;
+ OCStackResult res = CredToCBORPayload(cred, &payload, &size);
+ if ((OC_STACK_OK == res) && payload)
{
- ret = true;
+ if (OC_STACK_OK == UpdateSecureResourceInPS(OIC_JSON_CRED_NAME, payload, size))
+ {
+ ret = true;
+ }
+ OICFree(payload);
}
- OICFree(payload);
}
else //Empty cred list
{
- if (OC_STACK_OK == UpdateSecureResourceInPS(OIC_JSON_CRED_NAME, NULL, size))
+ if (OC_STACK_OK == UpdateSecureResourceInPS(OIC_JSON_CRED_NAME, NULL, 0))
{
ret = true;
}
//Generate owner credential based on recevied credential information
receviedCred->privateData.data = (uint8_t *)OICCalloc(1, OWNER_PSK_LENGTH_128);
VERIFY_NON_NULL(TAG, receviedCred->privateData.data, ERROR);
+ receviedCred->privateData.len = OWNER_PSK_LENGTH_128;
memcpy(receviedCred->privateData.data, ownerPSK, OWNER_PSK_LENGTH_128);
OIC_LOG(INFO, TAG, "PrivateData of OwnerPSK was calculated successfully");
static OCEntityHandlerResult HandlePutRequest(const OCEntityHandlerRequest * ehRequest)
{
OCEntityHandlerResult ret = OC_EH_ERROR;
+ OIC_LOG(DEBUG, TAG, "HandleCREDPutRequest IN");
- //Get binary representation of json
- OicSecCred_t * cred = NULL;
- uint8_t *payload = (((OCSecurityPayload*)ehRequest->payload)->securityData1);
- //size_t size = (((OCSecurityPayload*)ehRequest->payload)->payloadSize);
- OCStackResult res = CBORPayloadToCred(payload, 0, &cred);
+ //Get binary representation of cbor
+ OicSecCred_t *cred = NULL;
+ uint8_t *payload = (((OCSecurityPayload*)ehRequest->payload)->securityData);
+ size_t size = (((OCSecurityPayload*)ehRequest->payload)->payloadSize);
+ OCStackResult res = CBORPayloadToCred(payload, size, &cred);
if (res == OC_STACK_OK)
{
#ifdef __WITH_DTLS__
}
FreeCred(cred);
}
-
+ OIC_LOG(DEBUG, TAG, "HandleCREDPutRequest OUT");
return ret;
}
//Get binary representation of CBOR
OicSecCred_t *cred = NULL;
- uint8_t *payload = ((OCSecurityPayload*)ehRequest->payload)->securityData1;
- OCStackResult res = CBORPayloadToCred(payload, 0, &cred);
+ uint8_t *payload = ((OCSecurityPayload*)ehRequest->payload)->securityData;
+ size_t size = ((OCSecurityPayload*)ehRequest->payload)->payloadSize;
+ OCStackResult res = CBORPayloadToCred(payload, size, &cred);
if ((OC_STACK_OK == res) && cred)
{
//If the Post request credential has credId, it will be
OCEntityHandlerResult ehRet = OC_EH_ERROR;
if (NULL == ehRequest->query)
- {
- return ehRet;
- }
-
- OicParseQueryIter_t parseIter = { .attrPos=NULL };
- OicUuid_t subject = {.id={0}};
-
- //Parsing REST query to get the subject
- ParseQueryIterInit((unsigned char *)ehRequest->query, &parseIter);
- while (GetNextQuery(&parseIter))
- {
- if (strncasecmp((char *)parseIter.attrPos, OIC_JSON_SUBJECT_NAME,
- parseIter.attrLen) == 0)
- {
- memcpy(subject.id, parseIter.valPos, parseIter.valLen);
- }
- }
-
- if (OC_STACK_RESOURCE_DELETED == RemoveCredential(&subject))
- {
- ehRet = OC_EH_RESOURCE_DELETED;
- }
+ {
+ return ehRet;
+ }
+
+ OicParseQueryIter_t parseIter = { .attrPos=NULL };
+ OicUuid_t subject = {.id={0}};
+
+ //Parsing REST query to get the subject
+ ParseQueryIterInit((unsigned char *)ehRequest->query, &parseIter);
+ while (GetNextQuery(&parseIter))
+ {
+ if (strncasecmp((char *)parseIter.attrPos, OIC_JSON_SUBJECTID_NAME,
+ parseIter.attrLen) == 0)
+ {
+ OCStackResult ret = ConvertStrToUuid((const char*)parseIter.valPos, &subject);
+ VERIFY_SUCCESS(TAG, OC_STACK_OK == ret, ERROR);
+ }
+ }
+ if (OC_STACK_RESOURCE_DELETED == RemoveCredential(&subject))
+ {
+ ehRet = OC_EH_RESOURCE_DELETED;
+ }
+
+exit:
return ehRet;
}
}
//Send payload to request originator
- ret = (SendSRMCBORResponse(ehRequest, ret, NULL) == OC_STACK_OK) ?
+ ret = (SendSRMResponse(ehRequest, ret, NULL, 0) == OC_STACK_OK) ?
ret : OC_EH_ERROR;
return ret;
}
// Copy PSK.
- result_length = sizeof(cred->privateData.data);
+ result_length = cred->privateData.len;
memcpy(result, cred->privateData.data, result_length);
return result_length;
}
* @param[in] credType Type of credential to be added
* @param[in] pin numeric characters
* @param[in] pinSize length of 'pin'
- * @param[in] ownersLen Number of owners
- * @param[in] owners Array of owners
+ * @param[in] rownerID Resource owner's UUID
* @param[out] tmpCredSubject Generated credential's subject.
*
* @return OC_STACK_OK for success and errorcode otherwise.
*/
OCStackResult AddTmpPskWithPIN(const OicUuid_t* tmpSubject, OicSecCredType_t credType,
const char * pin, size_t pinSize,
- size_t ownersLen, const OicUuid_t * owners, OicUuid_t* tmpCredSubject)
+ const OicUuid_t * rownerID, OicUuid_t* tmpCredSubject)
{
OCStackResult ret = OC_STACK_ERROR;
+ OIC_LOG(DEBUG, TAG, "AddTmpPskWithPIN IN");
if(NULL == tmpSubject || NULL == pin || 0 == pinSize || NULL == tmpCredSubject)
{
}
uint8_t privData[OWNER_PSK_LENGTH_128] = {0,};
+ OicSecKey_t privKey = {privData, OWNER_PSK_LENGTH_128};
OicSecCred_t* cred = NULL;
- int dtlsRes = DeriveCryptoKeyFromPassword((const unsigned char *)pin, pinSize, owners->id,
+ int dtlsRes = DeriveCryptoKeyFromPassword((const unsigned char *)pin, pinSize, rownerID->id,
UUID_LENGTH, PBKDF_ITERATIONS,
OWNER_PSK_LENGTH_128, privData);
VERIFY_SUCCESS(TAG, (0 == dtlsRes) , ERROR);
cred = GenerateCredential(tmpSubject, credType, NULL,
- privData, ownersLen, owners);
+ &privKey, rownerID);
if(NULL == cred)
{
OIC_LOG(ERROR, TAG, "GeneratePskWithPIN() : Failed to generate credential");
RemoveCredential(tmpSubject);
OIC_LOG(ERROR, TAG, "GeneratePskWithPIN() : Failed to add credential");
}
+ OIC_LOG(DEBUG, TAG, "AddTmpPskWithPIN OUT");
exit:
return ret;
#define CERTIFICATE ("x5c")
#define PRIVATE_KEY ("d")
-static void WriteCertPrefix(uint8_t *prefix, uint32_t certLen)
-{
- for (size_t i = 0; i < CERT_LEN_PREFIX; ++i)
- {
- prefix[i] = (certLen >> (BYTE_SIZE * (CERT_LEN_PREFIX - 1 - i))) & 0xFF;
- }
-}
-
-static uint32_t ParseCertPrefix(uint8_t *prefix)
+static uint32_t parseCertPrefix(uint8_t *prefix)
{
uint32_t res = 0;
if (NULL != prefix)
return res;
}
-static uint32_t appendCert2Chain(uint8_t *appendPoint, uint8_t *cert, size_t len, uint32_t max_len)
-{
- uint32_t ret = 0;
- VERIFY_NON_NULL(TAG, appendPoint, ERROR);
- VERIFY_NON_NULL(TAG, cert, ERROR);
-
- memcpy(appendPoint + CERT_LEN_PREFIX, cert, max_len - CERT_LEN_PREFIX);
- WriteCertPrefix(appendPoint, len);
-
- ret = len + CERT_LEN_PREFIX;
-exit:
- return ret;
-}
-
static OCStackResult GetCAPublicKeyData(CADtlsX509Creds_t *credInfo)
{
OCStackResult ret = OC_STACK_ERROR;
uint8_t *ccPtr = credInfo->certificateChain;
for (uint8_t i = 0; i < credInfo->chainLen - 1; ++i)
{
- ccPtr += CERT_LEN_PREFIX + ParseCertPrefix(ccPtr);
+ ccPtr += CERT_LEN_PREFIX + parseCertPrefix(ccPtr);
}
- ByteArray cert = { .data = ccPtr + CERT_LEN_PREFIX, .len = ParseCertPrefix(ccPtr) };
+ ByteArray cert = { .data = ccPtr + CERT_LEN_PREFIX, .len = parseCertPrefix(ccPtr) };
CertificateX509 certStruct;
VERIFY_SUCCESS(TAG, PKI_SUCCESS == DecodeCertificate(cert, &certStruct), ERROR);
LL_SEARCH_SCALAR(gCred, cred, credType, SIGNED_ASYMMETRIC_KEY);
VERIFY_NON_NULL(TAG, cred, ERROR);
- CborValue credCbor = { .parser = NULL };
- CborParser parser = { .end = NULL };
- CborError cborFindResult = CborNoError;
- uint8_t *cborPayload = cred->publicData.data;
- int cborLen = cred->publicData.len;
- cbor_parser_init(cborPayload, cborLen, 0, &parser, &credCbor);
- CborValue certMap;
- cborFindResult = cbor_value_enter_container(&credCbor, &certMap);
- VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding Cred Map.");
-
- CborValue certs;
- cborFindResult = cbor_value_map_find_value(&certs, CERTIFICATE, &certs);
- if (cbor_value_is_array(&certs))
+ if (cred->publicData.len > MAX_CERT_MESSAGE_LEN || cred->privateData.len > PRIVATE_KEY_SIZE)
{
- cborFindResult = cbor_value_get_array_length(&certs, (size_t *)&credInfo->chainLen);
- VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding Chain Len.");
- CborValue cert;
- cborFindResult = cbor_value_enter_container(&certs, &cert);
- VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Entering Container.");
- size_t len = 0;
- size_t certLen = 0;
- uint8_t *val = NULL;
- while (cbor_value_is_byte_string(&cert))
- {
- cborFindResult = cbor_value_dup_byte_string(&cert, &val, &certLen, NULL);
- VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding a Period Array Value.");
- cborFindResult = cbor_value_advance(&cert);
- VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Advancing a Period Array.");
- uint32_t appendedLen = appendCert2Chain(credInfo->certificateChain + len, val, certLen, MAX_CERT_MESSAGE_LEN - len);
- len += appendedLen;
- }
- credInfo->certificateChainLen = len;
- GetCAPublicKeyData(credInfo);
+ goto exit;
}
- memcpy(credInfo->devicePrivateKey, cred->privateData.data, PRIVATE_KEY_SIZE);
-
+ credInfo->chainLen = 2;
+ memcpy(credInfo->certificateChain, cred->publicData.data, cred->publicData.len);
+ memcpy(credInfo->devicePrivateKey, cred->privateData.data, cred->privateData.len);
+ credInfo->certificateChainLen = cred->publicData.len;
+ GetCAPublicKeyData(credInfo);
ret = 0;
+
exit:
return ret;
}
#undef CERT_LEN_PREFIX
#endif /* __WITH_X509__ */
+
+OCStackResult SetCredRownerId(const OicUuid_t* newROwner)
+{
+ OCStackResult ret = OC_STACK_ERROR;
+ uint8_t *cborPayload = NULL;
+ size_t size = 0;
+ OicUuid_t prevId = {.id={0}};
+
+ if(NULL == newROwner)
+ {
+ ret = OC_STACK_INVALID_PARAM;
+ }
+ if(NULL == gCred)
+ {
+ ret = OC_STACK_NO_RESOURCE;
+ }
+
+ if(newROwner && gCred)
+ {
+ memcpy(prevId.id, gCred->rownerID.id, sizeof(prevId.id));
+ memcpy(gCred->rownerID.id, newROwner->id, sizeof(newROwner->id));
+
+ ret = CredToCBORPayload(gCred, &cborPayload, &size);
+ VERIFY_SUCCESS(TAG, OC_STACK_OK == ret, ERROR);
+
+ ret = UpdateSecureResourceInPS(OIC_JSON_CRED_NAME, cborPayload, size);
+ VERIFY_SUCCESS(TAG, OC_STACK_OK == ret, ERROR);
+
+ OICFree(cborPayload);
+ }
+
+ return ret;
+
+exit:
+ OICFree(cborPayload);
+ memcpy(gCred->rownerID.id, prevId.id, sizeof(prevId.id));
+ return ret;
+}
+
+OCStackResult GetCredRownerId(OicUuid_t *rowneruuid)
+{
+ OCStackResult retVal = OC_STACK_ERROR;
+ if (gCred)
+ {
+ *rowneruuid = gCred->rownerID;
+ retVal = OC_STACK_OK;
+ }
+ return retVal;
+}
projects / platform / upstream / iotivity.git / blobdiff