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 CAResult_t CAInitializeBlockWiseTransfer(CASendThreadFunc sendThreadFunc,
59 CAReceiveThreadFunc receivedThreadFunc)
61 OIC_LOG(DEBUG, TAG, "initialize");
63 // set block-wise transfer context
64 if (!g_context.sendThreadFunc)
66 g_context.sendThreadFunc = sendThreadFunc;
69 if (!g_context.receivedThreadFunc)
71 g_context.receivedThreadFunc = receivedThreadFunc;
74 if (!g_context.dataList)
76 g_context.dataList = u_arraylist_create();
79 CAResult_t res = CAInitBlockWiseMutexVariables();
80 if (CA_STATUS_OK != res)
82 OIC_LOG(ERROR, TAG, "init has failed");
88 CAResult_t CATerminateBlockWiseTransfer()
90 OIC_LOG(DEBUG, TAG, "terminate");
92 if (g_context.dataList)
94 u_arraylist_free(&g_context.dataList);
97 CATerminateBlockWiseMutexVariables();
102 CAResult_t CAInitBlockWiseMutexVariables()
104 OIC_LOG(DEBUG, TAG, "IN");
106 if (NULL == g_context.blockDataListMutex)
108 g_context.blockDataListMutex = ca_mutex_new();
109 if (NULL == g_context.blockDataListMutex)
111 OIC_LOG(ERROR, TAG, "ca_mutex_new has failed");
112 return CA_STATUS_FAILED;
116 if (NULL == g_context.blockDataSenderMutex)
118 g_context.blockDataSenderMutex = ca_mutex_new();
119 if (NULL == g_context.blockDataSenderMutex)
121 OIC_LOG(ERROR, TAG, "ca_mutex_new has failed");
122 CATerminateBlockWiseMutexVariables();
123 return CA_STATUS_FAILED;
130 void CATerminateBlockWiseMutexVariables()
132 OIC_LOG(DEBUG, TAG, "IN");
134 if (g_context.blockDataListMutex)
136 ca_mutex_free(g_context.blockDataListMutex);
137 g_context.blockDataListMutex = NULL;
140 if (g_context.blockDataSenderMutex)
142 ca_mutex_free(g_context.blockDataSenderMutex);
143 g_context.blockDataSenderMutex = NULL;
147 CAResult_t CASendBlockWiseData(const CAData_t *sendData)
149 VERIFY_NON_NULL(sendData, TAG, "sendData");
151 // check if message type is CA_MSG_RESET
152 if (NULL != sendData->responseInfo)
154 if (CA_MSG_RESET == sendData->responseInfo->info.type)
156 OIC_LOG(DEBUG, TAG, "reset message can't be sent to the block");
157 return CA_NOT_SUPPORTED;
161 // #1. check if it is already included in block data list
162 CABlockData_t *currData = NULL;
163 CAResult_t res = CACheckBlockDataValidation(sendData, &currData);
164 if (CA_STATUS_OK != res)
166 // #2. if it is not included, add the data into list
167 if (NULL == currData)
169 OIC_LOG(DEBUG, TAG, "There is no block data");
170 currData = CACreateNewBlockData(sendData);
171 if (NULL == currData)
173 OIC_LOG(ERROR, TAG, "failed to create block data");
174 return CA_MEMORY_ALLOC_FAILED;
179 // #3. check request/response block option type and payload length
180 res = CACheckBlockOptionType(currData);
181 if (CA_STATUS_OK == res)
183 // #4. send block message
184 OIC_LOG(DEBUG, TAG, "send first block msg");
185 res = CAAddSendThreadQueue(currData->sentData, (const CABlockDataID_t *)&currData->blockDataId);
186 if (CA_STATUS_OK != res)
188 OIC_LOG(ERROR, TAG, "add has failed");
196 CAResult_t CAAddSendThreadQueue(const CAData_t *sendData, const CABlockDataID_t *blockID)
198 VERIFY_NON_NULL(sendData, TAG, "sendData");
199 VERIFY_NON_NULL(blockID, TAG, "blockID");
201 CAData_t *cloneData = CACloneCAData(sendData);
202 if (NULL == cloneData)
204 OIC_LOG(ERROR, TAG, "clone has failed");
205 CARemoveBlockDataFromList(blockID);
206 return CA_STATUS_FAILED;
209 if (g_context.sendThreadFunc)
211 ca_mutex_lock(g_context.blockDataSenderMutex);
212 g_context.sendThreadFunc(cloneData);
213 ca_mutex_unlock(g_context.blockDataSenderMutex);
217 CADestroyDataSet(cloneData);
222 CAResult_t CACheckBlockOptionType(CABlockData_t *currData)
224 VERIFY_NON_NULL(currData, TAG, "currData");
225 VERIFY_NON_NULL(currData->sentData, TAG, "currData->sentData");
227 size_t payloadLen = 0;
228 CAGetPayloadInfo(currData->sentData, &payloadLen);
230 // check if message has to be transfered to a block
231 size_t maxBlockSize = BLOCK_SIZE(CA_DEFAULT_BLOCK_SIZE);
232 if (payloadLen <= maxBlockSize)
234 OIC_LOG_V(DEBUG, TAG, "payloadLen=%d, maxBlockSize=%d", payloadLen, maxBlockSize);
235 return CA_NOT_SUPPORTED;
238 // set block option (COAP_OPTION_BLOCK2 or COAP_OPTION_BLOCK1)
239 if (NULL != currData->sentData->requestInfo) // request message
241 currData->type = COAP_OPTION_BLOCK1;
243 else // response message
245 currData->type = COAP_OPTION_BLOCK2;
251 CAResult_t CAReceiveBlockWiseData(coap_pdu_t *pdu, const CAEndpoint_t *endpoint,
252 const CAData_t *receivedData, size_t dataLen)
254 OIC_LOG(DEBUG, TAG, "CAReceiveBlockWiseData");
255 VERIFY_NON_NULL(pdu, TAG, "pdu");
256 VERIFY_NON_NULL(pdu->hdr, TAG, "pdu->hdr");
257 VERIFY_NON_NULL(endpoint, TAG, "endpoint");
258 VERIFY_NON_NULL(receivedData, TAG, "receivedData");
260 // check if received message type is CA_MSG_RESET
261 if (CA_EMPTY == pdu->hdr->code)
263 OIC_LOG(DEBUG, TAG, "code is CA_EMPTY..");
265 // get token from block-wise transfer list when CA_EMPTY(RST/ACK) is received
266 CAResult_t res = CAGetTokenFromBlockDataList(pdu, endpoint, receivedData->responseInfo);
267 if (CA_STATUS_OK != res)
269 OIC_LOG(ERROR, TAG, "fail to get token");
273 CABlockDataID_t* blockDataID = CACreateBlockDatablockId(
274 receivedData->responseInfo->info.token,
275 receivedData->responseInfo->info.tokenLength,
277 if(NULL == blockDataID || NULL == blockDataID->id || blockDataID->idLength < 1)
279 OIC_LOG(ERROR, TAG, "blockId is null");
280 CADestroyBlockID(blockDataID);
281 return CA_STATUS_FAILED;
284 CARemoveBlockDataFromList(blockDataID);
285 CADestroyBlockID(blockDataID);
286 return CA_NOT_SUPPORTED;
289 // check if block option is set and get block data
290 coap_block_t block = {0};
293 int isBlock1 = coap_get_block(pdu, COAP_OPTION_BLOCK1, &block);
296 CAResult_t res = CASetNextBlockOption1(pdu, endpoint, receivedData, block, dataLen);
297 if (CA_STATUS_OK != res)
299 OIC_LOG(ERROR, TAG, "setting has failed");
305 int isBlock2 = coap_get_block(pdu, COAP_OPTION_BLOCK2, &block);
308 CAResult_t res = CASetNextBlockOption2(pdu, endpoint, receivedData, block, dataLen);
309 if (CA_STATUS_OK != res)
311 OIC_LOG(ERROR, TAG, "setting has failed");
316 // check if there is error code
317 if (!isBlock1 && !isBlock2)
319 uint32_t code = CA_RESPONSE_CODE(pdu->hdr->code);
320 if (CA_REQUEST_ENTITY_INCOMPLETE == code)
322 CABlockDataID_t* blockDataID = CACreateBlockDatablockId(
323 (CAToken_t)pdu->hdr->token,
324 pdu->hdr->token_length,
327 if(NULL == blockDataID || NULL == blockDataID->id || blockDataID->idLength < 1)
329 OIC_LOG(ERROR, TAG, "blockId is null");
330 CADestroyBlockID(blockDataID);
331 return CA_STATUS_FAILED;
334 CABlockData_t *data = CAGetBlockDataFromBlockDataList(blockDataID);
337 OIC_LOG(ERROR, TAG, "getting has failed");
338 CADestroyBlockID(blockDataID);
339 return CA_STATUS_FAILED;
342 if (COAP_OPTION_BLOCK2 == data->type)
344 coap_block_t *block2 = CAGetBlockOption(blockDataID,
348 OIC_LOG(ERROR, TAG, "block is null");
349 CADestroyBlockID(blockDataID);
350 return CA_STATUS_FAILED;
353 CAResult_t res = CASetNextBlockOption2(pdu, endpoint, receivedData, *block2,
355 if (CA_STATUS_OK != res)
357 OIC_LOG(ERROR, TAG, "setting has failed");
358 CADestroyBlockID(blockDataID);
362 else if (COAP_OPTION_BLOCK1 == data->type)
364 coap_block_t *block1 = CAGetBlockOption(blockDataID,
368 OIC_LOG(ERROR, TAG, "block is null");
369 CADestroyBlockID(blockDataID);
370 return CA_STATUS_FAILED;
373 CAResult_t res = CASetNextBlockOption1(pdu, endpoint, receivedData, *block1,
375 if (CA_STATUS_OK != res)
377 OIC_LOG(ERROR, TAG, "setting has failed");
378 CADestroyBlockID(blockDataID);
386 OIC_LOG(DEBUG, TAG, "it's normal pdu");
388 // if received data is response message
389 // and sent data remain in block data list, remove block data
390 if (receivedData->responseInfo)
392 CAResult_t res = CAGetTokenFromBlockDataList(pdu, endpoint,
393 receivedData->responseInfo);
394 if (CA_STATUS_OK != res)
396 OIC_LOG(ERROR, TAG, "fail to get token");
400 return CA_NOT_SUPPORTED;
407 CAResult_t CAProcessNextStep(const coap_pdu_t *pdu, const CAData_t *receivedData,
408 uint8_t blockWiseStatus, const CABlockDataID_t *blockID)
410 VERIFY_NON_NULL(pdu, TAG, "pdu");
411 VERIFY_NON_NULL(pdu->hdr, TAG, "pdu->hdr");
412 VERIFY_NON_NULL(blockID, TAG, "blockID");
414 CAResult_t res = CA_STATUS_OK;
415 CAData_t *data = NULL;
417 // process blockWiseStatus
418 switch (blockWiseStatus)
420 case CA_OPTION2_FIRST_BLOCK:
421 res = CAAddSendThreadQueue(receivedData, blockID);
422 if (CA_STATUS_OK != res)
424 OIC_LOG(ERROR, TAG, "add has failed");
430 // add data to send thread
431 data = CAGetDataSetFromBlockDataList(blockID);
434 OIC_LOG(ERROR, TAG, "it's unavailable");
435 return CA_STATUS_FAILED;
438 if (data->requestInfo)
440 data->requestInfo->info.messageId = pdu->hdr->id;
443 if (data->responseInfo)
445 data->responseInfo->info.messageId = pdu->hdr->id;
448 res = CAAddSendThreadQueue(data, blockID);
449 if (CA_STATUS_OK != res)
451 OIC_LOG(ERROR, TAG, "add has failed");
459 case CA_SENT_PREVIOUS_NON_MSG:
460 res = CASendBlockMessage(pdu, CA_MSG_CONFIRM, blockWiseStatus,
462 if (CA_STATUS_OK != res)
464 OIC_LOG(ERROR, TAG, "send has failed");
469 case CA_OPTION2_LAST_BLOCK:
470 // process last block and send upper layer
471 res = CAReceiveLastBlock(blockID, receivedData);
472 if (CA_STATUS_OK != res)
474 OIC_LOG(ERROR, TAG, "receive has failed");
478 // remove data from list
479 res = CARemoveBlockDataFromList(blockID);
480 if (CA_STATUS_OK != res)
482 OIC_LOG(ERROR, TAG, "remove has failed");
487 case CA_OPTION1_NO_ACK_LAST_BLOCK:
488 // process last block and send upper layer
489 res = CAReceiveLastBlock(blockID, receivedData);
490 if (CA_STATUS_OK != res)
492 OIC_LOG(ERROR, TAG, "receive has failed");
496 if (CA_MSG_NONCONFIRM == pdu->hdr->type)
498 // remove data from list
499 res = CARemoveBlockDataFromList(blockID);
500 if (CA_STATUS_OK != res)
502 OIC_LOG(ERROR, TAG, "remove has failed");
508 case CA_OPTION1_NO_ACK_BLOCK:
509 if (CA_MSG_CONFIRM == pdu->hdr->type)
511 // add data to send thread
512 res = CASendBlockMessage(pdu, CA_MSG_ACKNOWLEDGE, blockWiseStatus,
514 if (CA_STATUS_OK != res)
516 OIC_LOG(ERROR, TAG, "send has failed");
522 case CA_BLOCK_INCOMPLETE:
523 if (CA_MSG_CONFIRM == pdu->hdr->type || CA_MSG_ACKNOWLEDGE == pdu->hdr->type)
525 // add data to send thread
526 res = CASendErrorMessage(pdu, blockWiseStatus,
527 CA_REQUEST_ENTITY_INCOMPLETE,
529 if (CA_STATUS_OK != res)
531 OIC_LOG(ERROR, TAG, "send has failed");
537 case CA_BLOCK_TOO_LARGE:
538 if (CA_MSG_ACKNOWLEDGE == pdu->hdr->type)
540 res = CASendBlockMessage(pdu, CA_MSG_CONFIRM, blockWiseStatus,
542 if (CA_STATUS_OK != res)
544 OIC_LOG(ERROR, TAG, "send has failed");
548 else if (CA_MSG_CONFIRM == pdu->hdr->type)
550 res = CASendErrorMessage(pdu, blockWiseStatus,
551 CA_REQUEST_ENTITY_TOO_LARGE,
553 if (CA_STATUS_OK != res)
555 OIC_LOG(ERROR, TAG, "send has failed");
561 OIC_LOG_V(ERROR, TAG, "no logic [%d]", blockWiseStatus);
566 CAResult_t CASendBlockMessage(const coap_pdu_t *pdu, CAMessageType_t msgType,
567 uint8_t status, const CABlockDataID_t *blockID)
569 VERIFY_NON_NULL(pdu, TAG, "pdu");
570 VERIFY_NON_NULL(pdu->hdr, TAG, "pdu->hdr");
571 VERIFY_NON_NULL(blockID, TAG, "blockID");
573 CAData_t *data = CAGetDataSetFromBlockDataList(blockID);
576 OIC_LOG(ERROR, TAG, "CAData is unavailable");
577 return CA_STATUS_FAILED;
580 if (CA_MSG_CONFIRM == msgType)
582 OIC_LOG(DEBUG, TAG, "need new msgID");
583 if (data->requestInfo)
585 data->requestInfo->info.messageId = 0;
588 if (data->responseInfo)
590 data->responseInfo->info.messageId = 0;
593 else if (CA_MSG_ACKNOWLEDGE == msgType)
595 if (data->responseInfo)
597 OIC_LOG(DEBUG, TAG, "set ACK message");
598 data->responseInfo->info.messageId = pdu->hdr->id;
599 data->responseInfo->info.type = CA_MSG_ACKNOWLEDGE;
600 if (CA_OPTION1_NO_ACK_LAST_BLOCK == status)
602 data->responseInfo->result = CA_CHANGED;
604 else if (CA_OPTION1_NO_ACK_BLOCK == status)
606 data->responseInfo->result = CA_CONTINUE;
611 // add data to send thread
612 CAResult_t res = CAAddSendThreadQueue(data, blockID);
613 if (CA_STATUS_OK != res)
615 OIC_LOG(ERROR, TAG, "add has failed");
621 CAResult_t CASendErrorMessage(const coap_pdu_t *pdu, uint8_t status,
622 CAResponseResult_t responseResult,
623 const CABlockDataID_t *blockID)
625 VERIFY_NON_NULL(pdu, TAG, "pdu");
626 VERIFY_NON_NULL(pdu->hdr, TAG, "pdu->hdr");
627 VERIFY_NON_NULL(blockID, TAG, "blockID");
629 // create error responseInfo
630 CABlockData_t *data = CAGetBlockDataFromBlockDataList(blockID);
633 OIC_LOG(ERROR, TAG, "data is unavailable");
634 return CA_STATUS_FAILED;
637 CAData_t *cloneData = NULL;
638 if (data->sentData && data->sentData->responseInfo)
640 data->sentData->responseInfo->info.messageId = pdu->hdr->id;
641 data->sentData->responseInfo->info.type = CA_MSG_ACKNOWLEDGE;
642 data->sentData->responseInfo->result = responseResult;
643 cloneData = CACloneCAData(data->sentData);
644 if (NULL == cloneData)
646 OIC_LOG(ERROR, TAG, "clone has failed");
647 return CA_MEMORY_ALLOC_FAILED;
649 OIC_LOG(DEBUG, TAG, "set ACK message");
651 else if (data->sentData)
653 cloneData = CACreateNewDataSet(pdu, data->sentData->remoteEndpoint);
657 OIC_LOG(ERROR, TAG, PCF("CACreateNewDataSet failed"));
658 return CA_MEMORY_ALLOC_FAILED;
661 cloneData->responseInfo->info.type = CA_MSG_CONFIRM;
662 cloneData->responseInfo->result = responseResult;
663 OIC_LOG(DEBUG, TAG, "set CON message");
667 OIC_LOG(ERROR, TAG, "data has no sent-data");
668 return CA_MEMORY_ALLOC_FAILED;
671 // add data to send thread
672 if (g_context.sendThreadFunc)
674 ca_mutex_lock(g_context.blockDataSenderMutex);
675 g_context.sendThreadFunc(cloneData);
676 ca_mutex_unlock(g_context.blockDataSenderMutex);
680 CADestroyDataSet(cloneData);
683 // if error code is 4.08, remove the stored payload and initialize block number
684 if (CA_BLOCK_INCOMPLETE == status)
686 OICFree(data->payload);
687 data->payload = NULL;
688 data->payloadLength = 0;
689 data->receivedPayloadLen = 0;
690 data->block1.num = 0;
691 data->block2.num = 0;
697 CAResult_t CAReceiveLastBlock(const CABlockDataID_t *blockID,
698 const CAData_t *receivedData)
700 VERIFY_NON_NULL(blockID, TAG, "blockID");
701 VERIFY_NON_NULL(receivedData, TAG, "receivedData");
703 // total block data have to notify to Application
704 CAData_t *cloneData = CACloneCAData(receivedData);
705 if (NULL == cloneData)
707 OIC_LOG(ERROR, TAG, "clone has failed");
708 return CA_MEMORY_ALLOC_FAILED;
712 size_t fullPayloadLen = 0;
713 CAPayload_t fullPayload = CAGetPayloadFromBlockDataList(blockID,
715 if (NULL != fullPayload)
717 CAResult_t res = CAUpdatePayloadToCAData(cloneData, fullPayload, fullPayloadLen);
718 if (CA_STATUS_OK != res)
720 OIC_LOG(ERROR, TAG, "update has failed");
721 CADestroyDataSet(cloneData);
722 return CA_STATUS_FAILED;
726 if (g_context.receivedThreadFunc)
728 g_context.receivedThreadFunc(cloneData);
732 CADestroyDataSet(cloneData);
738 CAResult_t CASetNextBlockOption1(coap_pdu_t *pdu, const CAEndpoint_t *endpoint,
739 const CAData_t *receivedData, coap_block_t block,
742 OIC_LOG(INFO, TAG, "CASetNextBlockOption1");
743 VERIFY_NON_NULL(pdu, TAG, "pdu");
744 VERIFY_NON_NULL(pdu->hdr, TAG, "pdu->hdr");
745 VERIFY_NON_NULL(endpoint, TAG, "endpoint");
746 VERIFY_NON_NULL(receivedData, TAG, "receivedData");
748 OIC_LOG_V(INFO, TAG, "num:%d, M:%d, sze:%d", block.num, block.m, block.szx);
750 CABlockDataID_t* blockDataID = CACreateBlockDatablockId(
751 (CAToken_t)pdu->hdr->token,
752 pdu->hdr->token_length,
755 if(NULL == blockDataID || NULL == blockDataID->id || blockDataID->idLength < 1)
757 OIC_LOG(ERROR, TAG, "blockId is null");
758 CADestroyBlockID(blockDataID);
759 return CA_STATUS_FAILED;
762 // BlockData data is created if it not existed
763 if (!CAIsBlockDataInList(blockDataID))
765 OIC_LOG(DEBUG, TAG, "no message in list");
767 CAData_t *data = CACreateNewDataSet(pdu, endpoint);
770 OIC_LOG(ERROR, TAG, "data is null");
771 CADestroyBlockID(blockDataID);
772 return CA_STATUS_FAILED;
775 CABlockData_t *currData = CACreateNewBlockData(data);
776 if (NULL == currData)
778 OIC_LOG(ERROR, TAG, "currData is null");
779 CADestroyDataSet(data);
780 CADestroyBlockID(blockDataID);
781 return CA_STATUS_FAILED;
785 // update BLOCK OPTION1 type
786 CAResult_t res = CAUpdateBlockOptionType(blockDataID,
788 if (CA_STATUS_OK != res)
790 OIC_LOG(ERROR, TAG, "update has failed");
791 CARemoveBlockDataFromList(blockDataID);
792 CADestroyBlockID(blockDataID);
796 CABlockData_t *data = CAGetBlockDataFromBlockDataList(blockDataID);
799 OIC_LOG(ERROR, TAG, "getting has failed");
800 CADestroyBlockID(blockDataID);
801 return CA_STATUS_FAILED;
804 uint8_t blockWiseStatus = CA_BLOCK_UNKNOWN;
805 // received type from remote device
806 if (CA_MSG_ACKNOWLEDGE == pdu->hdr->type)
808 uint32_t code = CA_RESPONSE_CODE(pdu->hdr->code);
810 (CA_REQUEST_ENTITY_INCOMPLETE != code && CA_REQUEST_ENTITY_TOO_LARGE != code))
812 OIC_LOG(INFO, TAG, "Data has sent");
813 // initialize block number for response message
814 data->block1.num = 0;
815 CADestroyBlockID(blockDataID);
819 blockWiseStatus = CA_OPTION1_ACK;
820 res = CAUpdateBlockOptionItems(data, pdu, &block, COAP_OPTION_BLOCK1, blockWiseStatus);
821 if (CA_STATUS_OK != res)
823 OIC_LOG(ERROR, TAG, "update has failed");
824 CADestroyBlockID(blockDataID);
828 res = CAUpdateBlockData(data, block, COAP_OPTION_BLOCK1);
829 if (CA_STATUS_OK != res)
831 OIC_LOG(ERROR, TAG, "update has failed");
832 CARemoveBlockDataFromList(blockDataID);
833 CADestroyBlockID(blockDataID);
837 else // CON or NON message
839 OIC_LOG_V(INFO, TAG, "num:%d, M:%d", block.num, block.m);
841 // check the size option
842 bool isSizeOption = CAIsPayloadLengthInPduWithBlockSizeOption(pdu,
844 &(data->payloadLength));
846 // check if received payload is exact
847 if (CA_MSG_CONFIRM == pdu->hdr->type)
849 blockWiseStatus = CACheckBlockErrorType(data, &block, receivedData,
850 COAP_OPTION_BLOCK1, dataLen);
853 if (CA_BLOCK_RECEIVED_ALREADY != blockWiseStatus)
855 // store the received payload and merge
856 res = CAUpdatePayloadData(data, receivedData, blockWiseStatus,
857 isSizeOption, COAP_OPTION_BLOCK1);
858 if (CA_STATUS_OK != res)
860 OIC_LOG(ERROR, TAG, "update has failed");
861 CARemoveBlockDataFromList(blockDataID);
862 CADestroyBlockID(blockDataID);
866 res = CAUpdateBlockOptionItems(data, pdu, &block, COAP_OPTION_BLOCK1, blockWiseStatus);
867 if (CA_STATUS_OK != res)
869 OIC_LOG(ERROR, TAG, "update has failed");
870 CARemoveBlockDataFromList(blockDataID);
871 CADestroyBlockID(blockDataID);
876 res = CAUpdateBlockData(data, block, COAP_OPTION_BLOCK1);
877 if (CA_STATUS_OK != res)
879 OIC_LOG(ERROR, TAG, "update has failed");
880 CARemoveBlockDataFromList(blockDataID);
881 CADestroyBlockID(blockDataID);
886 // check the blcok-wise transfer status for next step
887 if (CA_BLOCK_UNKNOWN == blockWiseStatus || CA_BLOCK_RECEIVED_ALREADY == blockWiseStatus)
889 if (0 == block.m) // Last block is received
891 OIC_LOG(DEBUG, TAG, "M bit is 0");
892 blockWiseStatus = CA_OPTION1_NO_ACK_LAST_BLOCK;
896 OIC_LOG(DEBUG, TAG, "M bit is 1");
897 blockWiseStatus = CA_OPTION1_NO_ACK_BLOCK;
902 res = CAProcessNextStep(pdu, receivedData, blockWiseStatus, blockDataID);
903 if (CA_STATUS_OK != res)
905 OIC_LOG(ERROR, TAG, "setting has failed");
906 CARemoveBlockDataFromList(blockDataID);
909 CADestroyBlockID(blockDataID);
913 CAResult_t CASetNextBlockOption2(coap_pdu_t *pdu, const CAEndpoint_t *endpoint,
914 const CAData_t *receivedData, coap_block_t block,
917 OIC_LOG(DEBUG, TAG, "CASetNextBlockOption2");
918 OIC_LOG_V(INFO, TAG, "num:%d, M:%d, sze:%d", block.num, block.m, block.szx);
920 VERIFY_NON_NULL(pdu, TAG, "pdu");
921 VERIFY_NON_NULL(pdu->hdr, TAG, "pdu->hdr");
922 VERIFY_NON_NULL(endpoint, TAG, "endpoint");
923 VERIFY_NON_NULL(receivedData, TAG, "receivedData");
925 CABlockDataID_t* blockDataID = CACreateBlockDatablockId(
926 (CAToken_t)pdu->hdr->token,
927 pdu->hdr->token_length,
930 if(NULL == blockDataID || NULL == blockDataID->id || blockDataID->idLength < 1)
932 OIC_LOG(ERROR, TAG, "blockId is null");
933 CADestroyBlockID(blockDataID);
934 return CA_STATUS_FAILED;
937 // BlockData data is created if it not existed
938 if (!CAIsBlockDataInList(blockDataID))
940 OIC_LOG(DEBUG, TAG, "no msg in list.");
942 CAData_t *data = CACreateNewDataSet(pdu, endpoint);
945 OIC_LOG(ERROR, TAG, "data is null");
946 CADestroyBlockID(blockDataID);
947 return CA_STATUS_FAILED;
950 CABlockData_t *currData = CACreateNewBlockData(data);
951 if (NULL == currData)
953 OIC_LOG(ERROR, TAG, "data is null");
954 CADestroyDataSet(data);
955 CADestroyBlockID(blockDataID);
956 return CA_STATUS_FAILED;
960 // set Block Option Type
961 CAResult_t res = CAUpdateBlockOptionType(blockDataID,
963 if (CA_STATUS_OK != res)
965 OIC_LOG(ERROR, TAG, "update has failed");
966 CARemoveBlockDataFromList(blockDataID);
967 CADestroyBlockID(blockDataID);
971 CABlockData_t *data = CAGetBlockDataFromBlockDataList(blockDataID);
974 OIC_LOG(ERROR, TAG, "getting has failed");
975 CARemoveBlockDataFromList(blockDataID);
976 CADestroyBlockID(blockDataID);
977 return CA_STATUS_FAILED;
980 uint8_t blockWiseStatus = CA_BLOCK_UNKNOWN;
981 if (0 == block.num && CA_GET == pdu->hdr->code && 0 == block.m)
983 OIC_LOG(INFO, TAG, "first block number");
985 res = CAUpdateBlockOptionItems(data, pdu, &block, COAP_OPTION_BLOCK2, blockWiseStatus);
986 if (CA_STATUS_OK != res)
988 OIC_LOG(ERROR, TAG, "update has failed");
989 CARemoveBlockDataFromList(blockDataID);
990 CADestroyBlockID(blockDataID);
994 // first block data have to notify to Application
995 res = CAUpdateBlockData(data, block, COAP_OPTION_BLOCK2);
996 if (CA_STATUS_OK != res)
998 OIC_LOG(ERROR, TAG, "update has failed");
999 CARemoveBlockDataFromList(blockDataID);
1000 CADestroyBlockID(blockDataID);
1003 blockWiseStatus = CA_OPTION2_FIRST_BLOCK;
1007 // received type from remote device
1008 if (CA_MSG_ACKNOWLEDGE == pdu->hdr->type ||
1009 (CA_MSG_NONCONFIRM == pdu->hdr->type && NULL != receivedData->responseInfo))
1011 OIC_LOG(DEBUG, TAG, "received ACK or NON");
1013 // check the size option
1014 bool isSizeOption = CAIsPayloadLengthInPduWithBlockSizeOption(pdu,
1016 &(data->payloadLength));
1018 // check if received payload is exact
1019 if (CA_MSG_ACKNOWLEDGE == pdu->hdr->type)
1021 blockWiseStatus = CACheckBlockErrorType(data, &block, receivedData,
1022 COAP_OPTION_BLOCK2, dataLen);
1025 if (CA_BLOCK_RECEIVED_ALREADY != blockWiseStatus)
1027 // store the received payload and merge
1028 res = CAUpdatePayloadData(data, receivedData, blockWiseStatus,
1029 isSizeOption, COAP_OPTION_BLOCK2);
1030 if (CA_STATUS_OK != res)
1032 OIC_LOG(ERROR, TAG, "update has failed");
1033 CARemoveBlockDataFromList(blockDataID);
1034 CADestroyBlockID(blockDataID);
1039 if (0 == block.m && CA_BLOCK_UNKNOWN == blockWiseStatus) // Last block is received
1041 OIC_LOG(DEBUG, TAG, "M bit is 0");
1042 blockWiseStatus = CA_OPTION2_LAST_BLOCK;
1046 if (CA_BLOCK_UNKNOWN == blockWiseStatus ||
1047 CA_BLOCK_RECEIVED_ALREADY == blockWiseStatus)
1049 OIC_LOG(DEBUG, TAG, "M bit is 1");
1051 if (CA_MSG_ACKNOWLEDGE == pdu->hdr->type)
1053 blockWiseStatus = CA_OPTION2_ACK;
1057 blockWiseStatus = CA_OPTION2_NON;
1061 res = CAUpdateBlockOptionItems(data, pdu, &block, COAP_OPTION_BLOCK2,
1063 if (CA_STATUS_OK != res)
1065 OIC_LOG(ERROR, TAG, "update has failed");
1066 CARemoveBlockDataFromList(blockDataID);
1067 CADestroyBlockID(blockDataID);
1071 res = CAUpdateBlockData(data, block, COAP_OPTION_BLOCK2);
1072 if (CA_STATUS_OK != res)
1074 OIC_LOG(ERROR, TAG, "update has failed");
1075 CARemoveBlockDataFromList(blockDataID);
1076 CADestroyBlockID(blockDataID);
1081 else // CON message and so on.
1083 OIC_LOG_V(INFO, TAG, "num:%d, M:%d", block.num, block.m);
1085 blockWiseStatus = CA_OPTION2_CON;
1087 res = CAUpdateBlockOptionItems(data, pdu, &block, COAP_OPTION_BLOCK2, blockWiseStatus);
1088 if (CA_STATUS_OK != res)
1090 OIC_LOG(ERROR, TAG, "update has failed");
1091 CARemoveBlockDataFromList(blockDataID);
1092 CADestroyBlockID(blockDataID);
1096 res = CAUpdateBlockData(data, block, COAP_OPTION_BLOCK2);
1097 if (CA_STATUS_OK != res)
1099 OIC_LOG(ERROR, TAG, "update has failed");
1100 CARemoveBlockDataFromList(blockDataID);
1101 CADestroyBlockID(blockDataID);
1107 res = CAProcessNextStep(pdu, receivedData, blockWiseStatus, blockDataID);
1108 if (CA_STATUS_OK != res)
1110 OIC_LOG(ERROR, TAG, "setting has failed");
1111 CARemoveBlockDataFromList(blockDataID);
1112 CADestroyBlockID(blockDataID);
1116 CADestroyBlockID(blockDataID);
1117 return CA_STATUS_OK;
1120 CAResult_t CAUpdateBlockOptionItems(CABlockData_t *currData, const coap_pdu_t *pdu,
1121 coap_block_t *block, uint16_t blockType,
1124 VERIFY_NON_NULL(currData, TAG, "currData");
1125 VERIFY_NON_NULL(pdu, TAG, "pdu");
1126 VERIFY_NON_NULL(block, TAG, "block");
1128 // update block data
1129 CAResult_t res = CA_STATUS_OK;
1130 uint32_t code = CA_RESPONSE_CODE(pdu->hdr->code);
1132 if (CA_REQUEST_ENTITY_INCOMPLETE == code || CA_REQUEST_ENTITY_TOO_LARGE == code)
1134 // response error code of the received block message
1135 res = CAHandleBlockErrorResponse(block, blockType, code);
1136 if (CA_STATUS_OK != res)
1138 OIC_LOG(ERROR, TAG, "error handle has failed");
1144 // update block option items
1147 case CA_OPTION1_ACK:
1148 if (currData->block1.num > block->num)
1150 OIC_LOG(ERROR, TAG, "received incorrect block num");
1151 return CA_STATUS_FAILED;
1155 case CA_OPTION2_NON:
1159 case CA_OPTION2_CON:
1162 case CA_OPTION2_ACK:
1163 if (currData->block2.num > block->num)
1165 OIC_LOG(ERROR, TAG, "received incorrect block num");
1166 return CA_STATUS_FAILED;
1171 case CA_BLOCK_TOO_LARGE:
1172 // if state of received block message is CA_BLOCK_TOO_LARGE or CA_BLOCK_INCOMPLETE
1173 // we set the response error code appropriately and send
1174 if (COAP_OPTION_BLOCK2 == blockType)
1178 block->szx = currData->block2.szx;
1182 block->szx = currData->block1.szx;
1186 OIC_LOG_V(ERROR, TAG, "no logic [%d]", status);
1189 if (CA_BLOCK_INCOMPLETE != status && CA_BLOCK_TOO_LARGE != status)
1191 // negotiate block size
1192 res = CANegotiateBlockSize(currData, block, pdu->hdr->type, blockType);
1193 if (CA_STATUS_OK != res)
1195 OIC_LOG(ERROR, TAG, "negotiation has failed");
1203 CAResult_t CAGetMoreBitFromBlock(size_t payloadLen, coap_block_t *block)
1205 VERIFY_NON_NULL(block, TAG, "block");
1207 if (((block->num + 1) << (block->szx + BLOCK_NUMBER_IDX)) < payloadLen)
1209 OIC_LOG(DEBUG, TAG, "Set the M-bit(1)");
1214 OIC_LOG(DEBUG, TAG, "Set the M-bit(0)");
1218 return CA_STATUS_OK;
1221 CAResult_t CANegotiateBlockSize(CABlockData_t *currData, coap_block_t *block,
1222 CAMessageType_t msgType, uint16_t blockType)
1224 OIC_LOG(DEBUG, TAG, "IN-NegotiateBlockSize");
1226 VERIFY_NON_NULL(currData, TAG, "currData");
1227 VERIFY_NON_NULL(block, TAG, "block");
1229 // #1. check the block option type
1230 if (COAP_OPTION_BLOCK2 == blockType)
1232 // #2. check the message type
1233 if (CA_MSG_ACKNOWLEDGE == msgType)
1235 if (block->szx > currData->block2.szx)
1237 OIC_LOG(DEBUG, TAG, "sze is big");
1239 // #3. calculate new block number from block size
1240 unsigned int blockNum = BLOCK_SIZE(block->szx) /
1241 BLOCK_SIZE(currData->block2.szx) - 1;
1242 OIC_LOG(DEBUG, TAG, "num is set as Negotiation");
1243 block->num += blockNum;
1244 block->szx = currData->block2.szx;
1245 OIC_LOG_V(DEBUG, TAG, "updated block num: %d", block->num);
1250 if (block->szx > currData->block2.szx)
1252 OIC_LOG(DEBUG, TAG, "sze is big");
1253 block->szx = currData->block2.szx;
1257 else if (COAP_OPTION_BLOCK1 == blockType)
1259 if (CA_MSG_ACKNOWLEDGE == msgType)
1261 if (block->szx < currData->block1.szx)
1263 OIC_LOG(DEBUG, TAG, "sze is small");
1265 unsigned int blockNum = BLOCK_SIZE(currData->block1.szx) /
1266 BLOCK_SIZE(block->szx) - 1;
1267 block->num += blockNum;
1268 OIC_LOG_V(DEBUG, TAG, "updated block num: %d", block->num);
1273 if (block->szx > currData->block1.szx)
1275 OIC_LOG(DEBUG, TAG, "sze is big");
1276 block->szx = currData->block1.szx;
1282 OIC_LOG(DEBUG, TAG, "Invalid block option");
1283 return CA_STATUS_FAILED;
1286 OIC_LOG(DEBUG, TAG, "OUT-NegotiateBlockSize");
1288 return CA_STATUS_OK;
1291 CAResult_t CAUpdateBlockData(CABlockData_t *currData, coap_block_t block,
1294 VERIFY_NON_NULL(currData, TAG, "currData");
1296 // check if block size is bigger than CABlockSize_t
1297 if (block.szx > CA_BLOCK_SIZE_1024_BYTE)
1299 OIC_LOG(DEBUG, TAG, "invalid block szx");
1300 return CA_STATUS_FAILED;
1303 // update block option
1304 if (COAP_OPTION_BLOCK2 == blockType)
1306 currData->block2 = block;
1310 currData->block1 = block;
1313 OIC_LOG(DEBUG, TAG, "data has updated");
1314 return CA_STATUS_OK;
1317 CAResult_t CAUpdateMessageId(coap_pdu_t *pdu, const CABlockDataID_t *blockID)
1319 VERIFY_NON_NULL(pdu, TAG, "pdu");
1320 VERIFY_NON_NULL(blockID, TAG, "blockID");
1322 // if CON message is sent, update messageId in block-wise transfer list
1323 if (CA_MSG_CONFIRM == pdu->hdr->type)
1325 CAData_t * cadata = CAGetDataSetFromBlockDataList(blockID);
1328 OIC_LOG(ERROR, TAG, "CAData is unavailable");
1329 return CA_STATUS_FAILED;
1332 if (NULL != cadata->requestInfo)
1334 cadata->requestInfo->info.messageId = pdu->hdr->id;
1338 return CA_STATUS_OK;
1341 CAResult_t CAAddBlockOption(coap_pdu_t **pdu, const CAInfo_t info,
1342 const CAEndpoint_t *endpoint)
1344 OIC_LOG(DEBUG, TAG, "IN-AddBlockOption");
1345 VERIFY_NON_NULL(pdu, TAG, "pdu");
1346 VERIFY_NON_NULL((*pdu), TAG, "(*pdu)");
1347 VERIFY_NON_NULL((*pdu)->hdr, TAG, "(*pdu)->hdr");
1348 VERIFY_NON_NULL(endpoint, TAG, "endpoint");
1350 size_t dataLength = 0;
1353 dataLength = info.payloadSize;
1354 OIC_LOG_V(DEBUG, TAG, "dataLength - %d", dataLength);
1357 OIC_LOG_V(DEBUG, TAG, "previous payload - %s", (*pdu)->data);
1359 uint32_t code = CA_RESPONSE_CODE((*pdu)->hdr->code);
1360 if (CA_REQUEST_ENTITY_INCOMPLETE == code)
1362 OIC_LOG(INFO, TAG, "don't use option");
1363 return CA_STATUS_OK;
1366 CABlockDataID_t* blockDataID = CACreateBlockDatablockId(
1367 (CAToken_t)(*pdu)->hdr->token,
1368 (*pdu)->hdr->token_length,
1371 if(NULL == blockDataID || NULL == blockDataID->id || blockDataID->idLength < 1)
1373 OIC_LOG(ERROR, TAG, "blockId is null");
1374 CADestroyBlockID(blockDataID);
1375 return CA_STATUS_FAILED;
1378 uint8_t blockType = CAGetBlockOptionType(blockDataID);
1379 if (COAP_OPTION_BLOCK2 == blockType)
1381 CAResult_t res = CAAddBlockOption2(pdu, info, dataLength,
1383 if (CA_STATUS_OK != res)
1385 OIC_LOG(ERROR, TAG, "add has failed");
1386 CADestroyBlockID(blockDataID);
1390 else if (COAP_OPTION_BLOCK1 == blockType)
1392 CAResult_t res = CAAddBlockOption1(pdu, info, dataLength,
1394 if (CA_STATUS_OK != res)
1396 OIC_LOG(ERROR, TAG, "add has failed");
1397 CADestroyBlockID(blockDataID);
1403 OIC_LOG(DEBUG, TAG, "no BLOCK option");
1404 // if response data is so large. it have to send as block transfer
1405 if (!coap_add_data(*pdu, dataLength, (const unsigned char *) info.payload))
1407 OIC_LOG(INFO, TAG, "it have to use block");
1411 OIC_LOG(INFO, TAG, "not Blockwise Transfer");
1415 CAResult_t res = CAUpdateMessageId(*pdu, blockDataID);
1416 if (CA_STATUS_OK != res)
1418 OIC_LOG(ERROR, TAG, "fail to update CON message id ");
1419 CADestroyBlockID(blockDataID);
1423 CADestroyBlockID(blockDataID);
1424 OIC_LOG(DEBUG, TAG, "OUT-AddBlockOption");
1425 return CA_STATUS_OK;
1428 CAResult_t CAAddBlockOption2(coap_pdu_t **pdu, const CAInfo_t info, size_t dataLength,
1429 const CABlockDataID_t *blockID)
1431 OIC_LOG(DEBUG, TAG, "IN-AddBlockOption2");
1432 VERIFY_NON_NULL(pdu, TAG, "pdu");
1433 VERIFY_NON_NULL((*pdu), TAG, "(*pdu)");
1434 VERIFY_NON_NULL((*pdu)->hdr, TAG, "(*pdu)->hdr");
1435 VERIFY_NON_NULL(blockID, TAG, "blockID");
1437 // get set block data from CABlock list-set.
1438 coap_block_t *block1 = CAGetBlockOption(blockID,
1439 COAP_OPTION_BLOCK1);
1440 coap_block_t *block2 = CAGetBlockOption(blockID,
1441 COAP_OPTION_BLOCK2);
1442 if (!block1 || !block2)
1444 OIC_LOG(ERROR, TAG, "getting has failed");
1445 return CA_STATUS_FAILED;
1448 CALogBlockInfo(block2);
1451 if (CA_MSG_ACKNOWLEDGE == (*pdu)->hdr->type ||
1452 (CA_MSG_NONCONFIRM == (*pdu)->hdr->type && CA_GET != (*pdu)->hdr->code))
1454 int32_t res = coap_write_block_opt(block2, COAP_OPTION_BLOCK2, *pdu, dataLength);
1457 case -2: /* illegal block */
1458 code = COAP_RESPONSE_CODE(CA_BAD_REQ);
1459 OIC_LOG(ERROR, TAG, "write block option : -2");
1461 case -1: /* should really not happen */
1462 OIC_LOG(ERROR, TAG, "write block option : -1");
1464 case -3: /* cannot handle request */
1465 code = COAP_RESPONSE_CODE(CA_INTERNAL_SERVER_ERROR);
1466 OIC_LOG(ERROR, TAG, "write block option : -3");
1469 OIC_LOG(INFO, TAG, "success write block option");
1471 CALogBlockInfo(block2);
1475 OIC_LOG(DEBUG, TAG, "combining block1 and block2");
1476 CAResult_t res = CAAddBlockOptionImpl(*pdu, block1, COAP_OPTION_BLOCK1);
1477 if (CA_STATUS_OK != res)
1479 OIC_LOG(ERROR, TAG, "add has failed");
1480 CARemoveBlockDataFromList(blockID);
1483 // initialize block number
1487 // if block number is 0, add size2 option
1488 if (0 == block2->num)
1490 res = CAAddBlockSizeOption(*pdu, COAP_OPTION_SIZE2, dataLength);
1491 if (CA_STATUS_OK != res)
1493 OIC_LOG(ERROR, TAG, "add has failed");
1494 CARemoveBlockDataFromList(blockID);
1499 if (!coap_add_block(*pdu, dataLength, (const unsigned char *) info.payload,
1500 block2->num, block2->szx))
1502 OIC_LOG(ERROR, TAG, "Data length is smaller than the start index");
1503 return CA_STATUS_FAILED;
1508 // if sent message is last response block message, remove data
1509 CARemoveBlockDataFromList(blockID);
1513 if (CA_MSG_NONCONFIRM == (*pdu)->hdr->type)
1515 OIC_LOG(DEBUG, TAG, "NON, send next block..");
1516 // update block data
1518 CAResult_t res = CAProcessNextStep(*pdu, NULL,
1519 CA_SENT_PREVIOUS_NON_MSG,
1521 if (CA_STATUS_OK != res)
1523 OIC_LOG(ERROR, TAG, "failed to process next step");
1524 CARemoveBlockDataFromList(blockID);
1532 OIC_LOG(DEBUG, TAG, "option2, not ACK msg");
1533 CAResult_t res = CAAddBlockOptionImpl(*pdu, block2, COAP_OPTION_BLOCK2);
1534 if (CA_STATUS_OK != res)
1536 OIC_LOG(ERROR, TAG, "add has failed");
1537 CARemoveBlockDataFromList(blockID);
1542 return CA_STATUS_OK;
1545 OIC_LOG_V(ERROR, TAG, "error : %d", code);
1547 char* phrase = coap_response_phrase(code);
1550 coap_add_data(*pdu, strlen(phrase),
1551 (unsigned char *) phrase);
1553 return CA_STATUS_FAILED;
1556 CAResult_t CAAddBlockOption1(coap_pdu_t **pdu, const CAInfo_t info, size_t dataLength,
1557 const CABlockDataID_t *blockID)
1559 OIC_LOG(DEBUG, TAG, "IN-AddBlockOption1");
1560 VERIFY_NON_NULL(pdu, TAG, "pdu");
1561 VERIFY_NON_NULL((*pdu), TAG, "(*pdu)");
1562 VERIFY_NON_NULL((*pdu)->hdr, TAG, "(*pdu)->hdr");
1563 VERIFY_NON_NULL(blockID, TAG, "blockID");
1565 // get set block data from CABlock list-set.
1566 coap_block_t *block1 = CAGetBlockOption(blockID,
1567 COAP_OPTION_BLOCK1);
1570 OIC_LOG(ERROR, TAG, "getting has failed");
1571 return CA_STATUS_FAILED;
1574 CALogBlockInfo(block1);
1576 if (CA_MSG_ACKNOWLEDGE == (*pdu)->hdr->type)
1578 OIC_LOG(DEBUG, TAG, "option1 and ACK msg..");
1579 CAResult_t res = CAAddBlockOptionImpl(*pdu, block1, COAP_OPTION_BLOCK1);
1580 if (CA_STATUS_OK != res)
1582 OIC_LOG(ERROR, TAG, "add has failed");
1583 CARemoveBlockDataFromList(blockID);
1587 // reset block-list after write block
1590 // remove data from list
1591 CAResult_t res = CARemoveBlockDataFromList(blockID);
1592 if (CA_STATUS_OK != res)
1594 OIC_LOG(ERROR, TAG, "remove has failed");
1601 CAGetMoreBitFromBlock(dataLength, block1);
1602 CAResult_t res = CAAddBlockOptionImpl(*pdu, block1, COAP_OPTION_BLOCK1);
1603 if (CA_STATUS_OK != res)
1605 OIC_LOG(ERROR, TAG, "add has failed");
1606 CARemoveBlockDataFromList(blockID);
1609 CALogBlockInfo(block1);
1611 // if block number is 0, add size1 option
1612 if (0 == block1->num)
1614 res = CAAddBlockSizeOption(*pdu, COAP_OPTION_SIZE1, dataLength);
1615 if (CA_STATUS_OK != res)
1617 OIC_LOG(ERROR, TAG, "add has failed");
1618 CARemoveBlockDataFromList(blockID);
1623 if (!coap_add_block(*pdu, dataLength, (const unsigned char *) info.payload,
1624 block1->num, block1->szx))
1626 OIC_LOG(ERROR, TAG, "Data length is smaller than the start index");
1627 return CA_STATUS_FAILED;
1630 // check the message type and if message type is NON, next block message will be sent
1631 if (CA_MSG_NONCONFIRM == (*pdu)->hdr->type)
1635 OIC_LOG(DEBUG, TAG, "NON, send next block..");
1636 // update block data
1638 CAResult_t res = CAProcessNextStep(*pdu, NULL,
1639 CA_SENT_PREVIOUS_NON_MSG,
1641 if (CA_STATUS_OK != res)
1643 OIC_LOG(ERROR, TAG, "failed to process next step");
1644 CARemoveBlockDataFromList(blockID);
1650 CARemoveBlockDataFromList(blockID);
1655 OIC_LOG(DEBUG, TAG, "OUT-AddBlockOption1");
1657 return CA_STATUS_OK;
1660 CAResult_t CAAddBlockOptionImpl(coap_pdu_t *pdu, coap_block_t *block, uint8_t blockType)
1662 OIC_LOG(DEBUG, TAG, "IN-AddBlockOptionImpl");
1663 VERIFY_NON_NULL(pdu, TAG, "pdu");
1664 VERIFY_NON_NULL(block, TAG, "block");
1666 coap_option *option = (coap_option *) OICMalloc(sizeof(coap_option));
1669 OIC_LOG(ERROR, TAG, "out of memory");
1670 return CA_MEMORY_ALLOC_FAILED;
1673 unsigned char buf[BLOCKWISE_OPTION_BUFFER] = { 0 };
1674 option->key = blockType;
1675 option->length = coap_encode_var_bytes(buf,
1676 ((block->num << BLOCK_NUMBER_IDX)
1677 | (block->m << BLOCK_M_BIT_IDX) | block->szx));
1678 if (!coap_add_option(pdu, option->key, option->length, buf))
1680 OIC_LOG(ERROR, TAG, "coap_add_option has failed");
1682 return CA_STATUS_FAILED;
1687 OIC_LOG(DEBUG, TAG, "OUT-AddBlockOptionImpl");
1688 return CA_STATUS_OK;
1691 CAResult_t CAAddBlockSizeOption(coap_pdu_t *pdu, uint16_t sizeType, size_t dataLength)
1693 OIC_LOG(DEBUG, TAG, "IN-CAAddBlockSizeOption");
1694 VERIFY_NON_NULL(pdu, TAG, "pdu");
1696 if (sizeType != COAP_OPTION_SIZE1 && sizeType != COAP_OPTION_SIZE2)
1698 OIC_LOG(ERROR, TAG, "unknown option type");
1699 return CA_STATUS_FAILED;
1702 unsigned char value[BLOCKWISE_OPTION_BUFFER] = { 0 };
1703 unsigned int optionLength = coap_encode_var_bytes(value, dataLength);
1705 if (!coap_add_option(pdu, sizeType, optionLength, value))
1707 OIC_LOG(ERROR, TAG, "failed to add size option");
1708 return CA_STATUS_FAILED;
1711 OIC_LOG(DEBUG, TAG, "OUT-CAAddBlockSizeOption");
1713 return CA_STATUS_OK;
1716 bool CAIsPayloadLengthInPduWithBlockSizeOption(coap_pdu_t *pdu,
1718 size_t *totalPayloadLen)
1720 OIC_LOG(DEBUG, TAG, "IN-CAIsPayloadLengthInPduWithBlockSizeOption");
1721 VERIFY_NON_NULL(pdu, TAG, "pdu");
1722 VERIFY_NON_NULL(totalPayloadLen, TAG, "totalPayloadLen");
1724 if (sizeType != COAP_OPTION_SIZE1 && sizeType != COAP_OPTION_SIZE2)
1726 OIC_LOG(ERROR, TAG, "unknown option type");
1727 return CA_STATUS_FAILED;
1730 coap_opt_iterator_t opt_iter;
1731 coap_opt_t *option = coap_check_option(pdu, sizeType, &opt_iter);
1734 OIC_LOG(DEBUG, TAG, "get size option from pdu");
1735 *totalPayloadLen = coap_decode_var_bytes(COAP_OPT_VALUE(option),
1736 COAP_OPT_LENGTH(option));
1738 OIC_LOG_V(DEBUG, TAG, "the total payload length to be received is [%d]bytes",
1744 OIC_LOG(DEBUG, TAG, "OUT-CAIsPayloadLengthInPduWithBlockSizeOption");
1749 uint8_t CACheckBlockErrorType(CABlockData_t *currData, coap_block_t *receivedBlock,
1750 const CAData_t *receivedData, uint16_t blockType,
1753 OIC_LOG(DEBUG, TAG, "IN-CheckBlockError");
1755 VERIFY_NON_NULL(currData, TAG, "currData is NULL");
1756 VERIFY_NON_NULL(receivedBlock, TAG, "receivedBlock is NULL");
1757 VERIFY_NON_NULL(receivedData, TAG, "receivedData is NULL");
1759 // #1. check the received payload length
1760 size_t blockPayloadLen = 0;
1761 CAGetPayloadInfo(receivedData, &blockPayloadLen);
1763 // #2. check if the block sequence is right
1764 if (COAP_OPTION_BLOCK1 == blockType)
1766 size_t prePayloadLen = currData->receivedPayloadLen;
1767 if (prePayloadLen != BLOCK_SIZE(receivedBlock->szx) * receivedBlock->num)
1769 if (receivedBlock->num > currData->block1.num + 1)
1771 // 408 Error handling of block loss
1772 OIC_LOG(ERROR, TAG, "option1: error 4.08");
1773 OIC_LOG(ERROR, TAG, "it didn't order");
1774 return CA_BLOCK_INCOMPLETE;
1776 return CA_BLOCK_RECEIVED_ALREADY;
1779 else if (COAP_OPTION_BLOCK2 == blockType)
1781 if (receivedBlock->num != currData->block2.num)
1783 if (receivedBlock->num > currData->block2.num)
1785 // 408 Error handling of block loss
1786 OIC_LOG(ERROR, TAG, "option2: error 4.08");
1787 OIC_LOG(ERROR, TAG, "it didn't order");
1788 return CA_BLOCK_INCOMPLETE;
1790 return CA_BLOCK_RECEIVED_ALREADY;
1794 // #3. check if error check logic is required
1795 size_t optionLen = dataLen - blockPayloadLen;
1796 if (receivedBlock->m && blockPayloadLen != BLOCK_SIZE(receivedBlock->szx))
1798 // 413 Error handling of too large entity
1799 if (COAP_MAX_PDU_SIZE < BLOCK_SIZE(receivedBlock->szx) + optionLen)
1801 // buffer size is smaller than received block size
1802 OIC_LOG(ERROR, TAG, "error type 4.13");
1803 OIC_LOG(ERROR, TAG, "too large size");
1805 // set the block size to be smaller than COAP_MAX_PDU_SIZE
1806 for (int32_t size = CA_DEFAULT_BLOCK_SIZE; size >= 0; size--)
1808 if (COAP_MAX_PDU_SIZE >= BLOCK_SIZE(size) + optionLen)
1810 OIC_LOG_V(ERROR, TAG, "replace sze with %d", size);
1811 if (COAP_OPTION_BLOCK2 == blockType)
1813 currData->block2.szx = size;
1817 currData->block1.szx = size;
1822 return CA_BLOCK_TOO_LARGE;
1826 // 408 Error handling of payload loss
1827 OIC_LOG(ERROR, TAG, "error type 4.08");
1828 OIC_LOG(ERROR, TAG, "payload len != block sze");
1829 return CA_BLOCK_INCOMPLETE;
1832 else if (0 == receivedBlock->m && 0 != currData->payloadLength)
1834 // if the received block is last block, check the total payload length
1835 size_t receivedPayloadLen = currData->receivedPayloadLen;
1836 receivedPayloadLen += blockPayloadLen;
1838 if (receivedPayloadLen != currData->payloadLength)
1840 OIC_LOG(ERROR, TAG, "error type 4.08");
1841 OIC_LOG(ERROR, TAG, "total payload length is wrong");
1842 return CA_BLOCK_INCOMPLETE;
1846 OIC_LOG(DEBUG, TAG, "received all data normally");
1848 OIC_LOG(DEBUG, TAG, "OUT-CheckBlockError");
1850 return CA_BLOCK_UNKNOWN;
1853 CAResult_t CAUpdatePayloadData(CABlockData_t *currData, const CAData_t *receivedData,
1854 uint8_t status, bool isSizeOption, uint16_t blockType)
1856 OIC_LOG(DEBUG, TAG, "IN-UpdatePayloadData");
1858 VERIFY_NON_NULL(currData, TAG, "currData");
1859 VERIFY_NON_NULL(receivedData, TAG, "receivedData");
1861 // if error code is 4.08, do not update payload
1862 if (CA_BLOCK_INCOMPLETE == status)
1864 OIC_LOG(ERROR, TAG, "no require to update");
1865 return CA_STATUS_OK;
1868 size_t blockPayloadLen = 0;
1869 CAPayload_t blockPayload = CAGetPayloadInfo(receivedData, &blockPayloadLen);
1871 if (CA_BLOCK_TOO_LARGE == status)
1873 blockPayloadLen = (COAP_OPTION_BLOCK2 == blockType) ?
1874 BLOCK_SIZE(currData->block2.szx) : BLOCK_SIZE(currData->block1.szx);
1877 // memory allocation for the received block payload
1878 size_t prePayloadLen = currData->receivedPayloadLen;
1879 if (NULL != blockPayload)
1881 if (0 != currData->payloadLength)
1883 // in case the block message has the size option
1884 // allocate the memory for the total payload
1885 if (true == isSizeOption)
1887 CAPayload_t prePayload = currData->payload;
1889 OIC_LOG(DEBUG, TAG, "allocate memory for the total payload");
1890 currData->payload = (CAPayload_t) OICCalloc(currData->payloadLength + 1,
1892 if (NULL == currData->payload)
1894 OIC_LOG(ERROR, TAG, "out of memory");
1895 return CA_MEMORY_ALLOC_FAILED;
1897 memcpy(currData->payload, prePayload, prePayloadLen);
1898 OICFree(prePayload);
1901 // update the total payload
1902 memcpy(currData->payload + prePayloadLen, blockPayload, blockPayloadLen);
1906 OIC_LOG(DEBUG, TAG, "allocate memory for the received block payload");
1908 size_t totalPayloadLen = prePayloadLen + blockPayloadLen + 1;
1909 void *newPayload = realloc(currData->payload, totalPayloadLen);
1910 if (NULL == newPayload)
1912 OIC_LOG(ERROR, TAG, "out of memory");
1913 return CA_MEMORY_ALLOC_FAILED;
1916 // update the total payload
1917 memset(newPayload + prePayloadLen, 0, blockPayloadLen + 1);
1918 currData->payload = newPayload;
1919 memcpy(currData->payload + prePayloadLen, blockPayload, blockPayloadLen);
1922 // update received payload length
1923 currData->receivedPayloadLen += blockPayloadLen;
1925 OIC_LOG_V(DEBUG, TAG, "updated payload: %s, len: %d", currData->payload,
1926 currData->receivedPayloadLen);
1929 OIC_LOG(DEBUG, TAG, "OUT-UpdatePayloadData");
1930 return CA_STATUS_OK;
1933 CAData_t* CACreateNewDataSet(const coap_pdu_t *pdu, const CAEndpoint_t *endpoint)
1935 VERIFY_NON_NULL_RET(pdu, TAG, "pdu", NULL);
1936 VERIFY_NON_NULL_RET(pdu->hdr, TAG, "pdu->hdr", NULL);
1937 VERIFY_NON_NULL_RET(endpoint, TAG, "endpoint", NULL);
1939 CAInfo_t responseData = { 0 };
1940 responseData.token = (CAToken_t) OICMalloc(pdu->hdr->token_length);
1941 if (NULL == responseData.token)
1943 OIC_LOG(ERROR, TAG, "out of memory");
1946 memcpy(responseData.token, pdu->hdr->token, pdu->hdr->token_length);
1947 responseData.tokenLength = pdu->hdr->token_length;
1948 CAResponseInfo_t* responseInfo = (CAResponseInfo_t*) OICCalloc(1, sizeof(CAResponseInfo_t));
1949 if (NULL == responseInfo)
1951 OIC_LOG(ERROR, TAG, "out of memory");
1952 OICFree(responseData.token);
1955 responseInfo->info = responseData;
1957 CAData_t *data = (CAData_t *) OICCalloc(1, sizeof(CAData_t));
1960 OIC_LOG(ERROR, TAG, "out of memory");
1961 OICFree(responseInfo);
1965 data->requestInfo = NULL;
1966 data->responseInfo = responseInfo;
1967 data->remoteEndpoint = CACloneEndpoint(endpoint);
1968 data->type = SEND_TYPE_UNICAST;
1973 CAData_t *CACloneCAData(const CAData_t *data)
1975 VERIFY_NON_NULL_RET(data, TAG, "data", NULL);
1977 CAData_t *clone = (CAData_t *) OICCalloc(1, sizeof(CAData_t));
1980 OIC_LOG(ERROR, TAG, "out of memory");
1985 if (data->requestInfo)
1987 clone->requestInfo = CACloneRequestInfo(data->requestInfo);
1990 if (data->responseInfo)
1992 clone->responseInfo = CACloneResponseInfo(data->responseInfo);
1995 if (data->remoteEndpoint)
1997 clone->remoteEndpoint = CACloneEndpoint(data->remoteEndpoint);
2000 if (NULL != data->options && 0 < data->numOptions)
2003 CAHeaderOption_t *headerOption = (CAHeaderOption_t *) OICMalloc(sizeof(CAHeaderOption_t)
2004 * data->numOptions);
2005 if (NULL == headerOption)
2007 OIC_LOG(ERROR, TAG, "Out of memory");
2008 CADestroyDataSet(clone);
2011 memcpy(headerOption, data->options, sizeof(CAHeaderOption_t) * data->numOptions);
2013 clone->options = headerOption;
2019 CAResult_t CAUpdatePayloadToCAData(CAData_t *data, const CAPayload_t payload,
2022 OIC_LOG(DEBUG, TAG, "IN-UpdatePayload");
2024 VERIFY_NON_NULL(data, TAG, "data is NULL");
2025 VERIFY_NON_NULL(payload, TAG, "payload is NULL");
2027 if (NULL != data->requestInfo)
2029 // allocate payload field
2030 if (NULL != data->requestInfo->info.payload)
2032 char *temp = (char *) OICCalloc(payloadLen, sizeof(char));
2035 OIC_LOG(ERROR, TAG, "out of memory");
2036 return CA_STATUS_FAILED;
2038 memcpy(temp, payload, payloadLen);
2040 // save the full payload
2041 OICFree(data->requestInfo->info.payload);
2042 data->requestInfo->info.payload = (CAPayload_t) temp;
2044 data->requestInfo->info.payloadSize = payloadLen;
2047 if (NULL != data->responseInfo)
2049 // allocate payload field
2050 if (NULL != data->responseInfo->info.payload)
2052 char *temp = (char *) OICCalloc(payloadLen, sizeof(char));
2055 OIC_LOG(ERROR, TAG, "out of memory");
2056 return CA_STATUS_FAILED;
2058 memcpy(temp, payload, payloadLen);
2060 // save the full payload
2061 OICFree(data->responseInfo->info.payload);
2062 data->responseInfo->info.payload = (CAPayload_t) temp;
2064 data->responseInfo->info.payloadSize = payloadLen;
2067 OIC_LOG(DEBUG, TAG, "OUT-UpdatePayload");
2069 return CA_STATUS_OK;
2072 CAPayload_t CAGetPayloadInfo(const CAData_t *data, size_t *payloadLen)
2074 VERIFY_NON_NULL_RET(data, TAG, "data", NULL);
2075 VERIFY_NON_NULL_RET(payloadLen, TAG, "payloadLen", NULL);
2077 if (NULL != data->requestInfo)
2079 if (NULL != data->requestInfo->info.payload)
2081 *payloadLen = data->requestInfo->info.payloadSize;
2082 return data->requestInfo->info.payload;
2087 if (NULL != data->responseInfo->info.payload)
2089 *payloadLen = data->responseInfo->info.payloadSize;
2090 return data->responseInfo->info.payload;
2097 CAResult_t CAHandleBlockErrorResponse(coap_block_t *block, uint16_t blockType,
2098 uint32_t responseResult)
2100 OIC_LOG(DEBUG, TAG, "IN-HandleBlockErrorRes");
2101 VERIFY_NON_NULL(block, TAG, "block is NULL");
2103 // update block data
2104 switch (responseResult)
2106 case CA_REQUEST_ENTITY_INCOMPLETE:
2109 case CA_REQUEST_ENTITY_TOO_LARGE:
2110 if (COAP_OPTION_BLOCK1 == blockType)
2117 OIC_LOG_V(ERROR, TAG, "there is no Error Code of BWT[%d]", responseResult);
2120 OIC_LOG(DEBUG, TAG, "OUT-HandleBlockErrorRes");
2121 return CA_STATUS_OK;
2124 CAResult_t CAUpdateBlockOptionType(const CABlockDataID_t *blockID,
2127 OIC_LOG(DEBUG, TAG, "IN-UpdateBlockOptionType");
2128 VERIFY_NON_NULL(blockID, TAG, "blockID");
2130 ca_mutex_lock(g_context.blockDataListMutex);
2132 size_t len = u_arraylist_length(g_context.dataList);
2133 for (size_t i = 0; i < len; i++)
2135 CABlockData_t *currData = (CABlockData_t *) u_arraylist_get(g_context.dataList, i);
2136 if (CABlockidMatches(currData, blockID))
2138 currData->type = blockType;
2139 ca_mutex_unlock(g_context.blockDataListMutex);
2140 OIC_LOG(DEBUG, TAG, "OUT-UpdateBlockOptionType");
2141 return CA_STATUS_OK;
2144 ca_mutex_unlock(g_context.blockDataListMutex);
2146 OIC_LOG(DEBUG, TAG, "OUT-UpdateBlockOptionType");
2147 return CA_STATUS_FAILED;
2150 uint8_t CAGetBlockOptionType(const CABlockDataID_t *blockID)
2152 OIC_LOG(DEBUG, TAG, "IN-GetBlockOptionType");
2153 VERIFY_NON_NULL_RET(blockID, TAG, "blockID", 0);
2155 ca_mutex_lock(g_context.blockDataListMutex);
2157 size_t len = u_arraylist_length(g_context.dataList);
2158 for (size_t i = 0; i < len; i++)
2160 CABlockData_t *currData = (CABlockData_t *) u_arraylist_get(g_context.dataList, i);
2161 if (CABlockidMatches(currData, blockID))
2163 ca_mutex_unlock(g_context.blockDataListMutex);
2164 OIC_LOG(DEBUG, TAG, "OUT-GetBlockOptionType");
2165 return currData->type;
2168 ca_mutex_unlock(g_context.blockDataListMutex);
2170 OIC_LOG(DEBUG, TAG, "OUT-GetBlockOptionType");
2174 CAData_t *CAGetDataSetFromBlockDataList(const CABlockDataID_t *blockID)
2176 VERIFY_NON_NULL_RET(blockID, TAG, "blockID", NULL);
2178 ca_mutex_lock(g_context.blockDataListMutex);
2180 size_t len = u_arraylist_length(g_context.dataList);
2181 for (size_t i = 0; i < len; i++)
2183 CABlockData_t *currData = (CABlockData_t *) u_arraylist_get(g_context.dataList, i);
2184 if (CABlockidMatches(currData, blockID))
2186 ca_mutex_unlock(g_context.blockDataListMutex);
2187 return currData->sentData;
2190 ca_mutex_unlock(g_context.blockDataListMutex);
2195 CAResult_t CAGetTokenFromBlockDataList(const coap_pdu_t *pdu, const CAEndpoint_t *endpoint,
2196 CAResponseInfo_t *responseInfo)
2198 OIC_LOG(DEBUG, TAG, "IN-CAGetTokenFromBlockDataList");
2199 VERIFY_NON_NULL(pdu, TAG, "pdu");
2200 VERIFY_NON_NULL(endpoint, TAG, "endpoint");
2201 VERIFY_NON_NULL(responseInfo, TAG, "responseInfo");
2203 ca_mutex_lock(g_context.blockDataListMutex);
2205 size_t len = u_arraylist_length(g_context.dataList);
2206 for (size_t i = 0; i < len; i++)
2208 CABlockData_t *currData = (CABlockData_t *) u_arraylist_get(g_context.dataList, i);
2209 if (NULL == currData)
2214 if (NULL != currData->sentData && NULL != currData->sentData->requestInfo)
2216 if (pdu->hdr->id == currData->sentData->requestInfo->info.messageId &&
2217 endpoint->adapter == currData->sentData->remoteEndpoint->adapter)
2219 if (NULL != currData->sentData->requestInfo->info.token)
2221 uint8_t length = currData->sentData->requestInfo->info.tokenLength;
2222 responseInfo->info.tokenLength = length;
2223 responseInfo->info.token = (char *) OICMalloc(length);
2224 if (NULL == responseInfo->info.token)
2226 OIC_LOG(ERROR, TAG, "out of memory");
2227 ca_mutex_unlock(g_context.blockDataListMutex);
2228 return CA_MEMORY_ALLOC_FAILED;
2230 memcpy(responseInfo->info.token, currData->sentData->requestInfo->info.token,
2231 responseInfo->info.tokenLength);
2233 ca_mutex_unlock(g_context.blockDataListMutex);
2234 OIC_LOG(DEBUG, TAG, "OUT-CAGetTokenFromBlockDataList");
2235 return CA_STATUS_OK;
2241 ca_mutex_unlock(g_context.blockDataListMutex);
2243 OIC_LOG(DEBUG, TAG, "OUT-CAGetTokenFromBlockDataList");
2244 return CA_STATUS_OK;
2247 CAResult_t CACheckBlockDataValidation(const CAData_t *sendData, CABlockData_t **blockData)
2249 VERIFY_NON_NULL(sendData, TAG, "sendData");
2250 VERIFY_NON_NULL(blockData, TAG, "blockData");
2252 ca_mutex_lock(g_context.blockDataListMutex);
2254 size_t len = u_arraylist_length(g_context.dataList);
2255 for (size_t i = 0; i < len; i++)
2257 CABlockData_t *currData = (CABlockData_t *) u_arraylist_get(g_context.dataList, i);
2259 if (NULL == currData)
2264 if (NULL != sendData->requestInfo) // sendData is requestMessage
2266 OIC_LOG(DEBUG, TAG, "Send request");
2267 if (NULL != currData->blockDataId
2268 && NULL != currData->blockDataId->id
2269 && currData->blockDataId->idLength > 0
2270 && NULL != sendData->requestInfo->info.token)
2272 CABlockDataID_t* blockDataID = CACreateBlockDatablockId(
2273 (CAToken_t)sendData->requestInfo->info.token,
2274 sendData->requestInfo->info.tokenLength,
2275 sendData->remoteEndpoint->port);
2277 if(NULL == blockDataID || NULL == blockDataID->id || blockDataID->idLength < 1)
2279 OIC_LOG(ERROR, TAG, "blockId is null");
2280 CADestroyBlockID(blockDataID);
2281 return CA_STATUS_FAILED;
2284 if (CABlockidMatches(currData, blockDataID))
2286 OIC_LOG(ERROR, TAG, "already sent");
2287 CADestroyBlockID(blockDataID);
2290 CADestroyBlockID(blockDataID);
2293 else if (NULL != sendData->responseInfo) // sendData is responseMessage
2295 OIC_LOG(DEBUG, TAG, "Send response");
2296 if (NULL != currData->blockDataId
2297 && NULL != currData->blockDataId->id
2298 && currData->blockDataId->idLength > 0
2299 && NULL != sendData->responseInfo->info.token)
2301 CABlockDataID_t* blockDataID = CACreateBlockDatablockId(
2302 (CAToken_t)sendData->responseInfo->info.token,
2303 sendData->responseInfo->info.tokenLength,
2304 sendData->remoteEndpoint->port);
2306 if(NULL == blockDataID || NULL == blockDataID->id || blockDataID->idLength < 1)
2308 OIC_LOG(ERROR, TAG, "blockId is null");
2309 CADestroyBlockID(blockDataID);
2310 return CA_STATUS_FAILED;
2313 if (CABlockidMatches(currData, blockDataID))
2316 if (NULL != currData->sentData)
2318 OIC_LOG(DEBUG, TAG, "init block number");
2319 CADestroyDataSet(currData->sentData);
2321 currData->sentData = CACloneCAData(sendData);
2322 *blockData = currData;
2323 CADestroyBlockID(blockDataID);
2324 ca_mutex_unlock(g_context.blockDataListMutex);
2325 return CA_STATUS_OK;
2327 CADestroyBlockID(blockDataID);
2332 OIC_LOG(ERROR, TAG, "no CAInfo data");
2336 ca_mutex_unlock(g_context.blockDataListMutex);
2338 return CA_STATUS_FAILED;
2341 CABlockData_t *CAGetBlockDataFromBlockDataList(const CABlockDataID_t *blockID)
2343 VERIFY_NON_NULL_RET(blockID, TAG, "blockID", NULL);
2345 ca_mutex_lock(g_context.blockDataListMutex);
2347 size_t len = u_arraylist_length(g_context.dataList);
2348 for (size_t i = 0; i < len; i++)
2350 CABlockData_t *currData = (CABlockData_t *) u_arraylist_get(g_context.dataList, i);
2351 if (CABlockidMatches(currData, blockID))
2353 ca_mutex_unlock(g_context.blockDataListMutex);
2357 ca_mutex_unlock(g_context.blockDataListMutex);
2362 coap_block_t *CAGetBlockOption(const CABlockDataID_t *blockID,
2365 OIC_LOG(DEBUG, TAG, "IN-GetBlockOption");
2366 VERIFY_NON_NULL_RET(blockID, TAG, "blockID", NULL);
2368 ca_mutex_lock(g_context.blockDataListMutex);
2370 size_t len = u_arraylist_length(g_context.dataList);
2371 for (size_t i = 0; i < len; i++)
2373 CABlockData_t *currData = (CABlockData_t *) u_arraylist_get(g_context.dataList, i);
2374 if (CABlockidMatches(currData, blockID))
2376 ca_mutex_unlock(g_context.blockDataListMutex);
2377 OIC_LOG(DEBUG, TAG, "OUT-GetBlockOption");
2378 if (COAP_OPTION_BLOCK2 == blockType)
2380 return &currData->block2;
2384 return &currData->block1;
2388 ca_mutex_unlock(g_context.blockDataListMutex);
2390 OIC_LOG(DEBUG, TAG, "OUT-GetBlockOption");
2394 CAPayload_t CAGetPayloadFromBlockDataList(const CABlockDataID_t *blockID,
2395 size_t *fullPayloadLen)
2397 OIC_LOG(DEBUG, TAG, "IN-GetFullPayload");
2398 VERIFY_NON_NULL_RET(blockID, TAG, "blockID", NULL);
2399 VERIFY_NON_NULL_RET(fullPayloadLen, TAG, "fullPayloadLen", NULL);
2401 ca_mutex_lock(g_context.blockDataListMutex);
2403 size_t len = u_arraylist_length(g_context.dataList);
2404 for (size_t i = 0; i < len; i++)
2406 CABlockData_t *currData = (CABlockData_t *) u_arraylist_get(g_context.dataList, i);
2407 if (CABlockidMatches(currData, blockID))
2409 ca_mutex_unlock(g_context.blockDataListMutex);
2410 *fullPayloadLen = currData->receivedPayloadLen;
2411 OIC_LOG(DEBUG, TAG, "OUT-GetFullPayload");
2412 return currData->payload;
2415 ca_mutex_unlock(g_context.blockDataListMutex);
2417 OIC_LOG(DEBUG, TAG, "OUT-GetFullPayload");
2421 CABlockData_t *CACreateNewBlockData(const CAData_t *sendData)
2423 OIC_LOG(DEBUG, TAG, "IN-CACreateNewBlockData");
2424 VERIFY_NON_NULL_RET(sendData, TAG, "sendData", NULL);
2426 // create block data
2427 CABlockData_t *data = (CABlockData_t *) OICCalloc(1, sizeof(CABlockData_t));
2430 OIC_LOG(ERROR, TAG, "memory alloc has failed");
2434 data->block1.szx = CA_DEFAULT_BLOCK_SIZE;
2435 data->block2.szx = CA_DEFAULT_BLOCK_SIZE;
2436 data->sentData = CACloneCAData(sendData);
2439 OIC_LOG(ERROR, TAG, PCF("memory alloc has failed"));
2444 CAToken_t token = NULL;
2445 uint8_t tokenLength = 0;
2446 if (data->sentData->requestInfo)
2448 // update token info
2449 tokenLength = data->sentData->requestInfo->info.tokenLength;
2450 token = data->sentData->requestInfo->info.token;
2452 else if(data->sentData->responseInfo)
2454 tokenLength = data->sentData->responseInfo->info.tokenLength;
2455 token = data->sentData->responseInfo->info.token;
2458 CABlockDataID_t* blockDataID = CACreateBlockDatablockId(
2460 data->sentData->remoteEndpoint->port);
2461 if (NULL == blockDataID && NULL == blockDataID->id && blockDataID->idLength < 0)
2463 OIC_LOG(ERROR, TAG, "blockId is null");
2464 CADestroyBlockID(blockDataID);
2467 data->blockDataId = blockDataID;
2469 ca_mutex_lock(g_context.blockDataListMutex);
2471 CAResult_t res = u_arraylist_add(g_context.dataList, (void *) data);
2472 if (CA_STATUS_OK != res)
2474 OIC_LOG(ERROR, TAG, "add has failed");
2475 CADestroyBlockID(data->blockDataId);
2477 ca_mutex_unlock(g_context.blockDataListMutex);
2480 ca_mutex_unlock(g_context.blockDataListMutex);
2482 OIC_LOG(DEBUG, TAG, "OUT-CreateBlockData");
2486 CAResult_t CARemoveBlockDataFromList(const CABlockDataID_t *blockID)
2488 OIC_LOG(DEBUG, TAG, "CARemoveBlockData");
2489 VERIFY_NON_NULL(blockID, TAG, "blockID");
2491 ca_mutex_lock(g_context.blockDataListMutex);
2493 size_t len = u_arraylist_length(g_context.dataList);
2494 for (size_t i = 0; i < len; i++)
2496 CABlockData_t *currData = (CABlockData_t *) u_arraylist_get(g_context.dataList, i);
2497 if (CABlockidMatches(currData, blockID))
2499 CABlockData_t *removedData = u_arraylist_remove(g_context.dataList, i);
2500 if (NULL == removedData)
2502 OIC_LOG(ERROR, TAG, "data is NULL");
2503 ca_mutex_unlock(g_context.blockDataListMutex);
2504 return CA_STATUS_FAILED;
2508 if (currData->sentData)
2510 CADestroyDataSet(currData->sentData);
2512 OICFree(currData->payload);
2513 CADestroyBlockID(currData->blockDataId);
2514 ca_mutex_unlock(g_context.blockDataListMutex);
2515 return CA_STATUS_OK;
2518 ca_mutex_unlock(g_context.blockDataListMutex);
2520 return CA_STATUS_OK;
2523 bool CAIsBlockDataInList(const CABlockDataID_t *blockID)
2525 OIC_LOG(DEBUG, TAG, "IN-IsBlockDataInList");
2526 VERIFY_NON_NULL_RET(blockID, TAG, "blockID", false);
2528 ca_mutex_lock(g_context.blockDataListMutex);
2530 size_t len = u_arraylist_length(g_context.dataList);
2531 for (size_t i = 0; i < len; i++)
2533 CABlockData_t *currData = (CABlockData_t *) u_arraylist_get(g_context.dataList, i);
2534 if (CABlockidMatches(currData, blockID))
2536 OIC_LOG(DEBUG, TAG, "found block data");
2537 ca_mutex_unlock(g_context.blockDataListMutex);
2541 ca_mutex_unlock(g_context.blockDataListMutex);
2543 OIC_LOG(DEBUG, TAG, "OUT-IsBlockDataInList");
2547 void CADestroyDataSet(CAData_t* data)
2549 VERIFY_NON_NULL_VOID(data, TAG, "data");
2551 CAFreeEndpoint(data->remoteEndpoint);
2552 CADestroyRequestInfoInternal(data->requestInfo);
2553 CADestroyResponseInfoInternal(data->responseInfo);
2554 OICFree(data->options);
2558 CABlockDataID_t* CACreateBlockDatablockId(const CAToken_t token, uint8_t tokenLength,
2559 uint16_t portNumber)
2561 VERIFY_NON_NULL_RET(token, TAG, "token", NULL);
2563 char port[PORT_LENGTH] = {0,};
2564 port[0] = (char)((portNumber>>8) & 0xFF);
2565 port[1] = (char)(portNumber & 0xFF);
2567 CABlockDataID_t* blockDataID = (CABlockDataID_t *) OICMalloc(sizeof(CABlockDataID_t));
2568 blockDataID->idLength = tokenLength + sizeof(port);
2569 blockDataID->id = (uint8_t *) OICMalloc(blockDataID->idLength);
2570 if (!blockDataID->id)
2572 OIC_LOG(ERROR, TAG, "memory alloc has failed");
2573 OICFree(blockDataID);
2577 memcpy(blockDataID->id, token, tokenLength);
2578 memcpy(blockDataID->id + tokenLength, port, sizeof(port));
2580 OIC_LOG(DEBUG, TAG, "BlockID is ");
2581 OIC_LOG_BUFFER(DEBUG, TAG, (const uint8_t *)blockDataID->id, blockDataID->idLength);
2586 void CADestroyBlockID(CABlockDataID_t *blockID)
2588 VERIFY_NON_NULL_VOID(blockID, TAG, "blockID");
2589 OICFree(blockID->id);
2594 bool CABlockidMatches(const CABlockData_t *currData, const CABlockDataID_t *blockID)
2596 VERIFY_NON_NULL_RET(currData, TAG, "currData", false);
2597 VERIFY_NON_NULL_RET(blockID, TAG, "blockID", false);
2598 VERIFY_NON_NULL_RET(blockID->id, TAG, "blockID->id", false);
2600 if ((currData->blockDataId)
2601 && (currData->blockDataId->id)
2602 && (currData->blockDataId->idLength == blockID->idLength)
2603 && !memcmp(currData->blockDataId->id, blockID->id, currData->blockDataId->idLength))
2610 void CALogBlockInfo(coap_block_t *block)
2612 VERIFY_NON_NULL_VOID(block, TAG, "block");
2614 OIC_LOG(DEBUG, TAG, "block option info");
2616 OIC_LOG_V(DEBUG, TAG, "block option-num : %d", block->num);
2618 OIC_LOG_V(DEBUG, TAG, "block option-m : %d", block->m);
2620 OIC_LOG_V(DEBUG, TAG, "block option-szx : %d", block->szx);