void CAEDRNativeAddDeviceSocketToList(JNIEnv *env, jobject deviceSocket)
{
OIC_LOG(DEBUG, TAG, "CANativeAddDeviceobjToList");
if (!deviceSocket)
{
OIC_LOG(ERROR, TAG, "Device is null");
return;
}
if (!g_deviceObjectList)
{
OIC_LOG(ERROR, TAG, "gdeviceObjectList is null");
return;
}
jstring jni_remoteAddress = CAEDRNativeGetAddressFromDeviceSocket(env, deviceSocket);
if (!jni_remoteAddress)
{
OIC_LOG(ERROR, TAG, "jni_remoteAddress is null");
return;
}
const char* remoteAddress = (*env)->GetStringUTFChars(env, jni_remoteAddress, NULL);
if (!CAEDRNativeIsDeviceSocketInList(env, remoteAddress))
{
jobject gDeviceSocker = (*env)->NewGlobalRef(env, deviceSocket);
u_arraylist_add(g_deviceObjectList, gDeviceSocker);
OIC_LOG(DEBUG, TAG, "Set Socket Object to Array");
}
(*env)->ReleaseStringUTFChars(env, jni_remoteAddress, remoteAddress);
(*env)->DeleteLocalRef(env, jni_remoteAddress);
}
CAResult_t CAIPGetInterfaceInfo(u_arraylist_t **netInterfaceList)
{
OIC_LOG(DEBUG, IP_MONITOR_TAG, "IN");
VERIFY_NON_NULL(netInterfaceList, IP_MONITOR_TAG, "u_array_list is null");
VERIFY_NON_NULL(g_networkMonitorContext, IP_MONITOR_TAG, "g_networkMonitorContext is null");
VERIFY_NON_NULL(g_networkMonitorContextMutex, IP_MONITOR_TAG,
"g_networkMonitorContextMutex is null");
// Get the interface and ipaddress information from cache
ca_mutex_lock(g_networkMonitorContextMutex);
if (!g_networkMonitorContext->netInterfaceList
|| !(u_arraylist_length(g_networkMonitorContext->netInterfaceList)))
{
OIC_LOG(ERROR, IP_MONITOR_TAG, "Network not enabled");
ca_mutex_unlock(g_networkMonitorContextMutex);
return CA_ADAPTER_NOT_ENABLED;
}
uint32_t list_length = u_arraylist_length(g_networkMonitorContext->netInterfaceList);
OIC_LOG_V(DEBUG, IP_MONITOR_TAG, "CAIPGetInterfaceInfo list length [%d]",
list_length);
for (uint32_t list_index = 0; list_index < list_length; list_index++)
{
CANetInfo_t *info = (CANetInfo_t *) u_arraylist_get(
g_networkMonitorContext->netInterfaceList, list_index);
if (!info)
{
continue;
}
OIC_LOG_V(DEBUG, IP_MONITOR_TAG, "CAIPGetInterfaceInfo ip [%s]",
info->ipAddress);
CANetInfo_t *newNetinfo = (CANetInfo_t *) OICMalloc(sizeof(CANetInfo_t));
if (!newNetinfo)
{
OIC_LOG(ERROR, IP_MONITOR_TAG, "Malloc failed!");
ca_mutex_unlock(g_networkMonitorContextMutex);
return CA_MEMORY_ALLOC_FAILED;
}
*newNetinfo = *info;
CAResult_t result = u_arraylist_add(*netInterfaceList, (void *) newNetinfo);
if (CA_STATUS_OK != result)
{
OIC_LOG(ERROR, IP_MONITOR_TAG, "u_arraylist_add failed!");
ca_mutex_unlock(g_networkMonitorContextMutex);
return CA_STATUS_FAILED;
}
}
ca_mutex_unlock(g_networkMonitorContextMutex);
OIC_LOG(DEBUG, IP_MONITOR_TAG, "OUT");
return CA_STATUS_OK;
}
KeepAliveEntry_t *AddKeepAliveEntry(const CAEndpoint_t *endpoint, OCMode mode,
int64_t *intervalInfo)
{
if (!endpoint)
{
OIC_LOG(ERROR, TAG, "endpoint is NULL");
return NULL;
}
if (!g_keepAliveConnectionTable)
{
OIC_LOG(ERROR, TAG, "KeepAlive Table was not Created.");
return NULL;
}
KeepAliveEntry_t *entry = (KeepAliveEntry_t *) OICCalloc(1, sizeof(KeepAliveEntry_t));
if (NULL == entry)
{
OIC_LOG(ERROR, TAG, "Failed to Calloc KeepAlive Entry");
return NULL;
}
entry->mode = mode;
entry->timeStamp = OICGetCurrentTime(TIME_IN_US);
entry->remoteAddr.adapter = endpoint->adapter;
entry->remoteAddr.flags = endpoint->flags;
entry->remoteAddr.ifindex = endpoint->ifindex;
entry->remoteAddr.port = endpoint->port;
strncpy(entry->remoteAddr.addr, endpoint->addr, sizeof(entry->remoteAddr.addr));
entry->intervalSize = DEFAULT_INTERVAL_COUNT;
entry->intervalInfo = intervalInfo;
if (!entry->intervalInfo)
{
entry->intervalInfo = (int64_t*) OICMalloc(entry->intervalSize * sizeof(int64_t));
for (size_t i = 0; i < entry->intervalSize; i++)
{
entry->intervalInfo[i] = KEEPALIVE_MIN_INTERVAL << i;
}
}
entry->interval = entry->intervalInfo[0];
bool result = u_arraylist_add(g_keepAliveConnectionTable, (void *)entry);
if (!result)
{
OIC_LOG(ERROR, TAG, "Adding node to head failed");
OICFree(entry->intervalInfo);
OICFree(entry);
return NULL;
}
return entry;
}
static CAResult_t CAAddNetworkMonitorList(CAInterface_t *ifitem)
{
VERIFY_NON_NULL(g_netInterfaceList, TAG, "g_netInterfaceList is NULL");
VERIFY_NON_NULL(ifitem, TAG, "ifitem is NULL");
ca_mutex_lock(g_networkMonitorContextMutex);
bool result = u_arraylist_add(g_netInterfaceList, (void *) ifitem);
if (!result)
{
OIC_LOG(ERROR, TAG, "u_arraylist_add failed.");
ca_mutex_unlock(g_networkMonitorContextMutex);
return CA_STATUS_FAILED;
}
ca_mutex_unlock(g_networkMonitorContextMutex);
return CA_STATUS_OK;
}
static CAResult_t CAAddInterfaceItem(u_arraylist_t *iflist, int index,
const char *name, int family, uint32_t addr, int flags)
{
CAInterface_t *ifitem = CANewInterfaceItem(index, name, family, addr, flags);
if (!ifitem)
{
return CA_STATUS_FAILED;
}
bool result = u_arraylist_add(iflist, ifitem);
if (!result)
{
OIC_LOG(ERROR, TAG, "u_arraylist_add failed.");
OICFree(ifitem);
return CA_STATUS_FAILED;
}
return CA_STATUS_OK;
}
CAResult_t ca_thread_pool_add_task(ca_thread_pool_t thread_pool, ca_thread_func method,
void *data)
{
OIC_LOG(DEBUG, TAG, "IN");
if(NULL == thread_pool || NULL == method)
{
OIC_LOG(ERROR, TAG, "thread_pool or method was NULL");
return CA_STATUS_INVALID_PARAM;
}
ca_thread_pool_callback_info_t* info = OICMalloc(sizeof(ca_thread_pool_callback_info_t));
if(!info)
{
OIC_LOG(ERROR, TAG, "Failed to allocate for memory wrapper");
return CA_MEMORY_ALLOC_FAILED;
}
info->func = method;
info->data = data;
pthread_t threadHandle;
int result = pthread_create(&threadHandle, NULL, ca_thread_pool_pthreads_delegate, info);
if(result != 0)
{
OIC_LOG_V(ERROR, TAG, "Thread start failed with error %d", result);
return CA_STATUS_FAILED;
}
ca_mutex_lock(thread_pool->details->list_lock);
CAResult_t addResult = u_arraylist_add(thread_pool->details->threads_list, (void*)threadHandle);
ca_mutex_unlock(thread_pool->details->list_lock);
if(addResult != CA_STATUS_OK)
{
OIC_LOG_V(ERROR, TAG, "Arraylist Add failed, may not be properly joined: %d", addResult);
return addResult;
}
OIC_LOG(DEBUG, TAG, "OUT");
return CA_STATUS_OK;
}
static CAResult_t CAAddIdToPeerInfoList(const char *peerAddr, uint32_t port,
const unsigned char *id, uint16_t id_length)
{
if(NULL == peerAddr
|| NULL == id
|| 0 == port
|| 0 == id_length
|| CA_MAX_ENDPOINT_IDENTITY_LEN < id_length)
{
OIC_LOG(ERROR, NET_DTLS_TAG, "CAAddIdToPeerInfoList invalid parameters");
return CA_STATUS_INVALID_PARAM;
}
CASecureEndpoint_t *peer = (CASecureEndpoint_t *)OICCalloc(1, sizeof (CASecureEndpoint_t));
if (NULL == peer)
{
OIC_LOG(ERROR, NET_DTLS_TAG, "peerInfo malloc failed!");
return CA_MEMORY_ALLOC_FAILED;
}
OICStrcpy(peer->endpoint.addr, sizeof(peer->endpoint.addr), peerAddr);
peer->endpoint.port = port;
memcpy(peer->identity.id, id, id_length);
peer->identity.id_length = id_length;
if (NULL != GetPeerInfo(&peer->endpoint))
{
OIC_LOG(ERROR, NET_DTLS_TAG, "CAAddIdToPeerInfoList peer already exist");
OICFree(peer);
return CA_STATUS_FAILED;
}
bool result = u_arraylist_add(g_caDtlsContext->peerInfoList, (void *)peer);
if (!result)
{
OIC_LOG(ERROR, NET_DTLS_TAG, "u_arraylist_add failed!");
OICFree(peer);
return CA_STATUS_FAILED;
}
return CA_STATUS_OK;
}
static CAResult_t CADtlsCacheMsg(stCACacheMessage_t *msg)
{
OIC_LOG(DEBUG, NET_DTLS_TAG, "IN");
if (NULL == g_caDtlsContext)
{
OIC_LOG(ERROR, NET_DTLS_TAG, "Dtls Context is NULL");
return CA_STATUS_FAILED;
}
bool result = u_arraylist_add(g_caDtlsContext->cacheList, (void *)msg);
if (!result)
{
OIC_LOG(ERROR, NET_DTLS_TAG, "u_arraylist_add failed!");
}
OIC_LOG(DEBUG, NET_DTLS_TAG, "OUT");
return result;
}
void CAEDRNativeAddDeviceStateToList(state_t *state)
{
if(!state)
{
OIC_LOG(ERROR, TAG, "[EDR][Native] device is null");
return;
}
if(!g_deviceStateList)
{
OIC_LOG(ERROR, TAG, "[EDR][Native] gdevice_list is null");
return;
}
if(CAEDRNativeIsDeviceInList(state->address)) {
CAEDRNativeRemoveDevice(state->address); // delete previous state for update new state
}
u_arraylist_add(g_deviceStateList, state); // update new state
OIC_LOG_V(DEBUG, TAG, "Set State Info to List : %d", state->state);
}
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;
}
void CAManagerAddACData(JNIEnv *env, jstring jaddress)
{
OIC_LOG(DEBUG, TAG, "IN-CAManagerAddACData");
VERIFY_NON_NULL_VOID(env, TAG, "env");
VERIFY_NON_NULL_VOID(jaddress, TAG, "jaddress");
ca_mutex_lock(g_deviceACDataListMutex);
if(!CAManagerIsMatchedACData(env, jaddress))
{
OIC_LOG(DEBUG, TAG, "ACdata will be added");
// add CAManagerACData
jobject gaddress = (*env)->NewGlobalRef(env, jaddress);
CAManagerACData_t *data = CAManagerCreateACData(gaddress);
u_arraylist_add(g_deviceACDataList, data);
}
ca_mutex_unlock(g_deviceACDataListMutex);
OIC_LOG(DEBUG, TAG, "OUT-CAManagerAddACData");
}
void CAEDRNativeAddDeviceStateToList(CAConnectedDeviceInfo_t *deviceInfo)
{
if (!deviceInfo)
{
OIC_LOG(ERROR, TAG, "device is null");
return;
}
if (!g_deviceStateList)
{
OIC_LOG(ERROR, TAG, "gdevice_list is null");
return;
}
if (CAEDRNativeIsDeviceInList((const char*) deviceInfo->address))
{
// delete previous state for update new state
CAEDRNativeRemoveDevice((const char*) deviceInfo->address);
}
u_arraylist_add(g_deviceStateList, deviceInfo); // update new state
OIC_LOG_V(DEBUG, TAG, "Set State Info to List : %d", deviceInfo->state);
}
static void CAAcceptConnection()
{
struct sockaddr_storage clientaddr;
socklen_t clientlen = sizeof (struct sockaddr_in);
int sockfd = accept(g_acceptServerFD, (struct sockaddr *)&clientaddr,
&clientlen);
if (-1 != sockfd)
{
CATCPSessionInfo_t *svritem =
(CATCPSessionInfo_t *) OICCalloc(1, sizeof (*svritem));
if (!svritem)
{
OIC_LOG(ERROR, TAG, "Out of memory");
close(sockfd);
return;
}
svritem->fd = sockfd;
CAConvertAddrToName((struct sockaddr_storage *)&clientaddr, clientlen,
(char *) &svritem->sep.endpoint.addr, &svritem->sep.endpoint.port);
ca_mutex_lock(g_mutexObjectList);
bool result = u_arraylist_add(caglobals.tcp.svrlist, svritem);
if (!result)
{
OIC_LOG(ERROR, TAG, "u_arraylist_add failed.");
close(sockfd);
OICFree(svritem);
ca_mutex_unlock(g_mutexObjectList);
return;
}
ca_mutex_unlock(g_mutexObjectList);
CHECKFD(sockfd);
}
}
CAResult_t CAIPGetInterfaceInfo(u_arraylist_t **netInterfaceList)
{
CANetInfo_t *netInfo = (CANetInfo_t *)OICCalloc(1, sizeof(CANetInfo_t));
if (!netInfo)
{
OIC_LOG(ERROR, TAG, "Malloc failed");
return CA_STATUS_FAILED;
}
CAArduinoGetInterfaceAddress(netInfo->ipAddress, CA_IPADDR_SIZE);
CAIPGetSubnetMask(netInfo->subnetMask, CA_IPADDR_SIZE);
// set interface name
strncpy(netInfo->interfaceName, "ETH", strlen(netInfo->interfaceName));
CAResult_t result = u_arraylist_add(*netInterfaceList, (void *)netInfo);
if (CA_STATUS_OK != result)
{
OIC_LOG(ERROR, TAG, "u_arraylist_add failed");
return result;
}
return CA_STATUS_OK;
}
void CAEDRNativeAddDeviceSocketToList(JNIEnv *env, jobject deviceSocket)
{
OIC_LOG(DEBUG, TAG, "[EDR][Native] CANativeAddDeviceobjToList");
if(!deviceSocket)
{
OIC_LOG(ERROR, TAG, "[EDR][Native] Device is null");
return;
}
if(!g_deviceObjectList)
{
OIC_LOG(ERROR, TAG, "[EDR][Native] gdeviceObjectList is null");
return;
}
jstring jni_remoteAddress = CAEDRNativeGetAddressFromDeviceSocket(env, deviceSocket);
if(!jni_remoteAddress)
{
OIC_LOG(ERROR, TAG, "[EDR][Native] jni_remoteAddress is null");
return;
}
u_mutex_lock(g_mutexSocketListManager);
const char* remoteAddress = (*env)->GetStringUTFChars(env, jni_remoteAddress, NULL);
if(!CAEDRNativeIsDeviceSocketInList(env, remoteAddress))
{
jobject gDeviceSocker = (*env)->NewGlobalRef(env, deviceSocket);
u_arraylist_add(g_deviceObjectList, gDeviceSocker);
OIC_LOG(DEBUG, TAG, "Set Socket Object to Array");
}
u_mutex_unlock(g_mutexSocketListManager);
}
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;
}
static bool CACheckIsInterfaceInfoChanged(const CANetInfo_t *info)
{
VERIFY_NON_NULL_RET(info, IP_MONITOR_TAG, "info is null", false);
ca_mutex_lock(g_networkMonitorContextMutex);
uint32_t list_length = u_arraylist_length(g_networkMonitorContext->netInterfaceList);
for (uint32_t list_index = 0; list_index < list_length; list_index++)
{
CANetInfo_t *netInfo = (CANetInfo_t *) u_arraylist_get(
g_networkMonitorContext->netInterfaceList, list_index);
if (!netInfo)
{
continue;
}
if (strncmp(netInfo->interfaceName, info->interfaceName, strlen(info->interfaceName)) == 0)
{
if (strncmp(netInfo->ipAddress, info->ipAddress, strlen(info->ipAddress)) == 0)
{
ca_mutex_unlock(g_networkMonitorContextMutex);
return false;
}
else
{
OIC_LOG(DEBUG, IP_MONITOR_TAG, "Network interface info changed");
if (u_arraylist_remove(g_networkMonitorContext->netInterfaceList, list_index))
{
if (g_networkMonitorContext->networkChangeCb)
{
g_networkMonitorContext->networkChangeCb(netInfo->ipAddress,
CA_INTERFACE_DOWN);
}
OICFree(netInfo);
}
else
{
OIC_LOG(ERROR, IP_MONITOR_TAG, "u_arraylist_remove failed");
}
break;
}
}
}
CANetInfo_t *newNetInfo = (CANetInfo_t *) OICMalloc(sizeof(CANetInfo_t));
if (!newNetInfo)
{
OIC_LOG(ERROR, IP_MONITOR_TAG, "newNetInfo malloc failed");
ca_mutex_unlock(g_networkMonitorContextMutex);
return false;
}
*newNetInfo = *info;
OIC_LOG(DEBUG, IP_MONITOR_TAG, "New Interface found");
CAResult_t result = u_arraylist_add(g_networkMonitorContext->netInterfaceList,
(void *) newNetInfo);
if (CA_STATUS_OK != result)
{
OIC_LOG(ERROR, IP_MONITOR_TAG, "u_arraylist_add failed!");
OICFree(newNetInfo);
ca_mutex_unlock(g_networkMonitorContextMutex);
return false;
}
ca_mutex_unlock(g_networkMonitorContextMutex);
/*Callback will be unset only at the time of termination. By that time, all the threads will be
stopped gracefully. This callback is properly protected*/
if (g_networkMonitorContext->networkChangeCb)
{
g_networkMonitorContext->networkChangeCb(newNetInfo->ipAddress, CA_INTERFACE_UP);
}
return true;
}
static CAResult_t CAIPUpdateInterfaceInformation(u_arraylist_t **netInterfaceList)
{
OIC_LOG(DEBUG, IP_MONITOR_TAG, "IN");
VERIFY_NON_NULL(netInterfaceList, IP_MONITOR_TAG, "netInterfaceList is null");
/* Get a socket handle. */
int sck = -1;
#ifdef SOCK_CLOEXEC
sck = socket(AF_INET, SOCK_DGRAM | SOCK_CLOEXEC, IPPROTO_UDP);
#endif
if ( -1 == sck)
{
sck=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
}
if (sck < 0)
{
OIC_LOG(ERROR, IP_MONITOR_TAG, "Error in socket creation");
return CA_STATUS_FAILED;
}
char buf[MAX_INTERFACE_INFO_LENGTH] = { 0 };
struct ifconf ifc;
/* Query available interfaces. */
ifc.ifc_len = MAX_INTERFACE_INFO_LENGTH;
ifc.ifc_buf = buf;
if (ioctl(sck, SIOCGIFCONF, &ifc) < 0)
{
close(sck);
OIC_LOG(ERROR, IP_MONITOR_TAG, "Failed to get interface info");
return CA_STATUS_FAILED;
}
/* Iterate through the list of interfaces. */
struct ifreq* ifr = ifc.ifc_req;
int32_t interfaces = ifc.ifc_len / sizeof(struct ifreq);
OIC_LOG_V(DEBUG, IP_MONITOR_TAG, "CAIPUpdateInterfaceInformation : %d", interfaces);
if(0 == interfaces)
{
OIC_LOG(ERROR, IP_MONITOR_TAG, "no interfaces");
return CA_STATUS_FAILED;
}
for (int32_t i = 0; i < interfaces; i++)
{
struct ifreq temp_ifr = { 0 };
struct ifreq* item = &ifr[i];
char interfaceAddress[CA_IPADDR_SIZE] = { 0 };
char interfaceSubnetMask[CA_IPADDR_SIZE] = { 0 };
socklen_t len = sizeof(struct sockaddr_in);
OICStrcpy(temp_ifr.ifr_name, sizeof(temp_ifr.ifr_name), item->ifr_name);
if (ioctl(sck, SIOCGIFFLAGS, &temp_ifr))
{
OIC_LOG(ERROR, IP_MONITOR_TAG,
"CAIPUpdateInterfaceInformation, SIOCGIFFLAGS Failed");
close(sck);
return CA_STATUS_FAILED;
}
if ((temp_ifr.ifr_flags & IFF_LOOPBACK)
|| !(temp_ifr.ifr_flags & IFF_UP) || !(temp_ifr.ifr_flags & IFF_RUNNING))
{
OIC_LOG_V(ERROR, IP_MONITOR_TAG,
"interface is not up or not running or loopback = %x", temp_ifr.ifr_flags);
continue;
}
if (AF_INET != ((struct sockaddr_in*) &item->ifr_addr)->sin_family)
{
continue;
}
//get the interface ip address
if (0 != getnameinfo(&item->ifr_addr, len, interfaceAddress, sizeof(interfaceAddress),
NULL, 0, NI_NUMERICHOST))
{
OIC_LOG_V(ERROR, IP_MONITOR_TAG, "Failed to get IPAddress, Error code: %s",
strerror(errno));
close(sck);
return CA_STATUS_FAILED;
}
if (ioctl((int) sck, SIOCGIFNETMASK, item) < 0)
{
OIC_LOG(ERROR, IP_MONITOR_TAG,
"CAIPUpdateInterfaceInformation, SIOCGIFNETMASK Failed");
close(sck);
return CA_STATUS_FAILED;
}
// get the interface subnet mask
if (0 != getnameinfo(&item->ifr_netmask, len, interfaceSubnetMask,
sizeof(interfaceSubnetMask), NULL, 0, NI_NUMERICHOST))
{
OIC_LOG_V(ERROR, IP_MONITOR_TAG, "Failed to get subnet mask, Error code: %s",
strerror(errno));
close(sck);
return CA_STATUS_FAILED;
}
CANetInfo_t *netInfo = (CANetInfo_t *) OICCalloc(1, sizeof(CANetInfo_t));
if (!netInfo)
{
OIC_LOG(ERROR, IP_MONITOR_TAG, "Malloc failed");
close(sck);
return CA_MEMORY_ALLOC_FAILED;
}
// set interface name
OICStrcpy(netInfo->interfaceName, sizeof(netInfo->interfaceName), item->ifr_name);
// set local ip address
OICStrcpy(netInfo->ipAddress, sizeof(netInfo->ipAddress), interfaceAddress);
// set subnet mask
OICStrcpy(netInfo->subnetMask, sizeof(netInfo->subnetMask), interfaceSubnetMask);
CAResult_t result = u_arraylist_add(*netInterfaceList, (void *) netInfo);
if (CA_STATUS_OK != result)
{
OIC_LOG(ERROR, IP_MONITOR_TAG, "u_arraylist_add failed!Thread exiting.");
close(sck);
return CA_STATUS_FAILED;
}
OIC_LOG_V(DEBUG, IP_MONITOR_TAG, "ipAddress : %s, interfaceName : %s, subnetmask : %s",
netInfo->ipAddress, netInfo->interfaceName, netInfo->subnetMask);
}
close(sck);
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");
}
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;
}
