replace : iotivity -> iotivity-sec

[platform/upstream/iotivity.git] / resource / csdk / connectivity / src / adapter_util / cafragmentation.c

diff --git a/resource/csdk/connectivity/src/adapter_util/cafragmentation.c b/resource/csdk/connectivity/src/adapter_util/cafragmentation.c
index 64af936..67bd00b 100644 (file)
--- a/resource/csdk/connectivity/src/adapter_util/cafragmentation.c
+++ b/resource/csdk/connectivity/src/adapter_util/cafragmentation.c
@@ -24,6 +24,7 @@
 #include "cacommon.h"
 #include "caadapterutils.h"
 #include "cafragmentation.h"
+#include "caleinterface.h"
 
 /**
  * Debugging tag for fragmentation module.
@@ -56,12 +57,12 @@ static void CASetBits(uint8_t *x, unsigned p, unsigned n, unsigned v)
         OIC_LOG(ERROR, TAG, "set bits - lower err");
         return;
     }
-    else if(~(unsigned)(~0<<n) < v)
+    else if(~(unsigned)(~0u<<n) < v)
     {
         OIC_LOG(ERROR, TAG, "set bits - upper err");
         return;
     }
-    *x = (*x & (~(~0 << (p-n+1)))) | (*x & (~0 << (p+1))) | ((v & ~(~0 << n)) << (p-n+1));
+    *x = (*x & (~(~0u << (p-n+1)))) | (*x & (~0u << (p+1))) | ((v & ~(~0u << n)) << (p-n+1));
 }
 
 /**
@@ -76,19 +77,20 @@ static void CASetBits(uint8_t *x, unsigned p, unsigned n, unsigned v)
  */
 static uint8_t CAGetBits(uint8_t x, unsigned p, unsigned n)
 {
-    return (x >> (p + 1 - n)) & ~(~0 << n);
+    return (x >> (p + 1 - n)) & ~(~0u << n);
 }
 
 CAResult_t CAGenerateVariableForFragmentation(size_t dataLength,
                                               uint32_t *midPacketCount,
                                               size_t *remainingLen,
-                                              size_t *totalLength)
+                                              size_t *totalLength,
+                                              uint16_t mtuSize)
 {
-    OIC_LOG_V(DEBUG, TAG, "IN, dataLength = %d", dataLength);
+    OIC_LOG_V(DEBUG, TAG, "IN, dataLength = %zu, mtu = %zu", dataLength, mtuSize);
 
     size_t remainDataSize = 0;
     size_t dataOnlyLen =
-        CA_SUPPORTED_BLE_MTU_SIZE - (CA_BLE_HEADER_SIZE + CA_BLE_LENGTH_HEADER_SIZE);
+            mtuSize - (CA_BLE_HEADER_SIZE + CA_BLE_LENGTH_HEADER_SIZE);
     //total data size is smaller than 14 byte case.
     if (dataLength < dataOnlyLen)
     {
@@ -99,14 +101,14 @@ CAResult_t CAGenerateVariableForFragmentation(size_t dataLength,
         remainDataSize = dataLength - dataOnlyLen;
     }
 
-    if (CA_SUPPORTED_BLE_MTU_SIZE - CA_BLE_HEADER_SIZE <= 0)
+    if (mtuSize - CA_BLE_HEADER_SIZE <= 0)
     {
         OIC_LOG_V(ERROR, TAG, "BLE header size shouldn't be bigger than BLE MTU size.");
         return CA_STATUS_FAILED;
     }
 
-    *midPacketCount = (uint32_t)remainDataSize / (CA_SUPPORTED_BLE_MTU_SIZE - CA_BLE_HEADER_SIZE);
-    *remainingLen = (uint32_t)remainDataSize % (CA_SUPPORTED_BLE_MTU_SIZE - CA_BLE_HEADER_SIZE);
+    *midPacketCount = (uint32_t)remainDataSize / (mtuSize - CA_BLE_HEADER_SIZE);
+    *remainingLen = (uint32_t)remainDataSize % (mtuSize - CA_BLE_HEADER_SIZE);
     uint32_t remainHeaderSize = CA_BLE_HEADER_SIZE * (*midPacketCount + (*remainingLen == 0 ? 0:1));
     *totalLength = dataLength + (CA_BLE_HEADER_SIZE + CA_BLE_LENGTH_HEADER_SIZE) + remainHeaderSize;
 
@@ -121,14 +123,11 @@ CAResult_t CAGenerateHeader(uint8_t *header,
                             CABLEPacketSecure_t secure,
                             const uint8_t destPort)
 {
-    OIC_LOG(DEBUG, TAG, "IN");
-
     VERIFY_NON_NULL(header, TAG, "header is NULL");
 
     if (sourcePort > CA_SUPPORTED_BLE_MAX_PORT ||
         sourcePort < CA_SUPPORTED_BLE_MIN_PORT ||
-        destPort > CA_SUPPORTED_BLE_MAX_PORT ||
-        destPort < CA_BLE_MULTICAST_PORT)
+        destPort > CA_SUPPORTED_BLE_MAX_PORT)
     {
         OIC_LOG_V(ERROR, TAG, "source port(%d) or destination port(%d) is invalid number!!",
                 sourcePort, destPort);
@@ -170,8 +169,6 @@ CAResult_t CAMakeFirstDataSegment(uint8_t *dataSegment,
                                   const uint8_t *dataHeader,
                                   const uint8_t *lengthHeader)
 {
-    OIC_LOG(DEBUG, TAG, "IN");
-
     VERIFY_NON_NULL(dataSegment, TAG, "dataSegment is NULL");
     VERIFY_NON_NULL(dataHeader, TAG, "dataHeader is NULL");
     VERIFY_NON_NULL(lengthHeader, TAG, "lengthHeader is NULL");
@@ -179,37 +176,30 @@ CAResult_t CAMakeFirstDataSegment(uint8_t *dataSegment,
     memcpy(dataSegment, dataHeader, CA_BLE_HEADER_SIZE);
     memcpy(dataSegment + CA_BLE_HEADER_SIZE, lengthHeader, CA_BLE_LENGTH_HEADER_SIZE);
     memcpy(dataSegment + CA_BLE_HEADER_SIZE + CA_BLE_LENGTH_HEADER_SIZE, data, dataLength);
-
-    OIC_LOG(DEBUG, TAG, "OUT");
-
     return CA_STATUS_OK;
 }
 
 CAResult_t CAMakeRemainDataSegment(uint8_t *dataSegment,
-                                   const uint8_t *data,
-                                   const uint32_t dataLength,
-                                   const uint32_t index,
-                                   const uint8_t *dataHeader)
+                                   const uint32_t segmentPayloadLength,
+                                   const uint8_t *sourceData,
+                                   const uint32_t sourceDataLength,
+                                   const uint32_t segmentNum,
+                                   const uint8_t *dataHeader,
+                                   uint16_t mtuSize)
 {
-    OIC_LOG(DEBUG, TAG, "IN");
-
     VERIFY_NON_NULL(dataSegment, TAG, "dataSegment is NULL");
     VERIFY_NON_NULL(dataHeader, TAG, "dataHeader is NULL");
 
-    uint8_t *cur_pos = data +
-        (CA_SUPPORTED_BLE_MTU_SIZE - CA_BLE_HEADER_SIZE - CA_BLE_LENGTH_HEADER_SIZE +
-         (index * (CA_SUPPORTED_BLE_MTU_SIZE - CA_BLE_HEADER_SIZE)));
-    if (cur_pos == NULL)
+    uint32_t index = (mtuSize - CA_BLE_HEADER_SIZE - CA_BLE_LENGTH_HEADER_SIZE) +
+            (segmentNum * (mtuSize - CA_BLE_HEADER_SIZE));
+    if (sourceDataLength < index + segmentPayloadLength)
     {
-        OIC_LOG(ERROR, TAG, "data is NULL");
+        OIC_LOG(DEBUG, TAG, "dataSegment will exceed");
         return CA_STATUS_FAILED;
     }
 
     memcpy(dataSegment, dataHeader, CA_BLE_HEADER_SIZE);
-    memcpy(dataSegment + CA_BLE_HEADER_SIZE, cur_pos, dataLength);
-
-    OIC_LOG(DEBUG, TAG, "OUT");
-
+    memcpy(dataSegment + CA_BLE_HEADER_SIZE, sourceData + index, segmentPayloadLength);
     return CA_STATUS_OK;
 }
 
@@ -219,8 +209,6 @@ CAResult_t CAParseHeader(const uint8_t *header,
                          CABLEPacketSecure_t *secureFlag,
                          uint16_t *destPort)
 {
-    OIC_LOG(DEBUG, TAG, "IN");
-
     VERIFY_NON_NULL(header, TAG, "header is NULL");
 
     *startFlag = CAGetBits(header[0], CA_BLE_START_POS, CA_BLE_START_LEN);
@@ -228,8 +216,6 @@ CAResult_t CAParseHeader(const uint8_t *header,
     *secureFlag = CAGetBits(header[1], CA_BLE_SECURE_POS, CA_BLE_SECURE_LEN);
     *destPort = CAGetBits(header[1], CA_BLE_DESTINATION_PORT_POS, CA_BLE_DESTINATION_PORT_LEN);
 
-    OIC_LOG(DEBUG, TAG, "OUT");
-
     return CA_STATUS_OK;
 }
 
@@ -237,7 +223,6 @@ CAResult_t CAParseHeaderPayloadLength(uint8_t *header,
                                       size_t headerLength,
                                       uint32_t *dataLength)
 {
-    OIC_LOG(DEBUG, TAG, "IN");
     VERIFY_NON_NULL(header, TAG, "header is NULL");
 
     if (headerLength != CA_BLE_LENGTH_HEADER_SIZE)
@@ -251,6 +236,5 @@ CAResult_t CAParseHeaderPayloadLength(uint8_t *header,
         *dataLength |= header[CA_BLE_HEADER_SIZE+idx];
     }
 
-    OIC_LOG(DEBUG, TAG, "OUT");
     return CA_STATUS_OK;
 }