1 /* ****************************************************************
3 * Copyright 2015 Samsung Electronics All Rights Reserved.
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
11 * http://www.apache.org/licenses/LICENSE-2.0
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
19 ******************************************************************/
26 #ifndef __STDC_FORMAT_MACROS
27 #define __STDC_FORMAT_MACROS
31 #include "cainterface.h"
32 #include "caipnwmonitor.h"
33 #include "catcpadapter.h"
34 #include "catcpinterface.h"
35 #include "caqueueingthread.h"
36 #include "caadapterutils.h"
38 #include "uarraylist.h"
39 #include "caremotehandler.h"
41 #include "oic_malloc.h"
43 #include "ca_adapter_net_ssl.h"
47 * Logging tag for module name.
49 #define TAG "OIC_CA_TCP_ADAP"
52 * Holds internal thread TCP data information.
56 CAEndpoint_t *remoteEndpoint;
62 #define CA_TCP_LISTEN_BACKLOG 3
64 #define CA_TCP_SELECT_TIMEOUT 10
67 * Queue handle for Send Data.
69 static CAQueueingThread_t *g_sendQueueHandle = NULL;
72 * Network Packet Received Callback to CA.
74 static CANetworkPacketReceivedCallback g_networkPacketCallback = NULL;
77 * Adapter Changed Callback to CA.
79 static CAAdapterChangeCallback g_networkChangeCallback = NULL;
82 * Connection Changed Callback to CA.
84 static CAConnectionChangeCallback g_connectionChangeCallback = NULL;
87 * error Callback to CA adapter.
89 static CAErrorHandleCallback g_errorCallback = NULL;
91 static void CATCPPacketReceivedCB(const CASecureEndpoint_t *sep,
92 const void *data, uint32_t dataLength);
95 * KeepAlive Connected or Disconnected Callback to CA adapter.
97 static CAKeepAliveConnectionCallback g_connKeepAliveCallback = NULL;
99 static CAResult_t CATCPInitializeQueueHandles();
101 static void CATCPDeinitializeQueueHandles();
103 static void CATCPSendDataThread(void *threadData);
105 static CATCPData *CACreateTCPData(const CAEndpoint_t *remoteEndpoint,
106 const void *data, size_t dataLength,
108 void CAFreeTCPData(CATCPData *ipData);
110 static void CADataDestroyer(void *data, uint32_t size);
112 CAResult_t CATCPInitializeQueueHandles()
114 // Check if the message queue is already initialized
115 if (g_sendQueueHandle)
117 OIC_LOG(DEBUG, TAG, "send queue handle is already initialized!");
121 // Create send message queue
122 g_sendQueueHandle = OICMalloc(sizeof(CAQueueingThread_t));
123 if (!g_sendQueueHandle)
125 OIC_LOG(ERROR, TAG, "Memory allocation failed!");
126 return CA_MEMORY_ALLOC_FAILED;
129 if (CA_STATUS_OK != CAQueueingThreadInitialize(g_sendQueueHandle,
130 (const ca_thread_pool_t)caglobals.tcp.threadpool,
131 CATCPSendDataThread, CADataDestroyer))
133 OIC_LOG(ERROR, TAG, "Failed to Initialize send queue thread");
134 OICFree(g_sendQueueHandle);
135 g_sendQueueHandle = NULL;
136 return CA_STATUS_FAILED;
142 void CATCPDeinitializeQueueHandles()
144 CAQueueingThreadDestroy(g_sendQueueHandle);
145 OICFree(g_sendQueueHandle);
146 g_sendQueueHandle = NULL;
149 void CATCPConnectionStateCB(const char *ipAddress, CANetworkStatus_t status)
155 void CATCPPacketReceivedCB(const CASecureEndpoint_t *sep, const void *data,
158 VERIFY_NON_NULL_VOID(sep, TAG, "sep is NULL");
159 VERIFY_NON_NULL_VOID(data, TAG, "data is NULL");
161 OIC_LOG_V(DEBUG, TAG, "Address: %s, port:%d", sep->endpoint.addr, sep->endpoint.port);
163 if (g_networkPacketCallback)
165 g_networkPacketCallback(sep, data, dataLength);
170 static void CATCPPacketSendCB(CAEndpoint_t *endpoint, const void *data, uint32_t dataLength)
172 OIC_LOG_V(DEBUG, TAG, "In %s", __func__);
173 VERIFY_NON_NULL_VOID(endpoint, TAG, "endpoint is NULL");
174 VERIFY_NON_NULL_VOID(data, TAG, "data is NULL");
176 OIC_LOG_V(DEBUG, TAG, "Address: %s, port:%d", endpoint->addr, endpoint->port);
177 OIC_LOG_BUFFER(DEBUG, TAG, data, dataLength);
179 CATCPSendData(endpoint, data, dataLength, false);
180 OIC_LOG_V(DEBUG, TAG, "Out %s", __func__);
184 void CATCPErrorHandler(const CAEndpoint_t *endpoint, const void *data,
185 uint32_t dataLength, CAResult_t result)
187 VERIFY_NON_NULL_VOID(endpoint, TAG, "endpoint is NULL");
188 VERIFY_NON_NULL_VOID(data, TAG, "data is NULL");
192 g_errorCallback(endpoint, data, dataLength, result);
196 static void CATCPConnectionHandler(const CAEndpoint_t *endpoint, bool isConnected)
198 // Pass the changed connection status to RI Layer for keepalive.
199 if (g_connKeepAliveCallback)
201 g_connKeepAliveCallback(endpoint, isConnected);
204 // Pass the changed connection status to CAUtil.
205 if (g_connectionChangeCallback)
207 g_connectionChangeCallback(endpoint, isConnected);
211 void CATCPSetKeepAliveCallbacks(CAKeepAliveConnectionCallback ConnHandler)
213 g_connKeepAliveCallback = ConnHandler;
216 void CATCPAdapterHandler(CATransportAdapter_t adapter, CANetworkStatus_t status)
218 if (g_networkChangeCallback)
220 g_networkChangeCallback(adapter, status);
223 if (CA_INTERFACE_DOWN == status)
225 OIC_LOG(DEBUG, TAG, "Network status is down, close all session");
228 else if (CA_INTERFACE_UP == status)
230 OIC_LOG(DEBUG, TAG, "Network status is up, create new socket for listening");
232 CAResult_t ret = CA_STATUS_FAILED;
233 #ifndef SINGLE_THREAD
234 ret = CATCPStartServer((const ca_thread_pool_t)caglobals.tcp.threadpool);
236 ret = CATCPStartServer();
238 if (CA_STATUS_OK != ret)
240 OIC_LOG_V(DEBUG, TAG, "CATCPStartServer failed[%d]", ret);
245 static void CAInitializeTCPGlobals()
247 caglobals.tcp.ipv4.fd = -1;
248 caglobals.tcp.ipv6.fd = -1;
249 caglobals.tcp.selectTimeout = CA_TCP_SELECT_TIMEOUT;
250 caglobals.tcp.listenBacklog = CA_TCP_LISTEN_BACKLOG;
251 caglobals.tcp.svrlist = NULL;
253 CATransportFlags_t flags = 0;
254 if (caglobals.client)
256 flags |= caglobals.clientFlags;
258 if (caglobals.server)
260 flags |= caglobals.serverFlags;
263 caglobals.tcp.ipv4tcpenabled = flags & CA_IPV4;
264 caglobals.tcp.ipv6tcpenabled = flags & CA_IPV6;
267 CAResult_t CAInitializeTCP(CARegisterConnectivityCallback registerCallback,
268 CANetworkPacketReceivedCallback networkPacketCallback,
269 CAAdapterChangeCallback netCallback,
270 CAConnectionChangeCallback connCallback,
271 CAErrorHandleCallback errorCallback, ca_thread_pool_t handle)
273 OIC_LOG(DEBUG, TAG, "IN");
274 VERIFY_NON_NULL(registerCallback, TAG, "registerCallback");
275 VERIFY_NON_NULL(networkPacketCallback, TAG, "networkPacketCallback");
276 VERIFY_NON_NULL(netCallback, TAG, "netCallback");
277 #ifndef SINGLE_THREAD
278 VERIFY_NON_NULL(handle, TAG, "thread pool handle");
281 g_networkChangeCallback = netCallback;
282 g_connectionChangeCallback = connCallback;
283 g_networkPacketCallback = networkPacketCallback;
284 g_errorCallback = errorCallback;
286 CAInitializeTCPGlobals();
287 #ifndef SINGLE_THREAD
288 caglobals.tcp.threadpool = handle;
291 CATCPSetConnectionChangedCallback(CATCPConnectionHandler);
292 CATCPSetPacketReceiveCallback(CATCPPacketReceivedCB);
293 CATCPSetErrorHandler(CATCPErrorHandler);
296 if (CA_STATUS_OK != CAinitSslAdapter())
298 OIC_LOG(ERROR, TAG, "Failed to init SSL adapter");
302 CAsetSslAdapterCallbacks(CATCPPacketReceivedCB, CATCPPacketSendCB, CA_ADAPTER_TCP);
306 CAConnectivityHandler_t tcpHandler = {
307 .startAdapter = CAStartTCP,
308 .startListenServer = CAStartTCPListeningServer,
309 .stopListenServer = CAStopTCPListeningServer,
310 .startDiscoveryServer = CAStartTCPDiscoveryServer,
311 .sendData = CASendTCPUnicastData,
312 .sendDataToAll = CASendTCPMulticastData,
313 .GetnetInfo = CAGetTCPInterfaceInformation,
314 .readData = CAReadTCPData,
315 .stopAdapter = CAStopTCP,
316 .terminate = CATerminateTCP,
317 .cType = CA_ADAPTER_TCP};
319 registerCallback(tcpHandler);
321 OIC_LOG(INFO, TAG, "OUT IntializeTCP is Success");
325 CAResult_t CAStartTCP()
327 OIC_LOG(DEBUG, TAG, "IN");
329 // Start network monitoring to receive adapter status changes.
330 CAIPStartNetworkMonitor(CATCPAdapterHandler, CA_ADAPTER_TCP);
332 // Set the port number received from application.
333 caglobals.tcp.ipv4.port = caglobals.ports.tcp.u4;
334 caglobals.tcp.ipv6.port = caglobals.ports.tcp.u6;
336 #ifndef SINGLE_THREAD
337 if (CA_STATUS_OK != CATCPInitializeQueueHandles())
339 OIC_LOG(ERROR, TAG, "Failed to Initialize Queue Handle");
341 return CA_STATUS_FAILED;
344 // Start send queue thread
345 if (CA_STATUS_OK != CAQueueingThreadStart(g_sendQueueHandle))
347 OIC_LOG(ERROR, TAG, "Failed to Start Send Data Thread");
348 return CA_STATUS_FAILED;
351 CAResult_t ret = CATCPStartServer();
352 if (CA_STATUS_OK != ret)
354 OIC_LOG_V(DEBUG, TAG, "CATCPStartServer failed[%d]", ret);
362 CAResult_t CAStartTCPListeningServer()
364 #ifndef SINGLE_THREAD
365 if (!caglobals.server)
367 caglobals.server = true; // only needed to run CA tests
370 CAResult_t ret = CATCPStartServer((const ca_thread_pool_t)caglobals.tcp.threadpool);
371 if (CA_STATUS_OK != ret)
373 OIC_LOG_V(ERROR, TAG, "Failed to start listening server![%d]", ret);
381 CAResult_t CAStopTCPListeningServer()
386 CAResult_t CAStartTCPDiscoveryServer()
388 if (!caglobals.client)
390 caglobals.client = true; // only needed to run CA tests
393 CAResult_t ret = CATCPStartServer((const ca_thread_pool_t)caglobals.tcp.threadpool);
394 if (CA_STATUS_OK != ret)
396 OIC_LOG_V(ERROR, TAG, "Failed to start discovery server![%d]", ret);
403 static size_t CAQueueTCPData(bool isMulticast, const CAEndpoint_t *endpoint,
404 const void *data, size_t dataLength)
406 VERIFY_NON_NULL_RET(endpoint, TAG, "endpoint", -1);
407 VERIFY_NON_NULL_RET(data, TAG, "data", -1);
411 OIC_LOG(ERROR, TAG, "Invalid Data Length");
415 VERIFY_NON_NULL_RET(g_sendQueueHandle, TAG, "sendQueueHandle", -1);
417 // Create TCPData to add to queue
418 CATCPData *tcpData = CACreateTCPData(endpoint, data, dataLength, isMulticast);
421 OIC_LOG(ERROR, TAG, "Failed to create ipData!");
424 // Add message to send queue
425 CAQueueingThreadAddData(g_sendQueueHandle, tcpData, sizeof(CATCPData));
430 int32_t CASendTCPUnicastData(const CAEndpoint_t *endpoint,
431 const void *data, uint32_t dataLength,
432 CADataType_t dataType)
434 OIC_LOG(DEBUG, TAG, "IN");
436 #ifndef SINGLE_THREAD
437 return CAQueueTCPData(false, endpoint, data, dataLength);
439 CATCPSendData(endpoint, data, dataLength, false);
444 int32_t CASendTCPMulticastData(const CAEndpoint_t *endpoint,
445 const void *data, uint32_t dataLength,
446 CADataType_t dataType)
449 return CAQueueTCPData(true, endpoint, data, dataLength);
452 CAResult_t CAReadTCPData()
454 OIC_LOG(DEBUG, TAG, "IN");
461 CAResult_t CAStopTCP()
463 CAIPStopNetworkMonitor(CA_ADAPTER_TCP);
465 #ifndef SINGLE_THREAD
466 if (g_sendQueueHandle && g_sendQueueHandle->threadMutex)
468 CAQueueingThreadStop(g_sendQueueHandle);
470 CATCPDeinitializeQueueHandles();
475 //Re-initializing the Globals to start them again
476 CAInitializeTCPGlobals();
479 CAdeinitSslAdapter();
485 void CATerminateTCP()
488 CATCPSetPacketReceiveCallback(NULL);
491 void CATCPSendDataThread(void *threadData)
493 CATCPData *tcpData = (CATCPData *) threadData;
496 OIC_LOG(DEBUG, TAG, "Invalid TCP data!");
500 if (tcpData->isMulticast)
502 //Processing for sending multicast
503 OIC_LOG(DEBUG, TAG, "Send Multicast Data is called, not supported");
508 // Check payload length from CoAP over TCP format header.
509 CAResult_t result = CA_STATUS_OK;
510 size_t payloadLen = CACheckPayloadLengthFromHeader(tcpData->data, tcpData->dataLen);
513 // if payload length is zero, disconnect from remote device.
514 OIC_LOG(DEBUG, TAG, "payload length is zero, disconnect from remote device");
516 CATCPSessionInfo_t *svritem = CAGetTCPSessionInfoFromEndpoint(tcpData->remoteEndpoint,
520 result = CADisconnectTCPSession(svritem, index);
521 if (CA_STATUS_OK != result)
523 OIC_LOG_V(ERROR, TAG, "CADisconnectTCPSession failed, result[%d]", result);
530 if (tcpData->remoteEndpoint && tcpData->remoteEndpoint->flags & CA_SECURE)
532 OIC_LOG(DEBUG, TAG, "CAencryptSsl called!");
533 result = CAencryptSsl(tcpData->remoteEndpoint, tcpData->data, tcpData->dataLen);
535 if (CA_STATUS_OK != result)
537 OIC_LOG(ERROR, TAG, "CAAdapterNetDtlsEncrypt failed!");
539 OIC_LOG_V(DEBUG, TAG,
540 "CAAdapterNetDtlsEncrypt returned with result[%d]", result);
544 //Processing for sending unicast
545 CATCPSendData(tcpData->remoteEndpoint, tcpData->data, tcpData->dataLen, false);
549 CATCPData *CACreateTCPData(const CAEndpoint_t *remoteEndpoint, const void *data,
550 size_t dataLength, bool isMulticast)
552 VERIFY_NON_NULL_RET(remoteEndpoint, TAG, "remoteEndpoint is NULL", NULL);
553 VERIFY_NON_NULL_RET(data, TAG, "data is NULL", NULL);
555 CATCPData *tcpData = (CATCPData *) OICCalloc(1, sizeof(*tcpData));
558 OIC_LOG(ERROR, TAG, "Memory allocation failed!");
562 tcpData->remoteEndpoint = CACloneEndpoint(remoteEndpoint);
563 tcpData->data = (void *) OICMalloc(dataLength);
566 OIC_LOG(ERROR, TAG, "Memory allocation failed!");
567 CAFreeTCPData(tcpData);
571 memcpy(tcpData->data, data, dataLength);
572 tcpData->dataLen = dataLength;
574 tcpData->isMulticast = isMulticast;
579 void CAFreeTCPData(CATCPData *tcpData)
581 VERIFY_NON_NULL_VOID(tcpData, TAG, "tcpData is NULL");
583 CAFreeEndpoint(tcpData->remoteEndpoint);
584 OICFree(tcpData->data);
588 void CADataDestroyer(void *data, uint32_t size)
590 if (size < sizeof(CATCPData))
592 OIC_LOG_V(ERROR, TAG, "Destroy data too small %p %" PRIu32, data, size);
594 CATCPData *TCPData = (CATCPData *) data;
596 CAFreeTCPData(TCPData);
600 size_t CAGetTotalLengthFromPacketHeader(const unsigned char *recvBuffer, size_t size)
602 OIC_LOG(DEBUG, TAG, "IN - CAGetTotalLengthFromHeader");
604 if (NULL == recvBuffer || !size)
606 OIC_LOG(ERROR, TAG, "recvBuffer is NULL");
610 coap_transport_t transport = coap_get_tcp_header_type_from_initbyte(
611 ((unsigned char *)recvBuffer)[0] >> 4);
612 size_t optPaylaodLen = coap_get_length_from_header((unsigned char *)recvBuffer,
614 size_t headerLen = coap_get_tcp_header_length((unsigned char *)recvBuffer);
616 OIC_LOG_V(DEBUG, TAG, "option/paylaod length [%d]", optPaylaodLen);
617 OIC_LOG_V(DEBUG, TAG, "header length [%d]", headerLen);
618 OIC_LOG_V(DEBUG, TAG, "total data length [%d]", headerLen + optPaylaodLen);
620 OIC_LOG(DEBUG, TAG, "OUT - CAGetTotalLengthFromHeader");
621 return headerLen + optPaylaodLen;
624 void CAGetTCPHeaderDetails(unsigned char* recvBuffer, coap_transport_t *transport,
627 if (NULL == recvBuffer)
629 OIC_LOG(ERROR, TAG, "recvBuffer is NULL");
633 if (NULL == transport)
635 OIC_LOG(ERROR, TAG, "transport is NULL");
639 if (NULL == headerlen)
641 OIC_LOG(ERROR, TAG, "headerlen is NULL");
645 *transport = coap_get_tcp_header_type_from_initbyte(
646 ((unsigned char *)recvBuffer)[0] >> 4);
647 *headerlen = coap_get_tcp_header_length_for_transport(*transport);