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 ******************************************************************/
21 // Defining _BSD_SOURCE or _DEFAULT_SOURCE causes header files to expose
22 // definitions that may otherwise be skipped. Skipping can cause implicit
23 // declaration warnings and/or bugs and subtle problems in code execution.
24 // For glibc information on feature test macros,
25 // Refer http://www.gnu.org/software/libc/manual/html_node/Feature-Test-Macros.html
27 // This file requires #define use due to random()
28 // For details on compatibility and glibc support,
29 // Refer http://www.gnu.org/software/libc/manual/html_node/BSD-Random.html
30 #define _DEFAULT_SOURCE
37 #include "caadapterutils.h"
38 #include "cainterface.h"
39 #include "camessagehandler.h"
40 #include "caremotehandler.h"
41 #include "cablockwisetransfer.h"
42 #include "oic_malloc.h"
48 #define BLOCKWISE_OPTION_BUFFER (sizeof(unsigned int))
49 #define BLOCK_NUMBER_IDX 4
50 #define BLOCK_M_BIT_IDX 3
53 #define BLOCK_SIZE(arg) (1 << ((arg) + 4))
55 // context for block-wise transfer
56 static CABlockWiseContext_t g_context = { 0 };
58 static bool CACheckPayloadLength(const CAData_t *sendData)
60 size_t payloadLen = 0;
61 CAGetPayloadInfo(sendData, &payloadLen);
63 // check if message has to be transfered to a block
64 size_t maxBlockSize = BLOCK_SIZE(CA_DEFAULT_BLOCK_SIZE);
65 OIC_LOG_V(DEBUG, TAG, "payloadLen=%d, maxBlockSize=%d", payloadLen, maxBlockSize);
67 if (payloadLen <= maxBlockSize)
75 CAResult_t CAInitializeBlockWiseTransfer(CASendThreadFunc sendThreadFunc,
76 CAReceiveThreadFunc receivedThreadFunc)
78 OIC_LOG(DEBUG, TAG, "initialize");
80 // set block-wise transfer context
81 if (!g_context.sendThreadFunc)
83 g_context.sendThreadFunc = sendThreadFunc;
86 if (!g_context.receivedThreadFunc)
88 g_context.receivedThreadFunc = receivedThreadFunc;
91 if (!g_context.dataList)
93 g_context.dataList = u_arraylist_create();
96 CAResult_t res = CAInitBlockWiseMutexVariables();
97 if (CA_STATUS_OK != res)
99 OIC_LOG(ERROR, TAG, "init has failed");
105 CAResult_t CATerminateBlockWiseTransfer()
107 OIC_LOG(DEBUG, TAG, "terminate");
109 if (g_context.dataList)
111 u_arraylist_free(&g_context.dataList);
114 CATerminateBlockWiseMutexVariables();
119 CAResult_t CAInitBlockWiseMutexVariables()
121 OIC_LOG(DEBUG, TAG, "IN");
123 if (!g_context.blockDataListMutex)
125 g_context.blockDataListMutex = ca_mutex_new();
126 if (!g_context.blockDataListMutex)
128 OIC_LOG(ERROR, TAG, "ca_mutex_new has failed");
129 return CA_STATUS_FAILED;
133 if (!g_context.blockDataSenderMutex)
135 g_context.blockDataSenderMutex = ca_mutex_new();
136 if (!g_context.blockDataSenderMutex)
138 OIC_LOG(ERROR, TAG, "ca_mutex_new has failed");
139 CATerminateBlockWiseMutexVariables();
140 return CA_STATUS_FAILED;
147 void CATerminateBlockWiseMutexVariables()
149 OIC_LOG(DEBUG, TAG, "IN");
151 if (g_context.blockDataListMutex)
153 ca_mutex_free(g_context.blockDataListMutex);
154 g_context.blockDataListMutex = NULL;
157 if (g_context.blockDataSenderMutex)
159 ca_mutex_free(g_context.blockDataSenderMutex);
160 g_context.blockDataSenderMutex = NULL;
164 CAResult_t CASendBlockWiseData(const CAData_t *sendData)
166 VERIFY_NON_NULL(sendData, TAG, "sendData");
168 // check if message type is CA_MSG_RESET
169 if (sendData->requestInfo)
171 if (CA_MSG_RESET == sendData->requestInfo->info.type)
173 OIC_LOG(DEBUG, TAG, "reset message can't be sent to the block");
174 return CA_NOT_SUPPORTED;
177 else if (sendData->responseInfo)
179 if (CA_MSG_RESET == sendData->responseInfo->info.type)
181 OIC_LOG(DEBUG, TAG, "reset message can't be sent to the block");
182 return CA_NOT_SUPPORTED;
186 // #1. check if it is already included in block data list
187 CABlockData_t *currData = NULL;
188 CAResult_t res = CACheckBlockDataValidation(sendData, &currData);
189 if (CA_STATUS_OK != res)
191 // #2. if it is not included, add the data into list
194 OIC_LOG(DEBUG, TAG, "There is no block data");
196 bool isBlock = CACheckPayloadLength(sendData);
199 if (sendData->requestInfo)
201 currData = CACreateNewBlockData(sendData);
204 OIC_LOG(ERROR, TAG, "failed to create block data");
205 return CA_MEMORY_ALLOC_FAILED;
208 return CA_NOT_SUPPORTED;
210 currData = CACreateNewBlockData(sendData);
213 OIC_LOG(ERROR, TAG, "failed to create block data");
214 return CA_MEMORY_ALLOC_FAILED;
219 // #3. check request/response block option type and payload length
220 res = CACheckBlockOptionType(currData);
221 if (CA_STATUS_OK == res)
223 // #4. send block message
224 OIC_LOG(DEBUG, TAG, "send first block msg");
225 res = CAAddSendThreadQueue(currData->sentData,
226 (const CABlockDataID_t *)&currData->blockDataId);
227 if (CA_STATUS_OK != res)
229 OIC_LOG(ERROR, TAG, "add has failed");
237 CAResult_t CAAddSendThreadQueue(const CAData_t *sendData, const CABlockDataID_t *blockID)
239 VERIFY_NON_NULL(sendData, TAG, "sendData");
240 VERIFY_NON_NULL(blockID, TAG, "blockID");
242 CAData_t *cloneData = CACloneCAData(sendData);
245 OIC_LOG(ERROR, TAG, "clone has failed");
246 CARemoveBlockDataFromList(blockID);
247 return CA_STATUS_FAILED;
250 if (g_context.sendThreadFunc)
252 ca_mutex_lock(g_context.blockDataSenderMutex);
253 g_context.sendThreadFunc(cloneData);
254 ca_mutex_unlock(g_context.blockDataSenderMutex);
258 CADestroyDataSet(cloneData);
263 CAResult_t CACheckBlockOptionType(CABlockData_t *currData)
265 VERIFY_NON_NULL(currData, TAG, "currData");
266 VERIFY_NON_NULL(currData->sentData, TAG, "currData->sentData");
268 bool isBlock = CACheckPayloadLength(currData->sentData);
271 return CA_NOT_SUPPORTED;
274 // set block option (COAP_OPTION_BLOCK2 or COAP_OPTION_BLOCK1)
275 if (currData->sentData->requestInfo) // request message
277 currData->type = COAP_OPTION_BLOCK1;
279 else // response message
281 currData->type = COAP_OPTION_BLOCK2;
287 // TODO make pdu const after libcoap is updated to support that.
288 CAResult_t CAReceiveBlockWiseData(coap_pdu_t *pdu, const CAEndpoint_t *endpoint,
289 const CAData_t *receivedData, size_t dataLen)
291 OIC_LOG(DEBUG, TAG, "CAReceiveBlockWiseData");
292 VERIFY_NON_NULL(pdu, TAG, "pdu");
293 VERIFY_NON_NULL(pdu->hdr, TAG, "pdu->hdr");
294 VERIFY_NON_NULL(endpoint, TAG, "endpoint");
295 VERIFY_NON_NULL(receivedData, TAG, "receivedData");
297 // check if received message type is CA_MSG_RESET
298 if (CA_EMPTY == pdu->hdr->coap_hdr_udp_t.code)
300 OIC_LOG(DEBUG, TAG, "code is CA_EMPTY..");
302 // get token from block-wise transfer list when CA_EMPTY(RST/ACK) is received
303 CAResult_t res = CAGetTokenFromBlockDataList(pdu, endpoint, receivedData->responseInfo);
304 if (CA_STATUS_OK != res)
306 OIC_LOG(ERROR, TAG, "fail to get token");
310 CABlockDataID_t* blockDataID = CACreateBlockDatablockId(
311 receivedData->responseInfo->info.token,
312 receivedData->responseInfo->info.tokenLength,
314 if(NULL == blockDataID || NULL == blockDataID->id || blockDataID->idLength < 1)
316 OIC_LOG(ERROR, TAG, "blockId is null");
317 CADestroyBlockID(blockDataID);
318 return CA_STATUS_FAILED;
321 CARemoveBlockDataFromList(blockDataID);
322 CADestroyBlockID(blockDataID);
323 return CA_NOT_SUPPORTED;
326 // check if block option is set and get block data
327 coap_block_t block = {0, 0, 0};
330 int isBlock1 = coap_get_block(pdu, COAP_OPTION_BLOCK1, &block);
333 CAResult_t res = CASetNextBlockOption1(pdu, endpoint, receivedData, block, dataLen);
334 if (CA_STATUS_OK != res)
336 OIC_LOG(ERROR, TAG, "setting has failed");
342 int isBlock2 = coap_get_block(pdu, COAP_OPTION_BLOCK2, &block);
345 CAResult_t res = CASetNextBlockOption2(pdu, endpoint, receivedData, block, dataLen);
346 if (CA_STATUS_OK != res)
348 OIC_LOG(ERROR, TAG, "setting has failed");
353 // check if there is error code
354 if (!isBlock1 && !isBlock2)
356 uint32_t code = CA_RESPONSE_CODE(pdu->hdr->coap_hdr_udp_t.code);
357 if (CA_REQUEST_ENTITY_INCOMPLETE == code)
359 CABlockDataID_t* blockDataID = CACreateBlockDatablockId(
360 (CAToken_t)pdu->hdr->coap_hdr_udp_t.token,
361 pdu->hdr->coap_hdr_udp_t.token_length,
364 if(NULL == blockDataID || NULL == blockDataID->id || blockDataID->idLength < 1)
366 OIC_LOG(ERROR, TAG, "blockId is null");
367 CADestroyBlockID(blockDataID);
368 return CA_STATUS_FAILED;
371 CABlockData_t *data = CAGetBlockDataFromBlockDataList(blockDataID);
374 OIC_LOG(ERROR, TAG, "getting has failed");
375 CADestroyBlockID(blockDataID);
376 return CA_STATUS_FAILED;
379 if (COAP_OPTION_BLOCK2 == data->type)
381 coap_block_t *block2 = CAGetBlockOption(blockDataID, COAP_OPTION_BLOCK2);
384 OIC_LOG(ERROR, TAG, "block is null");
385 CADestroyBlockID(blockDataID);
386 return CA_STATUS_FAILED;
389 CAResult_t res = CASetNextBlockOption2(pdu, endpoint, receivedData, *block2,
391 if (CA_STATUS_OK != res)
393 OIC_LOG(ERROR, TAG, "setting has failed");
394 CADestroyBlockID(blockDataID);
398 else if (COAP_OPTION_BLOCK1 == data->type)
400 coap_block_t *block1 = CAGetBlockOption(blockDataID, COAP_OPTION_BLOCK1);
403 OIC_LOG(ERROR, TAG, "block is null");
404 CADestroyBlockID(blockDataID);
405 return CA_STATUS_FAILED;
408 CAResult_t res = CASetNextBlockOption1(pdu, endpoint, receivedData, *block1,
410 if (CA_STATUS_OK != res)
412 OIC_LOG(ERROR, TAG, "setting has failed");
413 CADestroyBlockID(blockDataID);
421 OIC_LOG(DEBUG, TAG, "it's normal pdu");
423 // if received data is response message
424 // and sent data remain in block data list, remove block data
425 if (receivedData->responseInfo)
427 CABlockDataID_t* blockDataID = CACreateBlockDatablockId(
428 (CAToken_t)pdu->hdr->coap_hdr_udp_t.token,
429 pdu->hdr->coap_hdr_udp_t.token_length,
431 if(NULL == blockDataID || NULL == blockDataID->id || blockDataID->idLength < 1)
433 OIC_LOG(ERROR, TAG, "blockId is null");
434 CADestroyBlockID(blockDataID);
435 return CA_STATUS_FAILED;
438 CARemoveBlockDataFromList(blockDataID);
439 CADestroyBlockID(blockDataID);
441 return CA_NOT_SUPPORTED;
448 CAResult_t CAProcessNextStep(const coap_pdu_t *pdu, const CAData_t *receivedData,
449 uint8_t blockWiseStatus, const CABlockDataID_t *blockID)
451 VERIFY_NON_NULL(pdu, TAG, "pdu");
452 VERIFY_NON_NULL(pdu->hdr, TAG, "pdu->hdr");
453 VERIFY_NON_NULL(blockID, TAG, "blockID");
455 CAResult_t res = CA_STATUS_OK;
456 CAData_t *data = NULL;
458 // process blockWiseStatus
459 switch (blockWiseStatus)
461 case CA_OPTION2_FIRST_BLOCK:
462 res = CAAddSendThreadQueue(receivedData, blockID);
463 if (CA_STATUS_OK != res)
465 OIC_LOG(ERROR, TAG, "add has failed");
471 // add data to send thread
472 data = CAGetDataSetFromBlockDataList(blockID);
475 OIC_LOG(ERROR, TAG, "it's unavailable");
476 return CA_STATUS_FAILED;
479 if (data->requestInfo)
481 data->requestInfo->info.messageId = pdu->hdr->coap_hdr_udp_t.id;
484 if (data->responseInfo)
486 data->responseInfo->info.messageId = pdu->hdr->coap_hdr_udp_t.id;
489 res = CAAddSendThreadQueue(data, blockID);
490 if (CA_STATUS_OK != res)
492 OIC_LOG(ERROR, TAG, "add has failed");
500 case CA_SENT_PREVIOUS_NON_MSG:
501 res = CASendBlockMessage(pdu, CA_MSG_CONFIRM, blockWiseStatus,
503 if (CA_STATUS_OK != res)
505 OIC_LOG(ERROR, TAG, "send has failed");
510 case CA_OPTION2_LAST_BLOCK:
511 // process last block and send upper layer
512 res = CAReceiveLastBlock(blockID, receivedData);
513 if (CA_STATUS_OK != res)
515 OIC_LOG(ERROR, TAG, "receive has failed");
519 // remove data from list
520 res = CARemoveBlockDataFromList(blockID);
521 if (CA_STATUS_OK != res)
523 OIC_LOG(ERROR, TAG, "remove has failed");
528 case CA_OPTION1_NO_ACK_LAST_BLOCK:
529 // process last block and send upper layer
530 res = CAReceiveLastBlock(blockID, receivedData);
531 if (CA_STATUS_OK != res)
533 OIC_LOG(ERROR, TAG, "receive has failed");
537 if (CA_MSG_NONCONFIRM == pdu->hdr->coap_hdr_udp_t.type)
539 // remove data from list
540 res = CARemoveBlockDataFromList(blockID);
541 if (CA_STATUS_OK != res)
543 OIC_LOG(ERROR, TAG, "remove has failed");
549 case CA_OPTION1_NO_ACK_BLOCK:
550 if (CA_MSG_CONFIRM == pdu->hdr->coap_hdr_udp_t.type)
552 // add data to send thread
553 res = CASendBlockMessage(pdu, CA_MSG_ACKNOWLEDGE, blockWiseStatus,
555 if (CA_STATUS_OK != res)
557 OIC_LOG(ERROR, TAG, "send has failed");
563 case CA_BLOCK_INCOMPLETE:
564 if (CA_MSG_CONFIRM == pdu->hdr->coap_hdr_udp_t.type ||
565 CA_MSG_ACKNOWLEDGE == pdu->hdr->coap_hdr_udp_t.type)
567 // add data to send thread
568 res = CASendErrorMessage(pdu, blockWiseStatus,
569 CA_REQUEST_ENTITY_INCOMPLETE,
571 if (CA_STATUS_OK != res)
573 OIC_LOG(ERROR, TAG, "send has failed");
579 case CA_BLOCK_TOO_LARGE:
580 if (CA_MSG_ACKNOWLEDGE == pdu->hdr->coap_hdr_udp_t.type)
582 res = CASendBlockMessage(pdu, CA_MSG_CONFIRM, blockWiseStatus,
584 if (CA_STATUS_OK != res)
586 OIC_LOG(ERROR, TAG, "send has failed");
590 else if (CA_MSG_CONFIRM == pdu->hdr->coap_hdr_udp_t.type)
592 res = CASendErrorMessage(pdu, blockWiseStatus,
593 CA_REQUEST_ENTITY_TOO_LARGE,
595 if (CA_STATUS_OK != res)
597 OIC_LOG(ERROR, TAG, "send has failed");
603 OIC_LOG_V(ERROR, TAG, "no logic [%d]", blockWiseStatus);
608 CAResult_t CASendBlockMessage(const coap_pdu_t *pdu, CAMessageType_t msgType,
609 uint8_t status, const CABlockDataID_t *blockID)
611 VERIFY_NON_NULL(pdu, TAG, "pdu");
612 VERIFY_NON_NULL(pdu->hdr, TAG, "pdu->hdr");
613 VERIFY_NON_NULL(blockID, TAG, "blockID");
615 CAData_t *data = CAGetDataSetFromBlockDataList(blockID);
618 OIC_LOG(ERROR, TAG, "CAData is unavailable");
619 return CA_STATUS_FAILED;
622 if (CA_MSG_CONFIRM == msgType)
624 OIC_LOG(DEBUG, TAG, "need new msgID");
625 if (data->requestInfo)
627 data->requestInfo->info.messageId = 0;
630 if (data->responseInfo)
632 data->responseInfo->info.messageId = 0;
635 else if (CA_MSG_ACKNOWLEDGE == msgType)
637 if (data->responseInfo)
639 OIC_LOG(DEBUG, TAG, "set ACK message");
640 data->responseInfo->info.messageId = pdu->hdr->coap_hdr_udp_t.id;
641 data->responseInfo->info.type = CA_MSG_ACKNOWLEDGE;
642 if (CA_OPTION1_NO_ACK_LAST_BLOCK == status)
644 data->responseInfo->result = CA_CHANGED;
646 else if (CA_OPTION1_NO_ACK_BLOCK == status)
648 data->responseInfo->result = CA_CONTINUE;
653 // add data to send thread
654 CAResult_t res = CAAddSendThreadQueue(data, blockID);
655 if (CA_STATUS_OK != res)
657 OIC_LOG(ERROR, TAG, "add has failed");
663 CAResult_t CASendErrorMessage(const coap_pdu_t *pdu, uint8_t status,
664 CAResponseResult_t responseResult,
665 const CABlockDataID_t *blockID)
667 VERIFY_NON_NULL(pdu, TAG, "pdu");
668 VERIFY_NON_NULL(pdu->hdr, TAG, "pdu->hdr");
669 VERIFY_NON_NULL(blockID, TAG, "blockID");
671 // create error responseInfo
672 CABlockData_t *data = CAGetBlockDataFromBlockDataList(blockID);
675 OIC_LOG(ERROR, TAG, "data is unavailable");
676 return CA_STATUS_FAILED;
679 CAData_t *cloneData = NULL;
680 if (data->sentData && data->sentData->responseInfo)
682 data->sentData->responseInfo->info.messageId = pdu->hdr->coap_hdr_udp_t.id;
683 data->sentData->responseInfo->info.type = CA_MSG_ACKNOWLEDGE;
684 data->sentData->responseInfo->result = responseResult;
685 cloneData = CACloneCAData(data->sentData);
688 OIC_LOG(ERROR, TAG, "clone has failed");
689 return CA_MEMORY_ALLOC_FAILED;
691 OIC_LOG(DEBUG, TAG, "set ACK message");
693 else if (data->sentData)
695 cloneData = CACreateNewDataSet(pdu, data->sentData->remoteEndpoint);
698 OIC_LOG(ERROR, TAG, PCF("CACreateNewDataSet failed"));
699 return CA_MEMORY_ALLOC_FAILED;
702 cloneData->responseInfo->info.type = CA_MSG_CONFIRM;
703 cloneData->responseInfo->result = responseResult;
704 OIC_LOG(DEBUG, TAG, "set CON message");
708 OIC_LOG(ERROR, TAG, "data has no sent-data");
709 return CA_MEMORY_ALLOC_FAILED;
712 // add data to send thread
713 if (g_context.sendThreadFunc)
715 ca_mutex_lock(g_context.blockDataSenderMutex);
716 g_context.sendThreadFunc(cloneData);
717 ca_mutex_unlock(g_context.blockDataSenderMutex);
721 CADestroyDataSet(cloneData);
724 // if error code is 4.08, remove the stored payload and initialize block number
725 if (CA_BLOCK_INCOMPLETE == status)
727 OICFree(data->payload);
728 data->payload = NULL;
729 data->payloadLength = 0;
730 data->receivedPayloadLen = 0;
731 data->block1.num = 0;
732 data->block2.num = 0;
738 CAResult_t CAReceiveLastBlock(const CABlockDataID_t *blockID,
739 const CAData_t *receivedData)
741 VERIFY_NON_NULL(blockID, TAG, "blockID");
742 VERIFY_NON_NULL(receivedData, TAG, "receivedData");
744 // total block data have to notify to Application
745 CAData_t *cloneData = CACloneCAData(receivedData);
748 OIC_LOG(ERROR, TAG, "clone has failed");
749 return CA_MEMORY_ALLOC_FAILED;
753 size_t fullPayloadLen = 0;
754 CAPayload_t fullPayload = CAGetPayloadFromBlockDataList(blockID,
758 CAResult_t res = CAUpdatePayloadToCAData(cloneData, fullPayload, fullPayloadLen);
759 if (CA_STATUS_OK != res)
761 OIC_LOG(ERROR, TAG, "update has failed");
762 CADestroyDataSet(cloneData);
767 if (g_context.receivedThreadFunc)
769 g_context.receivedThreadFunc(cloneData);
773 CADestroyDataSet(cloneData);
779 // TODO make pdu const after libcoap is updated to support that.
780 CAResult_t CASetNextBlockOption1(coap_pdu_t *pdu, const CAEndpoint_t *endpoint,
781 const CAData_t *receivedData, coap_block_t block,
784 OIC_LOG(INFO, TAG, "CASetNextBlockOption1");
785 VERIFY_NON_NULL(pdu, TAG, "pdu");
786 VERIFY_NON_NULL(pdu->hdr, TAG, "pdu->hdr");
787 VERIFY_NON_NULL(endpoint, TAG, "endpoint");
788 VERIFY_NON_NULL(receivedData, TAG, "receivedData");
790 OIC_LOG_V(INFO, TAG, "num:%d, M:%d, sze:%d", block.num, block.m, block.szx);
792 CABlockDataID_t* blockDataID = CACreateBlockDatablockId(
793 (CAToken_t)pdu->hdr->coap_hdr_udp_t.token,
794 pdu->hdr->coap_hdr_udp_t.token_length,
797 if(NULL == blockDataID || NULL == blockDataID->id || blockDataID->idLength < 1)
799 OIC_LOG(ERROR, TAG, "blockId is null");
800 CADestroyBlockID(blockDataID);
801 return CA_STATUS_FAILED;
804 // BlockData data is created if it not existed
805 if (!CAIsBlockDataInList(blockDataID))
807 OIC_LOG(DEBUG, TAG, "no message in list");
809 CAData_t *data = CACreateNewDataSet(pdu, endpoint);
812 OIC_LOG(ERROR, TAG, "data is null");
813 CADestroyBlockID(blockDataID);
814 return CA_STATUS_FAILED;
817 CABlockData_t *currData = CACreateNewBlockData(data);
820 OIC_LOG(ERROR, TAG, "currData is null");
821 CADestroyDataSet(data);
822 CADestroyBlockID(blockDataID);
823 return CA_STATUS_FAILED;
825 CADestroyDataSet(data);
828 // update BLOCK OPTION1 type
829 CAResult_t res = CAUpdateBlockOptionType(blockDataID,
831 if (CA_STATUS_OK != res)
833 OIC_LOG(ERROR, TAG, "update has failed");
834 CARemoveBlockDataFromList(blockDataID);
835 CADestroyBlockID(blockDataID);
839 CABlockData_t *data = CAGetBlockDataFromBlockDataList(blockDataID);
842 OIC_LOG(ERROR, TAG, "getting has failed");
843 CADestroyBlockID(blockDataID);
844 return CA_STATUS_FAILED;
847 uint8_t blockWiseStatus = CA_BLOCK_UNKNOWN;
848 // received type from remote device
849 if (CA_MSG_ACKNOWLEDGE == pdu->hdr->coap_hdr_udp_t.type)
851 uint32_t code = CA_RESPONSE_CODE(pdu->hdr->coap_hdr_udp_t.code);
853 (CA_REQUEST_ENTITY_INCOMPLETE != code && CA_REQUEST_ENTITY_TOO_LARGE != code))
855 OIC_LOG(INFO, TAG, "Data has sent");
856 // initialize block number for response message
857 data->block1.num = 0;
858 CADestroyBlockID(blockDataID);
862 blockWiseStatus = CA_OPTION1_ACK;
863 res = CAUpdateBlockOptionItems(data, pdu, &block, COAP_OPTION_BLOCK1, blockWiseStatus);
864 if (CA_STATUS_OK != res)
866 OIC_LOG(ERROR, TAG, "update has failed");
867 CADestroyBlockID(blockDataID);
871 res = CAUpdateBlockData(data, block, COAP_OPTION_BLOCK1);
872 if (CA_STATUS_OK != res)
874 OIC_LOG(ERROR, TAG, "update has failed");
875 CARemoveBlockDataFromList(blockDataID);
876 CADestroyBlockID(blockDataID);
880 else // CON or NON message
882 OIC_LOG_V(INFO, TAG, "num:%d, M:%d", block.num, block.m);
884 // check the size option
885 bool isSizeOption = CAIsPayloadLengthInPduWithBlockSizeOption(pdu,
887 &(data->payloadLength));
889 // check if received payload is exact
890 if (CA_MSG_CONFIRM == pdu->hdr->coap_hdr_udp_t.type)
892 blockWiseStatus = CACheckBlockErrorType(data, &block, receivedData,
893 COAP_OPTION_BLOCK1, dataLen);
896 if (CA_BLOCK_RECEIVED_ALREADY != blockWiseStatus)
898 // store the received payload and merge
899 res = CAUpdatePayloadData(data, receivedData, blockWiseStatus,
900 isSizeOption, COAP_OPTION_BLOCK1);
901 if (CA_STATUS_OK != res)
903 OIC_LOG(ERROR, TAG, "update has failed");
904 CARemoveBlockDataFromList(blockDataID);
905 CADestroyBlockID(blockDataID);
909 res = CAUpdateBlockOptionItems(data, pdu, &block, COAP_OPTION_BLOCK1, blockWiseStatus);
910 if (CA_STATUS_OK != res)
912 OIC_LOG(ERROR, TAG, "update has failed");
913 CARemoveBlockDataFromList(blockDataID);
914 CADestroyBlockID(blockDataID);
919 res = CAUpdateBlockData(data, block, COAP_OPTION_BLOCK1);
920 if (CA_STATUS_OK != res)
922 OIC_LOG(ERROR, TAG, "update has failed");
923 CARemoveBlockDataFromList(blockDataID);
924 CADestroyBlockID(blockDataID);
929 // check the blcok-wise transfer status for next step
930 if (CA_BLOCK_UNKNOWN == blockWiseStatus || CA_BLOCK_RECEIVED_ALREADY == blockWiseStatus)
932 if (0 == block.m) // Last block is received
934 OIC_LOG(DEBUG, TAG, "M bit is 0");
935 blockWiseStatus = CA_OPTION1_NO_ACK_LAST_BLOCK;
939 OIC_LOG(DEBUG, TAG, "M bit is 1");
940 blockWiseStatus = CA_OPTION1_NO_ACK_BLOCK;
945 res = CAProcessNextStep(pdu, receivedData, blockWiseStatus, blockDataID);
946 if (CA_STATUS_OK != res)
948 OIC_LOG(ERROR, TAG, "setting has failed");
949 CARemoveBlockDataFromList(blockDataID);
952 CADestroyBlockID(blockDataID);
956 // TODO make pdu const after libcoap is updated to support that.
957 CAResult_t CASetNextBlockOption2(coap_pdu_t *pdu, const CAEndpoint_t *endpoint,
958 const CAData_t *receivedData, coap_block_t block,
961 OIC_LOG(DEBUG, TAG, "CASetNextBlockOption2");
962 OIC_LOG_V(INFO, TAG, "num:%d, M:%d, sze:%d", block.num, block.m, block.szx);
964 VERIFY_NON_NULL(pdu, TAG, "pdu");
965 VERIFY_NON_NULL(pdu->hdr, TAG, "pdu->hdr");
966 VERIFY_NON_NULL(endpoint, TAG, "endpoint");
967 VERIFY_NON_NULL(receivedData, TAG, "receivedData");
969 CABlockDataID_t* blockDataID = CACreateBlockDatablockId(
970 (CAToken_t)pdu->hdr->coap_hdr_udp_t.token,
971 pdu->hdr->coap_hdr_udp_t.token_length,
974 if(NULL == blockDataID || NULL == blockDataID->id || blockDataID->idLength < 1)
976 OIC_LOG(ERROR, TAG, "blockId is null");
977 CADestroyBlockID(blockDataID);
978 return CA_STATUS_FAILED;
981 // BlockData data is created if it not existed
982 if (!CAIsBlockDataInList(blockDataID))
984 OIC_LOG(DEBUG, TAG, "no msg in list.");
986 CAData_t *data = CACreateNewDataSet(pdu, endpoint);
989 OIC_LOG(ERROR, TAG, "data is null");
990 CADestroyBlockID(blockDataID);
991 return CA_STATUS_FAILED;
994 CABlockData_t *currData = CACreateNewBlockData(data);
997 OIC_LOG(ERROR, TAG, "data is null");
998 CADestroyDataSet(data);
999 CADestroyBlockID(blockDataID);
1000 return CA_STATUS_FAILED;
1002 CADestroyDataSet(data);
1005 // set Block Option Type
1006 CAResult_t res = CAUpdateBlockOptionType(blockDataID,
1007 COAP_OPTION_BLOCK2);
1008 if (CA_STATUS_OK != res)
1010 OIC_LOG(ERROR, TAG, "update has failed");
1011 CARemoveBlockDataFromList(blockDataID);
1012 CADestroyBlockID(blockDataID);
1016 CABlockData_t *data = CAGetBlockDataFromBlockDataList(blockDataID);
1019 OIC_LOG(ERROR, TAG, "getting has failed");
1020 CARemoveBlockDataFromList(blockDataID);
1021 CADestroyBlockID(blockDataID);
1022 return CA_STATUS_FAILED;
1025 uint8_t blockWiseStatus = CA_BLOCK_UNKNOWN;
1026 if (0 == block.num && CA_GET == pdu->hdr->coap_hdr_udp_t.code && 0 == block.m)
1028 OIC_LOG(INFO, TAG, "first block number");
1030 res = CAUpdateBlockOptionItems(data, pdu, &block, COAP_OPTION_BLOCK2, blockWiseStatus);
1031 if (CA_STATUS_OK != res)
1033 OIC_LOG(ERROR, TAG, "update has failed");
1034 CARemoveBlockDataFromList(blockDataID);
1035 CADestroyBlockID(blockDataID);
1039 // first block data have to notify to Application
1040 res = CAUpdateBlockData(data, block, COAP_OPTION_BLOCK2);
1041 if (CA_STATUS_OK != res)
1043 OIC_LOG(ERROR, TAG, "update has failed");
1044 CARemoveBlockDataFromList(blockDataID);
1045 CADestroyBlockID(blockDataID);
1048 blockWiseStatus = CA_OPTION2_FIRST_BLOCK;
1052 // received type from remote device
1053 if (CA_MSG_ACKNOWLEDGE == pdu->hdr->coap_hdr_udp_t.type ||
1054 (CA_MSG_NONCONFIRM == pdu->hdr->coap_hdr_udp_t.type &&
1055 NULL != receivedData->responseInfo))
1057 OIC_LOG(DEBUG, TAG, "received ACK or NON");
1059 // check the size option
1060 bool isSizeOption = CAIsPayloadLengthInPduWithBlockSizeOption(pdu,
1062 &(data->payloadLength));
1064 // check if received payload is exact
1065 if (CA_MSG_ACKNOWLEDGE == pdu->hdr->coap_hdr_udp_t.type)
1067 blockWiseStatus = CACheckBlockErrorType(data, &block, receivedData,
1068 COAP_OPTION_BLOCK2, dataLen);
1071 if (CA_BLOCK_RECEIVED_ALREADY != blockWiseStatus)
1073 // store the received payload and merge
1074 res = CAUpdatePayloadData(data, receivedData, blockWiseStatus,
1075 isSizeOption, COAP_OPTION_BLOCK2);
1076 if (CA_STATUS_OK != res)
1078 OIC_LOG(ERROR, TAG, "update has failed");
1079 CARemoveBlockDataFromList(blockDataID);
1080 CADestroyBlockID(blockDataID);
1085 if (0 == block.m && CA_BLOCK_UNKNOWN == blockWiseStatus) // Last block is received
1087 OIC_LOG(DEBUG, TAG, "M bit is 0");
1088 blockWiseStatus = CA_OPTION2_LAST_BLOCK;
1092 if (CA_BLOCK_UNKNOWN == blockWiseStatus ||
1093 CA_BLOCK_RECEIVED_ALREADY == blockWiseStatus)
1095 OIC_LOG(DEBUG, TAG, "M bit is 1");
1097 if (CA_MSG_ACKNOWLEDGE == pdu->hdr->coap_hdr_udp_t.type)
1099 blockWiseStatus = CA_OPTION2_ACK;
1103 blockWiseStatus = CA_OPTION2_NON;
1107 res = CAUpdateBlockOptionItems(data, pdu, &block, COAP_OPTION_BLOCK2,
1109 if (CA_STATUS_OK != res)
1111 OIC_LOG(ERROR, TAG, "update has failed");
1112 CARemoveBlockDataFromList(blockDataID);
1113 CADestroyBlockID(blockDataID);
1117 res = CAUpdateBlockData(data, block, COAP_OPTION_BLOCK2);
1118 if (CA_STATUS_OK != res)
1120 OIC_LOG(ERROR, TAG, "update has failed");
1121 CARemoveBlockDataFromList(blockDataID);
1122 CADestroyBlockID(blockDataID);
1127 else // CON message and so on.
1129 OIC_LOG_V(INFO, TAG, "num:%d, M:%d", block.num, block.m);
1131 blockWiseStatus = CA_OPTION2_CON;
1133 res = CAUpdateBlockOptionItems(data, pdu, &block, COAP_OPTION_BLOCK2, blockWiseStatus);
1134 if (CA_STATUS_OK != res)
1136 OIC_LOG(ERROR, TAG, "update has failed");
1137 CARemoveBlockDataFromList(blockDataID);
1138 CADestroyBlockID(blockDataID);
1142 res = CAUpdateBlockData(data, block, COAP_OPTION_BLOCK2);
1143 if (CA_STATUS_OK != res)
1145 OIC_LOG(ERROR, TAG, "update has failed");
1146 CARemoveBlockDataFromList(blockDataID);
1147 CADestroyBlockID(blockDataID);
1153 res = CAProcessNextStep(pdu, receivedData, blockWiseStatus, blockDataID);
1154 if (CA_STATUS_OK != res)
1156 OIC_LOG(ERROR, TAG, "setting has failed");
1157 CARemoveBlockDataFromList(blockDataID);
1158 CADestroyBlockID(blockDataID);
1162 CADestroyBlockID(blockDataID);
1163 return CA_STATUS_OK;
1166 CAResult_t CAUpdateBlockOptionItems(CABlockData_t *currData, const coap_pdu_t *pdu,
1167 coap_block_t *block, uint16_t blockType,
1170 VERIFY_NON_NULL(currData, TAG, "currData");
1171 VERIFY_NON_NULL(pdu, TAG, "pdu");
1172 VERIFY_NON_NULL(block, TAG, "block");
1174 // update block data
1175 CAResult_t res = CA_STATUS_OK;
1176 uint32_t code = CA_RESPONSE_CODE(pdu->hdr->coap_hdr_udp_t.code);
1178 if (CA_REQUEST_ENTITY_INCOMPLETE == code || CA_REQUEST_ENTITY_TOO_LARGE == code)
1180 // response error code of the received block message
1181 res = CAHandleBlockErrorResponse(block, blockType, code);
1182 if (CA_STATUS_OK != res)
1184 OIC_LOG(ERROR, TAG, "error handle has failed");
1190 // update block option items
1193 case CA_OPTION1_ACK:
1194 if (currData->block1.num > block->num)
1196 OIC_LOG(ERROR, TAG, "received incorrect block num");
1197 return CA_STATUS_FAILED;
1201 case CA_OPTION2_NON:
1205 case CA_OPTION2_CON:
1208 case CA_OPTION2_ACK:
1209 if (currData->block2.num > block->num)
1211 OIC_LOG(ERROR, TAG, "received incorrect block num");
1212 return CA_STATUS_FAILED;
1217 case CA_BLOCK_TOO_LARGE:
1218 // if state of received block message is CA_BLOCK_TOO_LARGE or CA_BLOCK_INCOMPLETE
1219 // we set the response error code appropriately and send
1220 if (COAP_OPTION_BLOCK2 == blockType)
1224 block->szx = currData->block2.szx;
1228 block->szx = currData->block1.szx;
1232 OIC_LOG_V(ERROR, TAG, "no logic [%d]", status);
1235 if (CA_BLOCK_INCOMPLETE != status && CA_BLOCK_TOO_LARGE != status)
1237 // negotiate block size
1238 res = CANegotiateBlockSize(currData, block, pdu->hdr->coap_hdr_udp_t.type, blockType);
1239 if (CA_STATUS_OK != res)
1241 OIC_LOG(ERROR, TAG, "negotiation has failed");
1249 CAResult_t CAGetMoreBitFromBlock(size_t payloadLen, coap_block_t *block)
1251 VERIFY_NON_NULL(block, TAG, "block");
1253 if ((size_t)((block->num + 1) << (block->szx + BLOCK_NUMBER_IDX))
1256 OIC_LOG(DEBUG, TAG, "Set the M-bit(1)");
1261 OIC_LOG(DEBUG, TAG, "Set the M-bit(0)");
1265 return CA_STATUS_OK;
1268 CAResult_t CANegotiateBlockSize(CABlockData_t *currData, coap_block_t *block,
1269 CAMessageType_t msgType, uint16_t blockType)
1271 OIC_LOG(DEBUG, TAG, "IN-NegotiateBlockSize");
1273 VERIFY_NON_NULL(currData, TAG, "currData");
1274 VERIFY_NON_NULL(block, TAG, "block");
1276 // #1. check the block option type
1277 if (COAP_OPTION_BLOCK2 == blockType)
1279 // #2. check the message type
1280 if (CA_MSG_ACKNOWLEDGE == msgType)
1282 if (block->szx > currData->block2.szx)
1284 OIC_LOG(DEBUG, TAG, "sze is big");
1286 // #3. calculate new block number from block size
1287 unsigned int blockNum = BLOCK_SIZE(block->szx) /
1288 BLOCK_SIZE(currData->block2.szx) - 1;
1289 OIC_LOG(DEBUG, TAG, "num is set as Negotiation");
1290 block->num += blockNum;
1291 block->szx = currData->block2.szx;
1292 OIC_LOG_V(DEBUG, TAG, "updated block num: %d", block->num);
1297 if (block->szx > currData->block2.szx)
1299 OIC_LOG(DEBUG, TAG, "sze is big");
1300 block->szx = currData->block2.szx;
1304 else if (COAP_OPTION_BLOCK1 == blockType)
1306 if (CA_MSG_ACKNOWLEDGE == msgType)
1308 if (block->szx < currData->block1.szx)
1310 OIC_LOG(DEBUG, TAG, "sze is small");
1312 unsigned int blockNum = BLOCK_SIZE(currData->block1.szx) /
1313 BLOCK_SIZE(block->szx) - 1;
1314 block->num += blockNum;
1315 OIC_LOG_V(DEBUG, TAG, "updated block num: %d", block->num);
1320 if (block->szx > currData->block1.szx)
1322 OIC_LOG(DEBUG, TAG, "sze is big");
1323 block->szx = currData->block1.szx;
1329 OIC_LOG(DEBUG, TAG, "Invalid block option");
1330 return CA_STATUS_FAILED;
1333 OIC_LOG(DEBUG, TAG, "OUT-NegotiateBlockSize");
1335 return CA_STATUS_OK;
1338 CAResult_t CAUpdateBlockData(CABlockData_t *currData, coap_block_t block,
1341 VERIFY_NON_NULL(currData, TAG, "currData");
1343 // check if block size is bigger than CABlockSize_t
1344 if (block.szx > CA_BLOCK_SIZE_1024_BYTE)
1346 OIC_LOG(DEBUG, TAG, "invalid block szx");
1347 return CA_STATUS_FAILED;
1350 // update block option
1351 if (COAP_OPTION_BLOCK2 == blockType)
1353 currData->block2 = block;
1357 currData->block1 = block;
1360 OIC_LOG(DEBUG, TAG, "data has updated");
1361 return CA_STATUS_OK;
1364 CAResult_t CAUpdateMessageId(coap_pdu_t *pdu, const CABlockDataID_t *blockID)
1366 VERIFY_NON_NULL(pdu, TAG, "pdu");
1367 VERIFY_NON_NULL(blockID, TAG, "blockID");
1369 // if CON message is sent, update messageId in block-wise transfer list
1370 if (CA_MSG_CONFIRM == pdu->hdr->coap_hdr_udp_t.type)
1372 CAData_t * cadata = CAGetDataSetFromBlockDataList(blockID);
1375 OIC_LOG(ERROR, TAG, "CAData is unavailable");
1376 return CA_STATUS_FAILED;
1379 if (cadata->requestInfo)
1381 cadata->requestInfo->info.messageId = pdu->hdr->coap_hdr_udp_t.id;
1385 return CA_STATUS_OK;
1388 CAResult_t CAAddBlockOption(coap_pdu_t **pdu, const CAInfo_t *info,
1389 const CAEndpoint_t *endpoint)
1391 OIC_LOG(DEBUG, TAG, "IN-AddBlockOption");
1392 VERIFY_NON_NULL(pdu, TAG, "pdu");
1393 VERIFY_NON_NULL((*pdu), TAG, "(*pdu)");
1394 VERIFY_NON_NULL((*pdu)->hdr, TAG, "(*pdu)->hdr");
1395 VERIFY_NON_NULL(info, TAG, "info");
1396 VERIFY_NON_NULL(endpoint, TAG, "endpoint");
1398 size_t dataLength = 0;
1401 dataLength = info->payloadSize;
1402 OIC_LOG_V(DEBUG, TAG, "dataLength - %d", dataLength);
1405 OIC_LOG_V(DEBUG, TAG, "previous payload - %s", (*pdu)->data);
1407 CAResult_t res = CA_STATUS_OK;
1408 uint32_t code = CA_RESPONSE_CODE((*pdu)->hdr->coap_hdr_udp_t.code);
1409 if (CA_REQUEST_ENTITY_INCOMPLETE == code)
1411 OIC_LOG(INFO, TAG, "don't use option");
1415 CABlockDataID_t* blockDataID = CACreateBlockDatablockId(
1416 (CAToken_t)(*pdu)->hdr->coap_hdr_udp_t.token,
1417 (*pdu)->hdr->coap_hdr_udp_t.token_length,
1420 if(NULL == blockDataID || NULL == blockDataID->id || blockDataID->idLength < 1)
1422 OIC_LOG(ERROR, TAG, "blockId is null");
1423 res = CA_STATUS_FAILED;
1427 uint8_t blockType = CAGetBlockOptionType(blockDataID);
1428 if (COAP_OPTION_BLOCK2 == blockType)
1430 res = CAAddBlockOption2(pdu, info, dataLength, blockDataID);
1431 if (CA_STATUS_OK != res)
1433 OIC_LOG(ERROR, TAG, "add has failed");
1437 else if (COAP_OPTION_BLOCK1 == blockType)
1439 res = CAAddBlockOption1(pdu, info, dataLength, blockDataID);
1440 if (CA_STATUS_OK != res)
1442 OIC_LOG(ERROR, TAG, "add has failed");
1448 OIC_LOG(DEBUG, TAG, "no BLOCK option");
1449 // if response data is so large. it have to send as block transfer
1450 if (!coap_add_data(*pdu, dataLength, (const unsigned char *) info->payload))
1452 OIC_LOG(INFO, TAG, "it have to use block");
1456 OIC_LOG(INFO, TAG, "not Blockwise Transfer");
1461 // if received message type is RESET from remote device,
1462 // we have to use the updated message id to find token.
1463 res = CAUpdateMessageId(*pdu, blockDataID);
1464 if (CA_STATUS_OK != res)
1466 OIC_LOG(ERROR, TAG, "fail to update CON message id ");
1471 if (0 == endpoint->port)
1473 CARemoveBlockDataFromList(blockDataID);
1475 CADestroyBlockID(blockDataID);
1476 OIC_LOG(DEBUG, TAG, "OUT-AddBlockOption");
1480 CAResult_t CAAddBlockOption2(coap_pdu_t **pdu, const CAInfo_t *info, size_t dataLength,
1481 const CABlockDataID_t *blockID)
1483 OIC_LOG(DEBUG, TAG, "IN-AddBlockOption2");
1484 VERIFY_NON_NULL(pdu, TAG, "pdu");
1485 VERIFY_NON_NULL((*pdu), TAG, "(*pdu)");
1486 VERIFY_NON_NULL((*pdu)->hdr, TAG, "(*pdu)->hdr");
1487 VERIFY_NON_NULL(info, TAG, "info");
1488 VERIFY_NON_NULL(blockID, TAG, "blockID");
1490 // get set block data from CABlock list-set.
1491 coap_block_t *block1 = CAGetBlockOption(blockID,
1492 COAP_OPTION_BLOCK1);
1493 coap_block_t *block2 = CAGetBlockOption(blockID,
1494 COAP_OPTION_BLOCK2);
1495 if (!block1 || !block2)
1497 OIC_LOG(ERROR, TAG, "getting has failed");
1498 return CA_STATUS_FAILED;
1501 CALogBlockInfo(block2);
1504 if (CA_MSG_ACKNOWLEDGE == (*pdu)->hdr->coap_hdr_udp_t.type ||
1505 (CA_MSG_NONCONFIRM == (*pdu)->hdr->coap_hdr_udp_t.type &&
1506 CA_GET != (*pdu)->hdr->coap_hdr_udp_t.code))
1508 int32_t res = coap_write_block_opt(block2, COAP_OPTION_BLOCK2, *pdu, dataLength);
1511 case -2: /* illegal block */
1512 code = COAP_RESPONSE_CODE(CA_BAD_REQ);
1513 OIC_LOG(ERROR, TAG, "write block option : -2");
1515 case -1: /* should really not happen */
1516 OIC_LOG(ERROR, TAG, "write block option : -1");
1518 case -3: /* cannot handle request */
1519 code = COAP_RESPONSE_CODE(CA_INTERNAL_SERVER_ERROR);
1520 OIC_LOG(ERROR, TAG, "write block option : -3");
1523 OIC_LOG(INFO, TAG, "success write block option");
1525 CALogBlockInfo(block2);
1529 OIC_LOG(DEBUG, TAG, "combining block1 and block2");
1530 CAResult_t res = CAAddBlockOptionImpl(*pdu, block1, COAP_OPTION_BLOCK1);
1531 if (CA_STATUS_OK != res)
1533 OIC_LOG(ERROR, TAG, "add has failed");
1534 CARemoveBlockDataFromList(blockID);
1537 // initialize block number
1541 // if block number is 0, add size2 option
1542 if (0 == block2->num)
1544 res = CAAddBlockSizeOption(*pdu, COAP_OPTION_SIZE2, dataLength);
1545 if (CA_STATUS_OK != res)
1547 OIC_LOG(ERROR, TAG, "add has failed");
1548 CARemoveBlockDataFromList(blockID);
1553 if (!coap_add_block(*pdu, dataLength, (const unsigned char *) info->payload,
1554 block2->num, block2->szx))
1556 OIC_LOG(ERROR, TAG, "Data length is smaller than the start index");
1557 return CA_STATUS_FAILED;
1562 // if sent message is last response block message, remove data
1563 CARemoveBlockDataFromList(blockID);
1567 if (CA_MSG_NONCONFIRM == (*pdu)->hdr->coap_hdr_udp_t.type)
1569 OIC_LOG(DEBUG, TAG, "NON, send next block..");
1570 // update block data
1572 CAResult_t res = CAProcessNextStep(*pdu, NULL,
1573 CA_SENT_PREVIOUS_NON_MSG,
1575 if (CA_STATUS_OK != res)
1577 OIC_LOG(ERROR, TAG, "failed to process next step");
1578 CARemoveBlockDataFromList(blockID);
1586 OIC_LOG(DEBUG, TAG, "option2, not ACK msg");
1587 CAResult_t res = CAAddBlockOptionImpl(*pdu, block2, COAP_OPTION_BLOCK2);
1588 if (CA_STATUS_OK != res)
1590 OIC_LOG(ERROR, TAG, "add has failed");
1591 CARemoveBlockDataFromList(blockID);
1596 return CA_STATUS_OK;
1599 OIC_LOG_V(ERROR, TAG, "error : %d", code);
1601 char* phrase = coap_response_phrase(code);
1604 coap_add_data(*pdu, strlen(phrase),
1605 (unsigned char *) phrase);
1607 return CA_STATUS_FAILED;
1610 CAResult_t CAAddBlockOption1(coap_pdu_t **pdu, const CAInfo_t *info, size_t dataLength,
1611 const CABlockDataID_t *blockID)
1613 OIC_LOG(DEBUG, TAG, "IN-AddBlockOption1");
1614 VERIFY_NON_NULL(pdu, TAG, "pdu");
1615 VERIFY_NON_NULL((*pdu), TAG, "(*pdu)");
1616 VERIFY_NON_NULL((*pdu)->hdr, TAG, "(*pdu)->hdr");
1617 VERIFY_NON_NULL(info, TAG, "info");
1618 VERIFY_NON_NULL(blockID, TAG, "blockID");
1620 // get set block data from CABlock list-set.
1621 coap_block_t *block1 = CAGetBlockOption(blockID, COAP_OPTION_BLOCK1);
1624 OIC_LOG(ERROR, TAG, "getting has failed");
1625 return CA_STATUS_FAILED;
1628 CALogBlockInfo(block1);
1630 if (CA_MSG_ACKNOWLEDGE == (*pdu)->hdr->coap_hdr_udp_t.type)
1632 OIC_LOG(DEBUG, TAG, "option1 and ACK msg..");
1633 CAResult_t res = CAAddBlockOptionImpl(*pdu, block1, COAP_OPTION_BLOCK1);
1634 if (CA_STATUS_OK != res)
1636 OIC_LOG(ERROR, TAG, "add has failed");
1637 CARemoveBlockDataFromList(blockID);
1641 // reset block-list after write block
1644 // remove data from list
1645 CAResult_t res = CARemoveBlockDataFromList(blockID);
1646 if (CA_STATUS_OK != res)
1648 OIC_LOG(ERROR, TAG, "remove has failed");
1655 CAGetMoreBitFromBlock(dataLength, block1);
1656 CAResult_t res = CAAddBlockOptionImpl(*pdu, block1, COAP_OPTION_BLOCK1);
1657 if (CA_STATUS_OK != res)
1659 OIC_LOG(ERROR, TAG, "add has failed");
1660 CARemoveBlockDataFromList(blockID);
1663 CALogBlockInfo(block1);
1665 // if block number is 0, add size1 option
1666 if (0 == block1->num)
1668 res = CAAddBlockSizeOption(*pdu, COAP_OPTION_SIZE1, dataLength);
1669 if (CA_STATUS_OK != res)
1671 OIC_LOG(ERROR, TAG, "add has failed");
1672 CARemoveBlockDataFromList(blockID);
1677 if (!coap_add_block(*pdu, dataLength, (const unsigned char *) info->payload,
1678 block1->num, block1->szx))
1680 OIC_LOG(ERROR, TAG, "Data length is smaller than the start index");
1681 return CA_STATUS_FAILED;
1684 // check the message type and if message type is NON, next block message will be sent
1685 if (CA_MSG_NONCONFIRM == (*pdu)->hdr->coap_hdr_udp_t.type)
1689 OIC_LOG(DEBUG, TAG, "NON, send next block..");
1690 // update block data
1692 CAResult_t res = CAProcessNextStep(*pdu, NULL,
1693 CA_SENT_PREVIOUS_NON_MSG,
1695 if (CA_STATUS_OK != res)
1697 OIC_LOG(ERROR, TAG, "failed to process next step");
1698 CARemoveBlockDataFromList(blockID);
1704 CARemoveBlockDataFromList(blockID);
1709 OIC_LOG(DEBUG, TAG, "OUT-AddBlockOption1");
1711 return CA_STATUS_OK;
1714 CAResult_t CAAddBlockOptionImpl(coap_pdu_t *pdu, coap_block_t *block, uint8_t blockType)
1716 OIC_LOG(DEBUG, TAG, "IN-AddBlockOptionImpl");
1717 VERIFY_NON_NULL(pdu, TAG, "pdu");
1718 VERIFY_NON_NULL(block, TAG, "block");
1720 coap_option *option = (coap_option *) OICMalloc(sizeof(coap_option));
1723 OIC_LOG(ERROR, TAG, "out of memory");
1724 return CA_MEMORY_ALLOC_FAILED;
1727 unsigned char buf[BLOCKWISE_OPTION_BUFFER] = { 0 };
1728 option->key = blockType;
1729 option->length = coap_encode_var_bytes(buf,
1730 ((block->num << BLOCK_NUMBER_IDX)
1731 | (block->m << BLOCK_M_BIT_IDX) | block->szx));
1732 if (!coap_add_option(pdu, option->key, option->length, buf, coap_udp))
1734 OIC_LOG(ERROR, TAG, "coap_add_option has failed");
1736 return CA_STATUS_FAILED;
1741 OIC_LOG(DEBUG, TAG, "OUT-AddBlockOptionImpl");
1742 return CA_STATUS_OK;
1745 CAResult_t CAAddBlockSizeOption(coap_pdu_t *pdu, uint16_t sizeType, size_t dataLength)
1747 OIC_LOG(DEBUG, TAG, "IN-CAAddBlockSizeOption");
1748 VERIFY_NON_NULL(pdu, TAG, "pdu");
1750 if (sizeType != COAP_OPTION_SIZE1 && sizeType != COAP_OPTION_SIZE2)
1752 OIC_LOG(ERROR, TAG, "unknown option type");
1753 return CA_STATUS_FAILED;
1756 unsigned char value[BLOCKWISE_OPTION_BUFFER] = { 0 };
1757 unsigned int optionLength = coap_encode_var_bytes(value, dataLength);
1759 if (!coap_add_option(pdu, sizeType, optionLength, value, coap_udp))
1761 OIC_LOG(ERROR, TAG, "failed to add size option");
1762 return CA_STATUS_FAILED;
1765 OIC_LOG(DEBUG, TAG, "OUT-CAAddBlockSizeOption");
1767 return CA_STATUS_OK;
1770 // TODO make pdu const after libcoap is updated to support that.
1771 bool CAIsPayloadLengthInPduWithBlockSizeOption(coap_pdu_t *pdu,
1773 size_t *totalPayloadLen)
1775 OIC_LOG(DEBUG, TAG, "IN-CAIsPayloadLengthInPduWithBlockSizeOption");
1776 VERIFY_NON_NULL(pdu, TAG, "pdu");
1777 VERIFY_NON_NULL(totalPayloadLen, TAG, "totalPayloadLen");
1779 if (sizeType != COAP_OPTION_SIZE1 && sizeType != COAP_OPTION_SIZE2)
1781 OIC_LOG(ERROR, TAG, "unknown option type");
1782 return CA_STATUS_FAILED;
1785 coap_opt_iterator_t opt_iter;
1786 coap_opt_t *option = coap_check_option(pdu, sizeType, &opt_iter);
1789 OIC_LOG(DEBUG, TAG, "get size option from pdu");
1790 *totalPayloadLen = coap_decode_var_bytes(COAP_OPT_VALUE(option),
1791 COAP_OPT_LENGTH(option));
1793 OIC_LOG_V(DEBUG, TAG, "the total payload length to be received is [%d]bytes",
1799 OIC_LOG(DEBUG, TAG, "OUT-CAIsPayloadLengthInPduWithBlockSizeOption");
1804 uint8_t CACheckBlockErrorType(CABlockData_t *currData, coap_block_t *receivedBlock,
1805 const CAData_t *receivedData, uint16_t blockType,
1808 OIC_LOG(DEBUG, TAG, "IN-CheckBlockError");
1810 VERIFY_NON_NULL(currData, TAG, "currData is NULL");
1811 VERIFY_NON_NULL(receivedBlock, TAG, "receivedBlock is NULL");
1812 VERIFY_NON_NULL(receivedData, TAG, "receivedData is NULL");
1814 // #1. check the received payload length
1815 size_t blockPayloadLen = 0;
1816 CAGetPayloadInfo(receivedData, &blockPayloadLen);
1818 // #2. check if the block sequence is right
1819 if (COAP_OPTION_BLOCK1 == blockType)
1821 size_t prePayloadLen = currData->receivedPayloadLen;
1822 if (prePayloadLen != (size_t)BLOCK_SIZE(receivedBlock->szx)
1823 * receivedBlock->num)
1825 if (receivedBlock->num > currData->block1.num + 1)
1827 // 408 Error handling of block loss
1828 OIC_LOG(ERROR, TAG, "option1: error 4.08");
1829 OIC_LOG(ERROR, TAG, "it didn't order");
1830 return CA_BLOCK_INCOMPLETE;
1832 return CA_BLOCK_RECEIVED_ALREADY;
1835 else if (COAP_OPTION_BLOCK2 == blockType)
1837 if (receivedBlock->num != currData->block2.num)
1839 if (receivedBlock->num > currData->block2.num)
1841 // 408 Error handling of block loss
1842 OIC_LOG(ERROR, TAG, "option2: error 4.08");
1843 OIC_LOG(ERROR, TAG, "it didn't order");
1844 return CA_BLOCK_INCOMPLETE;
1846 return CA_BLOCK_RECEIVED_ALREADY;
1850 // #3. check if error check logic is required
1851 size_t optionLen = dataLen - blockPayloadLen;
1852 if (receivedBlock->m && blockPayloadLen !=
1853 (size_t)BLOCK_SIZE(receivedBlock->szx))
1855 // 413 Error handling of too large entity
1856 if (COAP_MAX_PDU_SIZE < BLOCK_SIZE(receivedBlock->szx) + optionLen)
1858 // buffer size is smaller than received block size
1859 OIC_LOG(ERROR, TAG, "error type 4.13");
1860 OIC_LOG(ERROR, TAG, "too large size");
1862 // set the block size to be smaller than COAP_MAX_PDU_SIZE
1863 for (int32_t size = CA_DEFAULT_BLOCK_SIZE; size >= 0; size--)
1865 if (COAP_MAX_PDU_SIZE >= BLOCK_SIZE(size) + optionLen)
1867 OIC_LOG_V(ERROR, TAG, "replace sze with %d", size);
1868 if (COAP_OPTION_BLOCK2 == blockType)
1870 currData->block2.szx = size;
1874 currData->block1.szx = size;
1879 return CA_BLOCK_TOO_LARGE;
1883 // 408 Error handling of payload loss
1884 OIC_LOG(ERROR, TAG, "error type 4.08");
1885 OIC_LOG(ERROR, TAG, "payload len != block sze");
1886 return CA_BLOCK_INCOMPLETE;
1889 else if (0 == receivedBlock->m && 0 != currData->payloadLength)
1891 // if the received block is last block, check the total payload length
1892 size_t receivedPayloadLen = currData->receivedPayloadLen;
1893 receivedPayloadLen += blockPayloadLen;
1895 if (receivedPayloadLen != currData->payloadLength)
1897 OIC_LOG(ERROR, TAG, "error type 4.08");
1898 OIC_LOG(ERROR, TAG, "total payload length is wrong");
1899 return CA_BLOCK_INCOMPLETE;
1903 OIC_LOG(DEBUG, TAG, "received all data normally");
1905 OIC_LOG(DEBUG, TAG, "OUT-CheckBlockError");
1907 return CA_BLOCK_UNKNOWN;
1910 CAResult_t CAUpdatePayloadData(CABlockData_t *currData, const CAData_t *receivedData,
1911 uint8_t status, bool isSizeOption, uint16_t blockType)
1913 OIC_LOG(DEBUG, TAG, "IN-UpdatePayloadData");
1915 VERIFY_NON_NULL(currData, TAG, "currData");
1916 VERIFY_NON_NULL(receivedData, TAG, "receivedData");
1918 // if error code is 4.08, do not update payload
1919 if (CA_BLOCK_INCOMPLETE == status)
1921 OIC_LOG(ERROR, TAG, "no require to update");
1922 return CA_STATUS_OK;
1925 size_t blockPayloadLen = 0;
1926 CAPayload_t blockPayload = CAGetPayloadInfo(receivedData, &blockPayloadLen);
1928 if (CA_BLOCK_TOO_LARGE == status)
1930 blockPayloadLen = (COAP_OPTION_BLOCK2 == blockType) ?
1931 BLOCK_SIZE(currData->block2.szx) : BLOCK_SIZE(currData->block1.szx);
1934 // memory allocation for the received block payload
1935 size_t prePayloadLen = currData->receivedPayloadLen;
1938 if (currData->payloadLength)
1940 // in case the block message has the size option
1941 // allocate the memory for the total payload
1944 CAPayload_t prePayload = currData->payload;
1946 OIC_LOG(DEBUG, TAG, "allocate memory for the total payload");
1947 currData->payload = (CAPayload_t) OICCalloc(1, currData->payloadLength);
1948 if (NULL == currData->payload)
1950 OIC_LOG(ERROR, TAG, "out of memory");
1951 return CA_MEMORY_ALLOC_FAILED;
1953 memcpy(currData->payload, prePayload, prePayloadLen);
1954 OICFree(prePayload);
1957 // update the total payload
1958 memcpy(currData->payload + prePayloadLen, blockPayload, blockPayloadLen);
1962 OIC_LOG(DEBUG, TAG, "allocate memory for the received block payload");
1964 size_t totalPayloadLen = prePayloadLen + blockPayloadLen;
1965 CAPayload_t newPayload = OICRealloc(currData->payload, totalPayloadLen);
1966 if (NULL == newPayload)
1968 OIC_LOG(ERROR, TAG, "out of memory");
1969 return CA_MEMORY_ALLOC_FAILED;
1972 // update the total payload
1973 memset(newPayload + prePayloadLen, 0, blockPayloadLen);
1974 currData->payload = newPayload;
1975 memcpy(currData->payload + prePayloadLen, blockPayload, blockPayloadLen);
1978 // update received payload length
1979 currData->receivedPayloadLen += blockPayloadLen;
1981 OIC_LOG_V(DEBUG, TAG, "updated payload: %s, len: %d", currData->payload,
1982 currData->receivedPayloadLen);
1985 OIC_LOG(DEBUG, TAG, "OUT-UpdatePayloadData");
1986 return CA_STATUS_OK;
1989 CAData_t* CACreateNewDataSet(const coap_pdu_t *pdu, const CAEndpoint_t *endpoint)
1991 VERIFY_NON_NULL_RET(pdu, TAG, "pdu", NULL);
1992 VERIFY_NON_NULL_RET(pdu->hdr, TAG, "pdu->hdr", NULL);
1993 VERIFY_NON_NULL_RET(endpoint, TAG, "endpoint", NULL);
1995 CAInfo_t responseData = { .tokenLength = pdu->hdr->coap_hdr_udp_t.token_length };
1996 responseData.token = (CAToken_t) OICMalloc(responseData.tokenLength);
1997 if (!responseData.token)
1999 OIC_LOG(ERROR, TAG, "out of memory");
2002 memcpy(responseData.token, pdu->hdr->coap_hdr_udp_t.token, responseData.tokenLength);
2004 CAResponseInfo_t* responseInfo = (CAResponseInfo_t*) OICCalloc(1, sizeof(CAResponseInfo_t));
2007 OIC_LOG(ERROR, TAG, "out of memory");
2008 OICFree(responseData.token);
2011 responseInfo->info = responseData;
2013 CAData_t *data = (CAData_t *) OICCalloc(1, sizeof(CAData_t));
2016 OIC_LOG(ERROR, TAG, "out of memory");
2017 OICFree(responseInfo);
2021 data->requestInfo = NULL;
2022 data->responseInfo = responseInfo;
2023 data->remoteEndpoint = CACloneEndpoint(endpoint);
2024 data->type = SEND_TYPE_UNICAST;
2029 CAData_t *CACloneCAData(const CAData_t *data)
2031 VERIFY_NON_NULL_RET(data, TAG, "data", NULL);
2033 CAData_t *clone = (CAData_t *) OICCalloc(1, sizeof(CAData_t));
2036 OIC_LOG(ERROR, TAG, "out of memory");
2041 if (data->requestInfo)
2043 clone->requestInfo = CACloneRequestInfo(data->requestInfo);
2045 else if (data->responseInfo)
2047 clone->responseInfo = CACloneResponseInfo(data->responseInfo);
2050 if (data->remoteEndpoint)
2052 clone->remoteEndpoint = CACloneEndpoint(data->remoteEndpoint);
2058 CAResult_t CAUpdatePayloadToCAData(CAData_t *data, const CAPayload_t payload,
2061 OIC_LOG(DEBUG, TAG, "IN-UpdatePayload");
2063 VERIFY_NON_NULL(data, TAG, "data is NULL");
2064 VERIFY_NON_NULL(payload, TAG, "payload is NULL");
2066 CAPayload_t newPayload = NULL;
2067 switch (data->dataType)
2069 case CA_REQUEST_DATA:
2070 if (!data->requestInfo)
2072 OIC_LOG(ERROR, TAG, "request info is null");
2073 return CA_STATUS_FAILED;
2075 // allocate payload field
2076 newPayload = OICRealloc(data->requestInfo->info.payload, payloadLen);
2079 OIC_LOG(ERROR, TAG, "out of memory");
2080 return CA_STATUS_FAILED;
2082 data->requestInfo->info.payload = newPayload;
2083 memcpy(data->requestInfo->info.payload, payload, payloadLen);
2084 data->requestInfo->info.payloadSize = payloadLen;
2087 case CA_RESPONSE_DATA:
2088 if (!data->responseInfo)
2090 OIC_LOG(ERROR, TAG, "response info is null");
2091 return CA_STATUS_FAILED;
2093 // allocate payload field
2094 newPayload = OICRealloc(data->responseInfo->info.payload, payloadLen);
2097 OIC_LOG(ERROR, TAG, "out of memory");
2098 return CA_STATUS_FAILED;
2100 data->responseInfo->info.payload = newPayload;
2101 memcpy(data->responseInfo->info.payload, payload, payloadLen);
2102 data->responseInfo->info.payloadSize = payloadLen;
2106 // does not occur case
2107 OIC_LOG(ERROR, TAG, "not supported data type");
2108 return CA_NOT_SUPPORTED;
2111 OIC_LOG(DEBUG, TAG, "OUT-UpdatePayload");
2113 return CA_STATUS_OK;
2116 CAPayload_t CAGetPayloadInfo(const CAData_t *data, size_t *payloadLen)
2118 VERIFY_NON_NULL_RET(data, TAG, "data", NULL);
2119 VERIFY_NON_NULL_RET(payloadLen, TAG, "payloadLen", NULL);
2121 if (data->requestInfo)
2123 if (data->requestInfo->info.payload)
2125 *payloadLen = data->requestInfo->info.payloadSize;
2126 return data->requestInfo->info.payload;
2131 if (data->responseInfo->info.payload)
2133 *payloadLen = data->responseInfo->info.payloadSize;
2134 return data->responseInfo->info.payload;
2141 CAResult_t CAHandleBlockErrorResponse(coap_block_t *block, uint16_t blockType,
2142 uint32_t responseResult)
2144 OIC_LOG(DEBUG, TAG, "IN-HandleBlockErrorRes");
2145 VERIFY_NON_NULL(block, TAG, "block is NULL");
2147 // update block data
2148 switch (responseResult)
2150 case CA_REQUEST_ENTITY_INCOMPLETE:
2153 case CA_REQUEST_ENTITY_TOO_LARGE:
2154 if (COAP_OPTION_BLOCK1 == blockType)
2161 OIC_LOG_V(ERROR, TAG, "there is no Error Code of BWT[%d]", responseResult);
2164 OIC_LOG(DEBUG, TAG, "OUT-HandleBlockErrorRes");
2165 return CA_STATUS_OK;
2168 CAResult_t CAUpdateBlockOptionType(const CABlockDataID_t *blockID,
2171 OIC_LOG(DEBUG, TAG, "IN-UpdateBlockOptionType");
2172 VERIFY_NON_NULL(blockID, TAG, "blockID");
2174 ca_mutex_lock(g_context.blockDataListMutex);
2176 size_t len = u_arraylist_length(g_context.dataList);
2177 for (size_t i = 0; i < len; i++)
2179 CABlockData_t *currData = (CABlockData_t *) u_arraylist_get(g_context.dataList, i);
2180 if (CABlockidMatches(currData, blockID))
2182 currData->type = blockType;
2183 ca_mutex_unlock(g_context.blockDataListMutex);
2184 OIC_LOG(DEBUG, TAG, "OUT-UpdateBlockOptionType");
2185 return CA_STATUS_OK;
2188 ca_mutex_unlock(g_context.blockDataListMutex);
2190 OIC_LOG(DEBUG, TAG, "OUT-UpdateBlockOptionType");
2191 return CA_STATUS_FAILED;
2194 uint8_t CAGetBlockOptionType(const CABlockDataID_t *blockID)
2196 OIC_LOG(DEBUG, TAG, "IN-GetBlockOptionType");
2197 VERIFY_NON_NULL_RET(blockID, TAG, "blockID", 0);
2199 ca_mutex_lock(g_context.blockDataListMutex);
2201 size_t len = u_arraylist_length(g_context.dataList);
2202 for (size_t i = 0; i < len; i++)
2204 CABlockData_t *currData = (CABlockData_t *) u_arraylist_get(g_context.dataList, i);
2205 if (CABlockidMatches(currData, blockID))
2207 ca_mutex_unlock(g_context.blockDataListMutex);
2208 OIC_LOG(DEBUG, TAG, "OUT-GetBlockOptionType");
2209 return currData->type;
2212 ca_mutex_unlock(g_context.blockDataListMutex);
2214 OIC_LOG(DEBUG, TAG, "OUT-GetBlockOptionType");
2218 CAData_t *CAGetDataSetFromBlockDataList(const CABlockDataID_t *blockID)
2220 VERIFY_NON_NULL_RET(blockID, TAG, "blockID", NULL);
2222 ca_mutex_lock(g_context.blockDataListMutex);
2224 size_t len = u_arraylist_length(g_context.dataList);
2225 for (size_t i = 0; i < len; i++)
2227 CABlockData_t *currData = (CABlockData_t *) u_arraylist_get(g_context.dataList, i);
2228 if (CABlockidMatches(currData, blockID))
2230 ca_mutex_unlock(g_context.blockDataListMutex);
2231 return currData->sentData;
2234 ca_mutex_unlock(g_context.blockDataListMutex);
2239 CAResult_t CAGetTokenFromBlockDataList(const coap_pdu_t *pdu, const CAEndpoint_t *endpoint,
2240 CAResponseInfo_t *responseInfo)
2242 OIC_LOG(DEBUG, TAG, "IN-CAGetTokenFromBlockDataList");
2243 VERIFY_NON_NULL(pdu, TAG, "pdu");
2244 VERIFY_NON_NULL(endpoint, TAG, "endpoint");
2245 VERIFY_NON_NULL(responseInfo, TAG, "responseInfo");
2247 ca_mutex_lock(g_context.blockDataListMutex);
2249 size_t len = u_arraylist_length(g_context.dataList);
2250 for (size_t i = 0; i < len; i++)
2252 CABlockData_t *currData = (CABlockData_t *) u_arraylist_get(g_context.dataList, i);
2253 if (NULL == currData)
2258 if (NULL != currData->sentData && NULL != currData->sentData->requestInfo)
2260 if (pdu->hdr->coap_hdr_udp_t.id == currData->sentData->requestInfo->info.messageId &&
2261 endpoint->adapter == currData->sentData->remoteEndpoint->adapter)
2263 if (NULL != currData->sentData->requestInfo->info.token)
2265 uint8_t length = currData->sentData->requestInfo->info.tokenLength;
2266 responseInfo->info.tokenLength = length;
2267 responseInfo->info.token = (char *) OICMalloc(length);
2268 if (NULL == responseInfo->info.token)
2270 OIC_LOG(ERROR, TAG, "out of memory");
2271 ca_mutex_unlock(g_context.blockDataListMutex);
2272 return CA_MEMORY_ALLOC_FAILED;
2274 memcpy(responseInfo->info.token, currData->sentData->requestInfo->info.token,
2275 responseInfo->info.tokenLength);
2277 ca_mutex_unlock(g_context.blockDataListMutex);
2278 OIC_LOG(DEBUG, TAG, "OUT-CAGetTokenFromBlockDataList");
2279 return CA_STATUS_OK;
2285 ca_mutex_unlock(g_context.blockDataListMutex);
2287 OIC_LOG(DEBUG, TAG, "OUT-CAGetTokenFromBlockDataList");
2288 return CA_STATUS_OK;
2291 CAResult_t CACheckBlockDataValidation(const CAData_t *sendData, CABlockData_t **blockData)
2293 VERIFY_NON_NULL(sendData, TAG, "sendData");
2294 VERIFY_NON_NULL(blockData, TAG, "blockData");
2296 ca_mutex_lock(g_context.blockDataListMutex);
2298 size_t len = u_arraylist_length(g_context.dataList);
2299 for (size_t i = 0; i < len; i++)
2301 CABlockData_t *currData = (CABlockData_t *) u_arraylist_get(g_context.dataList, i);
2308 if (sendData->requestInfo) // sendData is requestMessage
2310 OIC_LOG(DEBUG, TAG, "Send request");
2311 if (NULL != currData->blockDataId
2312 && NULL != currData->blockDataId->id
2313 && currData->blockDataId->idLength > 0
2314 && NULL != sendData->requestInfo->info.token)
2316 CABlockDataID_t* blockDataID = CACreateBlockDatablockId(
2317 (CAToken_t)sendData->requestInfo->info.token,
2318 sendData->requestInfo->info.tokenLength,
2319 sendData->remoteEndpoint->port);
2321 if(NULL == blockDataID || NULL == blockDataID->id || blockDataID->idLength < 1)
2323 OIC_LOG(ERROR, TAG, "blockId is null");
2324 CADestroyBlockID(blockDataID);
2325 return CA_STATUS_FAILED;
2328 if (CABlockidMatches(currData, blockDataID))
2330 OIC_LOG(ERROR, TAG, "already sent");
2331 CADestroyBlockID(blockDataID);
2334 CADestroyBlockID(blockDataID);
2337 else if (sendData->responseInfo) // sendData is responseMessage
2339 OIC_LOG(DEBUG, TAG, "Send response");
2340 if (NULL != currData->blockDataId
2341 && NULL != currData->blockDataId->id
2342 && currData->blockDataId->idLength > 0
2343 && NULL != sendData->responseInfo->info.token)
2345 CABlockDataID_t* blockDataID = CACreateBlockDatablockId(
2346 (CAToken_t)sendData->responseInfo->info.token,
2347 sendData->responseInfo->info.tokenLength,
2348 sendData->remoteEndpoint->port);
2350 if(NULL == blockDataID || NULL == blockDataID->id || blockDataID->idLength < 1)
2352 OIC_LOG(ERROR, TAG, "blockId is null");
2353 CADestroyBlockID(blockDataID);
2354 return CA_STATUS_FAILED;
2357 if (CABlockidMatches(currData, blockDataID))
2360 if (NULL != currData->sentData)
2362 OIC_LOG(DEBUG, TAG, "init block number");
2363 CADestroyDataSet(currData->sentData);
2365 currData->sentData = CACloneCAData(sendData);
2366 *blockData = currData;
2367 CADestroyBlockID(blockDataID);
2368 ca_mutex_unlock(g_context.blockDataListMutex);
2369 return CA_STATUS_OK;
2371 CADestroyBlockID(blockDataID);
2376 OIC_LOG(ERROR, TAG, "no CAInfo data");
2380 ca_mutex_unlock(g_context.blockDataListMutex);
2382 return CA_STATUS_FAILED;
2385 CABlockData_t *CAGetBlockDataFromBlockDataList(const CABlockDataID_t *blockID)
2387 VERIFY_NON_NULL_RET(blockID, TAG, "blockID", NULL);
2389 ca_mutex_lock(g_context.blockDataListMutex);
2391 size_t len = u_arraylist_length(g_context.dataList);
2392 for (size_t i = 0; i < len; i++)
2394 CABlockData_t *currData = (CABlockData_t *) u_arraylist_get(g_context.dataList, i);
2395 if (CABlockidMatches(currData, blockID))
2397 ca_mutex_unlock(g_context.blockDataListMutex);
2401 ca_mutex_unlock(g_context.blockDataListMutex);
2406 coap_block_t *CAGetBlockOption(const CABlockDataID_t *blockID,
2409 OIC_LOG(DEBUG, TAG, "IN-GetBlockOption");
2410 VERIFY_NON_NULL_RET(blockID, TAG, "blockID", NULL);
2412 ca_mutex_lock(g_context.blockDataListMutex);
2414 size_t len = u_arraylist_length(g_context.dataList);
2415 for (size_t i = 0; i < len; i++)
2417 CABlockData_t *currData = (CABlockData_t *) u_arraylist_get(g_context.dataList, i);
2418 if (CABlockidMatches(currData, blockID))
2420 ca_mutex_unlock(g_context.blockDataListMutex);
2421 OIC_LOG(DEBUG, TAG, "OUT-GetBlockOption");
2422 if (COAP_OPTION_BLOCK2 == blockType)
2424 return &currData->block2;
2428 return &currData->block1;
2432 ca_mutex_unlock(g_context.blockDataListMutex);
2434 OIC_LOG(DEBUG, TAG, "OUT-GetBlockOption");
2438 CAPayload_t CAGetPayloadFromBlockDataList(const CABlockDataID_t *blockID,
2439 size_t *fullPayloadLen)
2441 OIC_LOG(DEBUG, TAG, "IN-GetFullPayload");
2442 VERIFY_NON_NULL_RET(blockID, TAG, "blockID", NULL);
2443 VERIFY_NON_NULL_RET(fullPayloadLen, TAG, "fullPayloadLen", NULL);
2445 ca_mutex_lock(g_context.blockDataListMutex);
2447 size_t len = u_arraylist_length(g_context.dataList);
2448 for (size_t i = 0; i < len; i++)
2450 CABlockData_t *currData = (CABlockData_t *) u_arraylist_get(g_context.dataList, i);
2451 if (CABlockidMatches(currData, blockID))
2453 ca_mutex_unlock(g_context.blockDataListMutex);
2454 *fullPayloadLen = currData->receivedPayloadLen;
2455 OIC_LOG(DEBUG, TAG, "OUT-GetFullPayload");
2456 return currData->payload;
2459 ca_mutex_unlock(g_context.blockDataListMutex);
2461 OIC_LOG(DEBUG, TAG, "OUT-GetFullPayload");
2465 CABlockData_t *CACreateNewBlockData(const CAData_t *sendData)
2467 OIC_LOG(DEBUG, TAG, "IN-CACreateNewBlockData");
2468 VERIFY_NON_NULL_RET(sendData, TAG, "sendData", NULL);
2470 // create block data
2471 CABlockData_t *data = (CABlockData_t *) OICCalloc(1, sizeof(CABlockData_t));
2474 OIC_LOG(ERROR, TAG, "memory alloc has failed");
2478 data->block1.szx = CA_DEFAULT_BLOCK_SIZE;
2479 data->block2.szx = CA_DEFAULT_BLOCK_SIZE;
2480 data->sentData = CACloneCAData(sendData);
2483 OIC_LOG(ERROR, TAG, PCF("memory alloc has failed"));
2488 CAToken_t token = NULL;
2489 uint8_t tokenLength = 0;
2490 if (data->sentData->requestInfo)
2492 // update token info
2493 tokenLength = data->sentData->requestInfo->info.tokenLength;
2494 token = data->sentData->requestInfo->info.token;
2496 else if(data->sentData->responseInfo)
2498 tokenLength = data->sentData->responseInfo->info.tokenLength;
2499 token = data->sentData->responseInfo->info.token;
2502 CABlockDataID_t* blockDataID = CACreateBlockDatablockId(
2504 data->sentData->remoteEndpoint->port);
2505 if (NULL == blockDataID || NULL == blockDataID->id || blockDataID->idLength < 1)
2507 OIC_LOG(ERROR, TAG, "blockId is null");
2508 CADestroyBlockID(blockDataID);
2509 CADestroyDataSet(data->sentData);
2513 data->blockDataId = blockDataID;
2515 ca_mutex_lock(g_context.blockDataListMutex);
2517 bool res = u_arraylist_add(g_context.dataList, (void *) data);
2520 OIC_LOG(ERROR, TAG, "add has failed");
2521 CADestroyBlockID(data->blockDataId);
2522 CADestroyDataSet(data->sentData);
2524 ca_mutex_unlock(g_context.blockDataListMutex);
2527 ca_mutex_unlock(g_context.blockDataListMutex);
2529 OIC_LOG(DEBUG, TAG, "OUT-CreateBlockData");
2533 CAResult_t CARemoveBlockDataFromList(const CABlockDataID_t *blockID)
2535 OIC_LOG(DEBUG, TAG, "CARemoveBlockData");
2536 VERIFY_NON_NULL(blockID, TAG, "blockID");
2538 ca_mutex_lock(g_context.blockDataListMutex);
2540 size_t len = u_arraylist_length(g_context.dataList);
2541 for (size_t i = 0; i < len; i++)
2543 CABlockData_t *currData = (CABlockData_t *) u_arraylist_get(g_context.dataList, i);
2544 if (CABlockidMatches(currData, blockID))
2546 CABlockData_t *removedData = u_arraylist_remove(g_context.dataList, i);
2549 OIC_LOG(ERROR, TAG, "data is NULL");
2550 ca_mutex_unlock(g_context.blockDataListMutex);
2551 return CA_STATUS_FAILED;
2555 if (currData->sentData)
2557 CADestroyDataSet(currData->sentData);
2559 CADestroyBlockID(currData->blockDataId);
2560 OICFree(currData->payload);
2562 ca_mutex_unlock(g_context.blockDataListMutex);
2563 return CA_STATUS_OK;
2566 ca_mutex_unlock(g_context.blockDataListMutex);
2568 return CA_STATUS_OK;
2571 bool CAIsBlockDataInList(const CABlockDataID_t *blockID)
2573 OIC_LOG(DEBUG, TAG, "IN-IsBlockDataInList");
2574 VERIFY_NON_NULL_RET(blockID, TAG, "blockID", false);
2576 ca_mutex_lock(g_context.blockDataListMutex);
2578 size_t len = u_arraylist_length(g_context.dataList);
2579 for (size_t i = 0; i < len; i++)
2581 CABlockData_t *currData = (CABlockData_t *) u_arraylist_get(g_context.dataList, i);
2582 if (CABlockidMatches(currData, blockID))
2584 OIC_LOG(DEBUG, TAG, "found block data");
2585 ca_mutex_unlock(g_context.blockDataListMutex);
2589 ca_mutex_unlock(g_context.blockDataListMutex);
2591 OIC_LOG(DEBUG, TAG, "OUT-IsBlockDataInList");
2595 void CADestroyDataSet(CAData_t* data)
2597 VERIFY_NON_NULL_VOID(data, TAG, "data");
2599 CAFreeEndpoint(data->remoteEndpoint);
2600 CADestroyRequestInfoInternal(data->requestInfo);
2601 CADestroyResponseInfoInternal(data->responseInfo);
2605 CABlockDataID_t* CACreateBlockDatablockId(const CAToken_t token, uint8_t tokenLength,
2606 uint16_t portNumber)
2608 VERIFY_NON_NULL_RET(token, TAG, "token", NULL);
2610 char port[PORT_LENGTH] = {0,};
2611 port[0] = (char)((portNumber>>8) & 0xFF);
2612 port[1] = (char)(portNumber & 0xFF);
2614 CABlockDataID_t* blockDataID = (CABlockDataID_t *) OICMalloc(sizeof(CABlockDataID_t));
2617 OIC_LOG(ERROR, TAG, "memory alloc has failed");
2620 blockDataID->idLength = tokenLength + sizeof(port);
2621 blockDataID->id = (uint8_t *) OICMalloc(blockDataID->idLength);
2622 if (!blockDataID->id)
2624 OIC_LOG(ERROR, TAG, "memory alloc has failed");
2625 OICFree(blockDataID);
2629 memcpy(blockDataID->id, token, tokenLength);
2630 memcpy(blockDataID->id + tokenLength, port, sizeof(port));
2632 OIC_LOG(DEBUG, TAG, "BlockID is ");
2633 OIC_LOG_BUFFER(DEBUG, TAG, (const uint8_t *)blockDataID->id, blockDataID->idLength);
2638 void CADestroyBlockID(CABlockDataID_t *blockID)
2640 VERIFY_NON_NULL_VOID(blockID, TAG, "blockID");
2641 OICFree(blockID->id);
2646 bool CABlockidMatches(const CABlockData_t *currData, const CABlockDataID_t *blockID)
2648 VERIFY_NON_NULL_RET(currData, TAG, "currData", false);
2649 VERIFY_NON_NULL_RET(blockID, TAG, "blockID", false);
2650 VERIFY_NON_NULL_RET(blockID->id, TAG, "blockID->id", false);
2652 if ((currData->blockDataId)
2653 && (currData->blockDataId->id)
2654 && (currData->blockDataId->idLength == blockID->idLength)
2655 && !memcmp(currData->blockDataId->id, blockID->id, currData->blockDataId->idLength))
2662 void CALogBlockInfo(coap_block_t *block)
2664 VERIFY_NON_NULL_VOID(block, TAG, "block");
2666 OIC_LOG(DEBUG, TAG, "block option info");
2668 OIC_LOG_V(DEBUG, TAG, "block option-num : %d", block->num);
2670 OIC_LOG_V(DEBUG, TAG, "block option-m : %d", block->m);
2672 OIC_LOG_V(DEBUG, TAG, "block option-szx : %d", block->szx);