static void CATimeoutCallback(const CAEndpoint_t *endpoint, const void *pdu, uint32_t size) { OIC_LOG(DEBUG, TAG, "IN"); CAEndpoint_t* ep = CACloneEndpoint(endpoint); if (NULL == ep) { OIC_LOG(ERROR, TAG, "clone failed"); return; } CAResponseInfo_t* resInfo = (CAResponseInfo_t*) OICCalloc(1, sizeof(CAResponseInfo_t)); if (NULL == resInfo) { OIC_LOG(ERROR, TAG, "calloc failed"); CAFreeEndpoint(ep); return; } resInfo->result = CA_RETRANSMIT_TIMEOUT; resInfo->info.type = CAGetMessageTypeFromPduBinaryData(pdu, size); resInfo->info.messageId = CAGetMessageIdFromPduBinaryData(pdu, size); if (g_responseHandler) { g_responseHandler(ep, resInfo); } CAFreeEndpoint(ep); OICFree(resInfo); OIC_LOG(DEBUG, TAG, "OUT"); }
/** * implement for BT-EDR adapter common method */ CAResult_t CAEDRGetInterfaceInformation(CAEndpoint_t **info) { OIC_LOG(DEBUG, TAG, "IN - CAEDRGetInterfaceInformation"); if (!info) { OIC_LOG(ERROR, TAG, "endpoint info is null"); return CA_STATUS_FAILED; } int32_t netInfoSize = 1; char *macAddress = NULL; CAResult_t ret = CAEDRGetInterfaceInfo(&macAddress); OIC_LOG_V(ERROR, TAG, "address : %s", macAddress); if (NULL == macAddress) { OIC_LOG(ERROR, TAG, "mac address is null"); return CA_STATUS_FAILED; } if (CA_STATUS_OK != ret) { OIC_LOG_V(ERROR, TAG, "Failed to get interface info [%d]", ret); OICFree(macAddress); return ret; } // Create local endpoint using util function CAEndpoint_t *endpoint = CACreateEndpointObject(CA_DEFAULT_FLAGS, CA_ADAPTER_RFCOMM_BTEDR, macAddress, 0); if (NULL == endpoint) { OIC_LOG(ERROR, TAG, "Failed to create Local Endpoint!"); OICFree(macAddress); return CA_STATUS_FAILED; } // copy unicast server information CAEndpoint_t *netInfo = (CAEndpoint_t *)OICMalloc(sizeof(CAEndpoint_t) * netInfoSize); if (NULL == netInfo) { OIC_LOG(ERROR, TAG, "Invalid input.."); OICFree(macAddress); CAFreeEndpoint(endpoint); return CA_MEMORY_ALLOC_FAILED; } *netInfo = *endpoint; *info = netInfo; OICFree(macAddress); CAFreeEndpoint(endpoint); OIC_LOG(DEBUG, TAG, "OUT - CAEDRGetInterfaceInformation"); return CA_STATUS_OK; }
static void CATimeoutCallback(const CAEndpoint_t *endpoint, const void *pdu, uint32_t size) { OIC_LOG(DEBUG, TAG, "IN"); VERIFY_NON_NULL_VOID(endpoint, TAG, "endpoint"); VERIFY_NON_NULL_VOID(pdu, TAG, "pdu"); CAEndpoint_t* ep = CACloneEndpoint(endpoint); if (!ep) { OIC_LOG(ERROR, TAG, "clone failed"); return; } CAResponseInfo_t* resInfo = (CAResponseInfo_t*)OICCalloc(1, sizeof(CAResponseInfo_t)); if (!resInfo) { OIC_LOG(ERROR, TAG, "calloc failed"); CAFreeEndpoint(ep); return; } resInfo->result = CA_RETRANSMIT_TIMEOUT; resInfo->info.type = CAGetMessageTypeFromPduBinaryData(pdu, size); resInfo->info.messageId = CAGetMessageIdFromPduBinaryData(pdu, size); CAResult_t res = CAGetTokenFromPDU((const coap_hdr_t *) pdu, &(resInfo->info)); if (CA_STATUS_OK != res) { OIC_LOG(ERROR, TAG, "fail to get Token from retransmission list"); CADestroyResponseInfoInternal(resInfo); CAFreeEndpoint(ep); return; } CAData_t *cadata = (CAData_t *) OICCalloc(1, sizeof(CAData_t)); if (NULL == cadata) { OIC_LOG(ERROR, TAG, "memory allocation failed !"); CAFreeEndpoint(ep); CADestroyResponseInfoInternal(resInfo); return; } cadata->type = SEND_TYPE_UNICAST; cadata->remoteEndpoint = ep; cadata->requestInfo = NULL; cadata->responseInfo = resInfo; #ifdef SINGLE_THREAD CAProcessReceivedData(cadata); #else CAQueueingThreadAddData(&g_receiveThread, cadata, sizeof(CAData_t)); #endif OIC_LOG(DEBUG, TAG, "OUT"); }
void CARANotifyNetworkChange(const char *address, CANetworkStatus_t status) { OIC_LOG(DEBUG, RA_ADAPTER_TAG, "CARANotifyNetworkChange IN"); CAEndpoint_t *localEndpoint = CACreateEndpointObject(CA_DEFAULT_FLAGS, CA_ADAPTER_REMOTE_ACCESS, address, 0); if (!localEndpoint) { OIC_LOG(ERROR, RA_ADAPTER_TAG, "localEndpoint creation failed!"); return; } CANetworkChangeCallback networkChangeCallback = g_networkChangeCallback; if (networkChangeCallback) { networkChangeCallback(localEndpoint, status); } else { OIC_LOG(ERROR, RA_ADAPTER_TAG, "g_networkChangeCallback is NULL"); } CAFreeEndpoint(localEndpoint); OIC_LOG(DEBUG, RA_ADAPTER_TAG, "CARANotifyNetworkChange OUT"); }
void CATerminateEDR() { OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN"); // Stop EDR adapter CAStopEDR(); // Terminate EDR Network Monitor CAEDRTerminateNetworkMonitor(); // Terminate Send/Receive data messages queues CAAdapterTerminateQueues(); g_networkPacketReceivedCallback = NULL; g_networkChangeCallback = NULL; // Terminate thread pool g_edrThreadPool = NULL; // Terminate EDR Client CAEDRClientTerminate(); // Terminate EDR Server CAEDRServerTerminate(); // Free LocalConnectivity information CAFreeEndpoint(g_localConnectivity); g_localConnectivity = NULL; OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT"); }
void CAFreeIPData(CAIPData_t *ipData) { VERIFY_NON_NULL_VOID(ipData, TAG, "ipData is NULL"); CAFreeEndpoint(ipData->remoteEndpoint); OICFree(ipData->data); OICFree(ipData); }
void CAEDRFreeNetworkEvent(CAEDRNetworkEvent *event) { if (event) { CAFreeEndpoint(event->info); OICFree(event); } }
void CAFreeEDRData(CAEDRData *edrData) { VERIFY_NON_NULL_VOID(edrData, EDR_ADAPTER_TAG, "edrData is NULL"); CAFreeEndpoint(edrData->remoteEndpoint); OICFree(edrData->data); OICFree(edrData); }
void CAFreeTCPData(CATCPData *tcpData) { VERIFY_NON_NULL_VOID(tcpData, TAG, "tcpData is NULL"); CAFreeEndpoint(tcpData->remoteEndpoint); OICFree(tcpData->data); OICFree(tcpData); }
static void CASendErrorInfo(const CAEndpoint_t *endpoint, const CAInfo_t *info, CAResult_t result) { OIC_LOG(DEBUG, TAG, "CASendErrorInfo IN"); #ifndef SINGLE_THREAD CAData_t *cadata = (CAData_t *) OICCalloc(1, sizeof(CAData_t)); if (!cadata) { OIC_LOG(ERROR, TAG, "memory allocation failed"); return; } CAEndpoint_t* ep = CACloneEndpoint(endpoint); if (!ep) { OIC_LOG(ERROR, TAG, "endpoint clone failed"); OICFree(cadata); return; } CAErrorInfo_t *errorInfo = (CAErrorInfo_t *)OICCalloc(1, sizeof (CAErrorInfo_t)); if (!errorInfo) { OICFree(cadata); CAFreeEndpoint(ep); return; } CAResult_t res = CACloneInfo(info, &errorInfo->info); if (CA_STATUS_OK != res) { OICFree(cadata); OICFree(errorInfo); CAFreeEndpoint(ep); return; } errorInfo->result = result; cadata->remoteEndpoint = ep; cadata->errorInfo = errorInfo; cadata->dataType = CA_ERROR_DATA; CAQueueingThreadAddData(&g_receiveThread, cadata, sizeof(CAData_t)); #endif OIC_LOG(DEBUG, TAG, "CASendErrorInfo OUT"); }
void CARAXmppMessageReceivedCB(void * const param, xmpp_error_code_t result, const void *const sender, const void *const msg, size_t messageOctets) { if (g_networkPacketCallback) { VERIFY_NON_NULL_VOID(sender, RA_ADAPTER_TAG, "sender is NULL"); VERIFY_NON_NULL_VOID(msg, RA_ADAPTER_TAG, "message is NULL"); OIC_LOG_V (ERROR, RA_ADAPTER_TAG, "Message received from %s", sender); OIC_LOG_V (ERROR, RA_ADAPTER_TAG, "Message reception result %d", result); CAEndpoint_t *endPoint = CACreateEndpointObject(CA_DEFAULT_FLAGS, CA_ADAPTER_REMOTE_ACCESS, sender, 0); if (!endPoint) { OIC_LOG(ERROR, RA_ADAPTER_TAG, "EndPoint creation failed!"); return; } void *buf = OICMalloc(messageOctets); if (!buf) { OIC_LOG(ERROR, RA_ADAPTER_TAG, "Memory alloc of message failed!"); CAFreeEndpoint(endPoint); return; } memcpy(buf, msg, messageOctets); CANetworkPacketReceivedCallback networkPacketCallback = g_networkPacketCallback; if (networkPacketCallback) { g_networkPacketCallback(endPoint, buf, messageOctets); } CAFreeEndpoint (endPoint); } else { OIC_LOG_V (ERROR, RA_ADAPTER_TAG, "No callback for RA received message found"); } }
static void CADestroyData(void *data, uint32_t size) { OIC_LOG(DEBUG, TAG, "CADestroyData IN"); if ((size_t)size < sizeof(CAData_t)) { OIC_LOG_V(ERROR, TAG, "Destroy data too small %p %d", data, size); } CAData_t *cadata = (CAData_t *) data; if (NULL == cadata) { OIC_LOG(ERROR, TAG, "cadata is NULL"); return; } if (NULL != cadata->remoteEndpoint) { CAFreeEndpoint(cadata->remoteEndpoint); } if (NULL != cadata->requestInfo) { CADestroyRequestInfoInternal((CARequestInfo_t *) cadata->requestInfo); } if (NULL != cadata->responseInfo) { CADestroyResponseInfoInternal((CAResponseInfo_t *) cadata->responseInfo); } if (NULL != cadata->errorInfo) { CADestroyErrorInfoInternal(cadata->errorInfo); } OICFree(cadata); OIC_LOG(DEBUG, TAG, "CADestroyData OUT"); }
void CAAdapterDataReceiverHandler(void *context) { OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN_CAAdapterDataReceiverHandler"); CAEDRData *message = (CAEDRData *) context; if (NULL == message || NULL == message->remoteEndpoint) { OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to get message!"); return; } CAEndpoint_t *remoteEndpoint = CACreateEndpointObject(CA_DEFAULT_FLAGS, CA_ADAPTER_RFCOMM_BTEDR, message->remoteEndpoint->addr, 0); OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Sending data up !"); g_networkPacketReceivedCallback(remoteEndpoint, message->data, message->dataLen); CAFreeEndpoint(remoteEndpoint); OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT_CAAdapterDataReceiverHandler"); }
CAResult_t CAAdapterSendData(const char *remoteAddress, const char *serviceUUID, const uint8_t *data, uint32_t dataLength, uint32_t *sentLength) { OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN - CAAdapterSendData"); if (false == g_adapterState) { OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Bluetooth adapter is disabled!"); *sentLength = 0; return CA_ADAPTER_NOT_ENABLED; } // Input validation VERIFY_NON_NULL(serviceUUID, EDR_ADAPTER_TAG, "service UUID is null"); VERIFY_NON_NULL(data, EDR_ADAPTER_TAG, "Data is null"); VERIFY_NON_NULL(sentLength, EDR_ADAPTER_TAG, "Sent data length holder is null"); // Create remote endpoint CAEndpoint_t *remoteEndpoint = CACreateEndpointObject(CA_DEFAULT_FLAGS, CA_ADAPTER_RFCOMM_BTEDR, remoteAddress, 0); if (NULL == remoteEndpoint) { OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to create remote endpoint !"); return CA_MEMORY_ALLOC_FAILED; } // Add message to data queue CAEDRData *edrData = CACreateEDRData(remoteEndpoint, data, dataLength); CAQueueingThreadAddData(g_sendQueueHandle, edrData, sizeof (CAEDRData)); *sentLength = dataLength; // Free remote endpoint CAFreeEndpoint(remoteEndpoint); OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT - CAAdapterSendData"); return CA_STATUS_OK; }
void CAEDRErrorHandler(const char *remoteAddress, const uint8_t *data, uint32_t dataLength, CAResult_t result) { OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN"); // Input validation VERIFY_NON_NULL_VOID(data, EDR_ADAPTER_TAG, "Data is null"); // Create remote endpoint CAEndpoint_t *remoteEndpoint = CACreateEndpointObject(0, CA_ADAPTER_RFCOMM_BTEDR, remoteAddress, 0); if (!remoteEndpoint) { OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to create remote endpoint !"); return; } g_errorCallback(remoteEndpoint, data, dataLength, result); // Free remote endpoint CAFreeEndpoint(remoteEndpoint); OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT"); }
void CAAdapterRecvData(const char *remoteAddress, const uint8_t *data, uint32_t dataLength, uint32_t *sentLength) { OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN"); if (false == g_adapterState) { OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Bluetooth adapter is disabled!"); *sentLength = 0; return; } // Input validation VERIFY_NON_NULL_VOID(data, EDR_ADAPTER_TAG, "Data is null"); VERIFY_NON_NULL_VOID(sentLength, EDR_ADAPTER_TAG, "Sent data length holder is null"); // Create remote endpoint CAEndpoint_t *remoteEndpoint = CACreateEndpointObject(CA_DEFAULT_FLAGS, CA_ADAPTER_RFCOMM_BTEDR, remoteAddress, 0); if (NULL == remoteEndpoint) { OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to create remote endpoint !"); return; } // Add message to data queue CAEDRData *edrData = CACreateEDRData(remoteEndpoint, data, dataLength); CAQueueingThreadAddData(g_recvQueueHandle, edrData, sizeof(CAEDRData)); *sentLength = dataLength; // Free remote endpoint CAFreeEndpoint(remoteEndpoint); OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT"); }
void CADestroyEndpoint(CAEndpoint_t *rep) { OIC_LOG(DEBUG, TAG, "CADestroyEndpoint"); CAFreeEndpoint(rep); }
static CAData_t* CAGenerateHandlerData(const CAEndpoint_t *endpoint, const CARemoteId_t *identity, const void *data, CADataType_t dataType) { OIC_LOG(DEBUG, TAG, "CAGenerateHandlerData IN"); CAInfo_t *info = NULL; CAData_t *cadata = (CAData_t *) OICCalloc(1, sizeof(CAData_t)); if (!cadata) { OIC_LOG(ERROR, TAG, "memory allocation failed"); return NULL; } CAEndpoint_t* ep = CACloneEndpoint(endpoint); if (!ep) { OIC_LOG(ERROR, TAG, "endpoint clone failed"); OICFree(cadata); return NULL; } OIC_LOG_V(DEBUG, TAG, "address : %s", ep->addr); CAResult_t result; if(CA_RESPONSE_DATA == dataType) { CAResponseInfo_t* resInfo = (CAResponseInfo_t*)OICCalloc(1, sizeof(CAResponseInfo_t)); if (!resInfo) { OIC_LOG(ERROR, TAG, "memory allocation failed"); OICFree(cadata); CAFreeEndpoint(ep); return NULL; } result = CAGetResponseInfoFromPDU(data, resInfo, endpoint); if (CA_STATUS_OK != result) { OIC_LOG(ERROR, TAG, "CAGetResponseInfoFromPDU Failed"); CAFreeEndpoint(ep); CADestroyResponseInfoInternal(resInfo); OICFree(cadata); return NULL; } cadata->responseInfo = resInfo; info = &resInfo->info; if (identity) { info->identity = *identity; } OIC_LOG(DEBUG, TAG, "Response Info :"); CALogPayloadInfo(info); } else if (CA_REQUEST_DATA == dataType) { CARequestInfo_t* reqInfo = (CARequestInfo_t*)OICCalloc(1, sizeof(CARequestInfo_t)); if (!reqInfo) { OIC_LOG(ERROR, TAG, "memory allocation failed"); OICFree(cadata); CAFreeEndpoint(ep); return NULL; } result = CAGetRequestInfoFromPDU(data, endpoint, reqInfo); if (CA_STATUS_OK != result) { OIC_LOG(ERROR, TAG, "CAGetRequestInfoFromPDU failed"); CAFreeEndpoint(ep); CADestroyRequestInfoInternal(reqInfo); OICFree(cadata); return NULL; } if (CADropSecondMessage(&caglobals.ca.requestHistory, endpoint, reqInfo->info.messageId, reqInfo->info.token, reqInfo->info.tokenLength)) { OIC_LOG(ERROR, TAG, "Second Request with same Token, Drop it"); CAFreeEndpoint(ep); CADestroyRequestInfoInternal(reqInfo); OICFree(cadata); return NULL; } cadata->requestInfo = reqInfo; info = &reqInfo->info; if (identity) { info->identity = *identity; } OIC_LOG(DEBUG, TAG, "Request Info :"); CALogPayloadInfo(info); } else if (CA_ERROR_DATA == dataType) { CAErrorInfo_t *errorInfo = (CAErrorInfo_t *)OICCalloc(1, sizeof (CAErrorInfo_t)); if (!errorInfo) { OIC_LOG(ERROR, TAG, "Memory allocation failed!"); OICFree(cadata); CAFreeEndpoint(ep); return NULL; } CAResult_t result = CAGetErrorInfoFromPDU(data, endpoint, errorInfo); if (CA_STATUS_OK != result) { OIC_LOG(ERROR, TAG, "CAGetErrorInfoFromPDU failed"); CAFreeEndpoint(ep); OICFree(errorInfo); OICFree(cadata); return NULL; } cadata->errorInfo = errorInfo; info = &errorInfo->info; if (identity) { info->identity = *identity; } OIC_LOG(DEBUG, TAG, "error Info :"); CALogPayloadInfo(info); } cadata->remoteEndpoint = ep; cadata->dataType = dataType; return cadata; OIC_LOG(DEBUG, TAG, "CAGenerateHandlerData OUT"); }