static void deleteResourceInterface(OCResourceInterface *resourceInterface);
/**
- * Delete all child resources.
+ * Unbind all child resources.
*
- * @param resourceChild Specified binded resource is deleted from parent.
+ * @param resourceChild Specified binded resource head is deleted from parent.
*/
-static void deleteResourceChild(OCChildResource *resourceChild);
+static void unbindChildResources(OCChildResource *resourceChild);
/**
* Delete all of the dynamically allocated elements that were created for the resource.
*/
static void OCDefaultConnectionStateChangedHandler(const CAEndpoint_t *info, bool isConnected);
-/**
- * Register network monitoring callback.
- * Network status changes are delivered these callback.
- * @param adapterHandler Adapter state monitoring callback.
- * @param connectionHandler Connection state monitoring callback.
- */
-static void OCSetNetworkMonitorHandler(CAAdapterStateChangedCB adapterHandler,
- CAConnectionStateChangedCB connectionHandler);
-
//-----------------------------------------------------------------------------
// Internal functions
//-----------------------------------------------------------------------------
}
}
- OIC_LOG(INFO, TAG, "Callback for presence");
-
+ OIC_LOG(INFO, TAG, "Before calling into application address space for presence");
cbResult = cbNode->callBack(cbNode->context, cbNode->handle, &response);
+ OIC_LOG(INFO, TAG, "After calling into application address space for presence");
if (cbResult == OC_STACK_DELETE_TRANSACTION)
{
else if(responseInfo->result == CA_RETRANSMIT_TIMEOUT)
{
OIC_LOG(INFO, TAG, "Receiving A Timeout for this token");
- OIC_LOG(INFO, TAG, "Calling into application address space");
OCClientResponse response =
{.devAddr = {.adapter = OC_DEFAULT_ADAPTER}};
response.identity.id_length = responseInfo->info.identity.id_length;
response.result = CAResponseToOCStackResult(responseInfo->result);
+ OIC_LOG(INFO, TAG, "Before calling into application address space for reTrans timeout");
cbNode->callBack(cbNode->context,
cbNode->handle, &response);
+ OIC_LOG(INFO, TAG, "After calling into application address space for reTrans timeout");
FindAndDeleteClientCB(cbNode);
- OICFree(response.resourceUri);
+ OICFree((void *)response.resourceUri);
}
#ifdef __TIZENRT__
else if ((cbNode->method == OC_REST_OBSERVE || cbNode->method == OC_REST_OBSERVE_ALL)
response.identity.id_length = responseInfo->info.identity.id_length;
response.result = OC_STACK_UNAUTHORIZED_REQ;
+ OIC_LOG(INFO, TAG, "Before calling into application address space for observe resp");
cbNode->callBack(cbNode->context,
cbNode->handle,
&response);
+ OIC_LOG(INFO, TAG, "After calling into application address space for observe resp");
+
FindAndDeleteClientCB(cbNode);
OICFree(response.resourceUri);
}
else
{
OIC_LOG(INFO, TAG, "This is a regular response, A client call back is found");
- OIC_LOG(INFO, TAG, "Calling into application address space");
OCClientResponse response;
memset(&response, 0, sizeof(OCClientResponse));
{
OIC_LOG_V(ERROR, TAG, "Unknown Payload type in Discovery: %d %s",
cbNode->method, cbNode->requestUri);
- OICFree(response.resourceUri);
+ OICFree((void *)response.resourceUri);
return;
}
}
{
OIC_LOG_V(ERROR, TAG, "Unknown Payload type: %d %s",
cbNode->method, cbNode->requestUri);
- OICFree(response.resourceUri);
+ OICFree((void *)response.resourceUri);
return;
}
{
OIC_LOG(ERROR, TAG, "Error converting payload");
OCPayloadDestroy(response.payload);
- OICFree(response.resourceUri);
+ OICFree((void *)response.resourceUri);
return;
}
}
else
{
+ OICFree((void *)response.resourceUri);
response.resourceUri = OICStrdup(cbNode->requestUri);
}
}
{
OIC_LOG(ERROR, TAG, "#header options are more than MAX_HEADER_OPTIONS");
OCPayloadDestroy(response.payload);
- OICFree(response.resourceUri);
+ OICFree((void *)response.resourceUri);
return;
}
- for (uint8_t i = start; i < responseInfo->info.numOptions; i++)
+ if (response.numRcvdVendorSpecificHeaderOptions > 0)
{
- if(&(responseInfo->info.options[i]))
+ response.rcvdVendorSpecificHeaderOptions =
+ (OCHeaderOption *) OICCalloc(response.numRcvdVendorSpecificHeaderOptions, sizeof(OCHeaderOption));
+ if (NULL == response.rcvdVendorSpecificHeaderOptions)
{
- memcpy (&(response.rcvdVendorSpecificHeaderOptions[i-start]),
- &(responseInfo->info.options[i]), sizeof(OCHeaderOption));
+ OIC_LOG(ERROR, TAG, "Failed to allocate memory for vendor header options");
+ OCPayloadDestroy(response.payload);
+ OICFree((void *)response.resourceUri);
+ return;
}
+
+ memcpy(response.rcvdVendorSpecificHeaderOptions, responseInfo->info.options + start,
+ response.numRcvdVendorSpecificHeaderOptions*sizeof(OCHeaderOption));
}
}
HandleBatchResponse(cbNode->requestUri, (OCRepPayload **)&response.payload);
}
+ OIC_LOG(INFO, TAG, "Before calling into application address space for handleResponse");
OCStackApplicationResult appFeedback = cbNode->callBack(cbNode->context,
cbNode->handle,
&response);
+ OIC_LOG(INFO, TAG, "After calling into application address space for handleResponse");
+
cbNode->sequenceNumber = response.sequenceNumber;
if (appFeedback == OC_STACK_DELETE_TRANSACTION)
}
}
- OICFree(response.resourceUri);
+ OICFree((void *)response.resourceUri);
OCPayloadDestroy(response.payload);
+ OICFree(response.rcvdVendorSpecificHeaderOptions);
}
return;
}
response.identity.id_length = errorInfo->info.identity.id_length;
response.result = CAResultToOCResult(errorInfo->result);
+ OIC_LOG(INFO, TAG, "Before calling into application address space for error response");
cbNode->callBack(cbNode->context, cbNode->handle, &response);
+ OIC_LOG(INFO, TAG, "After calling into application address space for error response");
}
ResourceObserver *observer = GetObserverUsingToken(errorInfo->info.token,
OICFree(serverRequest.requestToken);
return;
}
+
serverRequest.numRcvdVendorSpecificHeaderOptions = tempNum;
if (serverRequest.numRcvdVendorSpecificHeaderOptions && requestInfo->info.options)
{
- memcpy (&(serverRequest.rcvdVendorSpecificHeaderOptions), requestInfo->info.options,
+ serverRequest.rcvdVendorSpecificHeaderOptions = (OCHeaderOption*) OICCalloc(tempNum, sizeof(OCHeaderOption));
+ if (NULL == serverRequest.rcvdVendorSpecificHeaderOptions)
+ {
+ OIC_LOG(ERROR, TAG, "Failed to allocated memory to vnd header options!");
+ OICFree(serverRequest.payload);
+ OICFree(serverRequest.requestToken);
+ return;
+ }
+
+ memcpy (serverRequest.rcvdVendorSpecificHeaderOptions, requestInfo->info.options,
sizeof(CAHeaderOption_t)*tempNum);
}
{
OIC_LOG_V(ERROR, TAG, "HandleStackRequests failed. error: %d", requestResult);
+ // Delete observer node if it is OBSERVE failure from app
+ if (serverRequest.observationOption == OC_OBSERVE_REGISTER)
+ {
+ DeleteObserverUsingToken(requestInfo->info.token, requestInfo->info.tokenLength);
+ }
+
CAResponseResult_t stackResponse =
OCToCAStackResult(requestResult, serverRequest.method);
// The token is copied in there, and is thus still owned by this function.
OICFree(serverRequest.payload);
OICFree(serverRequest.requestToken);
+ OICFree(serverRequest.rcvdVendorSpecificHeaderOptions);
OIC_LOG(INFO, TAG, "Exit OCHandleRequests");
}
OCStackResult OCInit1(OCMode mode, OCTransportFlags serverFlags, OCTransportFlags clientFlags)
{
+ OC_UNUSED(serverFlags);
+ OC_UNUSED(clientFlags);
+
OIC_LOG(DEBUG, TAG, "call OCInit1");
return OCInit2(mode, OC_DEFAULT_FLAGS, OC_DEFAULT_FLAGS, OC_DEFAULT_ADAPTER);
}
}
#endif
- InitializeObseverList();
+ InitializeObserverList();
exit:
if(result != OC_STACK_OK)
TerminateScheduleResourceList();
// Remove all observers
- TerminateObserverList();
+ DeleteObserverList();
// Free memory dynamically allocated for resources
deleteAllResources();
// Remove all the client callbacks
// TODO after BeachHead delivery: consolidate into single SRMDeInit()
SRMDeInitPolicyEngine();
+ // Destroy Observer List Mutex
+ TerminateObserverList();
+
stackState = OC_STACK_UNINITIALIZED;
return OC_STACK_OK;
}
goto exit;
}
+ token = NULL; // Client CB list entry now owns it
devAddr = NULL; // Client CB list entry now owns it
resourceUri = NULL; // Client CB list entry now owns it
resourceType = NULL; // Client CB list entry now owns it
OIC_LOG_V(DEBUG, TAG, "moving to TTL level %d",
cbNode->presence->TTLlevel);
+ OIC_LOG(INFO, TAG, "Before calling into application address space for presence timeout");
cbResult = cbNode->callBack(cbNode->context, cbNode->handle, &clientResponse);
+ OIC_LOG(INFO, TAG, "After calling into application address space for presence timeout");
+
if (cbResult == OC_STACK_DELETE_TRANSACTION)
{
FindAndDeleteClientCB(cbNode);
}
if (resource->rsrcChildResourcesHead)
{
- deleteResourceChild(resource->rsrcChildResourcesHead);
+ unbindChildResources(resource->rsrcChildResourcesHead);
resource->rsrcChildResourcesHead = NULL;
}
if (resource->rsrcAttributes)
}
}
-void deleteResourceChild(OCChildResource *resourceChild)
+void unbindChildResources(OCChildResource *head)
{
OCChildResource *next = NULL;
- for (OCChildResource *pointer = resourceChild; pointer; pointer = next)
+ for (OCChildResource *current = head; current; current = next)
{
- next = pointer->next ? pointer->next : NULL;
- if (pointer->rsrcResource)
- {
- deleteResourceElements(pointer->rsrcResource);
- pointer->rsrcResource = NULL;
- }
- OICFree(pointer);
+ next = current->next;
+ OICFree(current);
}
}
{
OCBindResourceInsToResource(handle, ins);
}
+
+ OICFree(uri);
+ uri = NULL;
}
}
+
+ // Free links
+ size_t count = calcDimTotal(dimensions);
+ for (size_t k = 0; k < count; k++)
+ {
+ OCRepPayloadDestroy(links[k]);
+ }
+ OICFree(links);
}
}
}
#endif
OCStackResult OCSetHeaderOption(OCHeaderOption* ocHdrOpt, size_t* numOptions, uint16_t optionID,
- void* optionData, size_t optionDataLength)
+ const void* optionData, size_t optionDataLength)
{
if (!ocHdrOpt)
{
}
}
-void OCSetNetworkMonitorHandler(CAAdapterStateChangedCB adapterHandler,
- CAConnectionStateChangedCB connectionHandler)
-{
- OIC_LOG(DEBUG, TAG, "OCSetNetworkMonitorHandler");
- g_adapterHandler = adapterHandler;
- g_connectionHandler = connectionHandler;
-}
-
OCStackResult OCGetDeviceId(OCUUIdentity *deviceId)
{
OicUuid_t oicUuid;
projects / platform / upstream / iotivity.git / blobdiff