1 /* *****************************************************************
3 * Copyright 2014 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 #include "cainterface.h"
27 #include "camessagehandler.h"
28 #include "caremotehandler.h"
29 #include "caprotocolmessage.h"
32 #ifndef WITH_UPSTREAM_LIBCOAP
33 #include "coap/config.h"
35 #include "oic_malloc.h"
36 #include "canetworkconfigurator.h"
37 #include "caadapterutils.h"
38 #include "cainterfacecontroller.h"
39 #include "caretransmission.h"
40 #include "oic_string.h"
43 #include "cablockwisetransfer.h"
48 #include "cathreadpool.h" /* for thread pool */
49 #include "caqueueingthread.h"
52 #define MAX_THREAD_POOL_SIZE 20
54 #define UNUSED(x) (void)(x)
57 static ca_thread_pool_t g_threadPoolHandle = NULL;
59 // message handler main thread
60 static CAQueueingThread_t g_sendThread;
61 static CAQueueingThread_t g_receiveThread;
63 #ifdef WITH_PROCESS_EVENT
64 static oc_event g_processEvent = NULL;
65 #endif // WITH_PROCESS_EVENT
68 #define CA_MAX_RT_ARRAY_SIZE 3
69 #endif // SINGLE_THREAD
71 #define TAG "OIC_CA_MSG_HANDLE"
73 static CARetransmission_t g_retransmissionContext;
76 static CARequestCallback g_requestHandler = NULL;
77 static CAResponseCallback g_responseHandler = NULL;
78 static CAErrorCallback g_errorHandler = NULL;
79 static CANetworkMonitorCallback g_nwMonitorHandler = NULL;
81 static void CAErrorHandler(const CAEndpoint_t *endpoint,
82 const void *data, uint32_t dataLen,
85 static CAData_t* CAGenerateHandlerData(const CAEndpoint_t *endpoint,
86 const CARemoteId_t *identity,
87 const void *data, CADataType_t dataType);
89 static void CASendErrorInfo(const CAEndpoint_t *endpoint, const CAInfo_t *info,
93 static void CAProcessReceivedData(CAData_t *data);
95 static void CADestroyData(void *data, uint32_t size);
96 static void CALogPayloadInfo(CAInfo_t *info);
97 static bool CADropSecondMessage(CAHistory_t *history, const CAEndpoint_t *endpoint, uint16_t id,
98 CAToken_t token, uint8_t tokenLength);
101 * print send / receive message of CoAP.
102 * @param[in] data CA information which has send/receive message and endpoint.
103 * @param[in] pdu CoAP pdu low data.
105 static void CALogPDUInfo(const CAData_t *data, const coap_pdu_t *pdu);
108 static char g_headerBuffer[MAX_LOG_BUFFER_SIZE] = {0};
109 static size_t g_headerIndex = 0;
110 static void CASamsungLogMessage(const CAData_t *data, const coap_pdu_t *pdu);
114 void CAAddDataToSendThread(CAData_t *data)
116 VERIFY_NON_NULL_VOID(data, TAG, "data");
119 CAResult_t result = CAQueueingThreadAddData(&g_sendThread, data, sizeof(CAData_t), true);
120 if (result != CA_STATUS_OK)
122 OIC_LOG(ERROR, TAG, "Failed to add message to data queue!");
123 CADestroyData(data, sizeof(CAData_t));
127 void CAAddDataToReceiveThread(CAData_t *data)
129 VERIFY_NON_NULL_VOID(data, TAG, "data");
132 CAResult_t result = CAQueueingThreadAddData(&g_receiveThread, data, sizeof(CAData_t), false);
133 if (result != CA_STATUS_OK)
135 OIC_LOG(ERROR, TAG, "Failed to add message to data queue!");
136 CADestroyData(data, sizeof(CAData_t));
140 #ifdef WITH_PROCESS_EVENT
143 oc_event_signal(g_processEvent);
149 static bool CAIsSelectedNetworkAvailable()
151 u_arraylist_t *list = CAGetSelectedNetworkList();
152 if (!list || u_arraylist_length(list) == 0)
154 OIC_LOG(ERROR, TAG, "No selected network");
161 static CAData_t* CAGenerateHandlerData(const CAEndpoint_t *endpoint,
162 const CARemoteId_t *identity,
163 const void *data, CADataType_t dataType)
165 OIC_LOG(DEBUG, TAG, "CAGenerateHandlerData IN");
166 CAInfo_t *info = NULL;
167 CAData_t *cadata = (CAData_t *) OICCalloc(1, sizeof(CAData_t));
170 OIC_LOG(ERROR, TAG, "memory allocation failed");
174 CAEndpoint_t* ep = endpoint;
176 CAEndpoint_t* ep = CACloneEndpoint(endpoint);
179 OIC_LOG(ERROR, TAG, "endpoint clone failed");
184 OIC_LOG_V(DEBUG, TAG, "address : %s", ep->addr);
186 if (CA_RESPONSE_DATA == dataType)
188 CAResponseInfo_t* resInfo = (CAResponseInfo_t*)OICCalloc(1, sizeof(CAResponseInfo_t));
191 OIC_LOG(ERROR, TAG, "memory allocation failed");
195 CAResult_t result = CAGetResponseInfoFromPDU(data, resInfo, endpoint);
196 if (CA_STATUS_OK != result)
198 OIC_LOG(ERROR, TAG, "CAGetResponseInfoFromPDU Failed");
199 CADestroyResponseInfoInternal(resInfo);
202 cadata->responseInfo = resInfo;
203 info = &resInfo->info;
206 info->identity = *identity;
208 OIC_LOG(DEBUG, TAG, "Response Info :");
209 CALogPayloadInfo(info);
211 else if (CA_REQUEST_DATA == dataType)
213 CARequestInfo_t* reqInfo = (CARequestInfo_t*)OICCalloc(1, sizeof(CARequestInfo_t));
216 OIC_LOG(ERROR, TAG, "memory allocation failed");
220 CAResult_t result = CAGetRequestInfoFromPDU(data, endpoint, reqInfo);
221 if (CA_STATUS_OK != result)
223 OIC_LOG(ERROR, TAG, "CAGetRequestInfoFromPDU failed");
224 CADestroyRequestInfoInternal(reqInfo);
228 if ((reqInfo->info.type != CA_MSG_CONFIRM) &&
229 CADropSecondMessage(&caglobals.ca.requestHistory, endpoint, reqInfo->info.messageId,
230 reqInfo->info.token, reqInfo->info.tokenLength))
232 OIC_LOG(INFO, TAG, "Second Request with same Token, Drop it");
233 CADestroyRequestInfoInternal(reqInfo);
237 cadata->requestInfo = reqInfo;
238 info = &reqInfo->info;
241 info->identity = *identity;
243 OIC_LOG(DEBUG, TAG, "Request Info :");
244 CALogPayloadInfo(info);
246 else if (CA_ERROR_DATA == dataType)
248 CAErrorInfo_t *errorInfo = (CAErrorInfo_t *)OICCalloc(1, sizeof (CAErrorInfo_t));
251 OIC_LOG(ERROR, TAG, "Memory allocation failed!");
255 CAResult_t result = CAGetErrorInfoFromPDU(data, endpoint, errorInfo);
256 if (CA_STATUS_OK != result)
258 OIC_LOG(ERROR, TAG, "CAGetErrorInfoFromPDU failed");
263 cadata->errorInfo = errorInfo;
264 info = &errorInfo->info;
267 info->identity = *identity;
269 OIC_LOG(DEBUG, TAG, "error Info :");
270 CALogPayloadInfo(info);
273 cadata->remoteEndpoint = ep;
274 cadata->dataType = dataType;
276 OIC_LOG(DEBUG, TAG, "CAGenerateHandlerData OUT");
281 #ifndef SINGLE_THREAD
287 static void CATimeoutCallback(const CAEndpoint_t *endpoint, const void *pdu, uint32_t size)
289 VERIFY_NON_NULL_VOID(endpoint, TAG, "endpoint");
290 VERIFY_NON_NULL_VOID(pdu, TAG, "pdu");
292 CAEndpoint_t* ep = endpoint;
294 CAEndpoint_t* ep = CACloneEndpoint(endpoint);
297 OIC_LOG(ERROR, TAG, "clone failed");
302 CAResponseInfo_t* resInfo = (CAResponseInfo_t*)OICCalloc(1, sizeof(CAResponseInfo_t));
306 OIC_LOG(ERROR, TAG, "calloc failed");
307 #ifndef SINGLE_THREAD
313 resInfo->result = CA_RETRANSMIT_TIMEOUT;
314 resInfo->info.type = CAGetMessageTypeFromPduBinaryData(pdu, size);
315 resInfo->info.messageId = CAGetMessageIdFromPduBinaryData(pdu, size);
317 CAResult_t res = CAGetTokenFromPDU((const coap_hdr_transport_t *) pdu, &(resInfo->info),
319 if (CA_STATUS_OK != res)
321 OIC_LOG(ERROR, TAG, "fail to get Token from retransmission list");
322 CADestroyResponseInfoInternal(resInfo);
323 #ifndef SINGLE_THREAD
329 CAData_t *cadata = (CAData_t *) OICCalloc(1, sizeof(CAData_t));
332 OIC_LOG(ERROR, TAG, "memory allocation failed !");
333 #ifndef SINGLE_THREAD
336 CADestroyResponseInfoInternal(resInfo);
340 cadata->type = SEND_TYPE_UNICAST;
341 cadata->remoteEndpoint = ep;
342 cadata->requestInfo = NULL;
343 cadata->responseInfo = resInfo;
346 if (CAIsSupportedBlockwiseTransfer(endpoint->adapter))
348 res = CARemoveBlockDataFromListWithSeed(resInfo->info.token, resInfo->info.tokenLength,
350 if (CA_STATUS_OK != res)
352 OIC_LOG(ERROR, TAG, "CARemoveBlockDataFromListWithSeed failed");
358 CAProcessReceivedData(cadata);
360 CAResult_t result = CAQueueingThreadAddData(&g_receiveThread, cadata, sizeof(CAData_t), false);
361 if (result != CA_STATUS_OK)
363 OIC_LOG(ERROR, TAG, "Failed to add message to data queue!");
364 CADestroyData(cadata, sizeof(CAData_t));
368 #ifdef WITH_PROCESS_EVENT
371 oc_event_signal(g_processEvent);
373 #endif//WITH_PROCESS_EVENT
374 #endif// SINGLE_THREAD
377 static void CADestroyData(void *data, uint32_t size)
379 OIC_LOG(DEBUG, TAG, "CADestroyData IN");
380 if ((size_t)size < sizeof(CAData_t))
382 OIC_LOG_V(ERROR, TAG, "Destroy data too small %p %d", data, size);
384 CAData_t *cadata = (CAData_t *) data;
388 OIC_LOG(ERROR, TAG, "cadata is NULL");
391 #ifndef SINGLE_THREAD
392 if (NULL != cadata->remoteEndpoint)
394 CAFreeEndpoint(cadata->remoteEndpoint);
398 if (NULL != cadata->requestInfo)
400 CADestroyRequestInfoInternal((CARequestInfo_t *) cadata->requestInfo);
403 if (NULL != cadata->responseInfo)
405 CADestroyResponseInfoInternal((CAResponseInfo_t *) cadata->responseInfo);
408 if (NULL != cadata->errorInfo)
410 CADestroyErrorInfoInternal(cadata->errorInfo);
414 OIC_LOG(DEBUG, TAG, "CADestroyData OUT");
418 static void CAProcessReceivedData(CAData_t *data)
420 OIC_LOG(DEBUG, TAG, "CAProcessReceivedData IN");
423 OIC_LOG(ERROR, TAG, "thread data error!!");
427 // parse the data and call the callbacks.
430 CAEndpoint_t *rep = (CAEndpoint_t *)(data->remoteEndpoint);
433 OIC_LOG(ERROR, TAG, "remoteEndpoint error!!");
437 if (data->requestInfo && g_requestHandler)
439 g_requestHandler(rep, data->requestInfo);
441 else if (data->responseInfo && g_responseHandler)
443 g_responseHandler(rep, data->responseInfo);
445 else if (data->errorInfo && g_errorHandler)
447 g_errorHandler(rep, data->errorInfo);
450 CADestroyData(data, sizeof(CAData_t));
452 OIC_LOG(DEBUG, TAG, "CAProcessReceivedData OUT");
456 #ifndef SINGLE_THREAD
457 static void CAReceiveThreadProcess(void *threadData)
459 #ifndef SINGLE_HANDLE
460 CAData_t *data = (CAData_t *) threadData;
461 OIC_TRACE_BEGIN(%s:CAProcessReceivedData, TAG);
462 CAProcessReceivedData(data);
468 #endif // SINGLE_THREAD
470 static CAResult_t CAProcessMulticastData(const CAData_t *data)
472 VERIFY_NON_NULL(data, TAG, "data");
473 VERIFY_NON_NULL(data->remoteEndpoint, TAG, "remoteEndpoint");
475 coap_pdu_t *pdu = NULL;
476 CAInfo_t *info = NULL;
477 coap_list_t *options = NULL;
478 coap_transport_t transport = COAP_UDP;
479 CAResult_t res = CA_SEND_FAILED;
481 if (!data->requestInfo && !data->responseInfo)
483 OIC_LOG(ERROR, TAG, "request or response info is empty");
487 if (data->requestInfo)
489 OIC_LOG(DEBUG, TAG, "requestInfo is available..");
491 info = &data->requestInfo->info;
492 pdu = CAGeneratePDU(CA_GET, info, data->remoteEndpoint, &options, &transport);
494 else if (data->responseInfo)
496 OIC_LOG(DEBUG, TAG, "responseInfo is available..");
498 info = &data->responseInfo->info;
499 pdu = CAGeneratePDU(data->responseInfo->result, info, data->remoteEndpoint,
500 &options, &transport);
505 OIC_LOG(ERROR,TAG,"Failed to generate multicast PDU");
506 CASendErrorInfo(data->remoteEndpoint, info, CA_SEND_FAILED);
507 coap_delete_list(options);
512 if (CAIsSupportedBlockwiseTransfer(data->remoteEndpoint->adapter))
514 // Blockwise transfer
515 res = CAAddBlockOption(&pdu, info, data->remoteEndpoint, &options);
516 if (CA_STATUS_OK != res)
518 OIC_LOG(DEBUG, TAG, "CAAddBlockOption has failed");
524 CALogPDUInfo(data, pdu);
526 res = CASendMulticastData(data->remoteEndpoint, pdu->transport_hdr, pdu->length, data->dataType);
527 if (CA_STATUS_OK != res)
529 OIC_LOG_V(ERROR, TAG, "send failed:%d", res);
533 coap_delete_list(options);
534 coap_delete_pdu(pdu);
538 CAErrorHandler(data->remoteEndpoint, pdu->transport_hdr, pdu->length, res);
539 coap_delete_list(options);
540 coap_delete_pdu(pdu);
544 static CAResult_t CAProcessSendData(const CAData_t *data)
546 VERIFY_NON_NULL(data, TAG, "data");
547 VERIFY_NON_NULL(data->remoteEndpoint, TAG, "remoteEndpoint");
549 CAResult_t res = CA_STATUS_FAILED;
551 if (CA_NETWORK_COMMAND == data->dataType)
553 if (CA_REQ_DISCONNECT == data->eventInfo)
556 // request TCP disconnect
557 if (CA_ADAPTER_TCP == data->remoteEndpoint->adapter)
559 OIC_LOG(INFO, TAG, "request TCP disconnect");
560 return CADisconnectSession(data->remoteEndpoint);
566 CASendDataType_t type = data->type;
568 coap_pdu_t *pdu = NULL;
569 CAInfo_t *info = NULL;
570 coap_list_t *options = NULL;
571 coap_transport_t transport = COAP_UDP;
573 if (SEND_TYPE_UNICAST == type)
575 OIC_LOG(DEBUG,TAG,"Unicast message");
577 #ifdef ROUTING_GATEWAY
579 * When forwarding a packet, do not attempt retransmission as its the responsibility of
580 * packet originator node
582 bool skipRetransmission = false;
585 if (NULL != data->requestInfo)
587 OIC_LOG(DEBUG, TAG, "requestInfo is available..");
589 info = &data->requestInfo->info;
590 #ifdef ROUTING_GATEWAY
591 skipRetransmission = data->requestInfo->info.skipRetransmission;
593 pdu = CAGeneratePDU(data->requestInfo->method, info, data->remoteEndpoint,
594 &options, &transport);
596 else if (NULL != data->responseInfo)
598 OIC_LOG(DEBUG, TAG, "responseInfo is available..");
600 info = &data->responseInfo->info;
601 #ifdef ROUTING_GATEWAY
602 skipRetransmission = data->responseInfo->info.skipRetransmission;
604 pdu = CAGeneratePDU(data->responseInfo->result, info, data->remoteEndpoint,
605 &options, &transport);
609 OIC_LOG(DEBUG, TAG, "request info, response info is empty");
610 return CA_STATUS_INVALID_PARAM;
613 // interface controller function call.
617 if (CAIsSupportedBlockwiseTransfer(data->remoteEndpoint->adapter))
619 // Blockwise transfer
622 CAResult_t res = CAAddBlockOption(&pdu, info,
623 data->remoteEndpoint,
625 if (CA_STATUS_OK != res)
627 OIC_LOG(INFO, TAG, "to write block option has failed");
628 CAErrorHandler(data->remoteEndpoint, pdu->transport_hdr, pdu->length, res);
629 coap_delete_list(options);
630 coap_delete_pdu(pdu);
636 CALogPDUInfo(data, pdu);
638 OIC_LOG_V(INFO, TAG, "CASendUnicastData type : %d", data->dataType);
639 res = CASendUnicastData(data->remoteEndpoint, pdu->transport_hdr, pdu->length, data->dataType);
640 if (CA_STATUS_OK != res)
642 OIC_LOG_V(ERROR, TAG, "send failed:%d", res);
643 CAErrorHandler(data->remoteEndpoint, pdu->transport_hdr, pdu->length, res);
644 coap_delete_list(options);
645 coap_delete_pdu(pdu);
650 if (CAIsSupportedCoAPOverTCP(data->remoteEndpoint->adapter))
652 OIC_LOG(INFO, TAG, "retransmission will be not worked");
656 #ifdef ROUTING_GATEWAY
657 if (!skipRetransmission)
660 // for retransmission
661 res = CARetransmissionSentData(&g_retransmissionContext,
662 data->remoteEndpoint,
664 pdu->transport_hdr, pdu->length);
665 if ((CA_STATUS_OK != res) && (CA_NOT_SUPPORTED != res))
667 //when retransmission not supported this will return CA_NOT_SUPPORTED, ignore
668 OIC_LOG_V(INFO, TAG, "retransmission is not enabled due to error, res : %d", res);
669 coap_delete_list(options);
670 coap_delete_pdu(pdu);
675 coap_delete_list(options);
676 coap_delete_pdu(pdu);
680 OIC_LOG(ERROR,TAG,"Failed to generate unicast PDU");
681 CASendErrorInfo(data->remoteEndpoint, info, CA_SEND_FAILED);
682 return CA_SEND_FAILED;
685 else if (SEND_TYPE_MULTICAST == type)
687 OIC_LOG(DEBUG,TAG,"Multicast message");
690 * If CoAP over TCP is enabled, the CoAP pdu wont be same for IP and other adapters.
691 * That's why we need to generate two pdu's, one for IP and second for other transports.
692 * Two possible cases we might have to split: a) when adapter is CA_DEFAULT_ADAPTER
693 * b) when one of the adapter is IP adapter(ex: CA_ADAPTER_IP | CA_ADAPTER_GATT_BTLE)
695 if (data->remoteEndpoint->adapter == CA_DEFAULT_ADAPTER ||
696 (CA_ADAPTER_IP & data->remoteEndpoint->adapter &&
697 CA_ADAPTER_IP != data->remoteEndpoint->adapter))
699 if (data->remoteEndpoint->adapter == CA_DEFAULT_ADAPTER)
701 data->remoteEndpoint->adapter = CA_ALL_ADAPTERS ^ CA_ADAPTER_IP;
705 data->remoteEndpoint->adapter = data->remoteEndpoint->adapter ^ CA_ADAPTER_IP;
707 CAProcessMulticastData(data);
708 data->remoteEndpoint->adapter = CA_ADAPTER_IP;
709 CAProcessMulticastData(data);
713 CAProcessMulticastData(data);
716 CAProcessMulticastData(data);
722 #ifndef SINGLE_THREAD
723 static void CASendThreadProcess(void *threadData)
725 CAData_t *data = (CAData_t *) threadData;
726 OIC_TRACE_BEGIN(%s:CAProcessSendData, TAG);
727 CAProcessSendData(data);
733 * If a second message arrives with the same message ID, token and the other address
734 * family, drop it. Typically, IPv6 beats IPv4, so the IPv4 message is dropped.
736 static bool CADropSecondMessage(CAHistory_t *history, const CAEndpoint_t *ep, uint16_t id,
737 CAToken_t token, uint8_t tokenLength)
743 if (ep->adapter != CA_ADAPTER_IP)
747 if (!caglobals.ip.dualstack)
755 if (tokenLength > CA_MAX_TOKEN_LEN)
758 * If token length is more than CA_MAX_TOKEN_LEN,
759 * we compare the first CA_MAX_TOKEN_LEN bytes only.
761 tokenLength = CA_MAX_TOKEN_LEN;
765 CATransportFlags_t familyFlags = ep->flags & CA_IPFAMILY_MASK;
767 for (size_t i = 0; i < sizeof(history->items) / sizeof(history->items[0]); i++)
769 CAHistoryItem_t *item = &(history->items[i]);
770 if (id == item->messageId && tokenLength == item->tokenLength
771 && ep->ifindex == item->ifindex && memcmp(item->token, token, tokenLength) == 0)
773 OIC_LOG_V(INFO, TAG, "IPv%c duplicate message ignored",
774 familyFlags & CA_IPV6 ? '6' : '4');
780 history->items[history->nextIndex].flags = familyFlags;
781 history->items[history->nextIndex].messageId = id;
782 history->items[history->nextIndex].ifindex = ep->ifindex;
783 if (token && tokenLength)
785 memcpy(history->items[history->nextIndex].token, token, tokenLength);
786 history->items[history->nextIndex].tokenLength = tokenLength;
789 if (++history->nextIndex >= HISTORYSIZE)
791 history->nextIndex = 0;
797 static CAResult_t CAReceivedPacketCallback(const CASecureEndpoint_t *sep,
798 const void *data, uint32_t dataLen)
800 VERIFY_NON_NULL(sep, TAG, "remoteEndpoint");
801 VERIFY_NON_NULL(data, TAG, "data");
802 OIC_TRACE_BEGIN(%s:CAReceivedPacketCallback, TAG);
806 OIC_LOG(ERROR, TAG, "dataLen is zero");
809 return CA_STATUS_FAILED;
813 OIC_LOG(DEBUG, TAG, "received pdu data :");
816 OIC_LOG_BUFFER(DEBUG, TAG, data, dataLen);
820 OIC_LOG_BUFFER(DEBUG, TAG, data, 32);
823 CAResult_t res = CA_STATUS_OK;
824 uint32_t code = CA_NOT_FOUND;
825 CAData_t *cadata = NULL;
827 coap_pdu_t *pdu = (coap_pdu_t *) CAParsePDU((const char *) data, dataLen, &code,
831 OIC_LOG(ERROR, TAG, "Parse PDU failed");
832 res = CA_STATUS_FAILED;
836 OIC_LOG_V(DEBUG, TAG, "code = %d", code);
837 if (CA_GET == code || CA_POST == code || CA_PUT == code || CA_DELETE == code)
839 cadata = CAGenerateHandlerData(&(sep->endpoint), &(sep->identity), pdu, CA_REQUEST_DATA);
842 OIC_LOG(ERROR, TAG, "CAReceivedPacketCallback, CAGenerateHandlerData failed!");
843 coap_delete_pdu(pdu);
849 cadata = CAGenerateHandlerData(&(sep->endpoint), &(sep->identity), pdu, CA_RESPONSE_DATA);
852 OIC_LOG(ERROR, TAG, "CAReceivedPacketCallback, CAGenerateHandlerData failed!");
853 coap_delete_pdu(pdu);
858 if (CAIsSupportedCoAPOverTCP(sep->endpoint.adapter))
860 OIC_LOG(INFO, TAG, "retransmission is not supported");
865 // for retransmission
866 void *retransmissionPdu = NULL;
867 CARetransmissionReceivedData(&g_retransmissionContext, cadata->remoteEndpoint, pdu->transport_hdr,
868 pdu->length, &retransmissionPdu);
870 // get token from saved data in retransmission list
871 if (retransmissionPdu && CA_EMPTY == code)
873 if (cadata->responseInfo)
875 CAInfo_t *info = &cadata->responseInfo->info;
876 CAResult_t res = CAGetTokenFromPDU((const coap_hdr_transport_t *)retransmissionPdu,
877 info, &(sep->endpoint));
878 if (CA_STATUS_OK != res)
880 OIC_LOG(ERROR, TAG, "fail to get Token from retransmission list");
881 OICFree(info->token);
883 info->tokenLength = 0;
887 OICFree(retransmissionPdu);
891 cadata->type = SEND_TYPE_UNICAST;
893 CALogPDUInfo(cadata, pdu);
896 CAProcessReceivedData(cadata);
899 if (CAIsSupportedBlockwiseTransfer(sep->endpoint.adapter))
901 CAResult_t res = CAReceiveBlockWiseData(pdu, &(sep->endpoint), cadata, dataLen);
902 if (CA_NOT_SUPPORTED == res || CA_REQUEST_TIMEOUT == res)
904 OIC_LOG(DEBUG, TAG, "this message does not have block option");
905 CAAddDataToReceiveThread(cadata);
909 CADestroyData(cadata, sizeof(CAData_t));
915 CAResult_t result = CAQueueingThreadAddData(&g_receiveThread, cadata, sizeof(CAData_t), false);
916 if (result != CA_STATUS_OK)
918 OIC_LOG(ERROR, TAG, "Failed to add message to data queue!");
919 CADestroyData(cadata, sizeof(CAData_t));
920 coap_delete_pdu(pdu);
924 #ifdef WITH_PROCESS_EVENT
927 oc_event_signal(g_processEvent);
931 #endif // SINGLE_THREAD
933 coap_delete_pdu(pdu);
936 OIC_LOG(DEBUG, TAG, "OUT - Recv Thread");
941 static void CAAdapterStateChangedCallback(CATransportAdapter_t transportType, bool enabled)
945 CAClearMessageHandler(transportType);
949 static bool CAClearQueueEndpointDataContext(void *data, uint32_t size, void *ctx)
952 if (NULL == data || NULL == ctx)
957 CAData_t *caData = (CAData_t *)data;
958 const CAEndpoint_t *endpoint = (const CAEndpoint_t *)ctx;
960 if (NULL != caData && NULL != caData->remoteEndpoint)
962 if (strcmp(caData->remoteEndpoint->addr, endpoint->addr) == 0
963 && caData->remoteEndpoint->port == endpoint->port
964 && caData->remoteEndpoint->adapter == endpoint->adapter)
972 static void CAConnectionStateChangedCallback(const CAEndpoint_t *info, bool isConnected)
976 CAResult_t res = CAQueueingThreadClearContextData(&g_sendThread,
977 CAClearQueueEndpointDataContext,
979 if (CA_STATUS_OK != res)
981 OIC_LOG(ERROR, TAG, "Could not clear the send queue");
986 static u_queue_message_t *get_receive_queue_item(void)
988 u_queue_message_t *item = NULL;
990 oc_mutex_lock(g_receiveThread.threadMutex);
991 item = u_queue_get_element(g_receiveThread.dataQueue);
992 oc_mutex_unlock(g_receiveThread.threadMutex);
998 void CAHandleRequestResponseCallbacks()
1000 #ifdef SINGLE_THREAD
1002 CARetransmissionBaseRoutine((void *)&g_retransmissionContext);
1004 #ifdef SINGLE_HANDLE
1005 // parse the data and call the callbacks.
1006 // #1 parse the data
1009 u_queue_message_t *item = NULL;
1010 #ifdef WITH_PROCESS_EVENT
1011 while ((item = get_receive_queue_item()) != NULL)
1013 if ((item = get_receive_queue_item()) != NULL)
1015 { if (NULL == item->msg)
1018 #ifdef WITH_PROCESS_EVENT
1026 CAData_t *td = (CAData_t *) item->msg;
1028 if (td->requestInfo && g_requestHandler)
1030 OIC_LOG_V(DEBUG, TAG, "request callback : %d", td->requestInfo->info.numOptions);
1031 g_requestHandler(td->remoteEndpoint, td->requestInfo);
1033 else if (td->responseInfo && g_responseHandler)
1035 OIC_LOG_V(DEBUG, TAG, "response callback : %d", td->responseInfo->info.numOptions);
1036 g_responseHandler(td->remoteEndpoint, td->responseInfo);
1038 else if (td->errorInfo && g_errorHandler)
1040 OIC_LOG_V(DEBUG, TAG, "error callback error: %d", td->errorInfo->result);
1041 g_errorHandler(td->remoteEndpoint, td->errorInfo);
1044 CADestroyData(item->msg, sizeof(CAData_t));
1047 #endif // SINGLE_HANDLE
1048 #endif // SINGLE_THREAD
1051 static CAData_t* CAPrepareSendData(const CAEndpoint_t *endpoint, const void *sendData,
1052 CADataType_t dataType)
1054 OIC_LOG(DEBUG, TAG, "CAPrepareSendData IN");
1056 CAData_t *cadata = (CAData_t *) OICCalloc(1, sizeof(CAData_t));
1059 OIC_LOG(ERROR, TAG, "memory allocation failed");
1063 if (CA_REQUEST_DATA == dataType)
1065 #ifdef SINGLE_THREAD
1066 CARequestInfo_t *request = (CARequestInfo_t *)sendData;
1068 // clone request info
1069 CARequestInfo_t *request = CACloneRequestInfo((CARequestInfo_t *)sendData);
1072 OIC_LOG(ERROR, TAG, "CACloneRequestInfo failed");
1076 cadata->type = request->isMulticast ? SEND_TYPE_MULTICAST : SEND_TYPE_UNICAST;
1077 cadata->requestInfo = request;
1079 else if (CA_RESPONSE_DATA == dataType || CA_RESPONSE_FOR_RES == dataType)
1081 #ifdef SINGLE_THREAD
1082 CAResponseInfo_t *response = (CAResponseInfo_t *)sendData;
1084 // clone response info
1085 CAResponseInfo_t *response = CACloneResponseInfo((CAResponseInfo_t *)sendData);
1088 OIC_LOG(ERROR, TAG, "CACloneResponseInfo failed");
1092 cadata->type = response->isMulticast ? SEND_TYPE_MULTICAST : SEND_TYPE_UNICAST;
1093 cadata->responseInfo = response;
1097 OIC_LOG(ERROR, TAG, "CAPrepareSendData unknown data type");
1101 #ifdef SINGLE_THREAD
1102 CAEndpoint_t* ep = endpoint;
1104 CAEndpoint_t* ep = CACloneEndpoint(endpoint);
1107 OIC_LOG(ERROR, TAG, "endpoint clone failed");
1111 cadata->remoteEndpoint = ep;
1112 cadata->dataType = dataType;
1116 #ifndef SINGLE_THREAD
1117 CADestroyData(cadata, sizeof(CAData_t));
1124 CAResult_t CADetachSendNetworkReqMessage(const CAEndpoint_t *endpoint,
1125 CAConnectEvent_t event,
1126 CADataType_t dataType)
1128 VERIFY_NON_NULL(endpoint, TAG, "endpoint");
1130 if (false == CAIsSelectedNetworkAvailable())
1132 return CA_STATUS_FAILED;
1135 #ifndef SINGLE_THREAD
1136 CAData_t *cadata = (CAData_t *) OICCalloc(1, sizeof(CAData_t));
1139 OIC_LOG(ERROR, TAG, "cadata memory allocation failed");
1140 return CA_MEMORY_ALLOC_FAILED;
1143 CAEndpoint_t* ep = CACloneEndpoint(endpoint);
1146 OIC_LOG(ERROR, TAG, "endpoint clone failed");
1148 return CA_MEMORY_ALLOC_FAILED;
1151 cadata->remoteEndpoint = ep;
1152 cadata->eventInfo = event;
1153 cadata->dataType = dataType;
1155 CAResult_t result = CAQueueingThreadAddData(&g_sendThread, cadata, sizeof(CAData_t), true);
1156 if (result != CA_STATUS_OK)
1158 OIC_LOG(ERROR, TAG, "Failed to add message to data queue!");
1159 CADestroyData(cadata, sizeof(CAData_t));
1164 return CA_STATUS_OK;
1167 CAResult_t CADetachSendMessage(const CAEndpoint_t *endpoint, const void *sendMsg,
1168 CADataType_t dataType)
1170 VERIFY_NON_NULL(endpoint, TAG, "endpoint");
1171 VERIFY_NON_NULL(sendMsg, TAG, "sendMsg");
1173 if (false == CAIsSelectedNetworkAvailable())
1175 return CA_STATUS_FAILED;
1179 // If max retransmission queue is reached, then don't handle new request
1180 if (CA_MAX_RT_ARRAY_SIZE == u_arraylist_length(g_retransmissionContext.dataList))
1182 OIC_LOG(ERROR, TAG, "max RT queue size reached!");
1183 return CA_SEND_FAILED;
1187 CAData_t *data = CAPrepareSendData(endpoint, sendMsg, dataType);
1190 OIC_LOG(ERROR, TAG, "CAPrepareSendData failed");
1191 return CA_MEMORY_ALLOC_FAILED;
1194 OIC_LOG_V(INFO_PRIVATE, TAG, "DID of endpoint of this message is %s", endpoint->remoteId);
1196 #ifdef SINGLE_THREAD
1197 CAResult_t result = CAProcessSendData(data);
1198 if (CA_STATUS_OK != result)
1200 OIC_LOG(ERROR, TAG, "CAProcessSendData failed");
1209 if (CAIsSupportedBlockwiseTransfer(endpoint->adapter))
1211 CACheckAndDeleteTimedOutBlockData();
1213 CAResult_t res = CASendBlockWiseData(data);
1214 if (CA_NOT_SUPPORTED == res)
1216 OIC_LOG(DEBUG, TAG, "normal msg will be sent");
1217 CAResult_t result = CAQueueingThreadAddData(&g_sendThread, data, sizeof(CAData_t), true);
1218 if (result != CA_STATUS_OK)
1220 OIC_LOG(ERROR, TAG, "Failed to add message to data queue!");
1221 CADestroyData(data, sizeof(CAData_t));
1224 return CA_STATUS_OK;
1228 CADestroyData(data, sizeof(CAData_t));
1236 CAResult_t result = CAQueueingThreadAddData(&g_sendThread, data, sizeof(CAData_t), true);
1237 if (result != CA_STATUS_OK)
1239 OIC_LOG(ERROR, TAG, "Failed to add message to data queue!");
1240 CADestroyData(data, sizeof(CAData_t));
1244 #endif // SINGLE_THREAD
1246 return CA_STATUS_OK;
1249 void CASetInterfaceCallbacks(CARequestCallback ReqHandler, CAResponseCallback RespHandler,
1250 CAErrorCallback errorHandler)
1252 g_requestHandler = ReqHandler;
1253 g_responseHandler = RespHandler;
1254 g_errorHandler = errorHandler;
1257 void CASetNetworkMonitorCallback(CANetworkMonitorCallback nwMonitorHandler)
1259 g_nwMonitorHandler = nwMonitorHandler;
1262 CAResult_t CAInitializeMessageHandler(CATransportAdapter_t transportType)
1264 CASetPacketReceivedCallback((CANetworkPacketReceivedCallback)CAReceivedPacketCallback);
1265 CASetErrorHandleCallback((CAErrorHandleCallback)CAErrorHandler);
1267 #ifndef SINGLE_THREAD
1268 // create thread pool
1269 CAResult_t res = ca_thread_pool_init(MAX_THREAD_POOL_SIZE, &g_threadPoolHandle);
1270 if (CA_STATUS_OK != res)
1272 OIC_LOG(ERROR, TAG, "thread pool initialize error.");
1276 // send thread initialize
1277 res = CAQueueingThreadInitialize(&g_sendThread, g_threadPoolHandle,
1278 CASendThreadProcess, CADestroyData);
1279 if (CA_STATUS_OK != res)
1281 OIC_LOG(ERROR, TAG, "Failed to Initialize send queue thread");
1285 // start send thread
1287 res = CAQueueingThreadStart(&g_sendThread);
1289 res = CAQueueingThreadStart(&g_sendThread, "IoT_MessageHandlerQueue");
1291 if (CA_STATUS_OK != res)
1293 OIC_LOG(ERROR, TAG, "thread start error(send thread).");
1297 // receive thread initialize
1298 res = CAQueueingThreadInitialize(&g_receiveThread, g_threadPoolHandle,
1299 CAReceiveThreadProcess, CADestroyData);
1300 if (CA_STATUS_OK != res)
1302 OIC_LOG(ERROR, TAG, "Failed to Initialize receive queue thread");
1306 #ifndef SINGLE_HANDLE // This will be enabled when RI supports multi threading
1307 // start receive thread
1308 res = CAQueueingThreadStart(&g_receiveThread);
1309 if (CA_STATUS_OK != res)
1311 OIC_LOG(ERROR, TAG, "thread start error(receive thread).");
1314 #endif // SINGLE_HANDLE
1316 // retransmission initialize
1317 res = CARetransmissionInitialize(&g_retransmissionContext, g_threadPoolHandle,
1318 CASendUnicastData, CATimeoutCallback, NULL);
1319 if (CA_STATUS_OK != res)
1321 OIC_LOG(ERROR, TAG, "Failed to Initialize Retransmission.");
1326 // block-wise transfer initialize
1327 res = CAInitializeBlockWiseTransfer(CAAddDataToSendThread, CAAddDataToReceiveThread);
1328 if (CA_STATUS_OK != res)
1330 OIC_LOG(ERROR, TAG, "Failed to Initialize BlockWiseTransfer.");
1335 // start retransmission
1336 res = CARetransmissionStart(&g_retransmissionContext);
1337 if (CA_STATUS_OK != res)
1339 OIC_LOG(ERROR, TAG, "thread start error(retransmission thread).");
1343 // initialize interface adapters by controller
1344 CAInitializeAdapters(g_threadPoolHandle, transportType);
1345 CASetNetworkMonitorCallbacks(CAAdapterStateChangedCallback, CAConnectionStateChangedCallback);
1347 // retransmission initialize
1348 CAResult_t res = CARetransmissionInitialize(&g_retransmissionContext, NULL, CASendUnicastData,
1349 CATimeoutCallback, NULL);
1350 if (CA_STATUS_OK != res)
1352 OIC_LOG(ERROR, TAG, "Failed to Initialize Retransmission.");
1356 CAInitializeAdapters();
1357 #endif // SINGLE_THREAD
1359 return CA_STATUS_OK;
1362 static bool CAClearQueueAdapterDataContext(void *data, uint32_t size, void *ctx)
1366 if (NULL == data || NULL == ctx)
1371 CAData_t *caData = (CAData_t *)data;
1372 CATransportAdapter_t *type = (CATransportAdapter_t *)ctx;
1374 if (NULL != caData && NULL != caData->remoteEndpoint
1375 && caData->remoteEndpoint->adapter == *type)
1382 void CAClearMessageHandler(CATransportAdapter_t transportType)
1384 CATransportAdapter_t *typeCtx = &transportType;
1386 CAResult_t res = CAQueueingThreadClearContextData(&g_sendThread,
1387 CAClearQueueAdapterDataContext,
1390 if (res != CA_STATUS_OK)
1392 OIC_LOG_V(ERROR, TAG, "Clear send data failed[%d]", res);
1395 if (transportType & DEFAULT_RETRANSMISSION_TYPE)
1397 res = CARetransmissionClearAdapterData(&g_retransmissionContext, transportType);
1398 if (res != CA_STATUS_OK)
1400 OIC_LOG_V(ERROR, TAG, "Clear retransmission data failed[%d]", res);
1405 void CATerminateMessageHandler()
1407 #ifndef SINGLE_THREAD
1408 CATransportAdapter_t connType;
1409 u_arraylist_t *list = CAGetSelectedNetworkList();
1410 uint32_t length = u_arraylist_length(list);
1412 #ifdef WITH_PROCESS_EVENT
1413 g_processEvent = NULL;
1417 for (i = 0; i < length; i++)
1419 void* ptrType = u_arraylist_get(list, i);
1421 if (NULL == ptrType)
1426 connType = *(CATransportAdapter_t *)ptrType;
1427 CAStopAdapter(connType);
1430 // stop retransmission
1431 if (NULL != g_retransmissionContext.threadMutex)
1433 CARetransmissionStop(&g_retransmissionContext);
1437 // delete thread data
1438 if (NULL != g_sendThread.threadMutex)
1440 CAQueueingThreadStop(&g_sendThread);
1444 // delete thread data
1445 if (NULL != g_receiveThread.threadMutex)
1447 #ifndef SINGLE_HANDLE // This will be enabled when RI supports multi threading
1448 CAQueueingThreadStop(&g_receiveThread);
1452 // destroy thread pool
1453 if (NULL != g_threadPoolHandle)
1455 ca_thread_pool_free(g_threadPoolHandle);
1456 g_threadPoolHandle = NULL;
1460 CATerminateBlockWiseTransfer();
1462 CARetransmissionDestroy(&g_retransmissionContext);
1463 CAQueueingThreadDestroy(&g_sendThread);
1464 CAQueueingThreadDestroy(&g_receiveThread);
1466 // terminate interface adapters by controller
1467 CATerminateAdapters();
1469 // terminate interface adapters by controller
1470 CATerminateAdapters();
1472 // stop retransmission
1473 CARetransmissionStop(&g_retransmissionContext);
1474 CARetransmissionDestroy(&g_retransmissionContext);
1475 #endif // SINGLE_THREAD
1478 static void CALogPayloadInfo(CAInfo_t *info)
1484 for (uint32_t i = 0; i < info->numOptions; i++)
1486 OIC_LOG_V(DEBUG, TAG, "optionID: %u", info->options[i].optionID);
1488 OIC_LOG_V(DEBUG, TAG, "list: %s", info->options[i].optionData);
1494 OIC_LOG_V(DEBUG, TAG, "payload: %p(%zu)", info->payload,
1500 OIC_LOG(DEBUG, TAG, "token:");
1501 OIC_LOG_BUFFER(DEBUG, TAG, (const uint8_t *) info->token,
1504 OIC_LOG_V(DEBUG, TAG, "msgID: %u", info->messageId);
1508 OIC_LOG(DEBUG, TAG, "info is NULL, cannot output log data");
1512 void CAErrorHandler(const CAEndpoint_t *endpoint,
1513 const void *data, uint32_t dataLen,
1516 OIC_LOG(DEBUG, TAG, "CAErrorHandler IN");
1517 VERIFY_NON_NULL_VOID(endpoint, TAG, "remoteEndpoint");
1518 VERIFY_NON_NULL_VOID(data, TAG, "data");
1522 OIC_LOG(ERROR, TAG, "dataLen is zero");
1526 #ifndef SINGLE_THREAD
1527 uint32_t code = CA_NOT_FOUND;
1528 //Do not free remoteEndpoint and data. Currently they will be freed in data thread
1530 coap_pdu_t *pdu = (coap_pdu_t *)CAParsePDU((const char *)data, dataLen, &code, endpoint);
1533 OIC_LOG(ERROR, TAG, "Parse PDU failed");
1537 CAData_t *cadata = CAGenerateHandlerData(endpoint, NULL, pdu, CA_ERROR_DATA);
1540 OIC_LOG(ERROR, TAG, "CAErrorHandler, CAGenerateHandlerData failed!");
1541 coap_delete_pdu(pdu);
1545 cadata->errorInfo->result = result;
1547 CAResult_t res = CAQueueingThreadAddData(&g_receiveThread, cadata, sizeof(CAData_t), false);
1548 if (res != CA_STATUS_OK)
1550 OIC_LOG(ERROR, TAG, "Failed to add message to data queue!");
1551 CADestroyData(cadata, sizeof(CAData_t));
1552 coap_delete_pdu(pdu);
1556 #ifdef WITH_PROCESS_EVENT
1559 oc_event_signal(g_processEvent);
1562 coap_delete_pdu(pdu);
1567 OIC_LOG(DEBUG, TAG, "CAErrorHandler OUT");
1571 static void CASendErrorInfo(const CAEndpoint_t *endpoint, const CAInfo_t *info, CAResult_t result)
1573 OIC_LOG(DEBUG, TAG, "CASendErrorInfo IN");
1574 #ifndef SINGLE_THREAD
1575 CAData_t *cadata = (CAData_t *) OICCalloc(1, sizeof(CAData_t));
1578 OIC_LOG(ERROR, TAG, "cadata memory allocation failed");
1582 CAEndpoint_t* ep = CACloneEndpoint(endpoint);
1585 OIC_LOG(ERROR, TAG, "endpoint clone failed");
1590 CAErrorInfo_t *errorInfo = (CAErrorInfo_t *)OICCalloc(1, sizeof (CAErrorInfo_t));
1593 OIC_LOG(ERROR, TAG, "errorInfo memory allocation failed");
1599 CAResult_t res = CACloneInfo(info, &errorInfo->info);
1600 if (CA_STATUS_OK != res)
1602 OIC_LOG(ERROR, TAG, "info clone failed");
1609 errorInfo->result = result;
1610 cadata->remoteEndpoint = ep;
1611 cadata->errorInfo = errorInfo;
1612 cadata->dataType = CA_ERROR_DATA;
1614 res = CAQueueingThreadAddData(&g_receiveThread, cadata, sizeof(CAData_t), false);
1615 if (res != CA_STATUS_OK)
1617 OIC_LOG(ERROR, TAG, "Failed to add message to data queue!");
1618 CADestroyData(cadata, sizeof(CAData_t));
1622 #ifdef WITH_PROCESS_EVENT
1625 oc_event_signal(g_processEvent);
1627 #endif//WITH_PROCESS_EVENT
1629 OIC_LOG(DEBUG, TAG, "CASendErrorInfo OUT");
1636 static void CALogPDUInfo(const CAData_t *data, const coap_pdu_t *pdu)
1639 if(data == NULL || pdu == NULL)
1641 printf("INVALID INPUT, CALogPDUInfo FAIL\n");
1646 switch(data->dataType)
1648 case CA_REQUEST_DATA:
1649 strncpy(type, "\e[32mREQUEST <<<<\e[m", 30);
1651 case CA_RESPONSE_DATA:
1652 strncpy(type, "\e[36mRESPONSE >>>>\e[m", 30);
1655 strncpy(type, "ERROR", 30);
1657 case CA_RESPONSE_FOR_RES:
1658 strncpy(type, "RESP_RES >>>>", 30);
1661 snprintf(type, 30, "Type : %d", data->dataType);
1666 char method[20] = "";
1667 const CAInfo_t *info = NULL;
1668 if (NULL != data->requestInfo)
1670 switch(data->requestInfo->method)
1673 strncpy(method, "GET", 20);
1676 strncpy(method, "POST", 20);
1679 strncpy(method, "PUT", 20);
1682 strncpy(method, "DEL", 20);
1685 sprintf(method, "Method : %d", data->requestInfo->method);
1688 info = &data->requestInfo->info;
1691 if(NULL != data->responseInfo)
1694 sprintf(method, "result : %d", data->responseInfo->result);
1695 info = &data->responseInfo->info;
1699 char log_buffer[1024] = "";
1700 sprintf(log_buffer, "CA_LOG [%5d] | %-13s | %-12s | msg size : %4d | %s", pdu->transport_hdr->udp.id , type, method, pdu->length, info->resourceUri);
1704 sprintf(log_buffer, "CA_LOG [%5d] | %-13s | %-12s | msg size : %4d | %s", pdu->transport_hdr->udp.id , type, method, pdu->length, info->resourceUri);
1713 static void CALogPDUInfo(const CAData_t *data, const coap_pdu_t *pdu)
1715 OIC_LOG(DEBUG, TAG, "CALogPDUInfo");
1717 VERIFY_NON_NULL_VOID(data, TAG, "data");
1718 VERIFY_NON_NULL_VOID(pdu, TAG, "pdu");
1719 OIC_TRACE_BEGIN(%s:CALogPDUInfo, TAG);
1721 OIC_LOG(INFO, ANALYZER_TAG, "=================================================");
1722 if(SEND_TYPE_MULTICAST == data->type)
1724 OIC_LOG(INFO, ANALYZER_TAG, "Is Multicast = true");
1728 OIC_LOG(INFO, ANALYZER_TAG, "Is Multicast = false");
1731 if (NULL != data->remoteEndpoint)
1733 CALogAdapterTypeInfo(data->remoteEndpoint->adapter);
1734 OIC_LOG_V(DEBUG, ANALYZER_TAG, "Address = [%s]:[%d]", data->remoteEndpoint->addr,
1735 data->remoteEndpoint->port);
1738 switch(data->dataType)
1740 case CA_REQUEST_DATA:
1741 OIC_LOG(INFO, ANALYZER_TAG, "Data Type = [CA_REQUEST_DATA]");
1743 case CA_RESPONSE_DATA:
1744 OIC_LOG(INFO, ANALYZER_TAG, "Data Type = [CA_RESPONSE_DATA]");
1747 OIC_LOG(INFO, ANALYZER_TAG, "Data Type = [CA_ERROR_DATA]");
1749 case CA_RESPONSE_FOR_RES:
1750 OIC_LOG(INFO, ANALYZER_TAG, "Data Type = [CA_RESPONSE_FOR_RES]");
1753 OIC_LOG_V(INFO, ANALYZER_TAG, "Data Type = [%d]", data->dataType);
1757 const CAInfo_t *info = NULL;
1758 if (NULL != data->requestInfo)
1760 switch(data->requestInfo->method)
1763 OIC_LOG(INFO, ANALYZER_TAG, "Method = [GET]");
1766 OIC_LOG(INFO, ANALYZER_TAG, "Method = [POST]");
1769 OIC_LOG(INFO, ANALYZER_TAG, "Method = [PUT]");
1772 OIC_LOG(INFO, ANALYZER_TAG, "Method = [DELETE]");
1775 OIC_LOG_V(INFO, ANALYZER_TAG, "Method = [%d]", data->requestInfo->method);
1778 info = &data->requestInfo->info;
1781 if (NULL != data->responseInfo)
1783 OIC_LOG_V(INFO, ANALYZER_TAG, "result code = [%d]", data->responseInfo->result);
1784 info = &data->responseInfo->info;
1787 if (pdu->transport_hdr)
1789 OIC_LOG_V(INFO, ANALYZER_TAG, "Msg ID = [%d]", pdu->transport_hdr->udp.id);
1794 OIC_LOG(INFO, ANALYZER_TAG, "Coap Token");
1795 OIC_LOG_BUFFER(INFO, ANALYZER_TAG, (const uint8_t *) info->token, info->tokenLength);
1796 OIC_TRACE_BUFFER("OIC_CA_MSG_HANDLE:CALogPDUInfo:token",
1797 (const uint8_t *) info->token, info->tokenLength);
1798 OIC_LOG_V(INFO_PRIVATE, ANALYZER_TAG, "Res URI = [%s]", info->resourceUri);
1799 OIC_TRACE_MARK(%s:CALogPDUInfo:uri:%s, TAG, info->resourceUri);
1801 if (CA_FORMAT_APPLICATION_CBOR == info->payloadFormat)
1803 OIC_LOG(INFO, ANALYZER_TAG, "Payload Format = [CA_FORMAT_APPLICATION_CBOR]");
1807 OIC_LOG_V(INFO, ANALYZER_TAG, "Payload Format = [%d]", info->payloadFormat);
1811 size_t payloadLen = (pdu->data) ? (unsigned char *) pdu->hdr + pdu->length - pdu->data : 0;
1812 OIC_LOG_V(INFO, ANALYZER_TAG, "CoAP Message Full Size = [%u]", pdu->length);
1813 OIC_LOG(INFO, ANALYZER_TAG, "CoAP Header (+ 0xFF)");
1814 OIC_LOG_BUFFER(INFO, ANALYZER_TAG, (const uint8_t *) pdu->transport_hdr,
1815 pdu->length - payloadLen);
1816 OIC_LOG_V(INFO, ANALYZER_TAG, "CoAP Header size = [%" PRIuPTR "]", (size_t) pdu->length - payloadLen);
1818 OIC_LOG_V(INFO, ANALYZER_TAG, "CoAP Payload");
1819 OIC_LOG_BUFFER(INFO_PRIVATE, ANALYZER_TAG, pdu->data, payloadLen);
1820 OIC_LOG_V(INFO, ANALYZER_TAG, "CoAP Payload Size = [%" PRIuPTR "]", payloadLen);
1821 OIC_LOG(INFO, ANALYZER_TAG, "=================================================");
1824 CASamsungLogMessage(data, pdu);
1828 static void CASamsungLogMessage(const CAData_t *data, const coap_pdu_t *pdu)
1830 OIC_LOG(INFO, TAG, "CASamsungLogMessage");
1831 VERIFY_NON_NULL_VOID(data, TAG, "data");
1832 VERIFY_NON_NULL_VOID(pdu, TAG, "pdu");
1833 VERIFY_NON_NULL_VOID(data->remoteEndpoint, TAG, "data->remoteEndpoint");
1835 const CAInfo_t *info = NULL;
1836 if (NULL != data->requestInfo)
1838 info = &data->requestInfo->info;
1841 if (NULL != data->responseInfo)
1843 info = &data->responseInfo->info;
1846 VERIFY_NON_NULL_VOID(info, TAG, "info");
1848 memset(g_headerBuffer, 0, MAX_LOG_BUFFER_SIZE);
1851 g_headerBuffer[g_headerIndex++] = data->dataType;
1852 g_headerBuffer[g_headerIndex++] = '|';
1853 g_headerBuffer[g_headerIndex++] = data->remoteEndpoint->adapter;
1854 g_headerBuffer[g_headerIndex++] = '|';
1855 g_headerBuffer[g_headerIndex++] = data->type;
1856 g_headerBuffer[g_headerIndex++] = '|';
1858 if (NULL != data->remoteEndpoint)
1861 while (data->remoteEndpoint->addr[i])
1863 g_headerBuffer[g_headerIndex++] = data->remoteEndpoint->addr[i];
1866 g_headerBuffer[g_headerIndex++] = ':';
1867 g_headerBuffer[g_headerIndex++] = (data->remoteEndpoint->port >> 8) & 0x0000ff;
1868 g_headerBuffer[g_headerIndex++] = data->remoteEndpoint->port & 0x000000ff;
1871 g_headerBuffer[g_headerIndex++] = '|';
1872 if (data->requestInfo)
1874 g_headerBuffer[g_headerIndex++] = data->requestInfo->method;
1878 g_headerBuffer[g_headerIndex++] = 0;
1881 g_headerBuffer[g_headerIndex++] = '|';
1882 if (data->responseInfo)
1884 g_headerBuffer[g_headerIndex++] = data->responseInfo->result;
1888 g_headerBuffer[g_headerIndex++] = 0;
1890 g_headerBuffer[g_headerIndex++] = '|';
1892 if (pdu->transport_hdr)
1894 g_headerBuffer[g_headerIndex++] = (pdu->transport_hdr->udp.id >> 8) & 0x0000ff;
1895 g_headerBuffer[g_headerIndex++] = pdu->transport_hdr->udp.id & 0x000000ff;
1899 g_headerBuffer[g_headerIndex++] = 0;
1900 g_headerBuffer[g_headerIndex++] = 0;
1902 g_headerBuffer[g_headerIndex++] = '|';
1904 if (info->token && info->tokenLength > 0)
1906 for (size_t i = 0; i < info->tokenLength; i++)
1908 g_headerBuffer[g_headerIndex++] = info->token[i];
1910 g_headerBuffer[g_headerIndex++] = '|';
1913 if (info->resourceUri)
1916 while (info->resourceUri[i])
1918 g_headerBuffer[g_headerIndex++] = info->resourceUri[i];
1921 g_headerBuffer[g_headerIndex++] = '|';
1924 OIC_LOG_CA_BUFFER(INFO, TAG, (uint8_t *) g_headerBuffer, g_headerIndex, 1);
1925 size_t payloadLen = (unsigned char *) pdu->hdr + pdu->length - pdu->data;
1926 OIC_LOG_CA_BUFFER(INFO_PRIVATE, TAG, pdu->data, payloadLen, 0);
1931 static void CALogPDUInfo(const CAData_t *data, const coap_pdu_t *pdu)
1933 VERIFY_NON_NULL_VOID(pdu, TAG, "pdu");
1936 OIC_LOG_V(DEBUG, TAG, "PDU Maker - payload : %s", pdu->data);
1937 OIC_LOG_V(DEBUG, TAG, "PDU Maker - type : %d", pdu->transport_hdr->udp.type);
1938 OIC_LOG_V(DEBUG, TAG, "PDU Maker - code : %d", pdu->transport_hdr->udp.code);
1939 OIC_LOG(DEBUG, TAG, "PDU Maker - token :");
1940 OIC_LOG_BUFFER(DEBUG, TAG, pdu->transport_hdr->udp.token,
1941 pdu->transport_hdr->udp.token_length);
1945 #ifdef WITH_PROCESS_EVENT
1946 void CARegisterMessageProcessEvent(oc_event event)
1948 g_processEvent = event;
1950 #endif // WITH_PROCESS_EVENT