OTMCallbackData_t CBData = {0};
if (OIC_JUST_WORKS == (OicSecOxm_t)OxmType)
{
- CBData.loadSecretCB = LoadSecretJustWorksCallback;
- CBData.createSecureSessionCB = CreateSecureSessionJustWorksCallback;
- CBData.createSelectOxmPayloadCB = CreateJustWorksSelectOxmPayload;
- CBData.createOwnerTransferPayloadCB = CreateJustWorksOwnerTransferPayload;
-
- result = OCSecure::setOwnerTransferCallbackData((OicSecOxm_t)OxmType,
- &CBData, NULL);
+ /*NO callback required for JUST_WORKS*/
+ result = OCSecure::setInputPinCallback(NULL);
}
if (OIC_RANDOM_DEVICE_PIN == (OicSecOxm_t)OxmType)
{
{
delete jniPinListener;
jniPinListener = new JniPinCheckListener(env, jListener);
- CBData.loadSecretCB = InputPinCodeCallback;
- CBData.createSecureSessionCB = CreateSecureSessionRandomPinCallback;
- CBData.createSelectOxmPayloadCB = CreatePinBasedSelectOxmPayload;
- CBData.createOwnerTransferPayloadCB = CreatePinBasedOwnerTransferPayload;
- result = OCSecure::setOwnerTransferCallbackData((OicSecOxm_t)OxmType,
- &CBData, Callback);
+ result = OCSecure::setInputPinCallback(Callback);
}
else
{
uint8_t *result, size_t result_length);
#if defined(__WITH_DTLS__) || defined(__WITH_TLS__)
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
/**
* API to get a secure connected peer information
*
* @return secure connected peer information on success, otherwise NULL
*/
const CASecureEndpoint_t *CAGetSecureEndpointData(const CAEndpoint_t *peer);
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
#endif
/**
const uint8_t* provServerDeviceId, const size_t provServerDeviceIdLen,
uint8_t* ownerPsk, const size_t ownerPskSize);
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
/**
* Gets CA secure endpoint info corresponding for endpoint.
*
env.AppendUnique(CPPDEFINES = ['__WITH_TLS__'])
if (multiple_owner == '1'):
- env.AppendUnique(CPPDEFINES=['_ENABLE_MULTIPLE_OWNER_'])
+ env.AppendUnique(CPPDEFINES=['MULTIPLE_OWNER'])
ca_common_src = None
return NULL;
}
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
/**
* Gets CA secure endpoint info corresponding for endpoint.
*
}
#if defined(__WITH_DTLS__) || defined(__WITH_TLS__)
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
const CASecureEndpoint_t *CAGetSecureEndpointData(const CAEndpoint_t *peer)
{
OIC_LOG(DEBUG, TAG, "IN CAGetSecurePeerInfo");
OIC_LOG(DEBUG, TAG, "OUT CAGetSecurePeerInfo");
return GetCASecureEndpointData(peer);
}
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
CAResult_t CAregisterSslHandshakeCallback(CAErrorCallback tlsHandshakeCallback)
{
libocsrm_env.AppendUnique(CPPDEFINES = ['TB_LOG'])
if env.get('MULTIPLE_OWNER') == '1':
- libocsrm_env.AppendUnique(CPPDEFINES=['_ENABLE_MULTIPLE_OWNER_'])
+ libocsrm_env.AppendUnique(CPPDEFINES=['MULTIPLE_OWNER'])
######################################################################
# Source files and Targets
*/
OCStackResult AclToCBORPayload(const OicSecAcl_t * acl, uint8_t **outPayload, size_t *size);
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
/**
* Function to check the ACL access of SubOwner
*
* @return ::true for valid access, otherwise invalid access
*/
bool IsValidAclAccessForSubOwner(const OicUuid_t* uuid, const uint8_t *cborPayload, const size_t size);
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
/**
OCStackResult CredToCBORPayload(const OicSecCred_t* cred, uint8_t **cborPayload,
size_t *cborSize, int secureFlag);
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
/**
* Function to check the credential access of SubOwner
*
* @return ::true for valid access, otherwise invalid access
*/
bool IsValidCredentialAccessForSubOwner(const OicUuid_t* uuid, const uint8_t *cborPayload, size_t size);
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
/**
* This function generates the bin credential data.
#define IOTVT_SRM_DOXM_H
#include "octypes.h"
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
#include "cacommon.h"
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
#ifdef __cplusplus
extern "C" {
*/
OCStackResult GetDoxmRownerId(OicUuid_t *rowneruuid);
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
/**
* Compare the UUID to SubOwner.
*
* @return true if uuid exists in the SubOwner list of doxm, else false.
*/
bool IsSubOwner(const OicUuid_t* uuid);
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
/** This function deallocates the memory for OicSecDoxm_t .
*
*/
void RestoreDoxmToInitState();
-#if defined(__WITH_DTLS__) && defined(_ENABLE_MULTIPLE_OWNER_)
+#if defined(__WITH_DTLS__) && defined(MULTIPLE_OWNER)
/**
* Callback function to handle MOT DTLS handshake result.
* @param[out] object remote device information.
*/
void MultipleOwnerDTLSHandshakeCB(const CAEndpoint_t *object,
const CAErrorInfo_t *errorInfo);
-#endif //__WITH_DTLS__ && _ENABLE_MULTIPLE_OWNER_
+#endif //__WITH_DTLS__ && MULTIPLE_OWNER
#ifdef __cplusplus
}
SRMAccessResponse_t retVal;
AmsMgrContext_t *amsMgrContext;
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
uint8_t* payload;
size_t payloadSize;
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
} PEContext_t;
/**
extern const char * OIC_JSON_OWNERS_NAME;
extern const char * OIC_JSON_OWNER_NAME;
extern const char * OIC_JSON_DEVOWNERID_NAME;
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
extern const char * OIC_JSON_SUBOWNERID_NAME;
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
extern const char * OIC_JSON_OWNED_NAME;
extern const char * OIC_JSON_OXM_NAME;
extern const char * OIC_JSON_OXMS_NAME;
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
extern const char * OIC_JSON_MOM_NAME;
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
extern const char * OIC_JSON_OXM_TYPE_NAME;
extern const char * OIC_JSON_OXM_SEL_NAME;
extern const char * OIC_JSON_DEVICE_ID_FORMAT_NAME;
extern const char * OIC_JSON_RT_NAME;
extern const char * OIC_JSON_IF_NAME;
extern const char * OIC_JSON_ROWNERID_NAME;
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
extern const char * OIC_JSON_EOWNERID_NAME;
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
extern const char * OIC_JSON_ENCODING_NAME;
extern const char * OIC_JSON_DATA_NAME;
extern const char * OIC_JSON_SEC_V_NAME;
extern const char * OXM_JUST_WORKS;
extern const char * OXM_RANDOM_DEVICE_PIN;
extern const char * OXM_MANUFACTURER_CERTIFICATE;
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
extern const char * OXM_PRECONF_PIN;
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
extern const char * OIC_SEC_ENCODING_BASE64;
extern const char * OIC_SEC_ENCODING_RAW;
*/
OCStackResult InputPin(char* pinBuffer, size_t bufferSize);
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
/**
* Function to save the Pre-configured PIN.
*
const unsigned char *UNUSED1, size_t UNUSED2,
unsigned char *result, size_t result_length);
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
/**
* This internal callback is used while Random PIN based MOT.
* This callback will be used to establish a temporary secure session according to
const unsigned char *UNUSED1, size_t UNUSED2,
unsigned char *result, size_t result_length);
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
/**
SECURITY_MANAGEMENT_SERVICES = (0x1 << 3),
PROVISION_CREDENTIALS = (0x1 << 4),
PROVISION_ACLS = (0x1 << 5),
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
TAKE_SUB_OWNER = (0x1 << 6),
#endif
// << 7 THROUGH 15 RESERVED
OIC_MANUFACTURER_CERTIFICATE = 0x2,
OIC_DECENTRALIZED_PUBLIC_KEY = 0x3,
OIC_OXM_COUNT,
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
OIC_PRECONFIG_PIN = 0xFF00,
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
}OicSecOxm_t;
typedef enum
OIC_ENCODING_DER = 4
}OicEncodingType_t;
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
typedef enum
{
MOT_STATUS_READY = 0,
MOT_STATUS_IN_PROGRESS = 1,
MOT_STATUS_DONE = 2,
}MotStatus_t;
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
/*
* oic.sec.mom type definition
typedef struct OicUuid OicUuid_t; //TODO is UUID type defined elsewhere?
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
typedef struct OicSecSubOwner OicSecSubOwner_t;
typedef struct OicSecMom OicSecMom_t;
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
#if defined(__WITH_DTLS__) || defined(__WITH_TLS__)
OicSecRsrc_t *resources; // 1:R:M:Y:Resource
uint16_t permission; // 2:R:S:Y:UINT16
OicSecValidity_t *validities; // 3:R:M:N:Time-interval
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
OicUuid_t* eownerID; //4:R:S:N:oic.uuid
#endif
OicSecAce_t *next;
OicSecKey_t privateData; // 6:R:S:N:oic.sec.key
char *period; // 7:R:S:N:String
OicUuid_t rownerID; // 8:R:S:Y:oic.uuid
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
OicUuid_t *eownerID; //9:R:S:N:oic.uuid
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
OicSecCred_t *next;
};
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
struct OicSecSubOwner {
OicUuid_t uuid;
MotStatus_t status;
struct OicSecMom{
OicSecMomType_t mode;
};
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
/**
* /oic/sec/doxm (Device Owner Transfer Methods) data type
OicUuid_t deviceID; // 6:R:S:Y:oic.uuid
bool dpc; // 7:R:S:Y:Boolean
OicUuid_t owner; // 8:R:S:Y:oic.uuid
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
OicSecSubOwner_t* subOwners; //9:R/W:M:N:oic.uuid
OicSecMom_t *mom; //10:R/W:S:N:oic.sec.mom
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
OicUuid_t rownerID; // 11:R:S:Y:oic.uuid
};
provisioning_env.AppendUnique(CPPDEFINES = ['TB_LOG'])
if provisioning_env.get('MULTIPLE_OWNER') == '1':
- provisioning_env.AppendUnique(CPPDEFINES=['_ENABLE_MULTIPLE_OWNER_'])
+ provisioning_env.AppendUnique(CPPDEFINES=['MULTIPLE_OWNER'])
######################################################################
# Source files and Targets
#include "octypes.h"\r
#include "pmtypes.h"\r
#include "ownershiptransfermanager.h"\r
-#ifdef _ENABLE_MULTIPLE_OWNER_\r
+#ifdef MULTIPLE_OWNER\r
#include "securevirtualresourcetypes.h"\r
-#endif //_ENABLE_MULTIPLE_OWNER_\r
+#endif //MULTIPLE_OWNER\r
\r
#ifdef __cplusplus\r
extern "C" {\r
*/\r
OCStackResult OCSetOxmAllowStatus(const OicSecOxm_t oxm, const bool allowStatus);\r
\r
-#ifdef _ENABLE_MULTIPLE_OWNER_\r
+#ifdef MULTIPLE_OWNER\r
/**\r
* API to perfrom multiple ownership transfer for MOT enabled device.\r
*\r
OCStackResult OCDoMultipleOwnershipTransfer(void* ctx,\r
OCProvisionDev_t *targetDevices,\r
OCProvisionResultCB resultCallback);\r
-#endif //_ENABLE_MULTIPLE_OWNER_\r
+#endif //MULTIPLE_OWNER\r
\r
/**\r
* API to register for particular OxM.\r
*/\r
OCStackResult OCDiscoverOwnedDevices(unsigned short timeout, OCProvisionDev_t **ppList);\r
\r
-#ifdef _ENABLE_MULTIPLE_OWNER_\r
+#ifdef MULTIPLE_OWNER\r
/**\r
* The function is responsible for discovery of MOT enabled device is current subnet.\r
*\r
* @return OC_STACK_OK in case of success and other value otherwise.\r
*/\r
OCStackResult OCDiscoverMultipleOwnedDevices(unsigned short timeout, OCProvisionDev_t **ppList);\r
-#endif //_ENABLE_MULTIPLE_OWNER_\r
+#endif //MULTIPLE_OWNER\r
\r
/**\r
* API to provision credentials between two devices and ACLs for the devices who act as a server.\r
const OCProvisionDev_t *pDev2,\r
OCProvisionResultCB resultCallback);\r
\r
-#ifdef _ENABLE_MULTIPLE_OWNER_\r
+#ifdef MULTIPLE_OWNER\r
/**\r
* API to provision preconfigured PIN to device(NOT LIST).\r
* If device does not support the Preconfigured PIN OxM,\r
*/\r
OCStackResult OCSelectMOTMethod(void *ctx, const OCProvisionDev_t *targetDeviceInfo,\r
const OicSecOxm_t oxmSelValue, OCProvisionResultCB resultCallback);\r
-#endif //_ENABLE_MULTIPLE_OWNER_\r
+#endif //MULTIPLE_OWNER\r
\r
/**\r
* Function to unlink devices.\r
*/
OCStackResult PMDeviceDiscovery(unsigned short waittime, bool isOwned, OCProvisionDev_t **ppList);
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
/**
* Discover multiple OTM enabled devices in the same IP subnet.
*
* @return OC_STACK_OK on success otherwise error.
*/
OCStackResult PMMultipleOwnerDeviceDiscovery(unsigned short waittime, bool isMultipleOwned, OCProvisionDev_t **ppDevicesList);
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
/**
* This function deletes list of provision target devices
if env.get('MULTIPLE_OWNER') == '1':
- provisioning_env.AppendUnique(CPPDEFINES = ['_ENABLE_MULTIPLE_OWNER_'])
+ provisioning_env.AppendUnique(CPPDEFINES = ['MULTIPLE_OWNER'])
provisioning_env.AppendUnique(CPPDEFINES = ['TB_LOG'])
#define _10_DISCOV_ALL_DEVS_ 10
#define _11_DISCOV_UNOWN_DEVS_ 11
#define _12_DISCOV_OWN_DEVS_ 12
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
#define _13_MOT_DISCOV_DEV_ 13
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
#define _20_REGIST_DEVS_ 20
#define _30_PROVIS_PAIR_DEVS_ 30
#define _31_PROVIS_CRED_ 31
#define _52_RESET_SELEC_DEV_ 52
#define _60_GET_CRED_ 60
#define _61_GET_ACL_ 61
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
#define _70_MOT_CHANGE_MOM_ 70
#define _71_MOT_PROV_PRECONF_PIN_ 71
#define _72_MOT_OXM_SEL_ 72
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
#define _80_SELECT_PROTOCOL_ 80
#define _99_EXIT_PRVN_CLT_ 99
static OCProvisionDev_t* g_unown_list;
static int g_own_cnt;
static int g_unown_cnt;
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
static OCProvisionDev_t* g_mot_enable_list;
static int g_mot_enable_cnt;
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
static bool g_doneCB;
#ifdef __WITH_TLS__
g_doneCB = true;
}
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
static void updateDoxmForMOTCB(void* ctx, int nOfRes, OCProvisionResult_t* arr, bool hasError)
{
if(!hasError)
}
g_doneCB = true;
}
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
static void inputPinCB(char* pin, size_t len)
{
return 0;
}
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
static int discoverMOTEnabledDevices(void)
{
// delete owned device list before updating it
return 0;
}
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
static int registerDevices(void)
{
return 0;
}
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
static int changeMultipleOwnershipTrnasferMode(void)
{
// check |own_list| for removing device
return 0;
}
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
static int resetDevice(void)
{
printf("** [A] DISCOVER DEVICES ON NETWORK\n");
printf("** 10. Discover All Un/Owned Devices on Network\n");
printf("** 11. Discover Only Unowned Devices on Network\n");
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
printf("** 12. Discover Only Owned Devices on Network\n");
printf("** 13. Discover Multiple Ownership Transfer Enabled Devices on Network\n\n");
#else
printf("** 12. Discover Only Owned Devices on Network\n\n");
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
printf("** [B] REGISTER/OWN ALL DISCOVERED UNOWNED DEVICES\n");
printf("** 20. Register/Own All Discovered Unowned Devices\n\n");
printf("** 60. Get the Credential resources of the Selected Device\n");
printf("** 61. Get the ACL resources of the Selected Device\n\n");
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
printf("** [G] UPDATE THE MULTIPLE OWNERSHIP TRANSFER RELATED VALUE\n");
printf("** 70. Change the Multiple Ownership transfer MODE(update mom)\n");
printf("** 71. Provision Preconfigured PIN\n");
printf("** 72. Change the Multiple Ownership transfer METHOD(update oxmsel)\n\n");
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
#ifdef __WITH_TLS__
printf("** [H] SELECT SECURE PROTOCOL DTLS/TLS\n");
OIC_LOG(WARNING, TAG, "Failed to disable OIC_DECENTRALIZED_PUBLIC_KEY OxM");
}
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
SetPreconfigPin("12341234", 8);
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
// main loop for provisioning manager
int mn_num = 0;
OIC_LOG(ERROR, TAG, "_12_DISCOV_OWN_DEVS_: error");
}
break;
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
case _13_MOT_DISCOV_DEV_:
if(discoverMOTEnabledDevices())
{
OIC_LOG(ERROR, TAG, "_13_MOT_DISCOV_DEV_: error");
}
break;
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
case _20_REGIST_DEVS_:
if(registerDevices())
{
OIC_LOG(ERROR, TAG, "_61_GET_ACL_: error");
}
break;
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
case _70_MOT_CHANGE_MOM_:
if(changeMultipleOwnershipTrnasferMode())
{
OIC_LOG(ERROR, TAG, "_72_MOT_OXM_SEL_: error");
}
break;
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
#ifdef __WITH_TLS__
case _80_SELECT_PROTOCOL_:
selectSecureProtocol();
}
OCDeleteDiscoveredDevices(g_own_list); // after here |g_own_list| points nothing
OCDeleteDiscoveredDevices(g_unown_list); // after here |g_unown_list| points nothing
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
OCDeleteDiscoveredDevices(g_mot_enable_list); // after here |g_motdev_list| points nothing
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
if(g_svr_fname)
{
}
}
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
#include <assert.h>
#include <thread>
g_LoopFlag = false;
oc_process_thread->join();
}
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
OCRepPayload* getPayload(const char* uri, int64_t power, bool state)
{
OIC_LOG(INFO, TAG, "Entering ocserver main loop...");
signal(SIGINT, handleSigInt);
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
StartOCProcessThread();
while(!gQuitFlag)
}
nanosleep(&timeout, NULL);
}
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
OIC_LOG(INFO, TAG, "Exiting ocserver main loop...");
// for error checking, the return value saved and printed
g_doneCB = false;
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
OCProvisionDev_t* dev = NULL;
LL_FOREACH(g_motdev_list, dev)
{
}
}
}
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
if(OC_STACK_OK != OCDoMultipleOwnershipTransfer(g_ctx, g_motdev_list, multipleOwnershipTransferCB))
{
#include "pmutility.h"
#include "srmutility.h"
#include "ownershiptransfermanager.h"
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
#include "multipleownershiptransfermanager.h"
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
#include "oic_malloc.h"
#include "logger.h"
#include "secureresourceprovider.h"
};
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
typedef struct ProvPreconfPINCtx ProvPreconfPINCtx_t;
struct ProvPreconfPINCtx
{
size_t pinLen;
OCProvisionResultCB resultCallback;
};
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
/**
* The function is responsible for initializaton of the provisioning manager. It will load
return PMDeviceDiscovery(timeout, true, ppList);
}
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
/**
* The function is responsible for discovery of MOT enabled device is current subnet.
*
}
return MOTDoOwnershipTransfer(ctx, targetDevices, resultCallback);
}
-#endif //_ENABLE_MULTIPLE_OWNER_
+
+#endif //MULTIPLE_OWNER
/**
* API to register for particular OxM.
return SRPProvisionDirectPairing(ctx, selectedDeviceInfo, pconf, resultCallback);
}
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
static void AddPreconfPinOxMCB(void* ctx, int nOfRes, OCProvisionResult_t *arr, bool hasError)
{
ProvPreconfPINCtx_t* provCtx = (ProvPreconfPINCtx_t*)ctx;
*/
return MOTAddMOTMethod((void*)provCtx, targetDeviceInfo, OIC_PRECONFIG_PIN, AddPreconfPinOxMCB);
}
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
/*
* Function to unlink devices.
FreePdAclList(pPdAcl);
}
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
/**
* API to update 'doxm.mom' to resource server.
*
{
return MOTSelectMOTMethod(ctx, targetDeviceInfo, oxmSelValue, resultCallback);
}
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
#if defined(__WITH_DTLS__) || defined(__WITH_TLS__)
/**
#include "oxmjustworks.h"
#include "oxmrandompin.h"
#include "oxmmanufacturercert.h"
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
#include "oxmpreconfpin.h"
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
#include "otmcontextlist.h"
#include "pmtypes.h"
#include "pmutility.h"
OIC_LOG(INFO, TAG, "IN OTMSetOTCallback");
VERIFY_NON_NULL(TAG, callbacks, ERROR);
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
VERIFY_SUCCESS(TAG, (OIC_OXM_COUNT > oxm || OIC_PRECONFIG_PIN == oxm), ERROR);
#else
VERIFY_SUCCESS(TAG, (OIC_OXM_COUNT > oxm), ERROR);
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
switch(oxm)
{
case OIC_DECENTRALIZED_PUBLIC_KEY:
OIC_LOG(ERROR, TAG, "OIC_DECENTRALIZED_PUBLIC_KEY not supported yet.");
return OC_STACK_INVALID_METHOD;
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
case OIC_PRECONFIG_PIN:
callbacks->loadSecretCB = LoadPreconfigPinCodeCallback;
callbacks->createSecureSessionCB = CreateSecureSessionPreconfigPinCallback;
callbacks->createSelectOxmPayloadCB = CreatePreconfigPinBasedSelectOxmPayload;
callbacks->createOwnerTransferPayloadCB = CreatePreconfigPinBasedOwnerTransferPayload;
break;
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
default:
OIC_LOG_V(ERROR, TAG, "Unknown OxM : %d", (int)oxm);
return OC_STACK_INVALID_PARAM;
res = OC_STACK_ERROR;
}
}
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
//in case of MOT
else if(true == otmCtx->selectedDeviceInfo->doxm->owned &&
otmCtx->selectedDeviceInfo->doxm->mom &&
res = OC_STACK_ERROR;
}
}
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
//Set the device id to derive temporal PSK
SetUuidForPinBasedOxm(&(otmCtx->selectedDeviceInfo->doxm->deviceID));
res = OC_STACK_ERROR;
}
}
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
//in case of MOT
else if(otmCtx->selectedDeviceInfo->doxm->owned &&
otmCtx->selectedDeviceInfo->doxm->mom &&
res = OC_STACK_ERROR;
}
}
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
//Set the device id to derive temporal PSK
SetUuidForPinBasedOxm(&(otmCtx->selectedDeviceInfo->doxm->deviceID));
return res;
}
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
static OCStackApplicationResult MOTDeviceDiscoveryHandler(void *ctx, OCDoHandle UNUSED,
OCClientResponse *clientResponse)
{
return res;
}
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
static OCStackResult SecurePortDiscovery(DiscoveryInfo* discoveryInfo,
const OCClientResponse *clientResponse)
sptest_env.AppendUnique(CPPDEFINES = ['TB_LOG'])
if sptest_env.get('MULTIPLE_OWNER') == '1':
- sptest_env.AppendUnique(CPPDEFINES=['_ENABLE_MULTIPLE_OWNER_'])
+ sptest_env.AppendUnique(CPPDEFINES=['MULTIPLE_OWNER'])
if target_os in ['msys_nt', 'windows']:
sptest_env.AppendUnique(LIBS = ['ws2_32',
#include "oxmmanufacturercert.h"
#include "securevirtualresourcetypes.h"
#include "provisioningdatabasemanager.h"
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
#include "multipleownershiptransfermanager.h"
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
#include "srmutility.h"
#include "doxmresource.h"
#include "pmtypes.h"
static const char* g_otmCtx = "Test User Context";
static OCProvisionDev_t* g_unownedDevices = NULL;
static OCProvisionDev_t* g_ownedDevices = NULL;
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
static OCProvisionDev_t* g_motEnabledDevices = NULL;
static OCProvisionDev_t* g_multiplOwnedDevices = NULL;
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
static void GetCurrentWorkingDirectory(char* buf, size_t bufsize)
{
g_doneCB = true;
}
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
static void updateDoxmForMOTCB(void* ctx, int nOfRes, OCProvisionResult_t* arr, bool hasError)
{
if(!hasError)
g_callbackResult = !hasError;
g_doneCB = true;
}
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
// callback function(s) for provisioning client using C-level provisioning API
static void removeDeviceCB(void* ctx, int UNUSED1, OCProvisionResult_t* UNUSED2, bool hasError)
EXPECT_EQ(OC_STACK_OK, result);
}
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
TEST(RegisterPreconfiguredPIN, NullParam)
{
OCStackResult result = SetPreconfigPin("12341234", strlen("12341234"));
EXPECT_TRUE(NULL != g_multiplOwnedDevices);
}*/
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
TEST(PerformRemoveDevice, NullParam)
{
validity = NULL;
}
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
OICFree(ace->eownerID);
#endif
}
}
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
if (ace->eownerID)
{
if (NULL == newAce->eownerID)
}
}
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
if(ace->eownerID)
{
aclMapSize++;
}
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
cborEncoderResult = cbor_encoder_create_map(&acesArray, &oicSecAclMap, aclMapSize);
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Creating ACES Map");
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Closing Validities Array.");
}
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
// Eownerid -- Not Mandatory
if(ace->eownerID)
{
OICFree(eowner);
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Addding eownerId Value.");
}
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
cborEncoderResult = cbor_encoder_close_container(&acesArray, &oicSecAclMap);
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Closing ACES Map.");
}
}
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
// eowner uuid -- Not Mandatory
if (strcmp(name, OIC_JSON_EOWNERID_NAME) == 0)
{
OICFree(eowner);
VERIFY_SUCCESS(TAG, OC_STACK_OK == ret , ERROR);
}
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
OICFree(name);
}
return acl;
}
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
bool IsValidAclAccessForSubOwner(const OicUuid_t* uuid, const uint8_t *cborPayload, const size_t size)
{
bool retValue = false;
return retValue;
}
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
/**
* This method removes ACE for the subject and resource from the ACL
return false;
}
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
static bool IsSameEowner(OicUuid_t* eowner1, OicUuid_t* eowner2)
{
if (NULL != eowner1 && NULL != eowner2)
return false;
}
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
if(false == IsSameEowner(ace1->eownerID, ace2->eownerID))
{
return false;
//Clean Period
OICFree(cred->period);
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
//Clean eowner
OICFree(cred->eownerID);
#endif
}
#if defined(__WITH_DTLS__) || defined(__WITH_TLS__)
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
if(cred->eownerID)
{
mapSize++;
}
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
if (SIGNED_ASYMMETRIC_KEY == cred->credType && cred->publicData.data)
{
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding Period Name Value.");
}
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
// Eownerid -- Not Mandatory
if(cred->eownerID)
{
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Addding eownerId Value.");
OICFree(eowner);
}
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
cborEncoderResult = cbor_encoder_close_container(&credArray, &credMap);
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Closing Cred Map.");
VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding Period.");
}
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
// Eowner uuid -- Not Mandatory
if (strcmp(OIC_JSON_EOWNERID_NAME, name) == 0 && cbor_value_is_text_string(&credMap))
{
OICFree(eowner);
VERIFY_SUCCESS(TAG, OC_STACK_OK == ret , ERROR);
}
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
if (cbor_value_is_valid(&credMap))
{
return ret;
}
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
bool IsValidCredentialAccessForSubOwner(const OicUuid_t* uuid, const uint8_t *cborPayload, size_t size)
{
OicSecCred_t* cred = NULL;
return isValidCred;
}
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
OicSecCred_t * GenerateCredential(const OicUuid_t * subject, OicSecCredType_t credType,
const OicSecCert_t * publicData, const OicSecKey_t* privateData,
VERIFY_NON_NULL(TAG, rownerID, ERROR);
memcpy(&cred->rownerID, rownerID, sizeof(OicUuid_t));
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
if(eownerID)
{
cred->eownerID = (OicUuid_t*)OICCalloc(1, sizeof(OicUuid_t));
VERIFY_NON_NULL(TAG, cred->eownerID, ERROR);
memcpy(cred->eownerID->id, eownerID->id, sizeof(eownerID->id));
}
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
ret = OC_STACK_OK;
}
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
/**
* Internal function to fill private data of SubOwner PSK.
*
OICFree(b64Buf);
return false;
}
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
#endif // __WITH_DTLS__ or __WITH_TLS__
static OCEntityHandlerResult HandlePostRequest(OCEntityHandlerRequest * ehRequest)
}
}
}
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
// In case SubOwner Credential
else if(doxm && doxm->owned && doxm->mom &&
OIC_MULTIPLE_OWNER_DISABLE != doxm->mom->mode &&
}
}
}
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
else
{
if(IsEmptyCred(cred))
}
OIC_LOG(DEBUG, TAG, "Can not find subject matched credential.");
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
const OicSecDoxm_t* doxm = GetDoxmResourceData();
if(doxm && doxm->mom && OIC_MULTIPLE_OWNER_DISABLE != doxm->mom->mode)
{
}
}
}
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
}
break;
}
{.id = {0}}, /* OicUuid_t deviceID */
false, /* bool dpc */
{.id = {0}}, /* OicUuid_t owner */
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
NULL, /* OicSecSubOwner_t sub-owner list */
NULL, /* OicSecMomType_t multiple owner mode */
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
{.id = {0}}, /* OicUuid_t rownerID */
};
//clean oxm
OICFree(doxm->oxm);
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
//clean mom
OICFree(doxm->mom);
OICFree(subowner);
}
}
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
//Clean doxm itself
OICFree(doxm);
strUuid = NULL;
}
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
//Device SubOwnerID -- Not Mandatory
if(doxm->subOwners)
{
cborEncoderResult = cbor_encode_int(&doxmMap, (int64_t)doxm->mom->mode);
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding mom Value.");
}
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
//devownerid -- Mandatory
cborEncoderResult = cbor_encode_text_string(&doxmMap, OIC_JSON_DEVOWNERID_NAME,
memcpy(doxm->owner.id, gDoxm->owner.id, sizeof(doxm->owner.id));
}
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
cborFindResult = cbor_value_map_find_value(&doxmCbor, OIC_JSON_MOM_NAME, &doxmMap);
if(CborNoError == cborFindResult && cbor_value_is_integer(&doxmMap))
{
LL_APPEND(doxm->subOwners, subOwnerId);
}
}
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
cborFindResult = cbor_value_map_find_value(&doxmCbor, OIC_JSON_ROWNERID_NAME, &doxmMap);
if (CborNoError == cborFindResult && cbor_value_is_text_string(&doxmMap))
bool bDeviceIDMatch = false; // does 'deviceid' query matches with doxm.deviceid ?
bool bInterfaceQry = false; // does querystring contains 'if' query ?
bool bInterfaceMatch = false; // does 'if' query matches with oic.if.baseline ?
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
bool bMotQry = false; // does querystring contains 'mom' and 'owned' query ?
bool bMotMatch = false; // does 'mom' query value is not '0' && does query value matches with doxm.owned status?
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
OicParseQueryIter_t parseIter = {.attrPos = NULL};
}
}
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
if (strncasecmp((char *)parseIter.attrPos, OIC_JSON_MOM_NAME, strlen(OIC_JSON_MOM_NAME)) == 0)
{
bMotQry = true;
}
return bMotMatch;
}
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
if (strncasecmp((char *)parseIter.attrPos, OIC_JSON_DEVICE_ID_NAME, parseIter.attrLen) == 0)
{
}
}
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
return ((bOwnedQry ? bOwnedMatch : true) &&
(bDeviceIDQry ? bDeviceIDMatch : true) &&
(bMotQry ? bMotMatch : true));
#else
return ((bOwnedQry ? bOwnedMatch : true) &&
(bDeviceIDQry ? bDeviceIDMatch : true));
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
}
static OCEntityHandlerResult HandleDoxmGetRequest (const OCEntityHandlerRequest * ehRequest)
dst->owned = src->owned;
}
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
if(src->mom)
{
OIC_LOG(DEBUG, TAG, "dectected 'mom' property");
}
}
}
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
}
}
#if defined(__WITH_DTLS__) || defined (__WITH_TLS__)
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
/**
* Callback function to handle MOT DTLS handshake result.
* @param[out] object remote device information.
OIC_LOG(DEBUG, TAG, "OUT MultipleOwnerDTLSHandshakeCB");
}
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
#endif // defined(__WITH_DTLS__) || defined (__WITH_TLS__)
/**
updateWriteableProperty(newDoxm, gDoxm);
#if defined(__WITH_DTLS__) || defined (__WITH_TLS__)
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
//handle mom
if(gDoxm->mom)
{
LL_APPEND(gDoxm->subOwners, subowner);
}
}
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
#endif // defined(__WITH_DTLS__) || defined (__WITH_TLS__)
//Update new state in persistent storage
return gDoxm;
}
-#if defined(__WITH_DTLS__) && defined(_ENABLE_MULTIPLE_OWNER_)
+#if defined(__WITH_DTLS__) && defined(MULTIPLE_OWNER)
/**
* Internal API to prepare MOT
*/
exit:
OIC_LOG(WARNING, TAG, "Error in PrepareMOT");
}
-#endif //defined(__WITH_DTLS__) && defined(_ENABLE_MULTIPLE_OWNER_)
+#endif //defined(__WITH_DTLS__) && defined(MULTIPLE_OWNER)
OCStackResult InitDoxmResource()
{
}
OICFree(data);
-#if defined(__WITH_DTLS__) && defined(_ENABLE_MULTIPLE_OWNER_)
+#if defined(__WITH_DTLS__) && defined(MULTIPLE_OWNER)
//if MOT is enabled, MOT should be prepared.
if(gDoxm && gDoxm->owned)
{
PrepareMOT(gDoxm);
}
-#endif // defined(__WITH_DTLS__) && defined(_ENABLE_MULTIPLE_OWNER_)
+#endif // defined(__WITH_DTLS__) && defined(MULTIPLE_OWNER)
return ret;
}
return retVal;
}
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
/**
* Compare the UUID to SubOwner.
*
}
return retVal;
}
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
/**
* Function to restore doxm resurce to initial status.
return OC_STACK_OK;
}
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
OCStackResult SetPreconfigPin(const char *pinBuffer, size_t pinLength)
{
if(NULL == pinBuffer || OXM_PRECONFIG_PIN_MAX_SIZE < pinLength)
return OC_STACK_OK;
}
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
#ifdef __WITH_DTLS__
return ret;
}
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
int32_t GetDtlsPskForMotRandomPinOxm( CADtlsPskCredType_t type,
const unsigned char *UNUSED1, size_t UNUSED2,
unsigned char *result, size_t result_length)
return ret;
}
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
#endif //__WITH_DTLS__
}
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
/**
* Compare the request's subject to SubOwner.
*
return isValidRequest;
}
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
// TODO - remove these function placeholders as they are implemented
{
context->retVal = ACCESS_GRANTED;
}
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
//Then check if request from SubOwner
else if(IsRequestFromSubOwner(context))
{
context->retVal = ACCESS_GRANTED;
}
}
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
// If not granted via DevOwner status and not a subowner,
// then check if request is for a SVR and coming from rowner
else if (IsRequestFromResourceOwner(context))
}
}
}
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
/*
* In case of ACL and CRED, The payload required to verify the payload.
* Payload information will be used for subowner's permission verification.
*/
g_policyEngineContext.payload = (uint8_t*)requestInfo->info.payload;
g_policyEngineContext.payloadSize = requestInfo->info.payloadSize;
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
//New request are only processed if the policy engine state is AWAITING_REQUEST.
if (AWAITING_REQUEST == g_policyEngineContext.state)
const char * OIC_JSON_OWNERS_NAME = "ownrs";
const char * OIC_JSON_OWNER_NAME = "ownr";
const char * OIC_JSON_DEVOWNERID_NAME = "devowneruuid";
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
const char * OIC_JSON_SUBOWNERID_NAME = "subowneruuid";
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
const char * OIC_JSON_OWNED_NAME = "owned";
const char * OIC_JSON_OXM_NAME = "oxm";
const char * OIC_JSON_OXMS_NAME = "oxms";
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
const char * OIC_JSON_MOM_NAME = "mom";
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
const char * OIC_JSON_OXM_TYPE_NAME = "oxmtype";
const char * OIC_JSON_OXM_SEL_NAME = "oxmsel";
const char * OIC_JSON_DEVICE_ID_FORMAT_NAME = "didformat";
const char * OIC_JSON_RT_NAME = OC_RSRVD_RESOURCE_TYPE;
const char * OIC_JSON_IF_NAME = OC_RSRVD_INTERFACE;
const char * OIC_JSON_ROWNERID_NAME = "rowneruuid";
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
const char * OIC_JSON_EOWNERID_NAME = "eowneruuid";
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
const char * OIC_JSON_ENCODING_NAME = "encoding";
const char * OIC_JSON_DATA_NAME = "data";
const char * OIC_JSON_SEC_V_NAME = "secv";
const char * OXM_JUST_WORKS = "oic.sec.doxm.jw";
const char * OXM_RANDOM_DEVICE_PIN = "oic.sec.doxm.rdp";
const char * OXM_MANUFACTURER_CERTIFICATE = "oic.sec.doxm.mfgcert";
-#ifdef _ENABLE_MULTIPLE_OWNER_
-const char * OXM_PRECONF_PIN = "oic.sec.doxm.pcp";
-#endif //_ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
+const char * OXM_PRECONF_PIN = "oic.sec..doxm.pcp";
+#endif //MULTIPLE_OWNER
//Credential data encoding methods
const char * OIC_SEC_ENCODING_BASE64 = "oic.sec.encoding.base64";
return OXM_RANDOM_DEVICE_PIN;
case OIC_MANUFACTURER_CERTIFICATE:
return OXM_MANUFACTURER_CERTIFICATE;
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
case OIC_PRECONFIG_PIN:
return OXM_PRECONF_PIN;
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
default:
return NULL;
}
doxm->owned = jsonObj->valueint;
}
-#ifdef _ENABLE_MULTIPLE_OWNER_
+#ifdef MULTIPLE_OWNER
//mom -- Not Mandatory
jsonObj = cJSON_GetObjectItem(jsonDoxm, OIC_JSON_MOM_NAME);
if (jsonObj)
VERIFY_NON_NULL(TAG, doxm->mom, ERROR);
doxm->mom->mode = (OicSecMomType_t)jsonObj->valueint;
}
-#endif //_ENABLE_MULTIPLE_OWNER_
+#endif //MULTIPLE_OWNER
//DeviceId -- Mandatory
jsonObj = cJSON_GetObjectItem(jsonDoxm, OIC_JSON_DEVICE_ID_NAME);
srmtest_env.AppendUnique(CPPDEFINES = ['TB_LOG'])
if srmtest_env.get('MULTIPLE_OWNER') == '1':
- srmtest_env.AppendUnique(CPPDEFINES=['_ENABLE_MULTIPLE_OWNER_'])
+ srmtest_env.AppendUnique(CPPDEFINES=['MULTIPLE_OWNER'])
if target_os == 'windows':
srmtest_env.AppendUnique(LINKFLAGS = ['/subsystem:CONSOLE'])
const OicUuid_t* deviceID,
std::shared_ptr<OCSecureResource> &foundDevice);
+#ifdef MULTIPLE_OWNER
+ /**
+ * API is responsible for discovery of MOT(Mutilple Owner Transfer)
+ * devices in current subnet.
+ *
+ * @param timeout Timeout in seconds, time until which function will listen to
+ * responses from server before returning the list of devices.
+ * @param list List of MOT enabled devices.
+ * @return ::OC_STACK_OK in case of success and other value otherwise.
+ */
+ static OCStackResult discoverMultipleOwnerEnabledDevices(unsigned short timeout,
+ DeviceList_t &list);
+
+ /**
+ * API is responsible for discovery of Multiple owned device in
+ * current subnet.
+ *
+ * @param timeout Timeout in seconds, time until which function will listen to
+ * responses from server before returning the list of devices.
+ * @param list List of Multiple Owned devices.
+ * @return ::OC_STACK_OK in case of success and other value otherwise.
+ */
+ static OCStackResult discoverMultipleOwnedDevices(unsigned short timeout,
+ DeviceList_t &list);
+
+#endif
+
/**
- * API for registering Ownership transfer methods for a particular transfer Type.
+ * API for registering Pin Callback.
*
- * @param oxm Ownership transfer method.
- * @param callbackData CallbackData Methods for ownership transfer.
- * @param inputPin Callback method to input pin for verification.
+ * @param InputPinCallback inputPin caaback function.
* @return ::OC_STACK_OK in case of success and other value otherwise.
*/
- static OCStackResult setOwnerTransferCallbackData(OicSecOxm_t oxm,
- OTMCallbackData_t* callbackData, InputPinCallback inputPin);
+ static OCStackResult setInputPinCallback(InputPinCallback inputPin);
/**
* API to get status of all the devices in current subnet. The status include endpoint
static void callbackWrapper(void* ctx, int nOfRes,
OCProvisionResult_t *arr, bool hasError);
+#ifdef MULTIPLE_OWNER
+ /**
+ * API to update 'doxm.oxmsel' to resource server.
+ *
+ * @param resultCallback Callback provided by API user, callback will be
+ * called when credential revocation is finished.
+ * @param oxmSelVal Method of multiple ownership transfer (ref. oic.sec.oxm)
+ * @return ::OC_STACK_OK in case of success and other value otherwise.
+ */
+ OCStackResult selectMOTMethod( const OicSecOxm_t oxmSelVal,
+ ResultCallBack resultCallback);
+
+ /**
+ * API to update 'doxm.mom' to resource server.
+ *
+ * @param resultCallback Callback provided by API user, callback will be
+ * called when credential revocation is finished.
+ * @param momType Mode of multiple ownership transfer (ref. oic.sec.mom)
+ * @return ::OC_STACK_OK in case of success and other value otherwise.
+ */
+ OCStackResult changeMOTMode( const OicSecMomType_t momType,
+ ResultCallBack resultCallback);
+
+ /**
+ * API to add preconfigured PIN to local SVR DB.
+ *
+ * @param preconfPIN Preconfig PIN which is used while multiple owner authentication
+ * @param preconfPINLength Byte length of preconfig PIN
+ * @return ::OC_STACK_OK in case of success and other value otherwise.
+ */
+ OCStackResult addPreconfigPIN(const char* preconfPIN,
+ size_t preconfPINLength);
+
+ /**
+ * API to provision preconfigured PIN.
+ *
+ * @param resultCallback Callback provided by API user, callback will be called when
+ * credential revocation is finished.
+ * @param preconfPin Preconfig PIN which is used while multiple owner authentication
+ * @param preconfPinLength Byte length of preconfig PIN
+ * @return ::OC_STACK_OK in case of success and other value otherwise.
+ */
+ OCStackResult provisionPreconfPin(const char * preconfPin,
+ size_t preconfPinLength, ResultCallBack resultCallback);
+
+ /**
+ * API to do multiple ownership transfer for MOT enabled device.
+ *
+ * @param resultCallback Result callback function to be invoked when
+ * multiple ownership transfer finished.
+ * @return ::OC_STACK_OK in case of success and other value otherwise.
+ */
+ OCStackResult doMultipleOwnershipTransfer(ResultCallBack resultCallback);
+
+#endif // MULTIPLE_OWNER
+
private:
void validateSecureResource();
};
if target_os == 'tizen':
examples_env.AppendUnique(CPPDEFINES = ['__TIZEN__'])
-
+if examples_env.get('MULTIPLE_OWNER') == '1':
+ examples_env.AppendUnique(CPPDEFINES = ['MULTIPLE_OWNER'])
######################################################################
# Source files and Targets
######################################################################
provisioningclient = examples_env.Program('provisioningclient', 'provisioningclient.cpp')
+if examples_env.get('MULTIPLE_OWNER') == '1':
+ subownerclient = examples_env.Program('subownerclient', 'subownerclient.cpp')
if examples_env.get('WITH_TCP') == True:
cloudClient = examples_env.Program('cloudClient',['cloudClient.cpp', 'cloudAuth.cpp', 'cloudWrapper.cpp'])
clientjson = examples_env.Install(svr_db_build_dir, svr_db_src_dir + 'oic_svr_db_client.json')
clientdat = examples_env.Install(svr_db_build_dir, svr_db_src_dir + 'oic_svr_db_client.dat')
+if examples_env.get('MULTIPLE_OWNER') == '1':
+ subownerclientdat = examples_env.Install(svr_db_build_dir,
+ svr_db_src_dir + 'oic_svr_db_subowner_client.dat')
+ Alias("subowner", [subownerclientdat, subownerclient])
+ examples_env.AppendTarget("subowner")
+
if examples_env.get('WITH_TCP') == True:
clouddat = examples_env.Install(svr_db_build_dir,
svr_db_src_dir + 'cloud.dat')
--- /dev/null
+{\r
+ "acl": {\r
+ "aclist": {\r
+ "aces": [\r
+ {\r
+ "subjectuuid": "*",\r
+ "resources": [\r
+ {\r
+ "href": "/oic/res",\r
+ "rel": "",\r
+ "rt": ["oic.wk.res"],\r
+ "if": ["oic.if.ll"]\r
+ },{\r
+ "href": "/oic/d",\r
+ "rel": "",\r
+ "rt": ["oic.wk.d"],\r
+ "if": ["oic.if.baseline", "oic.if.r"]\r
+ },{\r
+ "href": "/oic/p",\r
+ "rel": "",\r
+ "rt": ["oic.wk.p"],\r
+ "if": ["oic.if.baseline", "oic.if.r"]\r
+ }\r
+ ],\r
+ "permission": 2\r
+ },\r
+ {\r
+ "subjectuuid": "*",\r
+ "resources": [\r
+ {\r
+ "href": "/oic/sec/doxm",\r
+ "rel": "",\r
+ "rt": ["oic.r.doxm"],\r
+ "if": ["oic.if.baseline"]\r
+ },\r
+ {\r
+ "href": "/oic/sec/pstat",\r
+ "rel": "",\r
+ "rt": ["oic.r.pstat"],\r
+ "if": ["oic.if.baseline"]\r
+ }\r
+ ],\r
+ "permission": 2\r
+ },\r
+ {\r
+ "subjectuuid": "*",\r
+ "resources": [\r
+ {\r
+ "href": "/oic/sec/pconf",\r
+ "rel": "",\r
+ "rt": ["oic.r.pconf"],\r
+ "if": ["oic.if.baseline"]\r
+ },\r
+ {\r
+ "href": "/oic/sec/dpairing",\r
+ "rel": "",\r
+ "rt": ["oic.r.dpairing"],\r
+ "if": ["oic.if.baseline"]\r
+ }\r
+ ],\r
+ "permission": 2\r
+ }\r
+ ]\r
+ },\r
+ "rowneruuid" : "5375624F-776E-6572-436C-69656E743030"\r
+ },\r
+ "pstat": {\r
+ "isop": true,\r
+ "cm": 0,\r
+ "tm": 0,\r
+ "om": 3,\r
+ "sm": 3,\r
+ "deviceuuid": "5375624F-776E-6572-436C-69656E743030",\r
+ "rowneruuid": "5375624F-776E-6572-436C-69656E743030"\r
+ },\r
+ "doxm": {\r
+ "oxms": [0],\r
+ "oxmsel": 0,\r
+ "sct": 1,\r
+ "owned": true,\r
+ "deviceuuid": "5375624F-776E-6572-436C-69656E743030",\r
+ "devowneruuid": "5375624F-776E-6572-436C-69656E743030",\r
+ "rowneruuid": "5375624F-776E-6572-436C-69656E743030"\r
+ }\r
+}\r
using namespace OC;
-DeviceList_t pUnownedDevList, pOwnedDevList;
+DeviceList_t pUnownedDevList, pOwnedDevList, pMOTEnabledDeviceList;
static int transferDevIdx, ask = 1;
static OicSecPconf_t g_pconf;
static uint16_t g_credId = 0;
std::cout << " 14. Provision the Trust Cert. Chain"<<std::endl;
std::cout << " 15. Read trust cert chain"<<std::endl;
#endif // __WITH_DTLS__ || __WITH_TLS__
+#ifdef MULTIPLE_OWNER
+ std::cout << " 16. Change Multiple Ownership Transfer Mode"<<std::endl;
+ std::cout << " 17. Select OxM method for Multiple Ownership Transfer"<<std::endl;
+ std::cout << " 18. Multiple Ownership Transfer Enabled Devices Discovery"<<std::endl;
+ std::cout << " 19. Provision pre configure PIN for Multiple Ownership Transfer Mode"<<std::endl;
+ std::cout << " 20. Add pre configure PIN for Multiple Ownership Transfer Mode"<<std::endl;
+#endif
std::cout << " 99. Exit loop"<<std::endl;
}
}
#endif // __WITH_DTLS__ or __WITH_TLS__
+#ifdef MULTIPLE_OWNER
+void MOTMethodCB(PMResultList_t *result, int hasError)
+{
+ if (hasError)
+ {
+ std::cout << "Error!!! in callback"<<std::endl;
+ }
+ else
+ {
+ std::cout<< "callback successfull"<<std::endl;
+ delete result;
+ }
+}
+#endif // MULTIPLE_OWNER
+
int main(void)
{
OCPersistentStorage ps {client_open, fread, fwrite, fclose, unlink };
//register callbacks for JUST WORKS and PIN methods
std::cout <<"Registering OTM Methods: 1. JUST WORKS and 2. PIN"<<std::endl;
-
- {
- OTMCallbackData_t justWorksCBData;
- justWorksCBData.loadSecretCB = LoadSecretJustWorksCallback;
- justWorksCBData.createSecureSessionCB =
- CreateSecureSessionJustWorksCallback;
- justWorksCBData.createSelectOxmPayloadCB =
- CreateJustWorksSelectOxmPayload;
- justWorksCBData.createOwnerTransferPayloadCB =
- CreateJustWorksOwnerTransferPayload;
- OCSecure::setOwnerTransferCallbackData(OIC_JUST_WORKS,
- &justWorksCBData, NULL);
- }
-
- {
- OTMCallbackData_t pinBasedCBData;
- pinBasedCBData.loadSecretCB = InputPinCodeCallback;
- pinBasedCBData.createSecureSessionCB =
- CreateSecureSessionRandomPinCallback;
- pinBasedCBData.createSelectOxmPayloadCB =
- CreatePinBasedSelectOxmPayload;
- pinBasedCBData.createOwnerTransferPayloadCB =
- CreatePinBasedOwnerTransferPayload;
- OCSecure::setOwnerTransferCallbackData(OIC_RANDOM_DEVICE_PIN,
- &pinBasedCBData, InputPinCB);
- }
+ OCSecure::setInputPinCallback(InputPinCB);
ask = 0;
std::cout << "Transfering ownership for : "<<
break;
}
#endif //__WITH_DTLS__ || __WITH_TLS__
+#ifdef MULTIPLE_OWNER
+ case 16:
+ {
+ if (!pOwnedDevList.size() && !pMOTEnabledDeviceList.size())
+ {
+ std::cout <<"Owned device list and MOT device list both are empty."<<std::endl;
+ break;
+ }
+ unsigned int dev_count = 0;
+ if (pOwnedDevList.size())
+ {
+ dev_count = pOwnedDevList.size();
+ printDevices(pOwnedDevList);
+ }
+
+ if (pMOTEnabledDeviceList.size())
+ {
+ dev_count += pMOTEnabledDeviceList.size();
+ for (unsigned int i = 0; i < pMOTEnabledDeviceList.size(); i++ )
+ {
+ std::cout << "Device ";
+ std::cout <<((dev_count - pMOTEnabledDeviceList.size())+ i + 1) ;
+ std::cout <<" ID : ";
+ std::cout << pMOTEnabledDeviceList[i]->getDeviceID()<<" From IP: ";
+ std::cout << pMOTEnabledDeviceList[i]->getDevAddr() << std::endl;
+ }
+ }
+
+ // select device
+ unsigned int dev_num = 0;
+ for( ; ; )
+ {
+ std::cout << "Enter Device Number, to change the mode: "<<std::endl;
+ std::cin >> dev_num;
+ if(0 < dev_num && dev_count >= dev_num)
+ {
+ break;
+ }
+ std::cout << " Entered Wrong Number. Please Enter Again"<<std::endl;
+ }
+
+ OicSecMomType_t momType = OIC_MULTIPLE_OWNER_ENABLE;
+ int mom = 0;
+ for( ; ; )
+ {
+ std::cout <<" 0. Disable Multiple Ownership Transfer"<<std::endl;
+ std::cout <<" 1. Enable Multiple Ownership Transfer "<<std::endl;
+ std::cout <<"> Enter Mode of Multiple Ownership Transfer :"<<std::endl;
+ for(int ret=0; 1!=ret; )
+ {
+ ret = scanf("%d", &mom);
+ for( ; 0x20<=getchar(); ); // for removing overflow garbages
+ // '0x20<=code' is character region
+ }
+ if(mom == 0)
+ {
+ momType = OIC_MULTIPLE_OWNER_DISABLE;
+ break;
+ }
+ if(mom == 1)
+ {
+ momType = OIC_MULTIPLE_OWNER_ENABLE;
+ break;
+ }
+ std::cout <<" Entered Wrong Number. Please Enter Again"<<std::endl;
+ }
+
+ if (!pOwnedDevList.size())
+ {
+ if(OC_STACK_OK != pMOTEnabledDeviceList[dev_num-1]->changeMOTMode(
+ (const OicSecMomType_t)momType,MOTMethodCB))
+ {
+ OIC_LOG(ERROR, TAG, "changeMOTMode API error");
+ }
+ }
+ else
+ {
+ if(dev_num <= pOwnedDevList.size())
+ {
+ if(OC_STACK_OK != pOwnedDevList[dev_num-1]->changeMOTMode(momType,
+ MOTMethodCB))
+ {
+ OIC_LOG(ERROR, TAG, "changeMOTMode API error");
+ }
+ }
+ else
+ {
+ if(OC_STACK_OK != pMOTEnabledDeviceList[(dev_num -
+ pOwnedDevList.size() - 1)]->changeMOTMode(momType,
+ MOTMethodCB))
+ {
+ OIC_LOG(ERROR, TAG, "changeMOTMode API error");
+ }
+ }
+ }
+ break;
+ }
+ case 17:
+ {
+ if (!pMOTEnabledDeviceList.size())
+ {
+ std::cout <<"Please discover the MOT device first. Use option 18"<<std::endl;
+ break;
+ }
+
+ printDevices(pMOTEnabledDeviceList);
+ // select device
+ unsigned int dev_num = 0;
+ for( ; ; )
+ {
+ std::cout << "Enter Device Number, for MOT Device: "<<std::endl;
+ std::cin >> dev_num;
+ if(0 < dev_num && pMOTEnabledDeviceList.size() >=dev_num)
+ {
+ break;
+ }
+ std::cout << " Entered Wrong Number. Please Enter Again"<<std::endl;
+ }
+
+ int oxm = 0;
+ OicSecOxm_t secOxm = OIC_PRECONFIG_PIN;
+ std::cout << "Select method for Multiple Ownership Transfer: "<<std::endl;
+ for( ; ; )
+ {
+ std::cout << " 0. Random PIN OxM "<<std::endl;
+ std::cout << " 1. Pre-Configured PIN OxM "<<std::endl;
+ std::cout << " > Enter Number of OxM for Multiple Ownership Transfer : "<<std::endl;
+ std::cin >> oxm;
+ if(0 == oxm)
+ {
+ secOxm = OIC_RANDOM_DEVICE_PIN;
+ break;
+ }
+ if(1 == oxm)
+ {
+ secOxm = OIC_PRECONFIG_PIN;
+ break;
+ }
+ std::cout << " Entered Wrong Number. Please Enter Again"<<std::endl;
+ }
+
+ if(OC_STACK_OK != pMOTEnabledDeviceList[dev_num-1]->selectMOTMethod((const OicSecOxm_t)secOxm,
+ MOTMethodCB))
+ {
+ OIC_LOG(ERROR, TAG, "selectMOTMethod API error");
+ }
+ break;
+ }
+ case 18:
+ {
+ pMOTEnabledDeviceList.clear();
+ std::cout << "Started MOT Enabled device discovery..." <<std::endl;
+ OCStackResult result = OCSecure::discoverMultipleOwnerEnabledDevices
+ (DISCOVERY_TIMEOUT, pMOTEnabledDeviceList);
+ if (result != OC_STACK_OK)
+ {
+ std::cout<< "!!Error - MOT Enabled dev Discovery failed."<<std::endl;
+ }
+ else if (pMOTEnabledDeviceList.size())
+ {
+ std::cout <<"Found MOT enabled devices, count = " <<
+ pMOTEnabledDeviceList.size() << std::endl;
+ printDevices(pMOTEnabledDeviceList);
+ }
+ else
+ {
+ std::cout <<"No MOT enabled Secure devices found"<<std::endl;
+ }
+ break;
+ }
+ case 19:
+ {
+ if (!pMOTEnabledDeviceList.size())
+ {
+ std::cout <<"Please discover the MOT device first. Use option 16"<<std::endl;
+ break;
+ }
+
+ printDevices(pMOTEnabledDeviceList);
+ // select device
+ unsigned int dev_num = 0;
+ for( ; ; )
+ {
+ std::cout << "Enter Device Number, for MOT Device: "<<std::endl;
+ std::cin >> dev_num;
+ if(0 < dev_num && pMOTEnabledDeviceList.size() >=dev_num)
+ {
+ break;
+ }
+ std::cout << " Entered Wrong Number. Please Enter Again"<<std::endl;
+ }
+
+ char preconfigPin[9] = {0};
+ std::cout << " > Input the 8 digit PreconfigPin (e.g. 12341234) :" <<std::endl;
+ for(int ret=0; 1!=ret; )
+ {
+ ret = scanf("%8s", preconfigPin);
+ for( ; 0x20<=getchar(); ); // for removing overflow garbages
+ // '0x20<=code' is character region
+ }
+ size_t preconfPinLength = strlen(preconfigPin);
+ if(OC_STACK_OK != pMOTEnabledDeviceList[dev_num-1]->provisionPreconfPin(preconfigPin,
+ preconfPinLength, MOTMethodCB))
+ {
+ OIC_LOG(ERROR, TAG, "provisionPreconfPin API error");
+ }
+ break;
+ }
+ case 20:
+ {
+ if (!pMOTEnabledDeviceList.size())
+ {
+ std::cout <<"Please discover the MOT device first. Use option 16"<<std::endl;
+ break;
+ }
+
+ printDevices(pMOTEnabledDeviceList);
+ // select device
+ unsigned int dev_num = 0;
+ for( ; ; )
+ {
+ std::cout << "Enter Device Number, for MOT Device: "<<std::endl;
+ std::cin >> dev_num;
+ if(0 < dev_num && pMOTEnabledDeviceList.size() >=dev_num)
+ {
+ break;
+ }
+ std::cout << " Entered Wrong Number. Please Enter Again"<<std::endl;
+ }
+
+ char preconfPIN[9] = {0};
+ std::cout << " > Input the 8 digit preconfPIN (e.g. 12341234) :" <<std::endl;
+ for(int ret=0; 1!=ret; )
+ {
+ ret = scanf("%8s", preconfPIN);
+ for( ; 0x20<=getchar(); ); // for removing overflow garbages
+ // '0x20<=code' is character region
+ }
+ size_t preconfPinLength = strlen(preconfPIN);
+ if(OC_STACK_OK != pMOTEnabledDeviceList[dev_num-1]->addPreconfigPIN(preconfPIN,
+ preconfPinLength))
+ {
+ OIC_LOG(ERROR, TAG, "addPreconfigPIN API error");
+ }
+ break;
+ }
+#endif //MULTIPLE_OWNER
case 99:
default:
out = 1;
--- /dev/null
+/* *****************************************************************
+ *
+ * Copyright 2016 Samsung Electronics All Rights Reserved.
+ *
+ *
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * *****************************************************************/
+
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <string>
+#include <map>
+#include <cstdlib>
+#include <pthread.h>
+#include <mutex>
+#include <condition_variable>
+
+#include "logger.h"
+#include "oic_malloc.h"
+#include "oic_string.h"
+#include "OCPlatform.h"
+#include "OCApi.h"
+#include "OCProvisioningManager.hpp"
+#include "oxmjustworks.h"
+#include "oxmrandompin.h"
+#include "aclresource.h"
+#include "utlist.h"
+
+#define MAX_PERMISSION_LENGTH (5)
+#define ACL_RESRC_ARRAY_SIZE (3)
+#define CREATE (1)
+#define READ (2)
+#define UPDATE (4)
+#define DELETE (8)
+#define NOTIFY (16)
+#define DASH '-'
+#define PREDEFINED_TIMEOUT (10)
+#define MAX_OWNED_DEVICE (10)
+#define TAG "subownerclient"
+
+#define JSON_DB_PATH "./oic_svr_db_subowner_client.json"
+#define DAT_DB_PATH "./oic_svr_db_subowner_client.dat"
+#define DEV_STATUS_ON "DEV_STATUS_ON"
+#define DEV_STATUS_OFF "DEV_STATUS_OFF"
+
+#define DISCOVERY_TIMEOUT 5
+
+using namespace OC;
+
+DeviceList_t pMOwnedDeviceList, pMOTEnabledDeviceList;
+static int transferDevIdx, ask = 1;
+
+static FILE* client_open(const char *UNUSED_PARAM, const char *mode)
+{
+ (void)UNUSED_PARAM;
+ return fopen(DAT_DB_PATH, mode);
+}
+
+void printMenu()
+{
+ std::cout << "\nChoose an option:"<<std::endl;
+ std::cout << " 1. Discover Multiple Ownership Transfer Enabled Devices"<<std::endl;
+ std::cout << " 2. Discover Multiple Owned Devices"<<std::endl;
+ std::cout << " 3. Perform the Multiple Ownership Transfer"<<std::endl;
+ std::cout << " 4. Get LED resource"<<std::endl;
+ std::cout << " 5. Get PUT resource"<<std::endl;
+ std::cout << " 99. Exit loop"<<std::endl;
+}
+
+void moveTransferredDevice()
+{
+ pMOwnedDeviceList.push_back(pMOTEnabledDeviceList[transferDevIdx]);
+ pMOTEnabledDeviceList.erase(pMOTEnabledDeviceList.begin() + transferDevIdx);
+}
+
+void InputPinCB(char* pinBuf, size_t bufSize)
+{
+ if(pinBuf)
+ {
+ std::cout <<"INPUT PIN : ";
+ std::string ptr;
+ std::cin >> ptr;
+ OICStrcpy(pinBuf, bufSize, ptr.c_str());
+ return;
+ }
+}
+
+void printUuid(OicUuid_t uuid)
+{
+ for (int i = 0; i < UUID_LENGTH; i++)
+ {
+ std::cout <<std::hex << uuid.id[i] << " ";
+ }
+ std::cout<<std::endl;
+}
+
+void multipleOwnershipTransferCB(PMResultList_t *result, int hasError)
+{
+ if (hasError)
+ {
+ std::cout << "Error!!! in MultipleOwnershipTransfer"<<std::endl;
+ }
+ else
+ {
+ std::cout<< "\nTransferred MultipleOwnership successfuly for device : ";
+ printUuid(result->at(0).deviceId);
+ delete result;
+
+ moveTransferredDevice();
+ }
+ ask = 1;
+}
+
+void printStatus(int status)
+{
+ static std::map<int, std::string> devStatus = {{1<<0, DEV_STATUS_ON}, {1<<1, DEV_STATUS_OFF}};
+
+ std::cout <<devStatus[status] <<std::endl;
+}
+
+void printDevices(DeviceList_t &list)
+{
+ for (unsigned int i = 0; i < list.size(); i++ )
+ {
+ std::cout << "Device "<< i+1 <<" ID: ";
+ std::cout << list[i]->getDeviceID() << " From IP: ";
+ std::cout << list[i]->getDevAddr() << std::endl;
+ }
+}
+
+static void getCallback(const HeaderOptions& headerOptions, const OCRepresentation& rep, const int eCode)
+{
+ (void)(headerOptions);
+ try
+ {
+ if (OC_STACK_OK == eCode)
+ {
+ std::cout << "Callback Context for GET query recvd successfully" << std::endl;
+ std::cout << "Resource URI: " << rep.getUri() << std::endl;
+
+ bool state = false;
+ int power = 0;
+ rep.getValue("state", state);
+ rep.getValue("power", power);
+
+ std::cout << "\tstate: " << state << std::endl;
+ std::cout << "\tpower: " << power << std::endl;
+ }
+ else
+ {
+ std::cout << "getCallback Response error: " << eCode << std::endl;
+ }
+ }
+ catch(std::exception& e)
+ {
+ std::cout << "Exception: " << e.what() << " in onGet" << std::endl;
+ }
+}
+
+void putCallback(const HeaderOptions& /*headerOptions*/, const OCRepresentation& rep, const int eCode)
+{
+ if(eCode == 0)
+ {
+ std::cout << "PUT request was successful !!!!!!" << std::endl;
+ }
+ else
+ {
+ std::cout << "onPut Response error !!!!!: " << eCode << std::endl;
+ }
+}
+
+int main(void)
+{
+ OCPersistentStorage ps {client_open, fread, fwrite, fclose, unlink };
+
+ // Create PlatformConfig object
+ PlatformConfig cfg {
+ OC::ServiceType::InProc,
+ OC::ModeType::Both,
+ "0.0.0.0",
+ 0,
+ OC::QualityOfService::LowQos,
+ &ps
+ };
+
+ OCPlatform::Configure(cfg);
+
+ //set Input Pin callback
+ OCSecure::setInputPinCallback(InputPinCB);
+
+ try
+ {
+ int choice;
+ OicSecAcl_t *acl1 = nullptr, *acl2 = nullptr;
+ if (OCSecure::provisionInit("") != OC_STACK_OK)
+ {
+ std::cout <<"PM Init failed"<< std::endl;
+ return 1;
+ }
+
+ for (int out = 0; !out;)
+ {
+ while (!ask)
+ {
+ sleep(1);
+ }
+
+ printMenu();
+ std::cin >> choice;
+ switch(choice) {
+ case 1:
+ {
+ pMOTEnabledDeviceList.clear();
+ std::cout << "Started MOT enabled device discovery..." <<std::endl;
+ OCStackResult result = OCSecure::discoverMultipleOwnerEnabledDevices(
+ DISCOVERY_TIMEOUT, pMOTEnabledDeviceList);
+ if (result != OC_STACK_OK)
+ {
+ std::cout<< "!!Error - MOT enabled dev Discovery failed."<<std::endl;
+ }
+ else if (pMOTEnabledDeviceList.size())
+ {
+ std::cout <<"Found MOT enabled devices, count = " <<
+ pMOTEnabledDeviceList.size() << std::endl;
+ printDevices(pMOTEnabledDeviceList);
+ }
+ else
+ {
+ std::cout <<"NO MOT enabled devices found"<<std::endl;
+ }
+ break;
+ }
+ case 2:
+ {
+ pMOwnedDeviceList.clear();
+ std::cout << "Started Multiple Owned device discovery..." <<std::endl;
+ OCStackResult result = OCSecure::discoverMultipleOwnerEnabledDevices(
+ DISCOVERY_TIMEOUT, pMOwnedDeviceList);
+ if (result != OC_STACK_OK)
+ {
+ std::cout<< "!!Error - Multiple Owned dev Discovery failed."<<std::endl;
+ }
+ else if (pMOwnedDeviceList.size())
+ {
+ std::cout <<"Found Multiple Owned devices, count = " <<
+ pMOwnedDeviceList.size() << std::endl;
+ printDevices(pMOwnedDeviceList);
+ }
+ else
+ {
+ std::cout <<"NO Multiple Owned devices found"<<std::endl;
+ }
+ break;
+ }
+ case 3:
+ { //Multiple Ownrship Trasfer
+ unsigned int devNum;
+
+ if (!pMOTEnabledDeviceList.size())
+ {
+ std::cout <<"There are no MOT enabled devices"<<std::endl;
+ break;
+ }
+
+ for (unsigned int i = 0; i < pMOTEnabledDeviceList.size(); i++ )
+ {
+ std::cout << i+1 << ": "<< pMOTEnabledDeviceList[i]->getDeviceID();
+ std::cout << " From IP:" << pMOTEnabledDeviceList[i]->getDevAddr() <<std::endl;
+ }
+
+ std::cout <<"Select device number: "<<std::endl;
+ std::cin >> devNum;
+ if (devNum > pMOTEnabledDeviceList.size())
+ {
+ std::cout <<"Invalid device number"<<std::endl;
+ break;
+ }
+ transferDevIdx = devNum - 1;
+
+ ask = 0;
+ std::cout << "MOT for : "<<
+ pMOTEnabledDeviceList[devNum-1]->getDeviceID()<<std::endl;
+ if (pMOTEnabledDeviceList[devNum-1]->doMultipleOwnershipTransfer
+ (multipleOwnershipTransferCB)
+ != OC_STACK_OK)
+ {
+ std::cout<<"Multiple OwnershipTransferCallback is failed"<<std::endl;
+ ask = 1;
+ }
+ break;
+ }
+ case 4:
+ {
+ std::cout << "- Send data(GET Request) to device(led server) -" << std::endl;
+ printDevices(pMOwnedDeviceList);
+ printMenu();
+ std::cout << "Enter device number to GET data: ";
+ std::cin >> choice;
+ choice--;
+
+ std::vector<std::string> ledTypes = {"core.led"};
+ std::vector<std::string> ifaces = {DEFAULT_INTERFACE};
+
+ OCProvisionDev_t *selDev = pMOwnedDeviceList[choice]->getDevPtr();
+ std::stringstream host;
+ host << "coaps:://";
+ host << pMOwnedDeviceList[choice]->getDevAddr();
+ host << selDev->securePort;
+
+ OCResource::Ptr led = OC::OCPlatform::constructResourceObject(
+ host.str(), "/a/led", selDev->connType, false, ledTypes, ifaces);
+
+ if(!led)
+ {
+ std::cout << "Error: Led Object construction returned null" << std::endl;
+ break;
+ }
+ OCStackResult res = led->get(QueryParamsMap(), getCallback);
+
+ if (OC_STACK_OK != res)
+ {
+ std::cout << "Error: get Failed for Led" << std::endl;
+ }
+ break;
+ }
+ break;
+ case 5:
+ {
+ std::cout << "- Send data(Put Request) to device(led server) -" << std::endl;
+ printDevices(pMOwnedDeviceList);
+ printMenu();
+ std::cout << "Enter device number to GET data: ";
+ std::cin >> choice;
+ choice--;
+
+ std::vector<std::string> ledTypes = {"core.led"};
+ std::vector<std::string> ifaces = {DEFAULT_INTERFACE};
+
+
+ OCProvisionDev_t *selDev = pMOwnedDeviceList[choice]->getDevPtr();
+ std::stringstream host;
+ host << "coaps:://";
+ host << pMOwnedDeviceList[choice]->getDevAddr();
+ host << selDev->securePort;
+
+ OCResource::Ptr led = OC::OCPlatform::constructResourceObject(host.str(),
+ "/a/led", selDev->connType, false, ledTypes, ifaces);
+
+ if(!led)
+ {
+ std::cout << "Error: Led Object construction returned null" << std::endl;
+ break;
+ }
+ OCRepresentation rep;
+ bool state = true;
+ int power = 39;
+ rep.setValue("state", state);
+ rep.setValue("power", power);
+ OCStackResult res = led->put(rep, QueryParamsMap(), putCallback);
+
+ if (OC_STACK_OK != res)
+ {
+ std::cout << "Error: put Failed for Led" << std::endl;
+ }
+ break;
+ }
+ break;
+ case 99:
+ default:
+ out = 1;
+ break;
+ }
+ }
+ }
+ catch(OCException& e)
+ {
+ oclog() << "Exception in main: "<<e.what();
+ }
+
+ return 0;
+}
return result;
}
- OCStackResult OCSecure::setOwnerTransferCallbackData(OicSecOxm_t oxm,
- OTMCallbackData_t* callbackData, InputPinCallback inputPin)
+#ifdef MULTIPLE_OWNER
+ OCStackResult OCSecure::discoverMultipleOwnerEnabledDevices(unsigned short timeout,
+ DeviceList_t &list)
{
- if (NULL == callbackData || oxm >= OIC_OXM_COUNT)
+ OCStackResult result;
+ OCProvisionDev_t *pDevList = nullptr, *pCurDev = nullptr, *tmp = nullptr;
+ auto csdkLock = OCPlatform_impl::Instance().csdkLock();
+ auto cLock = csdkLock.lock();
+
+ if (cLock)
{
- oclog() <<"Invalid callbackData or OXM type";
- return OC_STACK_INVALID_PARAM;
+ std::lock_guard<std::recursive_mutex> lock(*cLock);
+ result = OCDiscoverMultipleOwnerEnabledDevices(timeout, &pDevList);
+ if (result == OC_STACK_OK)
+ {
+ pCurDev = pDevList;
+ while (pCurDev)
+ {
+ tmp = pCurDev;
+ list.push_back(std::shared_ptr<OCSecureResource>(
+ new OCSecureResource(csdkLock, pCurDev)));
+ pCurDev = pCurDev->next;
+ tmp->next = nullptr;
+ }
+ }
+ else
+ {
+ oclog() <<"MultipleOwner Enabled device discovery failed!";
+ }
}
-
- if ((OIC_RANDOM_DEVICE_PIN == oxm) && !inputPin)
+ else
{
- oclog() <<"for OXM type DEVICE_PIN, inputPin callback can't be null";
- return OC_STACK_INVALID_PARAM;
+ oclog() <<"Mutex not found";
+ result = OC_STACK_ERROR;
}
+ return result;
+ }
+
+ OCStackResult OCSecure::discoverMultipleOwnedDevices(unsigned short timeout,
+ DeviceList_t &list)
+ {
OCStackResult result;
- auto cLock = OCPlatform_impl::Instance().csdkLock().lock();
+ OCProvisionDev_t *pDevList = nullptr, *pCurDev = nullptr, *tmp = nullptr;
+ auto csdkLock = OCPlatform_impl::Instance().csdkLock();
+ auto cLock = csdkLock.lock();
if (cLock)
{
std::lock_guard<std::recursive_mutex> lock(*cLock);
- result = OCSetOwnerTransferCallbackData(oxm, callbackData);
- if (result == OC_STACK_OK && (OIC_RANDOM_DEVICE_PIN == oxm))
+ result = OCDiscoverMultipleOwnedDevices(timeout, &pDevList);
+ if (result == OC_STACK_OK)
+ {
+ pCurDev = pDevList;
+ while (pCurDev)
+ {
+ tmp = pCurDev;
+ list.push_back(std::shared_ptr<OCSecureResource>(
+ new OCSecureResource(csdkLock, pCurDev)));
+ pCurDev = pCurDev->next;
+ tmp->next = nullptr;
+ }
+ }
+ else
{
- SetInputPinCB(inputPin);
+ oclog() <<"Multiple Owned device discovery failed!";
}
}
else
}
return result;
+ }
+#endif
+ OCStackResult OCSecure::setInputPinCallback(InputPinCallback inputPin)
+ {
+ OCStackResult result;
+ auto cLock = OCPlatform_impl::Instance().csdkLock().lock();
+
+ if (cLock)
+ {
+ std::lock_guard<std::recursive_mutex> lock(*cLock);
+ SetInputPinCB(inputPin);
+ result = OC_STACK_OK;
+ }
+ else
+ {
+ oclog() <<"Mutex not found";
+ result = OC_STACK_ERROR;
+ }
+
+ return result;
}
OCStackResult OCSecure::getDevInfoFromNetwork(unsigned short timeout,
return result;
}
+#ifdef MULTIPLE_OWNER
+ OCStackResult OCSecureResource::doMultipleOwnershipTransfer(ResultCallBack resultCallback)
+ {
+ if (!resultCallback)
+ {
+ oclog() <<"Result callback can't be null";
+ return OC_STACK_INVALID_CALLBACK;
+ }
+
+ OCStackResult result;
+ auto cLock = m_csdkLock.lock();
+
+ if (cLock)
+ {
+ ProvisionContext* context = new ProvisionContext(resultCallback);
+
+ std::lock_guard<std::recursive_mutex> lock(*cLock);
+ result = OCDoMultipleOwnershipTransfer(static_cast<void*>(context),
+ devPtr, &OCSecureResource::callbackWrapper);
+ }
+ else
+ {
+ oclog() <<"Mutex not found";
+ result = OC_STACK_ERROR;
+ }
+ return result;
+ }
+
+#endif
OCStackResult OCSecureResource::provisionACL( const OicSecAcl_t* acl,
ResultCallBack resultCallback)
{
throw OCException("Incomplete secure resource", OC_STACK_RESOURCE_ERROR);
}
}
+
+#ifdef MULTIPLE_OWNER
+ OCStackResult OCSecureResource::selectMOTMethod( const OicSecOxm_t oxmSelVal,
+ ResultCallBack resultCallback)
+ {
+ if (!resultCallback)
+ {
+ oclog() <<"result callback can not be null";
+ return OC_STACK_INVALID_CALLBACK;
+ }
+
+ OCStackResult result;
+ auto cLock = m_csdkLock.lock();
+
+ if (cLock)
+ {
+ ProvisionContext* context = new ProvisionContext(resultCallback);
+
+ std::lock_guard<std::recursive_mutex> lock(*cLock);
+ result = OCSelectMOTMethod(static_cast<void*>(context),
+ devPtr, oxmSelVal,
+ &OCSecureResource::callbackWrapper);
+ }
+ else
+ {
+ oclog() <<"Mutex not found";
+ result = OC_STACK_ERROR;
+ }
+ return result;
+ }
+
+ OCStackResult OCSecureResource::changeMOTMode( const OicSecMomType_t momType,
+ ResultCallBack resultCallback)
+ {
+ if (!resultCallback)
+ {
+ oclog() <<"result callback can not be null";
+ return OC_STACK_INVALID_CALLBACK;
+ }
+
+ OCStackResult result;
+ auto cLock = m_csdkLock.lock();
+
+ if (cLock)
+ {
+ ProvisionContext* context = new ProvisionContext(resultCallback);
+
+ std::lock_guard<std::recursive_mutex> lock(*cLock);
+ result = OCChangeMOTMode(static_cast<void*>(context),
+ devPtr, momType,
+ &OCSecureResource::callbackWrapper);
+ }
+ else
+ {
+ oclog() <<"Mutex not found";
+ result = OC_STACK_ERROR;
+ }
+ return result;
+ }
+
+
+ OCStackResult OCSecureResource::addPreconfigPIN(const char* preconfPIN,
+ size_t preconfPINLength)
+ {
+ if (!preconfPIN)
+ {
+ oclog() <<"pre config pin can not be null";
+ return OC_STACK_INVALID_PARAM;
+ }
+ if (preconfPINLength <= 0)
+ {
+ oclog() <<"pre config pin length can not be zero or less";
+ return OC_STACK_INVALID_PARAM;
+ }
+ OCStackResult result;
+ auto cLock = m_csdkLock.lock();
+
+ if (cLock)
+ {
+ std::lock_guard<std::recursive_mutex> lock(*cLock);
+ result = OCAddPreconfigPin(devPtr, preconfPIN,
+ preconfPINLength);
+ }
+ else
+ {
+ oclog() <<"Mutex not found";
+ result = OC_STACK_ERROR;
+ }
+ return result;
+ }
+
+ OCStackResult OCSecureResource::provisionPreconfPin(const char * preconfPin,
+ size_t preconfPinLength, ResultCallBack resultCallback)
+ {
+ if (!resultCallback)
+ {
+ oclog() <<"result callback can not be null";
+ return OC_STACK_INVALID_CALLBACK;
+ }
+ if (!preconfPin)
+ {
+ oclog() <<"pre config pin can not be null";
+ return OC_STACK_INVALID_PARAM;
+ }
+ if (preconfPinLength <= 0)
+ {
+ oclog() <<"pre config pin length can not be zero or less";
+ return OC_STACK_INVALID_PARAM;
+ }
+
+ OCStackResult result;
+ auto cLock = m_csdkLock.lock();
+
+ if (cLock)
+ {
+ ProvisionContext* context = new ProvisionContext(resultCallback);
+
+ std::lock_guard<std::recursive_mutex> lock(*cLock);
+ result = OCProvisionPreconfigPin(static_cast<void*>(context),
+ devPtr, preconfPin, preconfPinLength,
+ &OCSecureResource::callbackWrapper);
+ }
+ else
+ {
+ oclog() <<"Mutex not found";
+ result = OC_STACK_ERROR;
+ }
+ return result;
+ }
+#endif // MULTIPLE_OWNER
}
EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSecure::discoverUnownedDevices(0, list));
}
+#ifdef MULTIPLE_OWNER
+ TEST(MOTDiscoveryTest, MultipleOwnerEnabledDevices)
+ {
+ DeviceList_t list;
+ EXPECT_EQ(OC_STACK_OK, OCSecure::discoverMultipleOwnerEnabledDevices(TIMEOUT, list));
+ }
+
+ TEST(MOTDiscoveryTest, MultipleOwnerEnabledDevicesZeroTimeOut)
+ {
+ DeviceList_t list;
+ EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSecure::discoverMultipleOwnerEnabledDevices(0, list));
+ }
+
+ TEST(MOTDiscoveryTest, MultipleOwnedDevices)
+ {
+ DeviceList_t list;
+ EXPECT_EQ(OC_STACK_OK, OCSecure::discoverMultipleOwnedDevices(TIMEOUT, list));
+ }
+
+ TEST(MOTDiscoveryTest, MultipleOwnedDevicesZeroTimeOut)
+ {
+ DeviceList_t list;
+ EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSecure::discoverMultipleOwnedDevices(0, list));
+ }
+#endif
+
TEST(DiscoveryTest, OwnedDevices)
{
DeviceList_t list;
EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSecure::discoverOwnedDevices(0, list));
}
- TEST(OwnershipTest, SetOwnershipTransferCBDataNull)
+ TEST(OwnershipTest, OwnershipTransferNullCallback)
{
- EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSecure::setOwnerTransferCallbackData(
- OIC_JUST_WORKS, NULL, NULL));
+ OCSecureResource device;
+ EXPECT_EQ(OC_STACK_INVALID_CALLBACK, device.doOwnershipTransfer(nullptr));
}
- TEST(OwnershipTest, SetOwnershipTransferCBData)
+#ifdef MULTIPLE_OWNER
+ TEST(MOTOwnershipTest, MOTOwnershipTransferNullCallback)
{
- OTMCallbackData_t justWorksCBData;
- justWorksCBData.loadSecretCB = LoadSecretJustWorksCallback;
- justWorksCBData.createSecureSessionCB = CreateSecureSessionJustWorksCallback;
- justWorksCBData.createSelectOxmPayloadCB = CreateJustWorksSelectOxmPayload;
- justWorksCBData.createOwnerTransferPayloadCB = CreateJustWorksOwnerTransferPayload;
- EXPECT_EQ(OC_STACK_OK, OCSecure::setOwnerTransferCallbackData(OIC_JUST_WORKS,
- &justWorksCBData, NULL));
+ OCSecureResource device;
+ EXPECT_EQ(OC_STACK_INVALID_CALLBACK, device.doMultipleOwnershipTransfer(nullptr));
}
- TEST(OwnershipTest, SetOwnershipTransferCBDataInvalidType)
+ TEST(selectMOTMethodTest, selectMOTMethodNullCallback)
{
- OTMCallbackData_t justWorksCBData;
- justWorksCBData.loadSecretCB = LoadSecretJustWorksCallback;
- justWorksCBData.createSecureSessionCB = CreateSecureSessionJustWorksCallback;
- justWorksCBData.createSelectOxmPayloadCB = CreateJustWorksSelectOxmPayload;
- justWorksCBData.createOwnerTransferPayloadCB = CreateJustWorksOwnerTransferPayload;
- EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSecure::setOwnerTransferCallbackData(OIC_OXM_COUNT,
- &justWorksCBData, NULL));
+ OCSecureResource device;
+ const OicSecOxm_t stsecOxm = OIC_PRECONFIG_PIN;
+ EXPECT_EQ(OC_STACK_INVALID_CALLBACK, device.selectMOTMethod(stsecOxm, NULL));
}
- TEST(OwnershipTest, SetOwnershipTransferCBDataNullInputPin)
+ TEST(changeMOTModeTest, changeMOTModeNullCallback)
{
- OTMCallbackData_t pinBasedCBData;
- pinBasedCBData.loadSecretCB = InputPinCodeCallback;
- pinBasedCBData.createSecureSessionCB = CreateSecureSessionRandomPinCallback;
- pinBasedCBData.createSelectOxmPayloadCB = CreatePinBasedSelectOxmPayload;
- pinBasedCBData.createOwnerTransferPayloadCB = CreatePinBasedOwnerTransferPayload;
- OTMSetOwnershipTransferCallbackData(OIC_RANDOM_DEVICE_PIN, &pinBasedCBData);
+ OCSecureResource device;
+ const OicSecMomType_t momType = OIC_MULTIPLE_OWNER_ENABLE;
+ EXPECT_EQ(OC_STACK_INVALID_CALLBACK, device.changeMOTMode(momType, NULL));
+ }
- EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSecure::setOwnerTransferCallbackData(
- OIC_RANDOM_DEVICE_PIN, &pinBasedCBData, NULL));
+ TEST(addPreconfigPINTest, addPreconfigPINNullPin)
+ {
+ OCSecureResource device;
+ EXPECT_EQ(OC_STACK_INVALID_PARAM, device.addPreconfigPIN(NULL, 0));
}
- TEST(OwnershipTest, OwnershipTransferNullCallback)
+ TEST(provisionPreconfPinTest, provisionPreconfPinNullCallback)
{
OCSecureResource device;
- EXPECT_EQ(OC_STACK_INVALID_CALLBACK, device.doOwnershipTransfer(nullptr));
+ const char *pin = "test";
+ size_t PinLength = 4;
+ EXPECT_EQ(OC_STACK_INVALID_CALLBACK, device.provisionPreconfPin(pin, PinLength, NULL));
}
+#endif
TEST(DeviceInfoTest, DevInfoFromNetwork)
{
OCStackResult result = OC_STACK_ERROR;
- OTMCallbackData_t justWorksCBData;
- justWorksCBData.loadSecretCB = LoadSecretJustWorksCallback;
- justWorksCBData.createSecureSessionCB = CreateSecureSessionJustWorksCallback;
- justWorksCBData.createSelectOxmPayloadCB = CreateJustWorksSelectOxmPayload;
- justWorksCBData.createOwnerTransferPayloadCB =
- CreateJustWorksOwnerTransferPayload;
- OCSecure::setOwnerTransferCallbackData(OIC_JUST_WORKS, &justWorksCBData, NULL);
-
OIC_LOG_V(DEBUG, ENROLEE_SECURITY_TAG, "Transfering ownership for : %s ",
m_securedResource->getDeviceID().c_str());
+ //In case of random pin, argument should be inputPinCallback func.
+ // for justwork, not required(NULL)
+ OCSecure::setInputPinCallback(NULL);
+
OC::ResultCallBack ownershipTransferCb = std::bind(
&EnrolleeSecurity::ownershipTransferCb, this, std::placeholders::_1,
std::placeholders::_2);
projects / platform / upstream / iotivity.git / commitdiff