*
* @return ::CA_STATUS_OK or ERROR CODES (::CAResult_t error codes in cacommon.h).
*/
-CAResult_t CAGetEDRInterfaceInformation(CAEndpoint_t **info, uint32_t *size);
+CAResult_t CAGetEDRInterfaceInformation(CAEndpoint_t **info, size_t *size);
/**
* Read Synchronous API callback.
* @retval #CA_STATUS_FAILED Operation failed
* @remarks info is allocated in this API and should be freed by the caller.
*/
-CAResult_t CAGetEDRInterfaceInformation(CAEndpoint_t **info, uint32_t *size);
+CAResult_t CAGetEDRInterfaceInformation(CAEndpoint_t **info, size_t *size);
/**
* @brief Read Synchronous API callback.
* @param[out] size Number of local connectivity structures.
* @return ::CA_STATUS_OK or Appropriate error code.
*/
-CAResult_t CAGetIPInterfaceInformation(CAEndpoint_t **info, uint32_t *size);
+CAResult_t CAGetIPInterfaceInformation(CAEndpoint_t **info, size_t *size);
/**
* Read Synchronous API callback.
*/
typedef void (*CAIPPacketReceivedCallback)(const CASecureEndpoint_t *sep,
const void *data,
- uint32_t dataLength);
+ size_t dataLength);
/**
* Callback to notify error in the IP adapter.
* @pre Callback must be registered using CAIPSetPacketReceiveCallback().
*/
typedef void (*CAIPErrorHandleCallback)(const CAEndpoint_t *endpoint, const void *data,
- uint32_t dataLength, CAResult_t result);
+ size_t dataLength, CAResult_t result);
/**
* Start IP server.
*/
void CAIPSendData(CAEndpoint_t *endpoint,
const void *data,
- uint32_t dataLength,
+ size_t dataLength,
bool isMulticast);
/**
* @return ::CA_STATUS_OK, if success or Appropriate error code.\r
* @remarks info is allocated in this API and must be freed by the caller.\r
*/\r
-CAResult_t CAGetNFCInterfaceInformation(CAEndpoint_t **info, uint32_t *size);\r
+CAResult_t CAGetNFCInterfaceInformation(CAEndpoint_t **info, size_t *size);\r
\r
/**\r
* Read Synchronous API callback.\r
* @param[in] result result of request.\r
*/\r
typedef void (*CANFCErrorHandleCallback)(const CAEndpoint_t *endpoint, const void *data,\r
- uint32_t dataLength, CAResult_t result);\r
+ size_t dataLength, CAResult_t result);\r
\r
/**\r
* Callback to be notified when exception occures on multicast/unicast server.\r
* @param[out] size Number of local connectivity structures.
* @return ::CA_STATUS_OK or Appropriate error code.
*/
-CAResult_t CAGetRAInterfaceInformation(CAEndpoint_t **info, uint32_t *size);
+CAResult_t CAGetRAInterfaceInformation(CAEndpoint_t **info, size_t *size);
/**
* Stops RA server and de-register XMPP callback listeners.
typedef struct CATCPSessionInfo_t
{
CASecureEndpoint_t sep; /**< secure endpoint information */
- int fd; /**< file descriptor info */
+ CASocketFd_t fd; /**< file descriptor info */
unsigned char* data; /**< received data from remote device */
size_t len; /**< received data length */
size_t totalLen; /**< total coap data length required to receive */
* @param[in] data Data which is required to be sent.
* @param[in] dataLen Size of data to be sent.
* @param[in] dataType Data type which is REQUEST or RESPONSE.
- * @note dataLen must be > 0.
+ * @note dataLen must be > 0 and <= INT_MAX.
* @return The number of bytes sent on the network, or -1 upon error.
*/
int32_t CASendTCPUnicastData(const CAEndpoint_t *endpoint,
* @param[in] data Data which is required to be sent.
* @param[in] dataLen Size of data to be sent.
* @param[in] dataType Data type which is REQUEST or RESPONSE.
- * @note dataLen must be > 0.
+ * @note dataLen must be > 0 and <= INT_MAX.
* @return The number of bytes sent on the network, or -1 upon error.
*/
int32_t CASendTCPMulticastData(const CAEndpoint_t *endpoint,
* @param[out] size Number of local connectivity structures.
* @return ::CA_STATUS_OK or Appropriate error code.
*/
-CAResult_t CAGetTCPInterfaceInformation(CAEndpoint_t **info, uint32_t *size);
+CAResult_t CAGetTCPInterfaceInformation(CAEndpoint_t **info, size_t *size);
/**
* Read Synchronous API callback.
return;
}
- uint32_t listLength = u_arraylist_length(iflist);
- for (uint32_t i = 0; i < listLength; i++)
+ size_t listLength = u_arraylist_length(iflist);
+ for (size_t i = 0; i < listLength; i++)
{
CAInterface_t *ifitem = (CAInterface_t *)u_arraylist_get(iflist, i);
if (!ifitem)
#define TAG "IPC"
+#define UINT16_MAX 65535
+
static int g_sockID = 0;
/**
}
void CAIPSendData(CAEndpoint_t *endpoint, const void *buf,
- uint32_t bufLen, bool isMulticast)
+ size_t bufLen, bool isMulticast)
{
if (!isMulticast && 0 == g_unicastPort)
{
return;
}
- if (bufLen > 65535) // Max value for uint16_t
+ if (bufLen > UINT16_MAX)
{
// This will never happen as max buffer size we are dealing with is COAP_MAX_PDU_SIZE
OIC_LOG(ERROR, TAG, "Size exceeded");
}
void CAIPSendData(CAEndpoint_t *endpoint,
- const void *data, uint32_t dataLength, bool isMulticast)
+ const void *data, size_t dataLength, bool isMulticast)
{
OIC_LOG(DEBUG, TAG, "IN");
IPAddress remoteIp(ip);
Udp.beginPacket(remoteIp, endpoint->port);
- uint32_t bytesWritten = 0;
+ size_t bytesWritten = 0;
while (bytesWritten < dataLength)
{
// get remaining bytes
if(writeCount == 0)
{
// write failed
- OIC_LOG_V(ERROR, TAG, "Failed after %u", bytesWritten);
+ OIC_LOG_V(ERROR, TAG, "Failed after %" PRIuPTR, bytesWritten);
break;
}
bytesWritten += writeCount;
CAArduinoCheckData();
}
-CAResult_t CAGetIPInterfaceInformation(CAEndpoint_t **info, uint32_t *size)
+CAResult_t CAGetIPInterfaceInformation(CAEndpoint_t **info, size_t *size)
{
OIC_LOG(DEBUG, TAG, "IN");
return CA_STATUS_FAILED;
}
- uint32_t len = u_arraylist_length(iflist);
+ size_t len = u_arraylist_length(iflist);
CAEndpoint_t *eps = (CAEndpoint_t *)OICCalloc(len, sizeof (CAEndpoint_t));
if (!eps)
return CA_MEMORY_ALLOC_FAILED;
}
- for (uint32_t i = 0, j = 0; i < len; i++)
+ for (size_t i = 0, j = 0; i < len; i++)
{
CAInterface_t *ifitem = (CAInterface_t *)u_arraylist_get(iflist, i);
if(!ifitem)
CAArduinoCheckData();
}
-CAResult_t CAGetIPInterfaceInformation(CAEndpoint_t **info, uint32_t *size)
+CAResult_t CAGetIPInterfaceInformation(CAEndpoint_t **info, size_t *size)
{
OIC_LOG(DEBUG, TAG, "IN");
return CA_STATUS_FAILED;
}
- uint32_t len = u_arraylist_length(iflist);
+ size_t len = u_arraylist_length(iflist);
CAEndpoint_t *eps = (CAEndpoint_t *)OICCalloc(len, sizeof (CAEndpoint_t));
if (!eps)
return CA_MEMORY_ALLOC_FAILED;
}
- for (uint32_t i = 0, j = 0; i < len; i++)
+ for (size_t i = 0, j = 0; i < len; i++)
{
CAInterface_t *ifitem = (CAInterface_t *)u_arraylist_get(iflist, i);
if(!ifitem)
OIC_LOG(DEBUG, TAG, "IP adapter status is on. Store the own IP address info");
CAEndpoint_t *eps = NULL;
- uint32_t numOfEps = 0;
+ size_t numOfEps = 0;
CAResult_t res = CAGetIPInterfaceInformation(&eps, &numOfEps);
if (CA_STATUS_OK != res)
OICFree(headEp);
headEp = NULL;
- uint32_t len = u_arraylist_length(g_ownIpEndpointList);
- for (uint32_t i = len; i > 0; i--)
+ size_t len = u_arraylist_length(g_ownIpEndpointList);
+ for (size_t i = len; i > 0; i--)
{
u_arraylist_remove(g_ownIpEndpointList, i - 1);
}
}
void CAIPErrorHandler(const CAEndpoint_t *endpoint, const void *data,
- uint32_t dataLength, CAResult_t result)
+ size_t dataLength, CAResult_t result)
{
VERIFY_NON_NULL_VOID(endpoint, TAG, "endpoint is NULL");
VERIFY_NON_NULL_VOID(data, TAG, "data is NULL");
u_arraylist_t *iflist = CAFindInterfaceChange();
if (iflist)
{
- uint32_t listLength = u_arraylist_length(iflist);
- for (uint32_t i = 0; i < listLength; i++)
+ size_t listLength = u_arraylist_length(iflist);
+ for (size_t i = 0; i < listLength; i++)
{
CAInterface_t *ifitem = (CAInterface_t *)u_arraylist_get(iflist, i);
if (ifitem)
{
CASocketFd_t socketArray[EVENT_ARRAY_SIZE];
HANDLE eventArray[EVENT_ARRAY_SIZE];
- int arraySize = 0;
- int eventIndex;
+ DWORD arraySize = 0;
+ DWORD eventIndex;
// socketArray and eventArray should have same number of elements
OC_STATIC_ASSERT(_countof(socketArray) == _countof(eventArray), "Arrays should have same number of elements");
while (!caglobals.ip.terminate)
{
- int ret = WSAWaitForMultipleEvents(arraySize, eventArray, FALSE, WSA_INFINITE, FALSE);
+ DWORD ret = WSAWaitForMultipleEvents(arraySize, eventArray, FALSE, WSA_INFINITE, FALSE);
assert(ret >= WSA_WAIT_EVENT_0);
assert(ret < (WSA_WAIT_EVENT_0 + arraySize));
u_arraylist_t *iflist = CAFindInterfaceChange();
if (iflist)
{
- uint32_t listLength = u_arraylist_length(iflist);
- for (uint32_t i = 0; i < listLength; i++)
+ size_t listLength = u_arraylist_length(iflist);
+ for (size_t i = 0; i < listLength; i++)
{
CAInterface_t *ifitem = (CAInterface_t *)u_arraylist_get(iflist, i);
if (ifitem)
}
- for (int i = 0; i < arraySize; i++)
+ for (size_t i = 0; i < arraySize; i++)
{
HANDLE h = eventArray[i];
if (h != caglobals.ip.addressChangeEvent)
void CAIPPullData()
{
- OIC_LOG(DEBUG, TAG, "IN");
- OIC_LOG(DEBUG, TAG, "OUT");
+ OIC_LOG_V(DEBUG, TAG, "IN %s", __func__);
+ OIC_LOG_V(DEBUG, TAG, "OUT %s", __func__);
}
static CASocketFd_t CACreateSocket(int family, uint16_t *port, bool isMulticast)
#define CHECKFD(FD)
#else
#define CHECKFD(FD) \
+do \
+{ \
if (FD > caglobals.ip.maxfd) \
- caglobals.ip.maxfd = FD;
+ { \
+ caglobals.ip.maxfd = FD; \
+ } \
+} while (0)
#endif
-
#define NEWSOCKET(FAMILY, NAME, MULTICAST) \
+do \
+{ \
caglobals.ip.NAME.fd = CACreateSocket(FAMILY, &caglobals.ip.NAME.port, MULTICAST); \
if (caglobals.ip.NAME.fd == OC_INVALID_SOCKET) \
{ \
caglobals.ip.NAME.port = 0; \
caglobals.ip.NAME.fd = CACreateSocket(FAMILY, &caglobals.ip.NAME.port, MULTICAST); \
} \
- CHECKFD(caglobals.ip.NAME.fd)
+ CHECKFD(caglobals.ip.NAME.fd); \
+} while(0)
static void CARegisterForAddressChanges()
{
+ OIC_LOG_V(DEBUG, TAG, "IN %s", __func__);
#ifdef _WIN32
caglobals.ip.addressChangeEvent = WSACreateEvent();
if (WSA_INVALID_EVENT != caglobals.ip.addressChangeEvent)
}
#endif
#endif
+ OIC_LOG_V(DEBUG, TAG, "OUT %s", __func__);
}
static void CAInitializeFastShutdownMechanism()
{
+ OIC_LOG_V(DEBUG, TAG, "IN %s", __func__);
caglobals.ip.selectTimeout = -1; // don't poll for shutdown
int ret = -1;
#if defined(WSA_WAIT_EVENT_0)
OIC_LOG_V(ERROR, TAG, "fast shutdown mechanism init failed: %s", CAIPS_GET_ERROR);
caglobals.ip.selectTimeout = SELECT_TIMEOUT; //poll needed for shutdown
}
+ OIC_LOG_V(DEBUG, TAG, "OUT %s", __func__);
}
CAResult_t CAIPStartServer(const ca_thread_pool_t threadPool)
if (caglobals.ip.ipv6enabled)
{
- NEWSOCKET(AF_INET6, u6, false)
- NEWSOCKET(AF_INET6, u6s, false)
- NEWSOCKET(AF_INET6, m6, true)
- NEWSOCKET(AF_INET6, m6s, true)
+ NEWSOCKET(AF_INET6, u6, false);
+ NEWSOCKET(AF_INET6, u6s, false);
+ NEWSOCKET(AF_INET6, m6, true);
+ NEWSOCKET(AF_INET6, m6s, true);
OIC_LOG_V(INFO, TAG, "IPv6 unicast port: %u", caglobals.ip.u6.port);
}
if (caglobals.ip.ipv4enabled)
{
- NEWSOCKET(AF_INET, u4, false)
- NEWSOCKET(AF_INET, u4s, false)
- NEWSOCKET(AF_INET, m4, true)
- NEWSOCKET(AF_INET, m4s, true)
+ NEWSOCKET(AF_INET, u4, false);
+ NEWSOCKET(AF_INET, u4s, false);
+ NEWSOCKET(AF_INET, m4, true);
+ NEWSOCKET(AF_INET, m4s, true);
OIC_LOG_V(INFO, TAG, "IPv4 unicast port: %u", caglobals.ip.u4.port);
}
}
}
-static void applyMulticast6(int fd, struct in6_addr *addr, uint32_t ifindex)
+static void applyMulticast6(CASocketFd_t fd, struct in6_addr *addr, uint32_t ifindex)
{
struct ipv6_mreq mreq = { .ipv6mr_interface = ifindex };
CAResult_t CAIPStartListenServer()
{
+ OIC_LOG_V(DEBUG, TAG, "IN %s", __func__);
u_arraylist_t *iflist = CAIPGetInterfaceInformation(0);
if (!iflist)
{
return CA_STATUS_FAILED;
}
- uint32_t len = u_arraylist_length(iflist);
+ size_t len = u_arraylist_length(iflist);
OIC_LOG_V(DEBUG, TAG, "IP network interfaces found: %d", len);
- for (uint32_t i = 0; i < len; i++)
+ for (size_t i = 0; i < len; i++)
{
CAInterface_t *ifitem = (CAInterface_t *)u_arraylist_get(iflist, i);
}
u_arraylist_destroy(iflist);
+ OIC_LOG_V(DEBUG, TAG, "OUT %s", __func__);
return CA_STATUS_OK;
}
return CA_STATUS_FAILED;
}
- uint32_t len = u_arraylist_length(iflist);
+ size_t len = u_arraylist_length(iflist);
OIC_LOG_V(DEBUG, TAG, "IP network interfaces found: %d", len);
- for (uint32_t i = 0; i < len; i++)
+ for (size_t i = 0; i < len; i++)
{
CAInterface_t *ifitem = (CAInterface_t *)u_arraylist_get(iflist, i);
g_packetReceivedCallback = callback;
}
-static void sendData(int fd, const CAEndpoint_t *endpoint,
- const void *data, uint32_t dlen,
+static void sendData(CASocketFd_t fd, const CAEndpoint_t *endpoint,
+ const void *data, size_t dlen,
const char *cast, const char *fam)
{
- OIC_LOG(DEBUG, TAG, "IN");
+ OIC_LOG_V(DEBUG, TAG, "IN %s", __func__);
if (!endpoint)
{
#else
int err = 0;
int len = 0;
- int sent = 0;
+ size_t sent = 0;
do {
- len = sendto(fd, ((char*)data) + sent, dlen - sent, 0, (struct sockaddr *)&sock, socklen);
+ int dataToSend = ((dlen - sent) > INT_MAX) ? INT_MAX : (int)(dlen - sent);
+ len = sendto(fd, ((char*)data) + sent, dataToSend, 0, (struct sockaddr *)&sock, socklen);
if (OC_SOCKET_ERROR == len)
{
err = WSAGetLastError();
{
OIC_LOG_V(DEBUG, TAG, "%s%s %s sendTo (Partial Send) is successful: "
"currently sent: %ld bytes, "
- "total sent: %ld bytes, "
- "remaining: %ld bytes",
- secure, cast, fam, len, sent, dlen-sent);
+ "total sent: %" PRIuPTR " bytes, "
+ "remaining: %" PRIuPTR " bytes",
+ secure, cast, fam, len, sent, (dlen - sent));
}
else
{
static void sendMulticastData6(const u_arraylist_t *iflist,
CAEndpoint_t *endpoint,
- const void *data, uint32_t datalen)
+ const void *data, size_t datalen)
{
if (!endpoint)
{
return;
}
OICStrcpy(endpoint->addr, sizeof(endpoint->addr), ipv6mcname);
- int fd = caglobals.ip.u6.fd;
+ CASocketFd_t fd = caglobals.ip.u6.fd;
- uint32_t len = u_arraylist_length(iflist);
- for (uint32_t i = 0; i < len; i++)
+ size_t len = u_arraylist_length(iflist);
+ for (size_t i = 0; i < len; i++)
{
CAInterface_t *ifitem = (CAInterface_t *)u_arraylist_get(iflist, i);
if (!ifitem)
static void sendMulticastData4(const u_arraylist_t *iflist,
CAEndpoint_t *endpoint,
- const void *data, uint32_t datalen)
+ const void *data, size_t datalen)
{
VERIFY_NON_NULL_VOID(endpoint, TAG, "endpoint is NULL");
#endif
OICStrcpy(endpoint->addr, sizeof(endpoint->addr), IPv4_MULTICAST);
- int fd = caglobals.ip.u4.fd;
+ CASocketFd_t fd = caglobals.ip.u4.fd;
- uint32_t len = u_arraylist_length(iflist);
- for (uint32_t i = 0; i < len; i++)
+ size_t len = u_arraylist_length(iflist);
+ for (size_t i = 0; i < len; i++)
{
CAInterface_t *ifitem = (CAInterface_t *)u_arraylist_get(iflist, i);
if (!ifitem)
}
}
-void CAIPSendData(CAEndpoint_t *endpoint, const void *data, uint32_t datalen,
+void CAIPSendData(CAEndpoint_t *endpoint, const void *data, size_t datalen,
bool isMulticast)
{
VERIFY_NON_NULL_VOID(endpoint, TAG, "endpoint is NULL");
}
}
-CAResult_t CAGetIPInterfaceInformation(CAEndpoint_t **info, uint32_t *size)
+CAResult_t CAGetIPInterfaceInformation(CAEndpoint_t **info, size_t *size)
{
VERIFY_NON_NULL(info, TAG, "info is NULL");
VERIFY_NON_NULL(size, TAG, "size is NULL");
return CA_STATUS_FAILED;
}
- uint32_t len = u_arraylist_length(iflist);
- uint32_t length = len;
+ size_t len = u_arraylist_length(iflist);
+ size_t length = len;
#ifdef __WITH_DTLS__
//If DTLS is supported, each interface can support secure port as well
return CA_MEMORY_ALLOC_FAILED;
}
- for (uint32_t i = 0, j = 0; i < len; i++)
+ for (size_t i = 0, j = 0; i < len; i++)
{
CAInterface_t *ifitem = (CAInterface_t *)u_arraylist_get(iflist, i);
if(!ifitem)
static bool CACmpNetworkList(uint32_t ifiindex)
{
+ OIC_LOG_V(DEBUG, TAG, "IN %s: ifiindex = %ul", __func__, ifiindex);
+
if (!g_netInterfaceList)
{
OIC_LOG(ERROR, TAG, "g_netInterfaceList is NULL");
oc_mutex_lock(g_networkMonitorContextMutex);
- uint32_t list_length = u_arraylist_length(g_netInterfaceList);
- for (uint32_t list_index = 0; list_index < list_length; list_index++)
+ size_t list_length = u_arraylist_length(g_netInterfaceList);
+ for (size_t list_index = 0; list_index < list_length; list_index++)
{
CAInterface_t *currItem = (CAInterface_t *) u_arraylist_get(g_netInterfaceList,
list_index);
}
}
oc_mutex_unlock(g_networkMonitorContextMutex);
+ OIC_LOG_V(DEBUG, TAG, "OUT %s", __func__);
return false;
}
static CAResult_t CAAddNetworkMonitorList(CAInterface_t *ifitem)
{
+ OIC_LOG_V(DEBUG, TAG, "IN %s", __func__);
VERIFY_NON_NULL(g_netInterfaceList, TAG, "g_netInterfaceList is NULL");
VERIFY_NON_NULL(ifitem, TAG, "ifitem is NULL");
return CA_STATUS_FAILED;
}
oc_mutex_unlock(g_networkMonitorContextMutex);
+ OIC_LOG_V(DEBUG, TAG, "OUT %s", __func__);
return CA_STATUS_OK;
}
oc_mutex_lock(g_networkMonitorContextMutex);
- uint32_t list_length = u_arraylist_length(g_netInterfaceList);
- for (uint32_t list_index = 0; list_index < list_length; list_index++)
+ size_t list_length = u_arraylist_length(g_netInterfaceList);
+ for (size_t list_index = 0; list_index < list_length; list_index++)
{
CAInterface_t *removedifitem = (CAInterface_t *) u_arraylist_get(
g_netInterfaceList, list_index);
static void CAIPPassNetworkChangesToAdapter(CANetworkStatus_t status)
{
+ OIC_LOG_V(DEBUG, TAG, "IN %s: status = %d", __func__, status);
CAIPCBData_t *cbitem = NULL;
LL_FOREACH(g_adapterCallbackList, cbitem)
{
CALogAdapterStateInfo(cbitem->adapter, status);
}
}
+ OIC_LOG_V(DEBUG, TAG, "OUT %s", __func__);
}
CAResult_t CAIPSetNetworkMonitorCallback(CAIPAdapterStateChangeCallback callback,
static CAInterface_t *CANewInterfaceItem(int index, const char *name, int family,
const char *addr, int flags)
{
+ OIC_LOG_V(DEBUG, TAG, "IN %s:"
+ "index = %d, name = \"%s\", family = %d, addr = \"%s\", flags = %d",
+ __func__, index, name, family, addr, flags);
CAInterface_t *ifitem = (CAInterface_t *)OICCalloc(1, sizeof (CAInterface_t));
if (!ifitem)
{
OICStrcpy(ifitem->addr, sizeof (ifitem->addr), addr);
ifitem->flags = flags;
+ OIC_LOG_V(DEBUG, TAG, "OUT %s", __func__);
return ifitem;
}
u_arraylist_t *CAIPGetInterfaceInformation(int desiredIndex)
{
+ OIC_LOG_V(DEBUG, TAG, "IN %s: desiredIndex = %d", __func__, desiredIndex);
if (desiredIndex < 0)
{
OIC_LOG_V(ERROR, TAG, "invalid index : %d", desiredIndex);
}
struct ifaddrs *ifa = NULL;
+ OIC_LOG(DEBUG, TAG, "Iterating over interface addresses.");
for (ifa = ifp; ifa; ifa = ifa->ifa_next)
{
if (!ifa->ifa_addr)
continue;
}
- int length = u_arraylist_length(iflist);
+ size_t length = u_arraylist_length(iflist);
int already = false;
- for (int i = length-1; i >= 0; i--)
+ OIC_LOG_V(DEBUG, TAG, "Iterating over %" PRIuPTR " interfaces.", length);
+ for (size_t i = 0; i < length; i++)
{
+ OIC_LOG_V(DEBUG, TAG, "Checking interface %" PRIuPTR ".", i);
CAInterface_t *ifitem = (CAInterface_t *)u_arraylist_get(iflist, i);
if (ifitem
}
}
freeifaddrs(ifp);
+ OIC_LOG_V(DEBUG, TAG, "OUT %s", __func__);
return iflist;
exit:
freeifaddrs(ifp);
u_arraylist_destroy(iflist);
+ OIC_LOG_V(DEBUG, TAG, "OUT %s", __func__);
return NULL;
}
*/
static bool CACmpNetworkList(uint32_t ifIndex, int family, const char *addr, u_arraylist_t *iflist)
{
- uint32_t list_length = u_arraylist_length(iflist);
- for (uint32_t list_index = 0; list_index < list_length; list_index++)
+ size_t list_length = u_arraylist_length(iflist);
+ for (size_t list_index = 0; list_index < list_length; list_index++)
{
CAInterface_t *currItem = (CAInterface_t *) u_arraylist_get(iflist, list_index);
if ((currItem->index == ifIndex) && (currItem->family == family) &&
// Fetch new network address info.
u_arraylist_t *newList = GetInterfaceInformation(0);
- uint32_t newLen = u_arraylist_length(newList);
+ size_t newLen = u_arraylist_length(newList);
u_arraylist_t *oldList = g_CAIPNetworkMonitorAddressList;
- uint32_t oldLen = u_arraylist_length(oldList);
+ size_t oldLen = u_arraylist_length(oldList);
if (caglobals.ip.addressChangeEvent)
{
// Check whether any addresses went away.
- for (uint32_t i = 0; i < oldLen; i++)
+ for (size_t i = 0; i < oldLen; i++)
{
CAInterface_t *ifitem = (CAInterface_t *)u_arraylist_get(oldList, i);
if (!CACmpNetworkList(ifitem->index, ifitem->family, ifitem->addr, newList))
}
// Check whether any new addresses are available.
- for (uint32_t i = 0; i < newLen; i++)
+ for (size_t i = 0; i < newLen; i++)
{
CAInterface_t *ifitem = (CAInterface_t *)u_arraylist_get(newList, i);
if (!CACmpNetworkList(ifitem->index, ifitem->family, ifitem->addr, oldList))
return err;
}
- SOCKET nwmSocket = WSASocket(
+ SOCKET nwmSocket = WSASocketW(
AF_INET6,
SOCK_DGRAM,
0, // Default proto.
// Avoid extra kernel calls by just duplicating what's in our cache.
oc_mutex_lock(g_CAIPNetworkMonitorMutex);
- uint32_t list_length = u_arraylist_length(g_CAIPNetworkMonitorAddressList);
- for (uint32_t list_index = 0; list_index < list_length; list_index++)
+ size_t list_length = u_arraylist_length(g_CAIPNetworkMonitorAddressList);
+ for (size_t list_index = 0; list_index < list_length; list_index++)
{
CAInterface_t *currItem = (CAInterface_t *)u_arraylist_get(g_CAIPNetworkMonitorAddressList,
list_index);
return;
}
-CAResult_t CAGetTCPInterfaceInformation(CAEndpoint_t **info, uint32_t *size)
+CAResult_t CAGetTCPInterfaceInformation(CAEndpoint_t **info, size_t *size)
{
OIC_LOG(DEBUG, TAG, "IN");
return -1;
}
- if (dlen > 65535) // Max value for uint16_t
+ if (dlen > UINT16_MAX)
{
// This will never happen as max buffer size we are dealing with is COAP_MAX_PDU_SIZE
OIC_LOG(ERROR, TAG, "Size exceeded");
static CAKeepAliveConnectionCallback g_connKeepAliveCallback = NULL;
static void CATCPPacketReceivedCB(const CASecureEndpoint_t *sep,
- const void *data, uint32_t dataLength);
+ const void *data, size_t dataLength);
static void CATCPErrorHandler(const CAEndpoint_t *endpoint, const void *data,
size_t dataLength, CAResult_t result);
}
void CATCPPacketReceivedCB(const CASecureEndpoint_t *sep, const void *data,
- uint32_t dataLength)
+ size_t dataLength)
{
VERIFY_NON_NULL_VOID(sep, TAG, "sep is NULL");
VERIFY_NON_NULL_VOID(data, TAG, "data is NULL");
return CA_STATUS_OK;
}
-static size_t CAQueueTCPData(bool isMulticast, const CAEndpoint_t *endpoint,
- const void *data, size_t dataLength)
+static int32_t CAQueueTCPData(bool isMulticast, const CAEndpoint_t *endpoint,
+ const void *data, uint32_t dataLength)
{
VERIFY_NON_NULL_RET(endpoint, TAG, "endpoint", -1);
VERIFY_NON_NULL_RET(data, TAG, "data", -1);
-
- if (0 == dataLength)
- {
- OIC_LOG(ERROR, TAG, "Invalid Data Length");
- return -1;
- }
-
+ VERIFY_TRUE_RET((dataLength <= INT_MAX) && (dataLength > 0),
+ TAG,
+ "Invalid Data Length",
+ -1);
VERIFY_NON_NULL_RET(g_sendQueueHandle, TAG, "sendQueueHandle", -1);
// Create TCPData to add to queue
// Add message to send queue
CAQueueingThreadAddData(g_sendQueueHandle, tcpData, sizeof(CATCPData));
- return dataLength;
+ return (int32_t)dataLength;
}
int32_t CASendTCPUnicastData(const CAEndpoint_t *endpoint,
{
OIC_LOG(DEBUG, TAG, "IN");
(void)dataType;
+ if ((0 == dataLength) || (dataLength > INT32_MAX))
+ {
+ OIC_LOG(ERROR, TAG, "Invalid Data Length");
+ return -1;
+ }
+
#ifndef SINGLE_THREAD
return CAQueueTCPData(false, endpoint, data, dataLength);
#else
- return CATCPSendData(endpoint, data, dataLength);
+ return (int32_t)CATCPSendData(endpoint, data, dataLength);
#endif
}
#define CHECKFD(FD)
#else
#define CHECKFD(FD) \
+do \
+{ \
if (FD > caglobals.tcp.maxfd) \
- caglobals.tcp.maxfd = FD;
+ { \
+ caglobals.tcp.maxfd = FD; \
+ } \
+} while (0)
#endif
#define CLOSE_SOCKET(TYPE) \
CASocketFd_t socketArray[EVENT_ARRAY_SIZE] = {0};
HANDLE eventArray[_countof(socketArray)];
int arraySize = 0;
-
+
if (OC_INVALID_SOCKET != caglobals.tcp.ipv4.fd)
{
CAPushSocket(caglobals.tcp.ipv4.fd, socketArray, eventArray, &arraySize, _countof(socketArray));
CAPushEvent(OC_INVALID_SOCKET, socketArray,
caglobals.tcp.updateEvent, eventArray, &arraySize, _countof(socketArray));
}
-
+
int svrlistBeginIndex = arraySize;
while (!caglobals.tcp.terminate)
nbRead = tlsLength - svritem->tlsLen;
}
- len = recv(fd, svritem->tlsdata + svritem->tlsLen, nbRead, 0);
+ len = recv(fd, svritem->tlsdata + svritem->tlsLen, (int)nbRead, 0);
if (len < 0)
{
OIC_LOG_V(ERROR, TAG, "recv failed %s", strerror(errno));
if (tlsLength > 0 && tlsLength == svritem->tlsLen)
{
//when successfully read data - pass them to callback.
- res = CAdecryptSsl(&svritem->sep, (uint8_t *)svritem->tlsdata, svritem->tlsLen);
+ res = CAdecryptSsl(&svritem->sep, (uint8_t *)svritem->tlsdata, (int)svritem->tlsLen);
svritem->tlsLen = 0;
OIC_LOG_V(DEBUG, TAG, "%s: CAdecryptSsl returned %d", __func__, res);
}
coap_transport_t transport = coap_get_tcp_header_type_from_initbyte(
((unsigned char *)data)[0] >> 4);
- coap_pdu_t *pdu = coap_new_pdu2(transport, dlen);
+ coap_pdu_t *pdu = coap_pdu_init2(0, 0,
+ ntohs(COAP_INVALID_TID),
+ dlen, transport);
if (!pdu)
{
OIC_LOG(ERROR, TAG, "outpdu is null");
size_t payloadLen = 0;
size_t headerSize = coap_get_tcp_header_length_for_transport(transport);
- OIC_LOG_V(DEBUG, TAG, "headerSize : %zu, pdu length : %d",
+ OIC_LOG_V(DEBUG, TAG, "headerSize : %" PRIuPTR ", pdu length : %d",
headerSize, pdu->length);
if (pdu->length > headerSize)
{
static ssize_t sendData(const CAEndpoint_t *endpoint, const void *data,
size_t dlen, const char *fam)
{
- OIC_LOG_V(INFO, TAG, "The length of data that needs to be sent is %zu bytes", dlen);
+ OIC_LOG_V(INFO, TAG, "The length of data that needs to be sent is %" PRIuPTR " bytes", dlen);
// #1. find a session info from list.
CASocketFd_t sockFd = CAGetSocketFDFromEndpoint(endpoint);
ssize_t remainLen = dlen;
do
{
- ssize_t len = send(sockFd, data, remainLen, 0);
+ int dataToSend = (remainLen > INT_MAX) ? INT_MAX : (int)remainLen;
+ ssize_t len = send(sockFd, data, dataToSend, 0);
if (-1 == len)
{
if (EWOULDBLOCK != errno)
#ifndef TB_LOG
(void)fam;
#endif
- OIC_LOG_V(INFO, TAG, "unicast %stcp sendTo is successful: %zu bytes", fam, dlen);
+ OIC_LOG_V(INFO, TAG, "unicast %stcp sendTo is successful: %" PRIuPTR " bytes", fam, dlen);
CALogSendStateInfo(endpoint->adapter, endpoint->addr, endpoint->port,
dlen, true, NULL);
return dlen;
return -1;
}
-CAResult_t CAGetTCPInterfaceInformation(CAEndpoint_t **info, uint32_t *size)
+CAResult_t CAGetTCPInterfaceInformation(CAEndpoint_t **info, size_t *size)
{
VERIFY_NON_NULL(info, TAG, "info is NULL");
VERIFY_NON_NULL(size, TAG, "size is NULL");
return CA_STATUS_FAILED;
}
- uint32_t len = u_arraylist_length(iflist);
+ size_t len = u_arraylist_length(iflist);
CAEndpoint_t *ep = (CAEndpoint_t *)OICCalloc(len, sizeof (CAEndpoint_t));
if (!ep)
return CA_MEMORY_ALLOC_FAILED;
}
- for (uint32_t i = 0, j = 0; i < len; i++)
+ for (size_t i = 0, j = 0; i < len; i++)
{
CAInterface_t *ifitem = (CAInterface_t *)u_arraylist_get(iflist, i);
if (!ifitem)
transport);
size_t headerLen = coap_get_tcp_header_length((unsigned char *)recvBuffer);
- OIC_LOG_V(DEBUG, TAG, "option/paylaod length [%zu]", optPaylaodLen);
- OIC_LOG_V(DEBUG, TAG, "header length [%zu]", headerLen);
- OIC_LOG_V(DEBUG, TAG, "total data length [%zu]", headerLen + optPaylaodLen);
+ OIC_LOG_V(DEBUG, TAG, "option/paylaod length [%" PRIuPTR "]", optPaylaodLen);
+ OIC_LOG_V(DEBUG, TAG, "header length [%" PRIuPTR "]", headerLen);
+ OIC_LOG_V(DEBUG, TAG, "total data length [%" PRIuPTR "]", headerLen + optPaylaodLen);
OIC_LOG(DEBUG, TAG, "OUT - CAGetTotalLengthFromHeader");
return headerLen + optPaylaodLen;
#ifdef _MSC_VER
#pragma warning( suppress : 4244 )
*value = val->i;
-
#else
*value = val->i;
-
#endif
return true;
}
#ifdef _MSC_VER
#pragma warning( suppress : 4244 )
(*array)[n] = val->arr.iArray[n];
-
#else
(*array)[n] = val->arr.iArray[n];
-
#endif
}
}
projects / contrib / iotivity.git / commitdiff