#include "srmresourcestrings.h" //@note: SRM's internal header
#include "doxmresource.h" //@note: SRM's internal header
#include "pstatresource.h" //@note: SRM's internal header
+#include "verresource.h" //@note: SRM's internal header
#include "pmtypes.h"
#include "pmutility.h"
bool isOwnedDiscovery;
} DiscoveryInfo;
+/*
+ * Function to discover secre port information through unicast
+ *
+ * @param[in] discoveryInfo The pointer of discovery information to matain result of discovery
+ * @param[in] clientResponse Response information(It will contain payload)
+ *
+ * @return OC_STACK_OK on success otherwise error.
+ */
+static OCStackResult SecurePortDiscovery(DiscoveryInfo* discoveryInfo,
+ const OCClientResponse *clientResponse);
+
+/*
+ * Function to discover security version information through unicast
+ *
+ * @param[in] discoveryInfo The pointer of discovery information to matain result of discovery
+ * @param[in] clientResponse Response information(It will contain payload)
+ *
+ * @return OC_STACK_OK on success otherwise error.
+ */
+static OCStackResult SecurityVersionDiscovery(DiscoveryInfo* discoveryInfo,
+ const OCClientResponse *clientResponse);
+
+/**
+ * Callback handler for PMDeviceDiscovery API.
+ *
+ * @param[in] ctx User context
+ * @param[in] handle Handler for response
+ * @param[in] clientResponse Response information (It will contain payload)
+ * @return OC_STACK_KEEP_TRANSACTION to keep transaction and
+ * OC_STACK_DELETE_TRANSACTION to delete it.
+ */
+static OCStackApplicationResult DeviceDiscoveryHandler(void *ctx, OCDoHandle UNUSED,
+ OCClientResponse *clientResponse);
+
+/**
+ * Callback handler for getting secure port information using /oic/res discovery.
+ *
+ * @param[in] ctx user context
+ * @param[in] handle Handle for response
+ * @param[in] clientResponse Response information(It will contain payload)
+ *
+ * @return OC_STACK_KEEP_TRANSACTION to keep transaction and
+ * OC_STACK_DELETE_TRANSACTION to delete it.
+ */
+static OCStackApplicationResult SecurePortDiscoveryHandler(void *ctx, OCDoHandle UNUSED,
+ OCClientResponse *clientResponse);
+
+/**
+ * Callback handler for security version discovery.
+ *
+ * @param[in] ctx User context
+ * @param[in] handle Handler for response
+ * @param[in] clientResponse Response information (It will contain payload)
+ * @return OC_STACK_KEEP_TRANSACTION to keep transaction and
+ * OC_STACK_DELETE_TRANSACTION to delete it.
+ */
+static OCStackApplicationResult SecVersionDiscoveryHandler(void *ctx, OCDoHandle UNUSED,
+ OCClientResponse *clientResponse);
+
/**
* Function to search node in linked list that matches given IP and port.
*
{
if(NULL == addr || NULL == *ppDevicesList)
{
- OC_LOG_V(ERROR, TAG, "Invalid Input parameters in [%s]\n", __FUNCTION__);
+ OIC_LOG_V(ERROR, TAG, "Invalid Input parameters in [%s]\n", __FUNCTION__);
return NULL;
}
ptr = (OCProvisionDev_t *)OICCalloc(1, sizeof (OCProvisionDev_t));
if (NULL == ptr)
{
- OC_LOG(ERROR, TAG, "Error while allocating memory for linkedlist node !!");
+ OIC_LOG(ERROR, TAG, "Error while allocating memory for linkedlist node !!");
return OC_STACK_NO_MEMORY;
}
ptr->next = NULL;
ptr->connType = connType;
ptr->devStatus = DEV_STATUS_ON; //AddDevice is called when discovery(=alive)
+ OICStrcpy(ptr->secVer, MAX_VERSION_LEN, DEFAULT_SEC_VERSION); // version initialization
LL_PREPEND(*ppDevicesList, ptr);
}
if(!ptr)
{
- OC_LOG(ERROR, TAG, "Can not find device information in the discovery device list");
+ OIC_LOG(ERROR, TAG, "Can not find device information in the discovery device list");
return OC_STACK_ERROR;
}
}
/**
+ * Function to set security version information from the given list of devices.
+ *
+ * @param[in] pList List of OCProvisionDev_t.
+ * @param[in] addr address of target device.
+ * @param[in] port port of remote server.
+ * @param[in] secVer security version information.
+ *
+ * @return OC_STACK_OK for success and errorcode otherwise.
+ */
+OCStackResult UpdateSecVersionOfDevice(OCProvisionDev_t **ppDevicesList, const char *addr,
+ uint16_t port, const char* secVer)
+{
+ if (NULL == secVer)
+ {
+ return OC_STACK_INVALID_PARAM;
+ }
+
+ OCProvisionDev_t *ptr = GetDevice(ppDevicesList, addr, port);
+
+ if(!ptr)
+ {
+ OIC_LOG(ERROR, TAG, "Can not find device information in the discovery device list");
+ return OC_STACK_ERROR;
+ }
+
+ OICStrcpy(ptr->secVer, MAX_VERSION_LEN, secVer);
+
+ return OC_STACK_OK;
+}
+
+/**
* This function deletes list of provision target devices
*
* @param[in] pDevicesList List of OCProvisionDev_t.
OCProvisionDev_t* PMCloneOCProvisionDev(const OCProvisionDev_t* src)
{
- OC_LOG(DEBUG, TAG, "IN PMCloneOCProvisionDev");
+ OIC_LOG(DEBUG, TAG, "IN PMCloneOCProvisionDev");
if (!src)
{
- OC_LOG(ERROR, TAG, "PMCloneOCProvisionDev : Invalid parameter");
+ OIC_LOG(ERROR, TAG, "PMCloneOCProvisionDev : Invalid parameter");
return NULL;
}
newDev->doxm->oxm = NULL;
}
+ if (0 == strlen(src->secVer))
+ {
+ OICStrcpy(newDev->secVer, MAX_VERSION_LEN, DEFAULT_SEC_VERSION);
+ }
+ else
+ {
+ OICStrcpy(newDev->secVer, MAX_VERSION_LEN, src->secVer);
+ }
+
newDev->securePort = src->securePort;
newDev->devStatus = src->devStatus;
newDev->connType = src->connType;
newDev->next = NULL;
- OC_LOG(DEBUG, TAG, "OUT PMCloneOCProvisionDev");
+ OIC_LOG(DEBUG, TAG, "OUT PMCloneOCProvisionDev");
return newDev;
exit:
- OC_LOG(ERROR, TAG, "PMCloneOCProvisionDev : Failed to allocate memory");
+ OIC_LOG(ERROR, TAG, "PMCloneOCProvisionDev : Failed to allocate memory");
if (newDev)
{
OICFree(newDev->pstat);
{
if(!address || !buffer || !uri)
{
- OC_LOG(ERROR, TAG, "PMGenerateQuery : Invalid parameters.");
+ OIC_LOG(ERROR, TAG, "PMGenerateQuery : Invalid parameters.");
return false;
}
prefix, address, port, uri);
break;
default:
- OC_LOG(ERROR, TAG, "Unknown address format.");
+ OIC_LOG(ERROR, TAG, "Unknown address format.");
return false;
}
// snprintf return value check
if (snRet < 0)
{
- OC_LOG_V(ERROR, TAG, "PMGenerateQuery : Error (snprintf) %d\n", snRet);
+ OIC_LOG_V(ERROR, TAG, "PMGenerateQuery : Error (snprintf) %d\n", snRet);
return false;
}
else if ((size_t)snRet >= bufferSize)
{
- OC_LOG_V(ERROR, TAG, "PMGenerateQuery : Truncated (snprintf) %d\n", snRet);
+ OIC_LOG_V(ERROR, TAG, "PMGenerateQuery : Truncated (snprintf) %d\n", snRet);
return false;
}
// TODO: We need to verify tinyDTLS in below cases
case CT_ADAPTER_GATT_BTLE:
case CT_ADAPTER_RFCOMM_BTEDR:
- OC_LOG(ERROR, TAG, "Not supported connectivity adapter.");
+ OIC_LOG(ERROR, TAG, "Not supported connectivity adapter.");
return false;
break;
default:
- OC_LOG(ERROR, TAG, "Unknown connectivity adapter.");
+ OIC_LOG(ERROR, TAG, "Unknown connectivity adapter.");
return false;
}
return true;
}
-/**
- * Callback handler for getting secure port information using /oic/res discovery.
- *
- * @param[in] ctx user context
- * @param[in] handle Handle for response
- * @param[in] clientResponse Response information(It will contain payload)
- *
- * @return OC_STACK_KEEP_TRANSACTION to keep transaction and
- * OC_STACK_DELETE_TRANSACTION to delete it.
- */
+static OCStackApplicationResult SecurityVersionDiscoveryHandler(void *ctx, OCDoHandle UNUSED,
+ OCClientResponse *clientResponse)
+{
+ if (ctx == NULL)
+ {
+ OIC_LOG(ERROR, TAG, "Lost List of device information");
+ return OC_STACK_KEEP_TRANSACTION;
+ }
+ (void)UNUSED;
+ if (clientResponse)
+ {
+ if (NULL == clientResponse->payload)
+ {
+ OIC_LOG(INFO, TAG, "Skiping Null payload");
+ return OC_STACK_KEEP_TRANSACTION;
+ }
+ if (OC_STACK_OK != clientResponse->result)
+ {
+ OIC_LOG(INFO, TAG, "Error in response");
+ return OC_STACK_KEEP_TRANSACTION;
+ }
+ else
+ {
+ if (PAYLOAD_TYPE_SECURITY != clientResponse->payload->type)
+ {
+ OIC_LOG(INFO, TAG, "Unknown payload type");
+ return OC_STACK_KEEP_TRANSACTION;
+ }
+
+ OicSecVer_t *ptrVer = NULL;
+ uint8_t *payload = ((OCSecurityPayload*)clientResponse->payload)->securityData;
+ size_t size = ((OCSecurityPayload*)clientResponse->payload)->payloadSize;
+
+ OCStackResult res = CBORPayloadToVer(payload, size, &ptrVer);
+ if ((NULL == ptrVer) && (OC_STACK_OK != res))
+ {
+ OIC_LOG(INFO, TAG, "Ignoring malformed CBOR");
+ return OC_STACK_KEEP_TRANSACTION;
+ }
+ else
+ {
+ OIC_LOG(DEBUG, TAG, "Successfully converted ver cbor to bin.");
+
+ //If this is owend device discovery we have to filter out the responses.
+ DiscoveryInfo* pDInfo = (DiscoveryInfo*)ctx;
+ res = UpdateSecVersionOfDevice(pDInfo->ppDevicesList, clientResponse->devAddr.addr,
+ clientResponse->devAddr.port, ptrVer->secv);
+ if (OC_STACK_OK != res)
+ {
+ OIC_LOG(ERROR, TAG, "Error while getting security version.");
+ DeleteVerBinData(ptrVer);
+ return OC_STACK_KEEP_TRANSACTION;
+ }
+
+ OIC_LOG(INFO, TAG, "= Discovered security version =");
+ OIC_LOG_V(DEBUG, TAG, "IP %s", clientResponse->devAddr.addr);
+ OIC_LOG_V(DEBUG, TAG, "PORT %d", clientResponse->devAddr.port);
+ OIC_LOG_V(DEBUG, TAG, "VERSION %s", ptrVer->secv);
+
+ OIC_LOG(INFO, TAG, "Exiting SecVersionDiscoveryHandler.");
+ DeleteVerBinData(ptrVer);
+ }
+ }
+ }
+ else
+ {
+ OIC_LOG(INFO, TAG, "Skiping Null response");
+ return OC_STACK_KEEP_TRANSACTION;
+ }
+
+ return OC_STACK_DELETE_TRANSACTION;
+}
+
static OCStackApplicationResult SecurePortDiscoveryHandler(void *ctx, OCDoHandle UNUSED,
OCClientResponse *clientResponse)
{
if (ctx == NULL)
{
- OC_LOG(ERROR, TAG, "Lost List of device information");
+ OIC_LOG(ERROR, TAG, "Lost List of device information");
return OC_STACK_DELETE_TRANSACTION;
}
(void)UNUSED;
{
if (NULL == clientResponse->payload)
{
- OC_LOG(INFO, TAG, "Skiping Null payload");
+ OIC_LOG(INFO, TAG, "Skiping Null payload");
}
else
{
if (PAYLOAD_TYPE_DISCOVERY != clientResponse->payload->type)
{
- OC_LOG(INFO, TAG, "Wrong payload type");
+ OIC_LOG(INFO, TAG, "Wrong payload type");
return OC_STACK_DELETE_TRANSACTION;
}
uint16_t securePort = 0;
OCResourcePayload* resPayload = ((OCDiscoveryPayload*)clientResponse->payload)->resources;
+ // Use seure port of doxm for OTM and Provision.
+ while (resPayload)
+ {
+ if (0 == strncmp(resPayload->uri, OIC_RSRC_DOXM_URI, strlen(OIC_RSRC_DOXM_URI)))
+ {
+ OIC_LOG_V(INFO,TAG,"resPaylod->uri:%s",resPayload->uri);
+ OIC_LOG(INFO, TAG, "Found doxm resource.");
+ break;
+ }
+ else
+ {
+ resPayload = resPayload->next;
+ }
+ }
+ if (NULL == resPayload)
+ {
+ OIC_LOG(ERROR, TAG, "Can not find doxm resource.");
+ return OC_STACK_DELETE_TRANSACTION;
+ }
if (resPayload && resPayload->secure)
{
securePort = resPayload->port;
}
else
{
- OC_LOG(INFO, TAG, "Can not find secure port information.");
+ OIC_LOG(INFO, TAG, "Can not find secure port information.");
return OC_STACK_DELETE_TRANSACTION;
}
DiscoveryInfo* pDInfo = (DiscoveryInfo*)ctx;
- OCProvisionDev_t **ppDevicesList = pDInfo->ppDevicesList;
-
- OCStackResult res = UpdateSecurePortOfDevice(ppDevicesList, clientResponse->devAddr.addr,
+ OCStackResult res = UpdateSecurePortOfDevice(pDInfo->ppDevicesList,
+ clientResponse->devAddr.addr,
clientResponse->devAddr.port, securePort);
if (OC_STACK_OK != res)
{
- OC_LOG(ERROR, TAG, "Error while getting secure port.");
+ OIC_LOG(ERROR, TAG, "Error while getting secure port.");
+ return OC_STACK_DELETE_TRANSACTION;
+ }
+
+ res = SecurityVersionDiscovery(pDInfo, clientResponse);
+ if(OC_STACK_OK != res)
+ {
+ OIC_LOG(ERROR, TAG, "Failed to SecurityVersionDiscovery");
return OC_STACK_DELETE_TRANSACTION;
}
- OC_LOG(INFO, TAG, "Exiting SecurePortDiscoveryHandler.");
+
+ OIC_LOG(INFO, TAG, "Exiting SecurePortDiscoveryHandler.");
}
return OC_STACK_DELETE_TRANSACTION;
}
else
{
- OC_LOG(INFO, TAG, "Skiping Null response");
+ OIC_LOG(INFO, TAG, "Skiping Null response");
}
+
return OC_STACK_DELETE_TRANSACTION;
}
-/**
- * Callback handler for PMDeviceDiscovery API.
- *
- * @param[in] ctx User context
- * @param[in] handle Handler for response
- * @param[in] clientResponse Response information (It will contain payload)
- * @return OC_STACK_KEEP_TRANSACTION to keep transaction and
- * OC_STACK_DELETE_TRANSACTION to delete it.
- */
static OCStackApplicationResult DeviceDiscoveryHandler(void *ctx, OCDoHandle UNUSED,
OCClientResponse *clientResponse)
{
if (ctx == NULL)
{
- OC_LOG(ERROR, TAG, "Lost List of device information");
+ OIC_LOG(ERROR, TAG, "Lost List of device information");
return OC_STACK_KEEP_TRANSACTION;
}
(void)UNUSED;
{
if (NULL == clientResponse->payload)
{
- OC_LOG(INFO, TAG, "Skiping Null payload");
+ OIC_LOG(INFO, TAG, "Skiping Null payload");
return OC_STACK_KEEP_TRANSACTION;
}
if (OC_STACK_OK != clientResponse->result)
{
- OC_LOG(INFO, TAG, "Error in response");
+ OIC_LOG(INFO, TAG, "Error in response");
return OC_STACK_KEEP_TRANSACTION;
}
else
{
if (PAYLOAD_TYPE_SECURITY != clientResponse->payload->type)
{
- OC_LOG(INFO, TAG, "Unknown payload type");
+ OIC_LOG(INFO, TAG, "Unknown payload type");
return OC_STACK_KEEP_TRANSACTION;
}
- OicSecDoxm_t *ptrDoxm = JSONToDoxmBin(
- ((OCSecurityPayload*)clientResponse->payload)->securityData);
- if (NULL == ptrDoxm)
+
+ OicSecDoxm_t *ptrDoxm = NULL;
+ uint8_t *payload = ((OCSecurityPayload*)clientResponse->payload)->securityData;
+ size_t size = ((OCSecurityPayload*)clientResponse->payload)->payloadSize;
+
+ OCStackResult res = CBORPayloadToDoxm(payload, size, &ptrDoxm);
+ if ((NULL == ptrDoxm) || (OC_STACK_OK != res))
{
- OC_LOG(INFO, TAG, "Ignoring malformed JSON");
+ OIC_LOG(INFO, TAG, "Ignoring malformed CBOR");
return OC_STACK_KEEP_TRANSACTION;
}
else
{
- OC_LOG(DEBUG, TAG, "Successfully converted doxm json to bin.");
+ OIC_LOG(DEBUG, TAG, "Successfully converted doxm cbor to bin.");
//If this is owend device discovery we have to filter out the responses.
DiscoveryInfo* pDInfo = (DiscoveryInfo*)ctx;
OCStackResult res = GetDoxmDevOwnerId(&myId);
if(OC_STACK_OK != res)
{
- OC_LOG(ERROR, TAG, "Error while getting my device ID.");
+ OIC_LOG(ERROR, TAG, "Error while getting my device ID.");
DeleteDoxmBinData(ptrDoxm);
return OC_STACK_KEEP_TRANSACTION;
}
if( (pDInfo->isOwnedDiscovery) &&
(0 != memcmp(&ptrDoxm->owner.id, &myId.id, sizeof(myId.id))) )
{
- OC_LOG(DEBUG, TAG, "Discovered device is not owend by me");
+ OIC_LOG(DEBUG, TAG, "Discovered device is not owend by me");
DeleteDoxmBinData(ptrDoxm);
return OC_STACK_KEEP_TRANSACTION;
}
- res = AddDevice(ppDevicesList, clientResponse->devAddr.addr,
- clientResponse->devAddr.port,
- clientResponse->devAddr.adapter,
- clientResponse->connType, ptrDoxm);
- if (OC_STACK_OK != res)
+ res = GetDoxmDeviceID(&myId);
+ if(OC_STACK_OK != res)
{
- OC_LOG(ERROR, TAG, "Error while adding data to linkedlist.");
+ OIC_LOG(ERROR, TAG, "Error while getting my UUID.");
DeleteDoxmBinData(ptrDoxm);
return OC_STACK_KEEP_TRANSACTION;
}
- char rsrc_uri[MAX_URI_LENGTH+1] = {0};
- int wr_len = snprintf(rsrc_uri, sizeof(rsrc_uri), "%s?%s=%s",
- OC_RSRVD_WELL_KNOWN_URI, OC_RSRVD_RESOURCE_TYPE, OIC_RSRC_TYPE_SEC_DOXM);
- if(wr_len <= 0 || (size_t)wr_len >= sizeof(rsrc_uri))
+ //if this is owned discovery and this is PT's reply, discard it
+ if((pDInfo->isOwnedDiscovery) &&
+ (0 == memcmp(&ptrDoxm->deviceID.id, &myId.id, sizeof(myId.id))) )
{
- OC_LOG(ERROR, TAG, "rsrc_uri_string_print failed");
- return OC_STACK_ERROR;
- }
- //Try to the unicast discovery to getting secure port
- char query[MAX_URI_LENGTH+MAX_QUERY_LENGTH+1] = {0};
- if(!PMGenerateQuery(false,
- clientResponse->devAddr.addr, clientResponse->devAddr.port,
- clientResponse->connType,
- query, sizeof(query), rsrc_uri))
- {
- OC_LOG(ERROR, TAG, "DeviceDiscoveryHandler : Failed to generate query");
+ OIC_LOG(DEBUG, TAG, "discarding provision tool's reply");
+ DeleteDoxmBinData(ptrDoxm);
return OC_STACK_KEEP_TRANSACTION;
}
- OC_LOG_V(DEBUG, TAG, "Query=%s", query);
-
- OCCallbackData cbData;
- cbData.cb = &SecurePortDiscoveryHandler;
- cbData.context = ctx;
- cbData.cd = NULL;
- OCStackResult ret = OCDoResource(NULL, OC_REST_DISCOVER, query, 0, 0,
- clientResponse->connType, OC_LOW_QOS, &cbData, NULL, 0);
- // TODO: Should we use the default secure port in case of error?
- if(OC_STACK_OK != ret)
+
+ res = AddDevice(ppDevicesList, clientResponse->devAddr.addr,
+ clientResponse->devAddr.port,
+ clientResponse->devAddr.adapter,
+ clientResponse->connType, ptrDoxm);
+ if (OC_STACK_OK != res)
{
- OC_LOG(ERROR, TAG, "Failed to Secure Port Discovery");
+ OIC_LOG(ERROR, TAG, "Error while adding data to linkedlist.");
+ DeleteDoxmBinData(ptrDoxm);
return OC_STACK_KEEP_TRANSACTION;
}
- else
+
+ res = SecurePortDiscovery(pDInfo, clientResponse);
+ if(OC_STACK_OK != res)
{
- OC_LOG_V(INFO, TAG, "OCDoResource with [%s] Success", query);
+ OIC_LOG(ERROR, TAG, "Failed to SecurePortDiscovery");
+ DeleteDoxmBinData(ptrDoxm);
+ return OC_STACK_KEEP_TRANSACTION;
}
- OC_LOG(INFO, TAG, "Exiting ProvisionDiscoveryHandler.");
+
+ OIC_LOG(INFO, TAG, "Exiting ProvisionDiscoveryHandler.");
}
return OC_STACK_KEEP_TRANSACTION;
}
else
{
- OC_LOG(INFO, TAG, "Skiping Null response");
+ OIC_LOG(INFO, TAG, "Skiping Null response");
return OC_STACK_KEEP_TRANSACTION;
}
*/
OCStackResult PMDeviceDiscovery(unsigned short waittime, bool isOwned, OCProvisionDev_t **ppDevicesList)
{
- OC_LOG(DEBUG, TAG, "IN PMDeviceDiscovery");
+ OIC_LOG(DEBUG, TAG, "IN PMDeviceDiscovery");
if (NULL != *ppDevicesList)
{
- OC_LOG(ERROR, TAG, "List is not null can cause memory leak");
+ OIC_LOG(ERROR, TAG, "List is not null can cause memory leak");
return OC_STACK_INVALID_PARAM;
}
DiscoveryInfo *pDInfo = OICCalloc(1, sizeof(DiscoveryInfo));
if(NULL == pDInfo)
{
- OC_LOG(ERROR, TAG, "PMDeviceDiscovery : Memory allocation failed.");
+ OIC_LOG(ERROR, TAG, "PMDeviceDiscovery : Memory allocation failed.");
return OC_STACK_NO_MEMORY;
}
OCDoHandle handle = NULL;
res = OCDoResource(&handle, OC_REST_DISCOVER, query, 0, 0,
- CT_DEFAULT, OC_LOW_QOS, &cbData, NULL, 0);
+ CT_DEFAULT, OC_HIGH_QOS, &cbData, NULL, 0);
if (res != OC_STACK_OK)
{
- OC_LOG(ERROR, TAG, "OCStack resource error");
+ OIC_LOG(ERROR, TAG, "OCStack resource error");
OICFree(pDInfo);
return res;
}
res = PMTimeout(waittime, true);
if(OC_STACK_OK != res)
{
- OC_LOG(ERROR, TAG, "Failed to wait response for secure discovery.");
+ OIC_LOG(ERROR, TAG, "Failed to wait response for secure discovery.");
OICFree(pDInfo);
- OCStackResult resCancel = OCCancel(handle, OC_LOW_QOS, NULL, 0);
+ OCStackResult resCancel = OCCancel(handle, OC_HIGH_QOS, NULL, 0);
if(OC_STACK_OK != resCancel)
{
- OC_LOG(ERROR, TAG, "Failed to remove registered callback");
+ OIC_LOG(ERROR, TAG, "Failed to remove registered callback");
}
return res;
}
- res = OCCancel(handle,OC_LOW_QOS,NULL,0);
+ res = OCCancel(handle,OC_HIGH_QOS,NULL,0);
if (OC_STACK_OK != res)
{
- OC_LOG(ERROR, TAG, "Failed to remove registered callback");
+ OIC_LOG(ERROR, TAG, "Failed to remove registered callback");
OICFree(pDInfo);
return res;
}
- OC_LOG(DEBUG, TAG, "OUT PMDeviceDiscovery");
+ OIC_LOG(DEBUG, TAG, "OUT PMDeviceDiscovery");
OICFree(pDInfo);
return res;
}
+static OCStackResult SecurePortDiscovery(DiscoveryInfo* discoveryInfo,
+ const OCClientResponse *clientResponse)
+{
+ OIC_LOG(DEBUG, TAG, "IN SecurePortDiscovery");
+
+ if(NULL == discoveryInfo || NULL == clientResponse)
+ {
+ return OC_STACK_INVALID_PARAM;
+ }
+ //Try to the unicast discovery to getting secure port
+ char query[MAX_URI_LENGTH+MAX_QUERY_LENGTH+1] = {0};
+ if(!PMGenerateQuery(false,
+ clientResponse->devAddr.addr, clientResponse->devAddr.port,
+ clientResponse->connType,
+ query, sizeof(query), OC_RSRVD_WELL_KNOWN_URI))
+ {
+ OIC_LOG(ERROR, TAG, "SecurePortDiscovery : Failed to generate query");
+ return OC_STACK_ERROR;
+ }
+ OIC_LOG_V(DEBUG, TAG, "Query=%s", query);
+
+ OCCallbackData cbData;
+ cbData.cb = &SecurePortDiscoveryHandler;
+ cbData.context = (void*)discoveryInfo;
+ cbData.cd = NULL;
+ OCStackResult ret = OCDoResource(NULL, OC_REST_DISCOVER, query, 0, 0,
+ clientResponse->connType, OC_HIGH_QOS, &cbData, NULL, 0);
+ if(OC_STACK_OK != ret)
+ {
+ OIC_LOG(ERROR, TAG, "Failed to Secure Port Discovery");
+ return ret;
+ }
+ else
+ {
+ OIC_LOG_V(INFO, TAG, "OCDoResource with [%s] Success", query);
+ }
+
+ OIC_LOG(DEBUG, TAG, "OUT SecurePortDiscovery");
+
+ return ret;
+}
+
+static OCStackResult SecurityVersionDiscovery(DiscoveryInfo* discoveryInfo,
+ const OCClientResponse *clientResponse)
+{
+ OIC_LOG(DEBUG, TAG, "IN SecurityVersionDiscovery");
+
+ if(NULL == discoveryInfo || NULL == clientResponse)
+ {
+ return OC_STACK_INVALID_PARAM;
+ }
+
+ //Try to the unicast discovery to getting security version
+ char query[MAX_URI_LENGTH+MAX_QUERY_LENGTH+1] = {0};
+ if(!PMGenerateQuery(false,
+ clientResponse->devAddr.addr, clientResponse->devAddr.port,
+ clientResponse->connType,
+ query, sizeof(query), OIC_RSRC_VER_URI))
+ {
+ OIC_LOG(ERROR, TAG, "SecurityVersionDiscovery : Failed to generate query");
+ return OC_STACK_ERROR;
+ }
+ OIC_LOG_V(DEBUG, TAG, "Query=%s", query);
+
+ OCCallbackData cbData;
+ cbData.cb = &SecurityVersionDiscoveryHandler;
+ cbData.context = (void*)discoveryInfo;
+ cbData.cd = NULL;
+ OCStackResult ret = OCDoResource(NULL, OC_REST_DISCOVER, query, 0, 0,
+ clientResponse->connType, OC_HIGH_QOS, &cbData, NULL, 0);
+ if(OC_STACK_OK != ret)
+ {
+ OIC_LOG(ERROR, TAG, "Failed to Security Version Discovery");
+ return ret;
+ }
+ else
+ {
+ OIC_LOG_V(INFO, TAG, "OCDoResource with [%s] Success", query);
+ }
+
+ OIC_LOG(DEBUG, TAG, "OUT SecurityVersionDiscovery");
+
+ return ret;
+}
+
/**
* Function to print OCProvisionDev_t for debug purpose.
*
- * @param[in] pDev Pointer to OCProvisionDev_t. It's information will be printed by OC_LOG_XX
+ * @param[in] pDev Pointer to OCProvisionDev_t. It's information will be printed by OIC_LOG_XX
*
*/
void PMPrintOCProvisionDev(const OCProvisionDev_t* pDev)
{
if (pDev)
{
- OC_LOG(DEBUG, TAG, "+++++ OCProvisionDev_t Information +++++");
- OC_LOG_V(DEBUG, TAG, "IP %s", pDev->endpoint.addr);
- OC_LOG_V(DEBUG, TAG, "PORT %d", pDev->endpoint.port);
- OC_LOG_V(DEBUG, TAG, "S-PORT %d", pDev->securePort);
- OC_LOG(DEBUG, TAG, "++++++++++++++++++++++++++++++++++++++++");
+ OIC_LOG(DEBUG, TAG, "+++++ OCProvisionDev_t Information +++++");
+ OIC_LOG_V(DEBUG, TAG, "IP %s", pDev->endpoint.addr);
+ OIC_LOG_V(DEBUG, TAG, "PORT %d", pDev->endpoint.port);
+ OIC_LOG_V(DEBUG, TAG, "S-PORT %d", pDev->securePort);
+ OIC_LOG(DEBUG, TAG, "++++++++++++++++++++++++++++++++++++++++");
}
else
{
- OC_LOG(DEBUG, TAG, "+++++ OCProvisionDev_t is NULL +++++");
+ OIC_LOG(DEBUG, TAG, "+++++ OCProvisionDev_t is NULL +++++");
}
}
projects / platform / upstream / iotivity.git / blobdiff