/**
* Device Socket Object List
*/
void CAEDRNativeCreateDeviceSocketList()
{
OIC_LOG(DEBUG, TAG, "CAEDRNativeCreateDeviceSocketList");
// create new object array
if (NULL == g_deviceObjectList)
{
OIC_LOG(DEBUG, TAG, "Create Device object list");
g_deviceObjectList = u_arraylist_create();
}
}
/**
* BT State List
*/
void CAEDRNativeCreateDeviceStateList()
{
OIC_LOG(DEBUG, TAG, "[EDR][Native] CAEDRNativeCreateDeviceStateList");
// create new object array
if (NULL == g_deviceStateList)
{
OIC_LOG(DEBUG, TAG, "Create device list");
g_deviceStateList = u_arraylist_create();
}
}
void CAManagerCreateACDataList(JNIEnv *env)
{
OIC_LOG(DEBUG, TAG, "CAManagerCreateACDataList");
VERIFY_NON_NULL_VOID(env, TAG, "env");
ca_mutex_lock(g_deviceACDataListMutex);
// create new object array
if (g_deviceACDataList == NULL)
{
OIC_LOG(DEBUG, TAG, "Create AC Data list");
g_deviceACDataList = u_arraylist_create();
}
ca_mutex_unlock(g_deviceACDataListMutex);
}
CAResult_t CAIPInitializeServer(const ca_thread_pool_t threadPool)
{
OIC_LOG(DEBUG, IP_SERVER_TAG, "IN");
// Input validation
VERIFY_NON_NULL(threadPool, IP_SERVER_TAG, "Thread pool handle is NULL");
// Initialize mutex
if (CA_STATUS_OK != CAIPServerCreateMutex())
{
OIC_LOG(ERROR, IP_SERVER_TAG, "Failed to create mutex!");
return CA_STATUS_FAILED;
}
ca_mutex_lock(g_mutexAdapterServerContext);
g_adapterIPServerContext = (CAAdapterIPServerContext_t *) OICCalloc(1,
sizeof(CAAdapterIPServerContext_t));
if (!g_adapterIPServerContext)
{
OIC_LOG(ERROR, IP_SERVER_TAG, "Malloc failed");
ca_mutex_unlock(g_mutexAdapterServerContext);
return CA_MEMORY_ALLOC_FAILED;
}
g_adapterIPServerContext->threadPool = threadPool;
ca_mutex_unlock(g_mutexAdapterServerContext);
ca_mutex_lock(g_mutexServerInfoList);
g_serverInfoList = u_arraylist_create();
if (!g_serverInfoList)
{
OIC_LOG(ERROR, IP_SERVER_TAG, "u_arraylist_create failed");
ca_mutex_unlock(g_mutexServerInfoList);
return CA_MEMORY_ALLOC_FAILED;
}
ca_mutex_unlock(g_mutexServerInfoList);
OIC_LOG(DEBUG, IP_SERVER_TAG, "OUT");
return CA_STATUS_OK;
}
u_arraylist_t *CAIPGetInterfaceInformation(int desiredIndex)
{
bool result = true;
u_arraylist_t *iflist = u_arraylist_create();
if (!iflist)
{
OIC_LOG(ERROR, TAG, "Failed to create iflist");
return NULL;
}
CAInterface_t *ifitem = (CAInterface_t *)OICCalloc(1, sizeof(CAInterface_t));
if (!ifitem)
{
OIC_LOG(ERROR, TAG, "Malloc failed");
goto exit;
}
// Since Arduino currently only supports one interface, the next 4 lines are sufficient.
OICStrcpy(ifitem->name, INTERFACE_NAME_MAX, "WIFI");
ifitem->index = 1;
ifitem->family = AF_INET;
ifitem->flags = 0;
CAArduinoGetInterfaceAddress(ifitem->addr, sizeof(ifitem->addr));
result = u_arraylist_add(iflist, ifitem);
if (!result)
{
OIC_LOG(ERROR, TAG, "u_arraylist_add failed.");
goto exit;
}
OIC_LOG_V(DEBUG, TAG, "Added interface: %s (%d)", ifitem->name, ifitem->family);
return iflist;
exit:
u_arraylist_destroy(iflist);
return NULL;
}
static CAResult_t CAIPInitializeNetworkMonitorList()
{
if (!g_networkMonitorContextMutex)
{
g_networkMonitorContextMutex = ca_mutex_new();
if (!g_networkMonitorContextMutex)
{
OIC_LOG(ERROR, TAG, "ca_mutex_new has failed");
return CA_STATUS_FAILED;
}
}
if (!g_netInterfaceList)
{
g_netInterfaceList = u_arraylist_create();
if (!g_netInterfaceList)
{
OIC_LOG(ERROR, TAG, "u_arraylist_create has failed");
CAIPDestroyNetworkMonitorList();
return CA_STATUS_FAILED;
}
}
}
OCStackResult InitializeKeepAlive(OCMode mode)
{
OIC_LOG(DEBUG, TAG, "InitializeKeepAlive IN");
if (g_isKeepAliveInitialized)
{
OIC_LOG(DEBUG, TAG, "KeepAlive already initialized");
return OC_STACK_OK;
}
if (OC_CLIENT != mode)
{
// Create the KeepAlive Resource[/oic/ping].
OCStackResult result = CreateKeepAliveResource();
if (OC_STACK_OK != result)
{
OIC_LOG_V(ERROR, TAG, "CreateKeepAliveResource failed[%d]", result);
return result;
}
}
if (!g_keepAliveConnectionTable)
{
g_keepAliveConnectionTable = u_arraylist_create();
if (NULL == g_keepAliveConnectionTable)
{
OIC_LOG(ERROR, TAG, "Creating KeepAlive Table failed");
TerminateKeepAlive(mode);
return OC_STACK_ERROR;
}
}
g_isKeepAliveInitialized = true;
OIC_LOG(DEBUG, TAG, "InitializeKeepAlive OUT");
return OC_STACK_OK;
}
u_arraylist_t *CAIPGetInterfaceInformation(int desiredIndex)
{
u_arraylist_t *iflist = u_arraylist_create();
if (!iflist)
{
OIC_LOG_V(ERROR, TAG, "Failed to create iflist: %s", strerror(errno));
return NULL;
}
char buf[MAX_INTERFACE_INFO_LENGTH] = { 0 };
struct ifconf ifc = { .ifc_len = MAX_INTERFACE_INFO_LENGTH, .ifc_buf = buf };
int s = caglobals.ip.u6.fd != -1 ? caglobals.ip.u6.fd : caglobals.ip.u4.fd;
if (ioctl(s, SIOCGIFCONF, &ifc) < 0)
{
OIC_LOG_V(ERROR, TAG, "SIOCGIFCONF failed: %s", strerror(errno));
u_arraylist_destroy(iflist);
return NULL;
}
struct ifreq* ifr = ifc.ifc_req;
size_t interfaces = ifc.ifc_len / sizeof (ifc.ifc_req[0]);
size_t ifreqsize = ifc.ifc_len;
if (ifreqsize > caglobals.ip.nm.sizeIfItems)
{
CAIfItem_t *items = (CAIfItem_t *)OICRealloc(caglobals.ip.nm.ifItems, ifreqsize);
if (!items)
{
OIC_LOG(ERROR, TAG, "OICRealloc failed");
goto exit;
}
caglobals.ip.nm.ifItems = items;
caglobals.ip.nm.sizeIfItems = ifreqsize;
}
caglobals.ip.nm.numIfItems = 0;
for (size_t i = 0; i < interfaces; i++)
{
CAResult_t result = CA_STATUS_OK;
struct ifreq* item = &ifr[i];
char *name = item->ifr_name;
struct sockaddr_in *sa4 = (struct sockaddr_in *)&item->ifr_addr;
uint32_t ipv4addr = sa4->sin_addr.s_addr;
if (ioctl(s, SIOCGIFFLAGS, item) < 0)
{
OIC_LOG_V(ERROR, TAG, "SIOCGIFFLAGS failed: %s", strerror(errno));
continue;
}
int16_t flags = item->ifr_flags;
if ((flags & IFF_LOOPBACK) || !(flags & IFF_RUNNING))
{
continue;
}
if (ioctl(s, SIOCGIFINDEX, item) < 0)
{
OIC_LOG_V(ERROR, TAG, "SIOCGIFINDEX failed: %s", strerror(errno));
continue;
}
int ifindex = item->ifr_ifindex;
caglobals.ip.nm.ifItems[i].ifIndex = ifindex;
caglobals.ip.nm.numIfItems++;
if (desiredIndex && (ifindex != desiredIndex))
{
continue;
}
// Add IPv4 interface
result = CAAddInterfaceItem(iflist, ifindex, name, AF_INET, ipv4addr, flags);
if (CA_STATUS_OK != result)
{
goto exit;
}
// Add IPv6 interface
result = CAAddInterfaceItem(iflist, ifindex, name, AF_INET6, ipv4addr, flags);
if (CA_STATUS_OK != result)
{
goto exit;
}
}
return iflist;
exit:
u_arraylist_destroy(iflist);
return NULL;
}
u_arraylist_t *CAIPGetInterfaceInformation(int desiredIndex)
{
if (desiredIndex < 0)
{
OIC_LOG_V(ERROR, TAG, "invalid index : %d", desiredIndex);
return NULL;
}
u_arraylist_t *iflist = u_arraylist_create();
if (!iflist)
{
OIC_LOG_V(ERROR, TAG, "Failed to create iflist: %s", strerror(errno));
return NULL;
}
struct ifaddrs *ifp = NULL;
if (-1 == getifaddrs(&ifp))
{
OIC_LOG_V(ERROR, TAG, "Failed to get ifaddrs: %s", strerror(errno));
u_arraylist_destroy(iflist);
return NULL;
}
OIC_LOG(DEBUG, TAG, "Got ifaddrs");
struct ifaddrs *ifa = NULL;
for (ifa = ifp; ifa; ifa = ifa->ifa_next)
{
if (!ifa->ifa_addr)
{
continue;
}
int family = ifa->ifa_addr->sa_family;
if ((ifa->ifa_flags & IFF_LOOPBACK) || (AF_INET != family && AF_INET6 != family))
{
continue;
}
int ifindex = if_nametoindex(ifa->ifa_name);
if (desiredIndex && (ifindex != desiredIndex))
{
continue;
}
int length = u_arraylist_length(iflist);
int already = false;
for (int i = length-1; i >= 0; i--)
{
CAInterface_t *ifitem = (CAInterface_t *)u_arraylist_get(iflist, i);
if (ifitem
&& (int)ifitem->index == ifindex
&& ifitem->family == (uint16_t)family)
{
already = true;
break;
}
}
if (already)
{
continue;
}
CAInterface_t *ifitem = (CAInterface_t *)OICCalloc(1, sizeof(CAInterface_t));
if (!ifitem)
{
OIC_LOG(ERROR, TAG, "Malloc failed");
goto exit;
}
OICStrcpy(ifitem->name, INTERFACE_NAME_MAX, ifa->ifa_name);
ifitem->index = ifindex;
ifitem->family = family;
ifitem->ipv4addr = ((struct sockaddr_in *)(ifa->ifa_addr))->sin_addr.s_addr;
ifitem->flags = ifa->ifa_flags;
bool result = u_arraylist_add(iflist, ifitem);
if (!result)
{
OIC_LOG(ERROR, TAG, "u_arraylist_add failed.");
goto exit;
}
OIC_LOG_V(DEBUG, TAG, "Added interface: %s (%d)", ifitem->name, family);
}
freeifaddrs(ifp);
return iflist;
exit:
freeifaddrs(ifp);
u_arraylist_destroy(iflist);
return NULL;
}
CAResult_t CAAddNetworkType(CATransportAdapter_t transportType)
{
OIC_LOG(DEBUG, TAG, "IN");
if (NULL == g_selectedNetworkList)
{
OIC_LOG(DEBUG, TAG, "Create network list");
g_selectedNetworkList = u_arraylist_create();
if (NULL == g_selectedNetworkList)
{
return CA_MEMORY_ALLOC_FAILED;
}
}
CAResult_t res = CA_STATUS_OK;
switch (transportType)
{
case CA_ADAPTER_IP:
#ifndef IP_ADAPTER
OIC_LOG(DEBUG, TAG, "Add network type(IP) - Not Supported");
return CA_NOT_SUPPORTED;
#endif /* IP_ADAPTER */
OIC_LOG(DEBUG, TAG, "Add network type(IP)");
if (u_arraylist_contains(g_selectedNetworkList, &NETWORK_IP))
{
goto exit;
}
res = u_arraylist_add(g_selectedNetworkList, &NETWORK_IP);
break;
case CA_ADAPTER_RFCOMM_BTEDR:
#ifndef EDR_ADAPTER
OIC_LOG(DEBUG, TAG, "Add network type(EDR) - Not Supported");
return CA_NOT_SUPPORTED;
#endif /* EDR_ADAPTER */
OIC_LOG(DEBUG, TAG, "Add network type(EDR)");
if (u_arraylist_contains(g_selectedNetworkList, &NETWORK_RFCOMM))
{
goto exit;
}
res = u_arraylist_add(g_selectedNetworkList, &NETWORK_RFCOMM);
break;
case CA_ADAPTER_GATT_BTLE:
#ifndef LE_ADAPTER
OIC_LOG(DEBUG, TAG, "Add network type(LE) - Not Supported");
return CA_NOT_SUPPORTED;
#endif /* LE_ADAPTER */
OIC_LOG(DEBUG, TAG, "Add network type(LE)");
if (u_arraylist_contains(g_selectedNetworkList, &NETWORK_GATT))
{
goto exit;
}
res = u_arraylist_add(g_selectedNetworkList, &NETWORK_GATT);
break;
default:
break;
}
if (CA_STATUS_OK != res)
{
OIC_LOG_V(ERROR, TAG, "Add arraylist failed[Err code: %d]", res);
return res;
}
// start selected interface adapter
res = CAStartAdapter(transportType);
OIC_LOG(DEBUG, TAG, "OUT");
return res;
exit:
OIC_LOG(DEBUG, TAG, "This adapter is already enabled");
return CA_STATUS_OK;
}
void CAIPSendNetworkChangeCallback(CANetworkStatus_t currNetworkStatus)
{
OIC_LOG(DEBUG, IP_MONITOR_TAG, "IN");
ca_mutex_lock(g_stopNetworkMonitorMutex);
if (g_stopNetworkMonitor)
{
OIC_LOG(DEBUG, IP_MONITOR_TAG, "Stop Network Monitor Thread is called");
ca_mutex_unlock(g_stopNetworkMonitorMutex);
return;
}
ca_mutex_unlock(g_stopNetworkMonitorMutex);
ca_mutex_lock(g_networkMonitorContextMutex);
if (!g_networkMonitorContext)
{
OIC_LOG(ERROR, IP_MONITOR_TAG, "g_networkMonitorContext is NULL");
ca_mutex_unlock(g_networkMonitorContextMutex);
return;
}
if (!g_networkMonitorContext->networkChangeCb)
{
OIC_LOG(ERROR, IP_MONITOR_TAG, "g_networkMonitorContext->networkChangeCb is NULL");
ca_mutex_unlock(g_networkMonitorContextMutex);
return;
}
ca_mutex_unlock(g_networkMonitorContextMutex);
u_arraylist_t *netInterfaceList = u_arraylist_create();
VERIFY_NON_NULL_VOID(netInterfaceList, IP_MONITOR_TAG,
"memory allocation failed for netInterfaceList");
// if network status is changed
CAResult_t ret = CAIPUpdateInterfaceInformation(&netInterfaceList);
if (CA_STATUS_OK != ret)
{
OIC_LOG(ERROR, IP_MONITOR_TAG, "could not update interface information");
}
ca_mutex_lock(g_networkMonitorContextMutex);
if (!g_networkMonitorContext->netInterfaceList)
{
OIC_LOG(ERROR, IP_MONITOR_TAG,
"u_arraylist_create failed. Network Monitor thread stopped");
CAClearNetInterfaceInfoList(netInterfaceList);
ca_mutex_unlock(g_networkMonitorContextMutex);
return;
}
uint32_t listLength = u_arraylist_length(g_networkMonitorContext->netInterfaceList);
for (uint32_t listIndex = 0; listIndex < listLength;)
{
CANetInfo_t *info = (CANetInfo_t *) u_arraylist_get(
g_networkMonitorContext->netInterfaceList, listIndex);
if (!info)
{
listIndex++;
continue;
}
bool ret = CACheckIsAnyInterfaceDown(netInterfaceList, info);
if (ret)
{
OIC_LOG(DEBUG, IP_MONITOR_TAG, "Interface is down");
if (u_arraylist_remove(g_networkMonitorContext->netInterfaceList, listIndex))
{
OIC_LOG(DEBUG, IP_MONITOR_TAG, "u_arraylist_remove success");
if (g_networkMonitorContext->networkChangeCb)
{
g_networkMonitorContext->networkChangeCb(info->ipAddress, CA_INTERFACE_DOWN);
}
OICFree(info);
listLength--;
}
else
{
OIC_LOG(ERROR, IP_MONITOR_TAG, "u_arraylist_remove failed");
break;
}
}
else
{
listIndex++;
}
}
ca_mutex_unlock(g_networkMonitorContextMutex);
listLength = u_arraylist_length(netInterfaceList);
for (uint32_t listIndex = 0; listIndex < listLength; listIndex++)
{
CANetInfo_t *info = (CANetInfo_t *) u_arraylist_get(netInterfaceList, listIndex);
if (!info)
{
continue;
}
bool ret = CACheckIsInterfaceInfoChanged(info);
if (ret)
{
OIC_LOG(DEBUG, IP_MONITOR_TAG, "CACheckIsInterfaceInfoChanged true");
}
}
CAClearNetInterfaceInfoList(netInterfaceList);
OIC_LOG(DEBUG, IP_MONITOR_TAG, "OUT");
}
CAResult_t CAIPInitializeNetworkMonitor(const ca_thread_pool_t threadPool)
{
OIC_LOG(DEBUG, IP_MONITOR_TAG, "CAIPInitializeNetworkMonitor IN");
VERIFY_NON_NULL(threadPool, IP_MONITOR_TAG, "threadPool is null");
CAResult_t ret = CAIPJniInit();
if (CA_STATUS_OK != ret)
{
OIC_LOG(ERROR, IP_MONITOR_TAG, "Initialization failed");
return ret;
}
ret = CAIPJniSetContext();
if (CA_STATUS_OK != ret)
{
OIC_LOG(ERROR, IP_MONITOR_TAG, "CAIPJniSetContext failed");
return ret;
}
ret = CACreateIPJNIInterfaceObject(g_context);
if (CA_STATUS_OK != ret)
{
OIC_LOG(ERROR, IP_MONITOR_TAG, "unable to create CaIpInterface instance");
return ret;
}
ret = CAInitializeNetworkMonitorMutexes();
if (CA_STATUS_OK != ret)
{
OIC_LOG(ERROR, IP_MONITOR_TAG, "CAInitializeNetworkMonitorMutexes failed");
return CA_STATUS_FAILED;
}
ca_mutex_lock(g_networkMonitorContextMutex);
g_networkMonitorContext = (CAIPNetworkMonitorContext *) OICCalloc(
1, sizeof(*g_networkMonitorContext));
if (!g_networkMonitorContext)
{
OIC_LOG(ERROR, IP_MONITOR_TAG, "g_networkMonitorContext Malloc failed");
ca_mutex_unlock(g_networkMonitorContextMutex);
CADestroyNetworkMonitorMutexes();
return CA_MEMORY_ALLOC_FAILED;
}
g_networkMonitorContext->threadPool = threadPool;
g_networkMonitorContext->netInterfaceList = u_arraylist_create();
if (!g_networkMonitorContext->netInterfaceList)
{
OIC_LOG(ERROR, IP_MONITOR_TAG, "u_arraylist_create failed");
OICFree(g_networkMonitorContext);
ca_mutex_unlock(g_networkMonitorContextMutex);
CADestroyNetworkMonitorMutexes();
return CA_MEMORY_ALLOC_FAILED;
}
CAIPUpdateInterfaceInformation(&g_networkMonitorContext->netInterfaceList);
if (u_arraylist_length(g_networkMonitorContext->netInterfaceList))
{
g_networkMonitorContext->nwConnectivityStatus = CA_INTERFACE_UP;
}
else
{
g_networkMonitorContext->nwConnectivityStatus = CA_INTERFACE_DOWN;
}
ca_mutex_unlock(g_networkMonitorContextMutex);
OIC_LOG(DEBUG, IP_MONITOR_TAG, "OUT");
return CA_STATUS_OK;
}
static void CAReceiveHandler(void *data)
{
OIC_LOG(DEBUG, IP_SERVER_TAG, "IN");
fd_set readFds;
int maxSd = 0;
struct timeval timeout;
char recvBuffer[COAP_MAX_PDU_SIZE] = { 0 };
while (true != g_packetHandlerStopFlag)
{
timeout.tv_sec = 1;
timeout.tv_usec = 0;
FD_ZERO(&readFds);
ca_mutex_lock(g_mutexServerInfoList);
uint32_t listIndex = 0;
uint32_t listLength = u_arraylist_length(g_serverInfoList);
u_arraylist_t *tempServerInfoList = u_arraylist_create();
if (!tempServerInfoList)
{
OIC_LOG(ERROR, IP_SERVER_TAG, "u_arraylist_create failed");
ca_mutex_unlock(g_mutexServerInfoList);
return;
}
for (listIndex = 0; listIndex < listLength; listIndex++)
{
CAServerInfo_t *info = (CAServerInfo_t *) u_arraylist_get(g_serverInfoList, listIndex);
if (!info)
{
listIndex++;
continue;
}
int sd = info->socketFd;
//if valid socket descriptor then add to read list
if (sd > 0)
{
FD_SET(sd, &readFds);
}
//highest file descriptor number, need it for the select function
if (sd > maxSd)
{
maxSd = sd;
}
CAServerInfo_t *newInfo = (CAServerInfo_t *) OICMalloc(sizeof(CAServerInfo_t));
if (!newInfo)
{
OIC_LOG(ERROR, IP_SERVER_TAG, "Malloc failed");
CAClearServerInfoList(tempServerInfoList);
ca_mutex_unlock(g_mutexServerInfoList);
return;
}
*newInfo = *info;
CAResult_t result = u_arraylist_add(tempServerInfoList, (void *) newInfo);
if (CA_STATUS_OK != result)
{
OIC_LOG(ERROR, IP_SERVER_TAG, "u_arraylist_add failed!Thread exit");
CAClearServerInfoList(tempServerInfoList);
ca_mutex_unlock(g_mutexServerInfoList);
return;
}
}
ca_mutex_unlock(g_mutexServerInfoList);
int ret = select(maxSd + 1, &readFds, NULL, NULL, &timeout);
if (g_packetHandlerStopFlag)
{
OIC_LOG_V(DEBUG, IP_SERVER_TAG,
"Packet receiver handler Stop request received. Thread exited");
CAClearServerInfoList(tempServerInfoList);
break;
}
if (ret < 0)
{
OIC_LOG_V(FATAL, IP_SERVER_TAG, "select returned error %s", strerror(errno));
CAClearServerInfoList(tempServerInfoList);
continue;
}
listLength = u_arraylist_length(tempServerInfoList);
for (listIndex = 0; listIndex < listLength; listIndex++)
{
CAServerInfo_t *info = (CAServerInfo_t *) u_arraylist_get(tempServerInfoList,
listIndex);
if (!info)
{
continue;
}
int sd = info->socketFd;
if (FD_ISSET(sd , &readFds))
{
OIC_LOG_V(ERROR, IP_SERVER_TAG,
"data Received server information ip %s, port %d socket %d",
info->endpoint.addr, info->endpoint.port, sd);
memset(recvBuffer, 0, sizeof(recvBuffer));
struct sockaddr_in srcSockAddress = { 0 };
socklen_t srcAddressLen = sizeof(srcSockAddress);
//Reading from socket
ssize_t recvLen = recvfrom(sd, recvBuffer, sizeof(recvBuffer), 0,
(struct sockaddr *) &srcSockAddress, &srcAddressLen);
if (-1 == recvLen)
{
OIC_LOG_V(ERROR, IP_SERVER_TAG, "Recvfrom failed %s", strerror(errno));
continue;
}
else if (0 == recvLen)
{
OIC_LOG_V(ERROR, IP_SERVER_TAG, "Server socket shutdown sock fd[%d]", sd);
ca_mutex_lock(g_mutexAdapterServerContext);
// Notify upper layer this exception
if (g_adapterIPServerContext->exceptionCallback)
{
// need to make proper exception callback.
//g_adapterIPServerContext->exceptionCallback(ctx->type);
}
ca_mutex_unlock(g_mutexAdapterServerContext);
}
char srcIPAddress[CA_IPADDR_SIZE] = { 0 };
if (!inet_ntop(AF_INET, &srcSockAddress.sin_addr.s_addr, srcIPAddress,
sizeof(srcIPAddress)))
{
OIC_LOG(ERROR, IP_SERVER_TAG, "inet_ntop is failed!");
continue;
}
uint16_t srcPort = ntohs(srcSockAddress.sin_port);
OIC_LOG_V(DEBUG, IP_SERVER_TAG, "Received packet from %s:%d len %d",
srcIPAddress, srcPort, recvLen);
char *netMask = NULL;
if (CA_STATUS_OK != CAIPGetInterfaceSubnetMask(info->ifAddr, &netMask))
{
OIC_LOG(ERROR, IP_SERVER_TAG, "Failed to get IP subnet");
continue;
}
if (!CAAdapterIsSameSubnet(info->ifAddr, srcIPAddress, netMask))
{
OIC_LOG(DEBUG, IP_SERVER_TAG,
"Packet received from different subnet, Ignore!");
OICFree(netMask);
continue;
}
OICFree(netMask);
CAEndpoint_t ep;
strncpy(ep.addr, srcIPAddress, MAX_ADDR_STR_SIZE_CA);
ep.port = srcPort;
ep.flags = (CATransportFlags_t)CA_IPV4 | CA_IPV6;
ep.adapter = CA_ADAPTER_IP;
if (info->endpoint.flags & CA_SECURE)
{
#ifdef __WITH_DTLS__
ep.flags |= CA_SECURE;
(void)CAAdapterNetDtlsDecrypt(&ep, (uint8_t *)recvBuffer, recvLen);
OIC_LOG_V(DEBUG, IP_SERVER_TAG,
"CAAdapterNetDtlsDecrypt returns [%d]", ret);
#endif
}
else //both multicast and unicast
{
ca_mutex_lock(g_mutexAdapterServerContext);
if (g_adapterIPServerContext->packetReceivedCallback)
{
g_adapterIPServerContext->packetReceivedCallback(&ep,
recvBuffer, recvLen);
}
ca_mutex_unlock(g_mutexAdapterServerContext);
}
}
}
CAClearServerInfoList(tempServerInfoList);
}
OIC_LOG(DEBUG, IP_SERVER_TAG, "OUT");
}
// this implementation doesn't do a thread pool, so this function is essentially
// a no-op besides creating a valid ca_thread_pool_t object. It was determined after
// reading through the existing implementation that the thread-pooling was unnecessary
// for the posix platforms. Behavior shouldn't be changed since previously num_of_threads
// was greater than the number of requested threads.
CAResult_t ca_thread_pool_init(int32_t num_of_threads, ca_thread_pool_t *thread_pool)
{
OIC_LOG(DEBUG, TAG, "IN");
if(!thread_pool)
{
OIC_LOG(ERROR, TAG, "Parameter thread_pool was null!");
return CA_STATUS_INVALID_PARAM;
}
if(num_of_threads <= 0)
{
OIC_LOG(ERROR, TAG, "num_of_threads must be positive and non-zero");
return CA_STATUS_INVALID_PARAM;
}
*thread_pool = OICMalloc(sizeof(struct ca_thread_pool));
if(!*thread_pool)
{
OIC_LOG(ERROR, TAG, "Failed to allocate for thread-pool");
return CA_MEMORY_ALLOC_FAILED;
}
(*thread_pool)->details = OICMalloc(sizeof(struct ca_thread_pool_details_t));
if(!(*thread_pool)->details)
{
OIC_LOG(ERROR, TAG, "Failed to allocate for thread-pool details");
OICFree(*thread_pool);
*thread_pool=NULL;
return CA_MEMORY_ALLOC_FAILED;
}
(*thread_pool)->details->list_lock = ca_mutex_new();
if(!(*thread_pool)->details->list_lock)
{
OIC_LOG(ERROR, TAG, "Failed to create thread-pool mutex");
goto exit;
}
(*thread_pool)->details->threads_list = u_arraylist_create();
if(!(*thread_pool)->details->threads_list)
{
OIC_LOG(ERROR, TAG, "Failed to create thread-pool list");
if(!ca_mutex_free((*thread_pool)->details->list_lock))
{
OIC_LOG(ERROR, TAG, "Failed to free thread-pool mutex");
}
goto exit;
}
OIC_LOG(DEBUG, TAG, "OUT");
return CA_STATUS_OK;
exit:
OICFree((*thread_pool)->details);
OICFree(*thread_pool);
*thread_pool = NULL;
return CA_STATUS_FAILED;
}
CAResult_t CAAddNetworkType(CAConnectivityType_t connectivityType)
{
OIC_LOG(DEBUG, TAG, "IN");
if (g_selectedNetworkList == NULL)
{
g_selectedNetworkList = u_arraylist_create();
if (NULL == g_selectedNetworkList)
{
return CA_MEMORY_ALLOC_FAILED;
}
}
CAResult_t res = CA_STATUS_OK;
switch (connectivityType)
{
case CA_ETHERNET:
{
#ifndef ETHERNET_ADAPTER
OIC_LOG(DEBUG, TAG, "Add network type(ETHERNET) - Not Supported");
return CA_NOT_SUPPORTED;
#endif /* ETHERNET_ADAPTER */
OIC_LOG(DEBUG, TAG, "Add network type(ETHERNET)");
if (!u_arraylist_contains(g_selectedNetworkList, &NETWORK_ETHERNET))
{
res = u_arraylist_add(g_selectedNetworkList, &NETWORK_ETHERNET);
if (CA_STATUS_OK != res)
{
OIC_LOG_V(ERROR, TAG, "Add arraylist failed[Err code: %d]", res);
return res;
}
}
}
break;
case CA_WIFI:
{
#ifndef WIFI_ADAPTER
OIC_LOG(DEBUG, TAG, "Add network type(WIFI) - Not Supported");
return CA_NOT_SUPPORTED;
#endif /* WIFI_ADAPTER */
OIC_LOG(DEBUG, TAG, "Add network type(WIFI)");
if (!u_arraylist_contains(g_selectedNetworkList, &NETWORK_WIFI))
{
res = u_arraylist_add(g_selectedNetworkList, &NETWORK_WIFI);
if (CA_STATUS_OK != res)
{
OIC_LOG_V(ERROR, TAG, "Add arraylist failed[Err code: %d]", res);
return res;
}
}
}
break;
case CA_EDR:
{
#ifndef EDR_ADAPTER
OIC_LOG(DEBUG, TAG, "Add network type(EDR) - Not Supported");
return CA_NOT_SUPPORTED;
#endif /* EDR_ADAPTER */
OIC_LOG(DEBUG, TAG, "Add network type(EDR)");
if (!u_arraylist_contains(g_selectedNetworkList, &NETWORK_EDR))
{
res = u_arraylist_add(g_selectedNetworkList, &NETWORK_EDR);
if (CA_STATUS_OK != res)
{
OIC_LOG_V(ERROR, TAG, "Add arraylist failed[Err code: %d]", res);
return res;
}
}
}
break;
case CA_LE:
{
#ifndef LE_ADAPTER
OIC_LOG(DEBUG, TAG, "Add network type(LE) - Not Supported");
return CA_NOT_SUPPORTED;
#endif /* LE_ADAPTER */
OIC_LOG(DEBUG, TAG, "Add network type(LE)");
if (!u_arraylist_contains(g_selectedNetworkList, &NETWORK_LE))
{
res = u_arraylist_add(g_selectedNetworkList, &NETWORK_LE);
if (CA_STATUS_OK != res)
{
OIC_LOG_V(ERROR, TAG, "Add arraylist failed[Err code: %d]", res);
return res;
}
}
}
break;
}
// start selected interface adapter
res = CAStartAdapter((CAConnectivityType_t)connectivityType);
OIC_LOG(DEBUG, TAG, "OUT");
return res;
}
