X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=service%2Feasy-setup%2Fmediator%2Frichsdk%2Finc%2FESRichCommon.h;h=48584d155bbf8e10ed3baf8ef99c70e910576864;hb=refs%2Ftags%2Ftizen_4.0.m2_release;hp=e9e344b9c0a5ee718c7f78e177dc2898fc635087;hpb=cf56a410a2150ae474c676e7e6d01b89552a4873;p=platform%2Fupstream%2Fiotivity.git diff --git a/service/easy-setup/mediator/richsdk/inc/ESRichCommon.h b/service/easy-setup/mediator/richsdk/inc/ESRichCommon.h index e9e344b..48584d1 100755 --- a/service/easy-setup/mediator/richsdk/inc/ESRichCommon.h +++ b/service/easy-setup/mediator/richsdk/inc/ESRichCommon.h @@ -25,355 +25,1064 @@ #include #ifndef WITH_ARDUINO #include +#include #endif +#include "OCPlatform.h" #include "ocstack.h" #include "octypes.h" +#ifdef __WITH_DTLS__ +#include "securevirtualresourcetypes.h" +#include "OCProvisioningManager.hpp" +#include "ocrandom.h" +#endif -using namespace std; +#include "escommon.h" -// Defines -#define OIC_STRING_MAX_VALUE 100 -#define IPV4_ADDR_SIZE 16 -#define IP_PORT 55555 -#define NET_WIFI_SSID_SIZE 100 -#define NET_WIFI_PWD_SIZE 100 - -/** - * @brief Mac address length for BT port - */ -#define NET_MACADDR_SIZE 18 - -/** - * Attributes used to form a proper easysetup conforming JSON message. - */ -#define OC_RSRVD_ES_PS "ps" -#define OC_RSRVD_ES_TNN "tnn" -#define OC_RSRVD_ES_CD "cd" -#define OC_RSRVD_ES_TR "tr" -#define OC_RSRVD_ES_TNT "tnt" -#define OC_RSRVD_ES_ANT "ant" - -/** - * Easysetup defined resoruce types and uris. - */ -#define OC_RSRVD_ES_PROV_RES_TYPE "oic.r.prov" -#define OC_RSRVD_ES_URI_PROV "/oic/prov" -#define OC_RSRVD_ES_URI_NET "/oic/net" - -/** - * @brief Defines for Provisioning status accepted values - */ -#define ES_PS_NEED_PROVISIONING 1 -#define ES_PS_PROVISIONING_COMPLETED 2 -#define ES_PS_TRIGGER_INIT_VALUE 0 -#define ES_PS_TRIGGER_CONNECTION 1 +using namespace OC; +using namespace std; #ifndef WITH_ARDUINO namespace OIC { namespace Service { - /** - * Device Roles defined for each device type used in easy setup - */ - typedef enum + * @brief Properties of easysetup resource. It includes a provisioning status and last + * error code. + */ + class EnrolleeStatus { - ENROLLEE, - MEDIATOR, - ENROLLER, - } DeviceRole; + public: + + /** + * Constructor + */ + EnrolleeStatus(const OCRepresentation& rep) + { + m_rep = rep; + } + + EnrolleeStatus(const EnrolleeStatus& enrolleeStatus) : + m_rep(enrolleeStatus.getRepresentation()) + { + } + + EnrolleeStatus(const EnrolleeStatus&& enrolleeStatus) : + m_rep(std::move(enrolleeStatus.getRepresentation())) + { + } + + /** + * Get a provisioning status property of Enrollee. + * + * @return a provisioning status property of Enrollee + */ + ProvStatus getProvStatus() const + { + if(m_rep.hasAttribute(OC_RSRVD_ES_PROVSTATUS)) + { + return static_cast( + m_rep.getValue(OC_RSRVD_ES_PROVSTATUS)); + } + return ES_STATE_INIT; + } + + /** + * Get a last error code property of Enrollee. + * + * @return a last error code property of Enrollee. + */ + ESErrorCode getLastErrCode() const + { + if(m_rep.hasAttribute(OC_RSRVD_ES_LAST_ERRORCODE)) + { + return static_cast( + m_rep.getValue(OC_RSRVD_ES_LAST_ERRORCODE)); + } + return ES_ERRCODE_NO_ERROR; + } + + /** + * Get OCRepresentation object + * + * @return OCRepresentation object + */ + const OCRepresentation& getRepresentation() const + { + return m_rep; + } + protected: + OCRepresentation m_rep; + }; /** - * On-boarding connection to create Adhoc network. - */ - typedef enum + * @brief Data class stored for provisioning of coap cloud server properties + */ + class CloudProp { - SOFTAP, - BLE, - } OBConnection; + public: - typedef enum - { - ES_ERROR = -1, - ES_OK = 0, - ES_NETWORKFOUND = 1, - ES_NETWORKCONNECTED, - ES_NETWORKNOTCONNECTED, - ES_RESOURCECREATED = 11, - ES_RECVREQOFPROVRES = 21, - ES_RECVREQOFNETRES, - ES_RECVUPDATEOFPROVRES, - ES_RECVTRIGGEROFPROVRES, - } ESResult; - - typedef enum - { /** - * Default state of the device + * Constructor */ - ES_INIT_STATE, + CloudProp() + { + m_cloudID = ""; + m_credID = 0; + } + + CloudProp(const CloudProp& cloudProp) : + m_rep(cloudProp.toOCRepresentation()), + m_cloudID(cloudProp.getCloudID()), + m_credID(cloudProp.getCredID()) + { + } + + CloudProp(const CloudProp&& cloudProp) : + m_rep(std::move(cloudProp.toOCRepresentation())), + m_cloudID(cloudProp.getCloudID()), + m_credID(cloudProp.getCredID()) + { + } /** - * Device will move to this state once the on boarding begins + * Constructor with OCRepresentation object. This is used for JNI communication. */ - ES_ON_BOARDING_STATE, + CloudProp(const OCRepresentation &rep) + { + m_rep = rep; + m_cloudID = ""; + m_credID = 0; + } /** - * Device will move to this state after successful on-boarding of the device + * Set CoapCloudConf resource properties to be delivered to Enrollee + * + * @param authCode Auth code issued by OAuth2.0-compatible account server + * @param authProvider Auth provider ID + * @param ciServer Cloud interface server URL which an Enrollee is going to registered */ - ES_ON_BOARDED_STATE, + void setCloudProp(string authCode, string authProvider, string ciServer) + { + m_rep.setValue(OC_RSRVD_ES_AUTHCODE, authCode); + m_rep.setValue(OC_RSRVD_ES_AUTHPROVIDER, authProvider); + m_rep.setValue(OC_RSRVD_ES_CISERVER, ciServer); + } /** - * Device will move to this state once the on boarding is done + * Set CoapCloudConf resource properties with Access token to be delivered to Enrollee + * + * @param accessToken Access token which is given in a return of auth code issued by + * OAuth2.0-compatible account server + * @param tokenType Access token type, i.e. "bearer" + * @param authProvider Auth provider ID + * @param ciServer Cloud interface server URL which an Enrollee is going to registered + * + * @see OAUTH_TOKENTYPE */ - ES_PROVISIONING_STATE, + void setCloudPropWithAccessToken(string accessToken, OAUTH_TOKENTYPE tokenType, + string authProvider, string ciServer) + { + m_rep.setValue(OC_RSRVD_ES_ACCESSTOKEN, accessToken); + m_rep.setValue(OC_RSRVD_ES_ACCESSTOKEN_TYPE, tokenType); + m_rep.setValue(OC_RSRVD_ES_AUTHPROVIDER, authProvider); + m_rep.setValue(OC_RSRVD_ES_CISERVER, ciServer); + } /** - * Easy setup process is successful. + * Set CloudServer's UUID + * + * @param cloudID Cloud Interface server's UUID */ - ES_PROVISIONED_STATE, + void setCloudID(string cloudID) + { + m_cloudID = cloudID; + } /** - * This state is arbitrary one, any time device can come into this state - * Device will move to this state if the ownership transfer initiated by the Application + * Set CloudServer's credential ID of certificate + * + * @param credID Cloud Interface server's credential ID of certificate */ - ES_OWNERSHIP_TRANSFERRING_STATE, + void setCredID(int credID) + { + m_credID = credID; + } /** - * This state is arbitrary one, any time device can come into this state - * Device will move to this state if the ownership transfer is completed + * Get an auth code to be delivered. + * + * @return an auth code to be delivered. */ - ES_OWNERSHIP_TRANSFERRED_STATE, + std::string getAuthCode() const + { + if(m_rep.hasAttribute(OC_RSRVD_ES_AUTHCODE)) + { + return m_rep.getValue(OC_RSRVD_ES_AUTHCODE); + } + return std::string(""); + } /** - * This state is arbitrary one, any time device can come into this state - * Device will move to this state once the Application factory reset the device + * Get an auth provider which issued an auth code + * + * @return an auth provider which issued an auth code */ - ES_FACTORY_RESET_STATE, + std::string getAuthProvider() const + { + if(m_rep.hasAttribute(OC_RSRVD_ES_AUTHPROVIDER)) + { + return m_rep.getValue(OC_RSRVD_ES_AUTHPROVIDER); + } + return std::string(""); + } /** - * Enrollee moves to this state after connecting to target network + * Get a CI server to be delivered + * + * @return a CI server to be delivered */ - ES_ON_BOARDED_TARGET_NETWORK_STATE, - }EnrolleeState; + std::string getCiServer() const + { + if(m_rep.hasAttribute(OC_RSRVD_ES_CISERVER)) + { + return m_rep.getValue(OC_RSRVD_ES_CISERVER); + } + return std::string(""); + } - /** - * Provisioning Device Status - */ - typedef struct - { - // Address of remote server - OCDevAddr * addr; - // Indicates adaptor type on which the response was received - OCConnectivityType connType; - } EasySetupDeviceInfo; + /** + * Get a CI server's Uuid to be delivered + * + * @return a CI server's Uuid to be delivered + */ + std::string getCloudID() const + { + return m_cloudID; + } + + /** + * Get a CI server's credential ID of certificate + * + * @return a CI server's credential ID of certificated + */ + int getCredID() const + { + return m_credID; + } + + /** + * Get an access token to be delivered. + * + * @return an access token to be delivered. + */ + std::string getAccessToken() const + { + if(m_rep.hasAttribute(OC_RSRVD_ES_ACCESSTOKEN)) + { + return m_rep.getValue(OC_RSRVD_ES_ACCESSTOKEN); + } + return std::string(""); + } + + /** + * Get an access token type to be delivered. + * + * @return an access token type to be delivered. + */ + OAUTH_TOKENTYPE getAccessTokenType() const + { + + if(m_rep.hasAttribute(OC_RSRVD_ES_ACCESSTOKEN_TYPE)) + { + return static_cast( + m_rep.getValue(OC_RSRVD_ES_ACCESSTOKEN_TYPE)); + } + return NONE_OAUTH_TOKENTYPE; + } + + /** + * Get OCRepresentation object + * + * @return OCRepresentation object + */ + const OCRepresentation &toOCRepresentation() const + { + return m_rep; + } + protected: + OCRepresentation m_rep; + std::string m_cloudID; + int m_credID; + }; /** - * Provosioning Status + * @brief Data class stored for provisioning of Device properties which includes + * properties of WiFiConf resource and DevConf resource */ - typedef enum + class DeviceProp { - DEVICE_PROVISIONED = 0, - DEVICE_NOT_PROVISIONED, - DEVICE_OWNED, - DEVICE_NOT_OWNED - } EasySetupState, ProvStatus; + public: + + /** + * Constructor + */ + DeviceProp() + { + } + + DeviceProp(const DeviceProp& deviceProp) : + m_rep(deviceProp.toOCRepresentation()) + { + } + + DeviceProp(const DeviceProp&& deviceProp) : + m_rep(std::move(deviceProp.toOCRepresentation())) + { + } + + /** + * Constructor with OCRepresentation object. This is used for JNI communication. + */ + DeviceProp(const OCRepresentation &rep) + { + m_rep = rep; + } + + /** + * Set WiFiConf resource properties to be delivered to Enrollee + * + * @param ssid Ssid of the Enroller + * @param pwd Pwd of the Enrolle + * @param authtype Auth type of the Enroller + * @param enctype Encryption type of the Enroller + * + * @see WIFI_AUTHTYPE + * @see WIFI_ENCTYPE + */ + void setWiFiProp(string ssid, string pwd, WIFI_AUTHTYPE authtype, WIFI_ENCTYPE enctype) + { + m_rep.setValue(OC_RSRVD_ES_SSID, ssid); + m_rep.setValue(OC_RSRVD_ES_CRED, pwd); + m_rep.setValue(OC_RSRVD_ES_AUTHTYPE, authtype); + m_rep.setValue(OC_RSRVD_ES_ENCTYPE, enctype); + } + + /** + * Get a SSID of Enroller + * + * @return a SSID of enroller + */ + std::string getSsid() const + { + if(m_rep.hasAttribute(OC_RSRVD_ES_SSID)) + { + return m_rep.getValue(OC_RSRVD_ES_SSID); + } + return std::string(""); + } + + /** + * Get a password of Enroller + * + * @return a password of enroller + */ + std::string getPassword() const + { + if(m_rep.hasAttribute(OC_RSRVD_ES_CRED)) + { + return m_rep.getValue(OC_RSRVD_ES_CRED); + } + return std::string(""); + } + + /** + * Get an auth type of Enroller + * + * @return an auth type of enroller + * + * @see WIFI_AUTHTYPE + */ + WIFI_AUTHTYPE getAuthType() const + { + if(m_rep.hasAttribute(OC_RSRVD_ES_AUTHTYPE)) + { + return static_cast(m_rep.getValue(OC_RSRVD_ES_AUTHTYPE)); + } + return NONE_AUTH; + } + + /** + * Get an encryption type of Enroller + * + * @return an encryption type of enroller + * + * @see WIFI_ENCTYPE + */ + WIFI_ENCTYPE getEncType() const + { + if(m_rep.hasAttribute(OC_RSRVD_ES_ENCTYPE)) + { + return static_cast(m_rep.getValue(OC_RSRVD_ES_ENCTYPE)); + } + return NONE_ENC; + } + + /** + * Get OCRepresentation object + * + * @return OCRepresentation object + */ + const OCRepresentation &toOCRepresentation() const + { + return m_rep; + } + + protected: + OCRepresentation m_rep; + }; /** - * Response from queries to remote servers. + * Security Provisioning Status */ - typedef struct + class SecProvisioningStatus { - // EasySetup Status - EasySetupState provStatus; - // EasySetup Device Info - EasySetupDeviceInfo provDeviceInfo; - } EasySetupInfo, ProvisioningInfo; + public: + SecProvisioningStatus(string deviceUUID, ESResult result) : + m_devUUID(deviceUUID), m_result(result) + { +#ifdef __WITH_DTLS__ + m_selectedOTMethod = OIC_JUST_WORKS; + m_isMOTEnabled = false; + m_isOwned = false; + m_ownerID = {}; +#endif + } +#ifdef __WITH_DTLS__ + SecProvisioningStatus(std::shared_ptr resource, ESResult result) : + m_result(result) + { + m_isMOTEnabled = false; + if(resource.get() != nullptr) + { + m_devUUID = resource->getDeviceID(); + m_isOwned = resource->getOwnedStatus(); +#ifdef MULTIPLE_OWNER + m_isMOTEnabled = resource->isMOTEnabled(); +#endif + + if( OC_STACK_OK != resource->getOTMethod(&m_selectedOTMethod) ) + { + m_selectedOTMethod = OIC_OXM_COUNT; // Out-of-range + } + + if(resource->getOwnedStatus()) + { + char uuidString[UUID_STRING_SIZE] = {}; + if(RAND_UUID_OK == OCConvertUuidToString(resource->getDevPtr()->doxm->owner.id, uuidString)) + { + m_ownerID = uuidString; + } + else + { + m_ownerID = {}; + } + } + } + } + + OicSecOxm_t getSelectedOTMethod() const + { + return m_selectedOTMethod; + } + + bool isMOTEnabled() const + { + return m_isMOTEnabled; + } + + bool isOwnedDevice() const + { + return m_isOwned; + } + + const std::string getOwnerID() + { + return m_ownerID; + } +#endif + const std::string getDeviceUUID() + { + return m_devUUID; + } + /** + * Get a result for about security provisioning is success or not. + * + * @return ::ES_OK\n + * ::ES_SEC_OPERATION_IS_NOT_SUPPORTED\n + * ::ES_SECURE_RESOURCE_DISCOVERY_FAILURE\n + * ::ES_OWNERSHIP_TRANSFER_FAILURE\n + * ::ES_ERROR\n + */ + ESResult getESResult() + { + return m_result; + } + private: + string m_devUUID; + ESResult m_result; +#ifdef __WITH_DTLS__ + OicSecOxm_t m_selectedOTMethod; + bool m_isMOTEnabled; + bool m_isOwned; + std::string m_ownerID; +#endif + }; /** - * @brief Network information of the Enroller + * @breif This provide a set of getter APIs from received response for getConfiguration(). + * Received information includes a device name, WiFi supported mode, and frequency. + * Additionally, you can know if Enrollee can be access to cloud server with this + * object. */ - typedef union + class EnrolleeConf { + public: /** - * @brief BT Mac Information + * Constructor + * The expected OCRepresentation is one for collection resource and has several child + * OCRepresentation object corresponding to WiFiConf, DevConf, and CoapCloudConf + * resources' representations. */ - struct + EnrolleeConf(const OCRepresentation& rep) : + m_EasySetupRep(rep) { - char btMacAddress[NET_MACADDR_SIZE]; /**< BT mac address **/ - } BT; + } + + EnrolleeConf(const EnrolleeConf& enrolleeConf) : + m_EasySetupRep(enrolleeConf.getEasySetupRep()) + { + } + + EnrolleeConf(const EnrolleeConf&& enrolleeConf) : + m_EasySetupRep(std::move(enrolleeConf.getEasySetupRep())) + { + } /** - * @brief LE MAC Information + * Get a device name of Enrollee. It is Device's human-friendly name like device model + * name. + * + * @return a device name of Enrollee */ - struct + std::string getDeviceName() const { - char leMacAddress[NET_MACADDR_SIZE]; /**< BLE mac address **/ - } LE; + std::vector children = m_EasySetupRep.getChildren(); + for(auto child = children.begin(); child != children.end(); ++child) + { + if(child->getUri().find(OC_RSRVD_ES_URI_DEVCONF) != std::string::npos) + { + OCRepresentation rep; + if(child->hasAttribute(OC_RSRVD_REPRESENTATION)) + { + rep = child->getValue(OC_RSRVD_REPRESENTATION); + } + else + { + return std::string(""); + } + + if(rep.hasAttribute(OC_RSRVD_ES_DEVNAME)) + { + return rep.getValue(OC_RSRVD_ES_DEVNAME); + } + } + } + return std::string(""); + } /** - * @brief IP Information + * Get a set of WiFi supported modes of Enrollee + * + * @return a set of WiFi supported modes of Enrollee + * + * @see WIFI_MODE */ - struct + vector getWiFiModes() const { - char ssid[NET_WIFI_SSID_SIZE]; /**< ssid of the Enroller**/ - char pwd[NET_WIFI_PWD_SIZE]; /**< pwd of the Enroller**/ - } WIFI; - } ProvData; + vector modes; + modes.clear(); - /** - * @brief Network Information - */ - typedef struct - { - ProvData provData; /**< Enroller Network Info**/ - OCConnectivityType connType; /**< Connectivity Type**/ - } ProvConfig; + std::vector children = m_EasySetupRep.getChildren(); + for(auto child = children.begin(); child != children.end(); ++child) + { + if(child->getUri().find(OC_RSRVD_ES_URI_WIFICONF) != std::string::npos) + { + OCRepresentation rep; + if(child->hasAttribute(OC_RSRVD_REPRESENTATION)) + { + rep = child->getValue(OC_RSRVD_REPRESENTATION); + } + else + { + return modes; + } - /** - * Client applications implement this callback to consume responses received from Servers. - */ - typedef void (*OCProvisioningStatusCB)(EasySetupInfo *easySetupInfo); + if(rep.hasAttribute(OC_RSRVD_ES_SUPPORTEDWIFIMODE)) + { + for(auto it : rep.getValue + >(OC_RSRVD_ES_SUPPORTEDWIFIMODE)) + { + modes.push_back(static_cast(it)); + } + } + } + } + return modes; + } - /** - * @brief This structure represent configuration information to create wifi onboarding SoftAP or connection. - */ + /** + * Get a WiFi supported frequency of Enrollee + * + * @return a WiFi supported frequency of Enrollee + * + * @see WIFI_FREQ + */ + WIFI_FREQ getWiFiFreq() const + { + std::vector children = m_EasySetupRep.getChildren(); + for(auto child = children.begin(); child != children.end(); ++child) + { + if(child->getUri().find(OC_RSRVD_ES_URI_WIFICONF) != std::string::npos) + { + OCRepresentation rep; + if(child->hasAttribute(OC_RSRVD_REPRESENTATION)) + { + rep = child->getValue(OC_RSRVD_REPRESENTATION); + } + else + { + return WIFI_FREQ_NONE; + } - // Note : Below structure is not currently used but added for future purpose. - typedef struct - { - char ssid[NET_WIFI_SSID_SIZE]; /**< ssid of the onboarding Adhoc Wifi network**/ - char pwd[NET_WIFI_PWD_SIZE]; /**< pwd of the onboarding Adhoc wifi network**/ - bool isSecured; /**< Secure connection**/ - }WiFiOnboardingConfig; + if(rep.hasAttribute(OC_RSRVD_ES_SUPPORTEDWIFIFREQ)) + { + return static_cast( + rep.getValue(OC_RSRVD_ES_SUPPORTEDWIFIFREQ)); + } + } + } + return WIFI_FREQ_NONE; + } - /** - * @brief This structure represent onboarding connection instance. - */ - typedef struct - { - /*Actual use of ipAddress is for unicast discovery, but also used to identify the Enrollee device as of now, - device identification should be based on DeviceID in next release.*/ - char ipAddress[IPV4_ADDR_SIZE]; /**< IP Address of the Enrollee **/ - bool isSecured; /**< Secure connection**/ - }WiFiOnboadingConnection; + /** + * Get a provisioning status property of Enrollee. + * + * @return a provisioning status property of Enrollee + */ + ProvStatus getProvStatus() const + { + OCRepresentation rep; + if(m_EasySetupRep.hasAttribute(OC_RSRVD_REPRESENTATION)) + { + rep = m_EasySetupRep.getValue(OC_RSRVD_REPRESENTATION); + } + else + { + return ES_STATE_INIT; + } - typedef enum - { - ES_PROVISIONING_ERROR = -1, - ES_NEED_PROVISIONING, - ES_PROVISIONED_ALREADY, - ES_PROVISIONING_SUCCESS - } ESState; + if(rep.hasAttribute(OC_RSRVD_ES_PROVSTATUS)) + { + return static_cast( + rep.getValue(OC_RSRVD_ES_PROVSTATUS)); + } + return ES_STATE_INIT; + } - typedef enum - { - ES_UNKNOWN = 0, - ES_ONBOARDED, - ES_OWNED, - ES_PROVISIONED - } CurrentESState; + /** + * Get a last error code property of Enrollee. + * + * @return a last error code property of Enrollee. + */ + ESErrorCode getLastErrCode() const + { + OCRepresentation rep; + if(m_EasySetupRep.hasAttribute(OC_RSRVD_REPRESENTATION)) + { + rep = m_EasySetupRep.getValue(OC_RSRVD_REPRESENTATION); + } + else + { + return ES_ERRCODE_NO_ERROR; + } - typedef enum - { - ES_SEC_UNKNOWN = 0, - ES_SEC_OWNED, - ES_SEC_ACL_PROVISIONED, - ES_SEC_CREDS_PROVISIONED - } EnrolleeSecState; + if(rep.hasAttribute(OC_RSRVD_ES_LAST_ERRORCODE)) + { + return static_cast( + rep.getValue(OC_RSRVD_ES_LAST_ERRORCODE)); + } + return ES_ERRCODE_NO_ERROR; + } + + /** + * Get an accessibility to cloud server of an Enrollee + * + * @return an accessibility to cloud server of an Enrollee + */ + bool isCloudAccessible() const + { + std::vector children = m_EasySetupRep.getChildren(); + for(auto child = children.begin(); child != children.end(); ++child) + { + for(auto rt : child->getResourceTypes()) + { + if(0 == rt.compare(OC_RSRVD_ES_RES_TYPE_COAPCLOUDCONF)) + { + return true; + } + } + } + return false; + } + + /** + * Get OCRepresentation object + * + * @return OCRepresentation object + */ + const OCRepresentation& getEasySetupRep() const + { + return m_EasySetupRep; + } + + protected: + OCRepresentation m_EasySetupRep; + }; /** - * Security Provisioning Status + * Status object for getStatus API. This object is given to application + * when a response for GET request to provisioning resource at Enrollee is arrived. + * It returns a result of the API and requested data delivered in the response which includes + * a provisioning status and last error code stored in Enrollee. + * + * @see EnrolleeStatus */ - class SecProvisioningResult + class GetEnrolleeStatus { public: - std::shared_ptr< SecProvisioningResult > shared_ptr; - SecProvisioningResult(std::string deviceUUID, ESResult result) : - m_devUUID(deviceUUID), m_result(result) + /** + * Constructor + */ + GetEnrolleeStatus(ESResult result, const EnrolleeStatus& status) : + m_result(result), m_enrolleeStatus(status) { - } - std::string getDeviceUUID() + /** + * Get a result of getting provisioning status and last error code of Enrollee + * + * @return ::ES_OK\n + * ::ES_COMMUNICATION_ERROR\n + * ::ES_ERROR\n + * @see ESResult + */ + ESResult getESResult() { - return m_devUUID; + return m_result; } - ESResult getResult() + /** + * Get Enrollee's status and last error code properties + * + * @return Enrollee's status and last error code properties + * + * @see EnrolleeStatus + */ + const EnrolleeStatus& getEnrolleeStatus() { - return m_result; + return m_enrolleeStatus; } + private: - std::string m_devUUID; ESResult m_result; + EnrolleeStatus m_enrolleeStatus; }; /** - * Callback function definition for providing Enrollee security status . + * Status object for getConfiguration API. This object is given to application + * when a response for GET request to provisioning resource at Enrollee is arrived. + * It returns a result of the API and requested data delivered in the response which includes + * WiFi configuration and device configuration stored in Enrollee. + * + * @see EnrolleeConf */ - typedef std::function< void(std::shared_ptr) > EnrolleeSecStatusCb; + class GetConfigurationStatus + { + public: + /** + * Constructor + */ + GetConfigurationStatus(ESResult result, const EnrolleeConf& conf) : + m_result(result), m_enrolleeConf(conf) + { + } + + /** + * Get a result of getting preconfiguration of Enrollee + * + * @return ::ES_OK\n + * ::ES_COMMUNICATION_ERROR\n + * ::ES_ERROR\n + * + * @see ESResult + */ + ESResult getESResult() + { + return m_result; + } + + /** + * Get Enrollee's pre-configuration properties + * + * @return Enrollee's pre-configuration properties + * + * @see EnrolleeConf + */ + EnrolleeConf& getEnrolleeConf() + { + return m_enrolleeConf; + } + + private: + ESResult m_result; + EnrolleeConf m_enrolleeConf; + }; /** - * Callback definition to be invoked when the security stack expects a pin from application. + * Status object for provisionDeviceProperties API. This object is given to application + * when a response for GET request to provisioning resource at Enrollee is arrived. + * It returns a result of the request. */ - typedef std::function< void(std::string&) > SecurityPinCb; + class DevicePropProvisioningStatus + { + public: + /** + * Constructor + */ + DevicePropProvisioningStatus(ESResult result) : + m_result(result) + { + } + + /** + * Get a result of Device property provisioning + * + * @return ::ES_OK\n + * ::ES_COMMUNICATION_ERROR\n + * ::ES_ERROR\n + * + * @see ESResult + */ + ESResult getESResult() + { + return m_result; + } + + private: + ESResult m_result; + }; /** - * Callback definition to be invoked when the stack expects a db path. + * Status object for provisionCloudProperties API. This object is given to application + * when a response for GET request to provisioning resource at Enrollee is arrived. + * It returns a result of the request and status of this provisioning. The status provides + * an information if the enrollee is found in a given network and the provisioning is + * successfully done. */ - typedef std::function< void(std::string&) > SecProvisioningDbPathCb; - - class ProvisioningStatus + class CloudPropProvisioningStatus { public: - std::shared_ptr< ProvisioningStatus > shared_ptr; - ProvisioningStatus(ESResult result, ESState esState) : - m_result(result), m_esState(esState) + /** + * Constructor + */ + CloudPropProvisioningStatus(ESResult result) : + m_result(result) { - } + /** + * Get a result of Cloud property provisioning + * + * @return ::ES_OK\n + * ::ES_ENROLLEE_DISCOVERY_FAILURE\n + * ::ES_SECURE_RESOURCE_DISCOVERY_FAILURE\n + * ::ES_ACL_PROVISIONING_FAILURE\n + * ::ES_CERT_PROVISIONING_FAILURE\n + * ::ES_COMMUNICATION_ERROR\n + * ::ES_ERROR\n + * + * @see ESResult + */ ESResult getESResult() { return m_result; } - ESState getESState() + private: + ESResult m_result; + }; + + /** + * Status object for connect API. This object is given to application + * when a response for 'Connect' request from Enrollee is arrived. + */ + class ConnectRequestStatus + { + public: + /** + * Constructor + */ + ConnectRequestStatus(ESResult result) : + m_result(result) { - return m_esState; } + + /** + * Get a result of Connect request + * + * @return ::ES_OK\n + * ::ES_COMMUNICATION_ERROR\n + * ::ES_ERROR\n + * + * @see ESResult + */ + ESResult getESResult() + { + return m_result; + } + private: ESResult m_result; - ESState m_esState; }; - class EasySetupStatus + class ESOwnershipTransferData { public: - std::shared_ptr< EasySetupStatus > shared_ptr; - EasySetupStatus(const EasySetupState& easySetupState, - const ProvConfig& provConfig) : - m_easySetupState(easySetupState), m_ProvConfig(provConfig) +#ifdef __WITH_DTLS__ + ESOwnershipTransferData() : + m_MOTMethod(OIC_OXM_COUNT), m_preconfiguredPin("") + { + } + + ESOwnershipTransferData(const ESOwnershipTransferData& data) : + m_MOTMethod(data.getMOTMethod()), + m_preconfiguredPin(data.getPreConfiguredPin()) + { + } + + ESResult setMOTMethod(OicSecOxm_t method) { +#ifdef MULTIPLE_OWNER + if(OIC_RANDOM_DEVICE_PIN != method) + { + return ES_ERROR; + } + + m_MOTMethod = method; + return ES_OK; +#else + (void) method; + + return ES_ERROR; +#endif + } + + ESResult setMOTMethod(OicSecOxm_t method, const std::string& pin) + { +#ifdef MULTIPLE_OWNER + if(OIC_PRECONFIG_PIN != method || pin.empty()) + { + return ES_ERROR; + } + + m_preconfiguredPin = pin; + m_MOTMethod = method; + return ES_OK; +#else + (void) method; + (void) pin; + return ES_ERROR; +#endif } - ProvConfig getProvConfig() + OicSecOxm_t getMOTMethod() const { - return m_ProvConfig; + return m_MOTMethod; } - EasySetupState getEasySetupState() + std::string getPreConfiguredPin() const { - return m_easySetupState; + return m_preconfiguredPin; } + private: - EasySetupState m_easySetupState; - ProvConfig m_ProvConfig; + OicSecOxm_t m_MOTMethod; + std::string m_preconfiguredPin; +#endif }; + + /** + * Callback function definition for providing Enrollee status + */ + typedef function< void(shared_ptr< GetEnrolleeStatus >) > GetStatusCb; + + /** + * Callback function definition for providing Enrollee configuration status + */ + typedef function< void(shared_ptr< GetConfigurationStatus >) > GetConfigurationStatusCb; + + /** + * Callback function definition for providing Enrollee device property provisioning status + */ + typedef function< void(shared_ptr< DevicePropProvisioningStatus >) > DevicePropProvStatusCb; + + /** + * Callback function definition for providing Enrollee cloud property provisioning status + */ + typedef function< void(shared_ptr< CloudPropProvisioningStatus >) > CloudPropProvStatusCb; + + /** + * Callback function definition for providing 'Connect' request status + */ + typedef function< void(shared_ptr< ConnectRequestStatus >) > ConnectRequestStatusCb; + + + /** + * Callback function definition for providing Enrollee security provisioning status + */ + typedef function< void(shared_ptr) > SecurityProvStatusCb; + + /** + * Callback function definition for providing Enrollee security provisioning status. + * This callback is an overloaded version of SecurityProvStatusCb, which has + * ESOwnershipTransferData as a return value. + */ + typedef function< ESOwnershipTransferData(shared_ptr) > + SecurityProvStatusCbWithOption; + + /** + * Callback definition to be invoked when the security stack expects a pin from application + */ + typedef function< void(string&) > SecurityPinCb; + + /** + * Callback definition to be invoked when the stack expects a db path + */ + typedef function< void(string&) > SecProvisioningDbPathCb; + } } #endif //WITH_ARDUINO