static size_t CAQueueTCPData(bool isMulticast, const CAEndpoint_t *endpoint,
const void *data, size_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_NON_NULL_RET(g_sendQueueHandle, TAG, "sendQueueHandle", -1);
// Create TCPData to add to queue
CATCPData *tcpData = CACreateTCPData(endpoint, data, dataLength, isMulticast);
if (!tcpData)
{
OIC_LOG(ERROR, TAG, "Failed to create ipData!");
return -1;
}
// Add message to send queue
CAQueueingThreadAddData(g_sendQueueHandle, tcpData, sizeof(CATCPData));
return dataLength;
}
int32_t CASendEDRUnicastData(const CAEndpoint_t *remoteEndpoint, const void *data,
uint32_t dataLength)
{
OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
// Input validation
VERIFY_NON_NULL_RET(remoteEndpoint, EDR_ADAPTER_TAG, "Remote endpoint is null", -1);
VERIFY_NON_NULL_RET(data, EDR_ADAPTER_TAG, "Data is null", -1);
if (0 == dataLength)
{
OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Invalid input: data length is zero!");
return -1;
}
if (0 == strlen(remoteEndpoint->addr))
{
OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Invalid input: EDR Address is empty!");
return -1;
}
uint32_t sentLength = 0;
const char *serviceUUID = OIC_EDR_SERVICE_ID;
const char *address = remoteEndpoint->addr;
CAResult_t err = CAAdapterSendData(address, serviceUUID, data, dataLength, &sentLength);
if (CA_STATUS_OK != err)
{
OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Send unicast data failed!, error num [%d]", err);
g_errorCallback(remoteEndpoint, data, dataLength, err);
return -1;
}
OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
return sentLength;
}
jobject CAManagerConnectGatt(JNIEnv *env, jstring remote_le_address)
{
VERIFY_NON_NULL_RET(env, TAG, "env", NULL);
VERIFY_NON_NULL_RET(remote_le_address, TAG, "remote_le_address", NULL);
OIC_LOG(DEBUG, TAG, "IN - CAManagerConnectGatt");
jobject jni_bluetooth = CAManagerGetRemoteDevice(env, remote_le_address);
if (!jni_bluetooth)
{
OIC_LOG(ERROR, TAG, "jni_bluetooth is null");
return NULL;
}
if (!CAManagerIsDeviceBonded(env, jni_bluetooth))
{
OIC_LOG(INFO, TAG, "device is BONDED_NONE");
}
// request to connection with AutoConnection Flag
OIC_LOG(INFO, TAG, "request gatt connection by CM auto connector");
jobject newGatt = (jobject)CALEClientConnect(env, jni_bluetooth, JNI_TRUE);
if (NULL == newGatt)
{
OIC_LOG(INFO, TAG, "re-connection will be started");
return NULL;
}
// set flag auto connection is requested.
CAManagerSetAutoConnectingFlag(env, remote_le_address, true);
OIC_LOG(DEBUG, TAG, "OUT - CAManagerConnectGatt");
return newGatt;
}
CAResult_t CABleGattDiscoverCharacteristics(bt_gatt_attribute_h service,
const char *remoteAddress)
{
OIC_LOG(DEBUG, TZ_BLE_CLIENT_TAG, "IN");
VERIFY_NON_NULL_RET(service, TZ_BLE_CLIENT_TAG, "service is NULL", CA_STATUS_FAILED);
VERIFY_NON_NULL_RET(remoteAddress, TZ_BLE_CLIENT_TAG, "remoteAddress is NULL", CA_STATUS_FAILED);
char *addr = OICStrdup(remoteAddress);
VERIFY_NON_NULL_RET(addr, TZ_BLE_CLIENT_TAG, "Malloc failed", CA_STATUS_FAILED);
int32_t ret = bt_gatt_discover_characteristics(service, CABleGattCharacteristicsDiscoveredCb,
(void *)addr); // addr will be freed in callback.
if (BT_ERROR_NONE != ret)
{
OIC_LOG_V(ERROR, TZ_BLE_CLIENT_TAG,
"bt_gatt_discover_characteristics failed with error [%d]", ret);
OICFree(addr);
return CA_STATUS_FAILED;
}
OIC_LOG(DEBUG, TZ_BLE_CLIENT_TAG, "OUT");
return CA_STATUS_OK;
}
static int32_t CAQueueIPData(bool isMulticast, const CAEndpoint_t *endpoint,
const void *data, uint32_t dataLength)
{
VERIFY_NON_NULL_RET(endpoint, TAG, "remoteEndpoint", -1);
VERIFY_NON_NULL_RET(data, TAG, "data", -1);
if (0 == dataLength)
{
OIC_LOG(ERROR, TAG, "Invalid Data Length");
return -1;
}
#ifdef SINGLE_THREAD
CAIPSendData(endpoint, data, dataLength, isMulticast);
return dataLength;
#else
VERIFY_NON_NULL_RET(g_sendQueueHandle, TAG, "sendQueueHandle", -1);
// Create IPData to add to queue
CAIPData_t *ipData = CACreateIPData(endpoint, data, dataLength, isMulticast);
if (!ipData)
{
OIC_LOG(ERROR, TAG, "Failed to create ipData!");
return -1;
}
// Add message to send queue
CAQueueingThreadAddData(g_sendQueueHandle, ipData, sizeof(CAIPData_t));
#endif // SINGLE_THREAD
return dataLength;
}
CAIPData_t *CACreateIPData(const CAEndpoint_t *remoteEndpoint, const void *data,
uint32_t dataLength, bool isMulticast)
{
VERIFY_NON_NULL_RET(remoteEndpoint, TAG, "remoteEndpoint is NULL", NULL);
VERIFY_NON_NULL_RET(data, TAG, "IPData is NULL", NULL);
CAIPData_t *ipData = (CAIPData_t *) OICMalloc(sizeof(*ipData));
if (!ipData)
{
OIC_LOG(ERROR, TAG, "Memory allocation failed!");
return NULL;
}
ipData->remoteEndpoint = CACloneEndpoint(remoteEndpoint);
ipData->data = (void *) OICMalloc(dataLength);
if (!ipData->data)
{
OIC_LOG(ERROR, TAG, "Memory allocation failed!");
CAFreeIPData(ipData);
return NULL;
}
memcpy(ipData->data, data, dataLength);
ipData->dataLen = dataLength;
ipData->isMulticast = isMulticast;
return ipData;
}
static eDtlsRet_t CAAdapterNetDtlsDecryptInternal(const stCADtlsAddrInfo_t *srcSession,
uint8_t *buf, uint32_t bufLen)
{
OIC_LOG(DEBUG, NET_DTLS_TAG, "IN");
VERIFY_NON_NULL_RET(srcSession, NET_DTLS_TAG, "Param srcSession is NULL", DTLS_FAIL);
VERIFY_NON_NULL_RET(buf, NET_DTLS_TAG, "Param buf is NULL", DTLS_FAIL);
if (0 == bufLen)
{
OIC_LOG(ERROR, NET_DTLS_TAG, "Given Packet length is equal to zero.");
return DTLS_FAIL;
}
eDtlsRet_t ret = DTLS_FAIL;
if (dtls_handle_message(g_caDtlsContext->dtlsContext, (session_t *)srcSession, buf, bufLen) == 0)
{
OIC_LOG(DEBUG, NET_DTLS_TAG, "dtls_handle_message success");
ret = DTLS_OK;
}
OIC_LOG(DEBUG, NET_DTLS_TAG, "OUT");
return ret;
}
jmethodID CAGetJNIMethodID(JNIEnv *env, const char* className,
const char* methodName,
const char* methodFormat)
{
VERIFY_NON_NULL_RET(env, CA_ADAPTER_UTILS_TAG, "env", NULL);
VERIFY_NON_NULL_RET(className, CA_ADAPTER_UTILS_TAG, "className", NULL);
VERIFY_NON_NULL_RET(methodName, CA_ADAPTER_UTILS_TAG, "methodName", NULL);
VERIFY_NON_NULL_RET(methodFormat, CA_ADAPTER_UTILS_TAG, "methodFormat", NULL);
jclass jni_cid = (*env)->FindClass(env, className);
if (!jni_cid)
{
OIC_LOG_V(ERROR, CA_ADAPTER_UTILS_TAG, "jni_cid [%s] is null", className);
return NULL;
}
jmethodID jni_midID = (*env)->GetMethodID(env, jni_cid, methodName, methodFormat);
if (!jni_midID)
{
OIC_LOG_V(ERROR, CA_ADAPTER_UTILS_TAG, "jni_midID [%s] is null", methodName);
(*env)->DeleteLocalRef(env, jni_cid);
return NULL;
}
(*env)->DeleteLocalRef(env, jni_cid);
return jni_midID;
}
jint CALEGetConstantsValue(JNIEnv *env, const char* classType, const char* name)
{
OIC_LOG(DEBUG, TAG, "CALEGetConstantsValue");
VERIFY_NON_NULL_RET(env, TAG, "env", -1);
VERIFY_NON_NULL_RET(classType, TAG, "classType", -1);
VERIFY_NON_NULL_RET(name, TAG, "name", -1);
jclass jni_cid = (*env)->FindClass(env, classType);
if (!jni_cid)
{
OIC_LOG(ERROR, TAG, "jni_cid is null");
return -1;
}
jfieldID jni_fieldID = (*env)->GetStaticFieldID(env, jni_cid,
name, "I");
if (!jni_fieldID)
{
OIC_LOG(ERROR, TAG, "jni_fieldID is null");
return -1;
}
return (*env)->GetStaticIntField(env, jni_cid, jni_fieldID);
}
jobject CALEGetParcelUuid(JNIEnv *env, jobject uuid)
{
VERIFY_NON_NULL_RET(env, TAG, "env is null", NULL);
VERIFY_NON_NULL_RET(uuid, TAG, "uuid is null", NULL);
jclass jni_cid_ParcelUuid = (*env)->FindClass(env, "android/os/ParcelUuid");
if (!jni_cid_ParcelUuid)
{
OIC_LOG(ERROR, TAG, "jni_cid_ParcelUuid is not available");
return NULL;
}
jmethodID jni_mid_ParcelUuid = (*env)->GetMethodID(env, jni_cid_ParcelUuid, "<init>",
"(Ljava/util/UUID;)V");
if (!jni_mid_ParcelUuid)
{
OIC_LOG(ERROR, TAG, "jni_mid_ParcelUuid is not available");
return NULL;
}
jobject jni_ParcelUuid = (*env)->NewObject(env, jni_cid_ParcelUuid, jni_mid_ParcelUuid, uuid);
if (!jni_ParcelUuid)
{
OIC_LOG(ERROR, TAG, "Fail to get jni ParcelUuid");
return NULL;
}
return jni_ParcelUuid;
}
jstring CALEGetAddressFromBTDevice(JNIEnv *env, jobject bluetoothDevice)
{
VERIFY_NON_NULL_RET(env, TAG, "env is null", NULL);
VERIFY_NON_NULL_RET(bluetoothDevice, TAG, "bluetoothDevice is null", NULL);
jclass jni_cid_device_list = (*env)->FindClass(env, "android/bluetooth/BluetoothDevice");
if (!jni_cid_device_list)
{
OIC_LOG(ERROR, TAG, "jni_cid_device_list is null");
return NULL;
}
jmethodID jni_mid_getAddress = (*env)->GetMethodID(env, jni_cid_device_list, "getAddress",
"()Ljava/lang/String;");
if (!jni_mid_getAddress)
{
OIC_LOG(ERROR, TAG, "jni_mid_getAddress is null");
return NULL;
}
jstring jni_address = (jstring)(*env)->CallObjectMethod(env, bluetoothDevice,
jni_mid_getAddress);
if (!jni_address)
{
OIC_LOG(ERROR, TAG, "jni_address is null");
return NULL;
}
return jni_address;
}
jint CALEGetBuildVersionCodeForName(JNIEnv *env, const char* versionName)
{
VERIFY_NON_NULL_RET(env, TAG, "env is null", -1);
VERIFY_NON_NULL_RET(versionName, TAG, "versionName is null", -1);
// VERSION is a nested class within android.os.Build (hence "$" rather than "/")
jclass jni_cls_version = (*env)->FindClass(env, "android/os/Build$VERSION_CODES");
if (!jni_cls_version)
{
OIC_LOG(ERROR, TAG, "jni_cls_version is null");
return -1;
}
jfieldID jni_fid_version = (*env)->GetStaticFieldID(env, jni_cls_version, versionName, "I");
if (!jni_fid_version)
{
OIC_LOG(ERROR, TAG, "jni_fid_version is null");
return -1;
}
jint jni_int_version = (*env)->GetStaticIntField(env, jni_cls_version, jni_fid_version);
OIC_LOG_V(DEBUG, TAG, "version [%s] is %d",versionName, jni_int_version);
return jni_int_version;
}
CAResult_t CABleGattDiscoverServices(const char *remoteAddress)
{
OIC_LOG(DEBUG, TZ_BLE_CLIENT_TAG, "IN");
VERIFY_NON_NULL_RET(remoteAddress, TZ_BLE_CLIENT_TAG,
"remote address is NULL", CA_STATUS_FAILED);
char *addr = OICStrdup(remoteAddress);
VERIFY_NON_NULL_RET(addr, TZ_BLE_CLIENT_TAG, "Malloc failed", CA_STATUS_FAILED);
int32_t ret = bt_gatt_foreach_primary_services(remoteAddress, CABleGattPrimaryServiceCb,
(void *)addr); // addr memory will be free in callback.
if (BT_ERROR_NONE != ret)
{
OIC_LOG_V(ERROR, TZ_BLE_CLIENT_TAG,
"bt_gatt_foreach_primary_services Failed with ret value [%d] ", ret);
OICFree(addr);
return CA_STATUS_FAILED;
}
else
{
OIC_LOG_V(DEBUG, TZ_BLE_CLIENT_TAG,
"bt_gatt_foreach_primary_services success for address [%s]", remoteAddress);
}
OIC_LOG(DEBUG, TZ_BLE_CLIENT_TAG, "OUT");
return CA_STATUS_OK;
}
CATCPData *CACreateTCPData(const CAEndpoint_t *remoteEndpoint, const void *data,
size_t dataLength, bool isMulticast)
{
VERIFY_NON_NULL_RET(remoteEndpoint, TAG, "remoteEndpoint is NULL", NULL);
VERIFY_NON_NULL_RET(data, TAG, "data is NULL", NULL);
CATCPData *tcpData = (CATCPData *) OICCalloc(1, sizeof(*tcpData));
if (!tcpData)
{
OIC_LOG(ERROR, TAG, "Memory allocation failed!");
return NULL;
}
tcpData->remoteEndpoint = CACloneEndpoint(remoteEndpoint);
tcpData->data = (void *) OICMalloc(dataLength);
if (!tcpData->data)
{
OIC_LOG(ERROR, TAG, "Memory allocation failed!");
CAFreeTCPData(tcpData);
return NULL;
}
memcpy(tcpData->data, data, dataLength);
tcpData->dataLen = dataLength;
tcpData->isMulticast = isMulticast;
return tcpData;
}
bool CAManagerGetAutoConnectionFlag(JNIEnv *env, jstring jaddress)
{
OIC_LOG(DEBUG, TAG, "IN-CAManagerGetAutoConnectionFlag");
VERIFY_NON_NULL_RET(env, TAG, "env", NULL);
VERIFY_NON_NULL_RET(jaddress, TAG, "jaddress", NULL);
ca_mutex_lock(g_deviceACDataListMutex);
const char* address = (*env)->GetStringUTFChars(env, jaddress, NULL);
if (!address)
{
OIC_LOG(ERROR, TAG, "address is null");
ca_mutex_unlock(g_deviceACDataListMutex);
return CA_STATUS_FAILED;
}
size_t length = u_arraylist_length(g_deviceACDataList);
for (size_t idx = 0; idx < length; idx++)
{
CAManagerACData_t *curData = (CAManagerACData_t *) u_arraylist_get(g_deviceACDataList,
idx);
if (!curData)
{
OIC_LOG(ERROR, TAG, "curData is null");
(*env)->ReleaseStringUTFChars(env, jaddress, address);
ca_mutex_unlock(g_deviceACDataListMutex);
return CA_STATUS_FAILED;
}
const char* setAddress = (*env)->GetStringUTFChars(env, curData->address, NULL);
if (!setAddress)
{
OIC_LOG(ERROR, TAG, "setAddress is null");
(*env)->ReleaseStringUTFChars(env, jaddress, address);
ca_mutex_unlock(g_deviceACDataListMutex);
return CA_STATUS_FAILED;
}
if (!strcmp(setAddress, address))
{
(*env)->ReleaseStringUTFChars(env, curData->address, setAddress);
(*env)->ReleaseStringUTFChars(env, jaddress, address);
ca_mutex_unlock(g_deviceACDataListMutex);
OIC_LOG_V(DEBUG, TAG, "flag is %d", curData->isAutoConnect);
return curData->isAutoConnect;
}
(*env)->ReleaseStringUTFChars(env, curData->address, setAddress);
}
(*env)->ReleaseStringUTFChars(env, jaddress, address);
ca_mutex_unlock(g_deviceACDataListMutex);
OIC_LOG(DEBUG, TAG, "OUT-CAManagerGetAutoConnectionFlag");
return false;
}
jobject CALEGetRemoteDevice(JNIEnv *env, jstring address)
{
OIC_LOG(DEBUG, TAG, "IN - CALEGetRemoteDevice");
VERIFY_NON_NULL_RET(env, TAG, "env is null", NULL);
VERIFY_NON_NULL_RET(address, TAG, "address is null", NULL);
jclass jni_cid_BTAdapter = (*env)->FindClass(env, CLASSPATH_BT_ADAPTER);
if (!jni_cid_BTAdapter)
{
OIC_LOG(ERROR, TAG, "jni_cid_BTAdapter is null");
return NULL;
}
// get remote bt adapter method
jmethodID jni_mid_getDefaultAdapter = (*env)->GetStaticMethodID(env, jni_cid_BTAdapter,
"getDefaultAdapter",
METHODID_OBJECTNONPARAM);
if (!jni_mid_getDefaultAdapter)
{
OIC_LOG(ERROR, TAG, "jni_mid_getDefaultAdapter is null");
return NULL;
}
// gat bt adapter object
jobject jni_obj_BTAdapter = (*env)->CallStaticObjectMethod(env, jni_cid_BTAdapter,
jni_mid_getDefaultAdapter);
if (!jni_obj_BTAdapter)
{
OIC_LOG(ERROR, TAG, "jni_obj_BTAdapter is null");
return NULL;
}
jmethodID jni_mid_getRemoteDevice = (*env)->GetMethodID(env, jni_cid_BTAdapter,
"getRemoteDevice",
METHODID_BT_REMOTE_DEVICE);
if (!jni_mid_getRemoteDevice)
{
OIC_LOG(ERROR, TAG, "jni_mid_getRemoteDevice is null");
return NULL;
}
jobject jni_obj_device = (*env)->CallObjectMethod(env, jni_obj_BTAdapter,
jni_mid_getRemoteDevice,
address);
if (!jni_obj_device)
{
OIC_LOG(ERROR, TAG, "jni_obj_device is null");
return NULL;
}
OIC_LOG(DEBUG, TAG, "OUT - CALEGetRemoteDevice");
return jni_obj_device;
}
coap_pdu_t *CAParsePDU(const char *data, uint32_t length, uint32_t *outCode,
const CAEndpoint_t *endpoint)
{
VERIFY_NON_NULL_RET(data, TAG, "data", NULL);
VERIFY_NON_NULL_RET(endpoint, TAG, "endpoint", NULL);
coap_transport_t transport = COAP_UDP;
#ifdef WITH_TCP
if (CAIsSupportedCoAPOverTCP(endpoint->adapter))
{
transport = coap_get_tcp_header_type_from_initbyte(((unsigned char *)data)[0] >> 4);
}
/*
* Class: org_iotivity_ca_CaNfcInterface
* Method: caNativeNfcInvokeBeam
* Signature: ()Z
*/
JNIEXPORT jboolean JNICALL
Java_org_iotivity_ca_CaNfcInterface_caNativeNfcInvokeBeam(JNIEnv *env, jobject obj)
{
OIC_LOG(DEBUG, TAG, "cANativeNfcInvokeBeam : IN");
VERIFY_NON_NULL_RET(env, TAG, "env is null", false);
VERIFY_NON_NULL_RET(obj, TAG, "obj is null", false);
VERIFY_NON_NULL_RET(g_context, TAG, "g_context is null", false);
VERIFY_NON_NULL_RET(g_activity, TAG, "g_activity is null", false);
jclass cid_NfcAdapter = (*env)->FindClass(env, "android/nfc/NfcAdapter");
if (!cid_NfcAdapter)
{
OIC_LOG(ERROR, TAG, "Could not get NfcAdapter cid_NfcAdapter ");
return JNI_FALSE;
}
jmethodID mid_getAdapter = (*env)->GetStaticMethodID(env, cid_NfcAdapter,
"getDefaultAdapter",
"(Landroid/content/Context;)Landroid/nfc/NfcAdapter;");
if (!mid_getAdapter)
{
OIC_LOG(ERROR, TAG, "Could not get methodId mid_getAdapter");
return JNI_FALSE;
}
jobject adapter = (*env)->CallStaticObjectMethod(env, cid_NfcAdapter, mid_getAdapter,
g_context);
if (!adapter)
{
OIC_LOG(ERROR, TAG, "getDefaultAdapter failed adapter");
return JNI_FALSE;
}
jmethodID mid_invokeBeam = (*env)->GetMethodID(env, cid_NfcAdapter, "invokeBeam",
"(Landroid/app/Activity;)Z");
if (!mid_invokeBeam)
{
OIC_LOG(ERROR, TAG, "Could not get methodId mid_invokeBeam");
return JNI_FALSE;
}
jboolean isSuccess = (*env)->CallBooleanMethod(env, adapter, mid_invokeBeam, g_activity);
if (!isSuccess)
{
OIC_LOG(ERROR, TAG, "invokeBeam has failed");
}
OIC_LOG(DEBUG, TAG, "cANativeNfcInvokeBeam : OUT");
return isSuccess;
}
bool CAAdapterIsSameSubnet(const char *ipAddress1, const char *ipAddress2,
const char *netMask)
{
VERIFY_NON_NULL_RET(ipAddress1, CA_ADAPTER_UTILS_TAG, "First address", false);
VERIFY_NON_NULL_RET(ipAddress2, CA_ADAPTER_UTILS_TAG, "Second address", false);
VERIFY_NON_NULL_RET(netMask, CA_ADAPTER_UTILS_TAG, "netMask", false);
uint8_t ipList1[IPV4_ADDR_ONE_OCTECT_LEN] = {0};
uint8_t ipList2[IPV4_ADDR_ONE_OCTECT_LEN] = {0};
uint8_t maskList[IPV4_ADDR_ONE_OCTECT_LEN] = {0};
CAResult_t ret = CA_STATUS_OK;
/* Local Loopback Address */
if (0 == strncmp(ipAddress1, "127.", 4)
|| 0 == strncmp(ipAddress2, "127.", 4))
{
return true;
}
uint16_t parsedPort = 0;
ret = CAParseIPv4AddressInternal(ipAddress1, ipList1, sizeof(ipList1),
&parsedPort);
if (ret != CA_STATUS_OK)
{
OIC_LOG_V(ERROR, CA_ADAPTER_UTILS_TAG, "First ip address parse fail %d", ret);
return false;
}
ret = CAParseIPv4AddressInternal(ipAddress2, ipList2, sizeof(ipList2),
&parsedPort);
if (ret != CA_STATUS_OK)
{
OIC_LOG_V(ERROR, CA_ADAPTER_UTILS_TAG, "Second ip address parse fail %d", ret);
return false;
}
ret = CAParseIPv4AddressInternal(netMask, maskList, sizeof(maskList),
&parsedPort);
if (ret != CA_STATUS_OK)
{
OIC_LOG_V(ERROR, CA_ADAPTER_UTILS_TAG, "Net mask parse fail %d", ret);
return false;
}
return ((ipList1[0] & maskList[0]) == (ipList2[0] & maskList[0]))
&& ((ipList1[1] & maskList[1]) == (ipList2[1] & maskList[1]))
&& ((ipList1[2] & maskList[2]) == (ipList2[2] & maskList[2]))
&& ((ipList1[3] & maskList[3]) == (ipList2[3] & maskList[3]));
}
int32_t CASendEDRMulticastData(const CAEndpoint_t *endpoint, const void *data, uint32_t dataLength)
{
OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN - CASendEDRMulticastData");
// Input validation
VERIFY_NON_NULL_RET(data, EDR_ADAPTER_TAG, "Data is null", -1);
if (0 == dataLength)
{
OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Invalid input: data length is zero!");
return -1;
}
uint32_t sentLen = 0;
const char *serviceUUID = OIC_EDR_SERVICE_ID;
CAResult_t err = CAAdapterSendData(NULL, serviceUUID, data, dataLength, &sentLen);
if (CA_STATUS_OK != err)
{
OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Send multicast data failed!, error num [%d]", err);
g_errorCallback(endpoint, data, dataLength, err);
return -1;
}
OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT - CASendEDRMulticastData");
return sentLen;
}
CAResult_t CABleGattConnect(const char *remoteAddress)
{
OIC_LOG(DEBUG, TZ_BLE_CLIENT_TAG, "IN");
VERIFY_NON_NULL_RET(remoteAddress, TZ_BLE_CLIENT_TAG,
"remote address is NULL", CA_STATUS_FAILED);
//Because of the platform issue, we added. Once platform is stablized, then it will be removed
sleep(1);
ca_mutex_lock(g_bleClientConnectMutex);
int ret = bt_gatt_connect(remoteAddress, true);
if (BT_ERROR_NONE != ret)
{
OIC_LOG_V(ERROR, TZ_BLE_CLIENT_TAG, "bt_gatt_connect Failed with ret value [%s] ",
CABTGetErrorMsg(ret));
ca_mutex_unlock(g_bleClientConnectMutex);
return CA_STATUS_FAILED;
}
ca_mutex_unlock(g_bleClientConnectMutex);
OIC_LOG(DEBUG, TZ_BLE_CLIENT_TAG, "OUT");
return CA_STATUS_OK;
}
bool CAManagerIsMatchedACData(JNIEnv *env, jstring jaddress)
{
VERIFY_NON_NULL_RET(env, TAG, "env", NULL);
VERIFY_NON_NULL_RET(jaddress, TAG, "jaddress", false);
const char* address = (*env)->GetStringUTFChars(env, jaddress, NULL);
if (!address)
{
OIC_LOG(ERROR, TAG, "address is null");
return false;
}
size_t length = u_arraylist_length(g_deviceACDataList);
for (size_t idx = 0; idx < length; idx++)
{
CAManagerACData_t *curData = (CAManagerACData_t *) u_arraylist_get(g_deviceACDataList,
idx);
if (!curData)
{
OIC_LOG(ERROR, TAG, "curData is null");
(*env)->ReleaseStringUTFChars(env, jaddress, address);
return false;
}
const char* setAddress = (*env)->GetStringUTFChars(env, curData->address, NULL);
if (!setAddress)
{
OIC_LOG(ERROR, TAG, "address is null");
(*env)->ReleaseStringUTFChars(env, jaddress, address);
return false;
}
if (!strcmp(setAddress, address))
{
(*env)->ReleaseStringUTFChars(env, curData->address, setAddress);
(*env)->ReleaseStringUTFChars(env, jaddress, address);
return true;
}
(*env)->ReleaseStringUTFChars(env, curData->address, setAddress);
}
(*env)->ReleaseStringUTFChars(env, jaddress, address);
return false;
}
static uint32_t CASendData(const char *remoteAddress, uint16_t port,
const void *data, uint32_t dataLength, int sockfd)
{
OIC_LOG(DEBUG, WIFI_CLIENT_TAG, "IN");
VERIFY_NON_NULL_RET(remoteAddress, WIFI_CLIENT_TAG, "IP address is NULL", 0);
VERIFY_NON_NULL_RET(data, WIFI_CLIENT_TAG, "data is NULL", 0);
if (dataLength == 0)
{
OIC_LOG(ERROR, WIFI_CLIENT_TAG, "Data length is 0 !");
return 0;
}
if (0 > sockfd)
{
OIC_LOG(ERROR, WIFI_CLIENT_TAG, "Unicast Server is not running !");
return 0;
}
struct sockaddr_in destAddr = {0};
destAddr.sin_family = AF_INET;
destAddr.sin_port = htons(port);
// Conversion from ASCII format to Network format
if (inet_aton(remoteAddress, &destAddr.sin_addr) == 0)
{
OIC_LOG(ERROR, WIFI_CLIENT_TAG, "Failed to convert from ASCII to Network Address");
return 0;
}
int sendDataLength = sendto(sockfd, data, dataLength, 0,
(struct sockaddr *)&destAddr, sizeof(destAddr));
if (sendDataLength == -1)
{
OIC_LOG_V(ERROR, WIFI_CLIENT_TAG, "Failed to Send Data, Error code: %s", strerror(errno));
return 0;
}
OIC_LOG_V(INFO, WIFI_CLIENT_TAG, "Sending data is successful, sent bytes[%d]", sendDataLength);
OIC_LOG(DEBUG, WIFI_CLIENT_TAG, "OUT");
return sendDataLength;
}
static eDtlsRet_t CAAdapterNetDtlsEncryptInternal(const stCADtlsAddrInfo_t *dstSession,
uint8_t *data, uint32_t dataLen)
{
OIC_LOG(DEBUG, NET_DTLS_TAG, "IN");
VERIFY_NON_NULL_RET(dstSession, NET_DTLS_TAG, "Param dstSession is NULL" , DTLS_FAIL);
VERIFY_NON_NULL_RET(data, NET_DTLS_TAG, "Param data is NULL" , DTLS_FAIL);
if (0 == dataLen)
{
OIC_LOG(ERROR, NET_DTLS_TAG, "Given Packet length is equal to zero.");
return DTLS_FAIL;
}
if (NULL == g_caDtlsContext)
{
OIC_LOG(ERROR, NET_DTLS_TAG, "Context is NULL");
return DTLS_FAIL;
}
int retLen = dtls_write(g_caDtlsContext->dtlsContext, (session_t *)dstSession, data,
dataLen);
OIC_LOG_V(DEBUG, NET_DTLS_TAG, "dtls_write retun len [%d]", retLen);
if (retLen < 0)
{
OIC_LOG(DEBUG, NET_DTLS_TAG, "OUT FAILURE");
return DTLS_FAIL;
}
if (0 == retLen)
{
// A new DTLS session was initiated by tinyDTLS library and wait for callback.
return DTLS_SESSION_INITIATED;
}
else if (dataLen != (uint32_t)retLen)
{
OIC_LOG(DEBUG, NET_DTLS_TAG, "OUT FAILURE");
return DTLS_FAIL;
}
OIC_LOG(DEBUG, NET_DTLS_TAG, "OUT");
return DTLS_OK;
}
jobject CALEGetUuidFromString(JNIEnv *env, const char* uuid)
{
VERIFY_NON_NULL_RET(uuid, TAG, "uuid is null", NULL);
VERIFY_NON_NULL_RET(env, TAG, "env is null", NULL);
OIC_LOG(DEBUG, TAG, "CALEGetUuidFromString");
jclass jni_cid_UUID = (*env)->FindClass(env, "java/util/UUID");
if (!jni_cid_UUID)
{
OIC_LOG(ERROR, TAG, "jni_cid_UUID is not available");
return NULL;
}
jmethodID jni_mid_fromString = (*env)->GetStaticMethodID(env, jni_cid_UUID, "fromString",
"(Ljava/lang/String;)"
"Ljava/util/UUID;");
if (!jni_mid_fromString)
{
OIC_LOG(ERROR, TAG, "jni_mid_fromString is not available");
return NULL;
}
jstring str_uuid = (*env)->NewStringUTF(env, uuid);
if (!str_uuid)
{
OIC_LOG(ERROR, TAG, "str_uuid is not available");
return NULL;
}
jobject jni_obj_uuid = (*env)->CallStaticObjectMethod(env, jni_cid_UUID, jni_mid_fromString,
str_uuid);
if (!jni_obj_uuid)
{
OIC_LOG(ERROR, TAG, "Fail to get jni uuid object");
return NULL;
}
return jni_obj_uuid;
}
static bool CACheckIsAnyInterfaceDown(const u_arraylist_t *netInterfaceList,
const CANetInfo_t *info)
{
VERIFY_NON_NULL_RET(netInterfaceList, IP_MONITOR_TAG, "netInterfaceList is null", false);
VERIFY_NON_NULL_RET(info, IP_MONITOR_TAG, "info is null", false);
uint32_t list_length = u_arraylist_length(netInterfaceList);
for (uint32_t list_index = 0; list_index < list_length; list_index++)
{
CANetInfo_t *netInfo = (CANetInfo_t *) u_arraylist_get(netInterfaceList, list_index);
if (!netInfo)
{
continue;
}
if (strncmp(netInfo->interfaceName, info->interfaceName, strlen(info->interfaceName)) == 0)
{
return false;
}
}
OIC_LOG(DEBUG, IP_MONITOR_TAG, "Interface is down");
return true;
}
void *u_linklist_get_next(u_linklist_iterator_t **iter)
{
VERIFY_NON_NULL_RET(iter, TAG, "iterator is null", NULL);
*iter = (*iter)->next;
if (NULL != *iter)
{
return (*iter)->data;
}
else
{
return NULL;
}
}
bool CALEIsBondedDevice(JNIEnv *env, jobject bluetoothDevice)
{
VERIFY_NON_NULL_RET(env, TAG, "env is null", false);
VERIFY_NON_NULL_RET(bluetoothDevice, TAG, "bluetoothDevice is null", false);
jclass jni_cid_device_list = (*env)->FindClass(env, "android/bluetooth/BluetoothDevice");
if (!jni_cid_device_list)
{
OIC_LOG(ERROR, TAG, "jni_cid_device_list is null");
return false;
}
jmethodID jni_mid_getBondState = (*env)->GetMethodID(env, jni_cid_device_list, "getBondState",
"()I");
if (!jni_mid_getBondState)
{
OIC_LOG(ERROR, TAG, "jni_mid_getBondState is null");
return false;
}
jint jni_bondState = (jint)(*env)->CallIntMethod(env, bluetoothDevice, jni_mid_getBondState);
OIC_LOG_V(DEBUG, TAG, "bond state is %d", jni_bondState);
if (BOND_BONDED == jni_bondState)
{
OIC_LOG(DEBUG, TAG, "remote device is bonded");
return true;
}
else
{
OIC_LOG(DEBUG, TAG, "remote device is not bonded");
return false;
}
return false;
}
CARemoteEndpoint_t *CAAdapterCopyRemoteEndpoint(const CARemoteEndpoint_t *remoteEndpoint)
{
VERIFY_NON_NULL_RET(remoteEndpoint, CA_ADAPTER_UTILS_TAG, "Remote endpoint is NULL", NULL);
CARemoteEndpoint_t *info = (CARemoteEndpoint_t *)
OICCalloc(1, sizeof(CARemoteEndpoint_t));
if (NULL == info)
{
OIC_LOG(ERROR, CA_ADAPTER_UTILS_TAG, "Memory allocation failed !");
return NULL;
}
info->connectivityType = remoteEndpoint->connectivityType;
if (CA_EDR == info->connectivityType && strlen(remoteEndpoint->addressInfo.BT.btMacAddress))
{
strncpy(info->addressInfo.BT.btMacAddress, remoteEndpoint->addressInfo.BT.btMacAddress,
CA_MACADDR_SIZE - 1);
info->addressInfo.BT.btMacAddress[CA_MACADDR_SIZE - 1] = '\0';
}
else if (CA_LE == info->connectivityType && strlen(remoteEndpoint->addressInfo.LE.leMacAddress))
{
strncpy(info->addressInfo.LE.leMacAddress, remoteEndpoint->addressInfo.LE.leMacAddress,
CA_MACADDR_SIZE - 1);
info->addressInfo.LE.leMacAddress[CA_MACADDR_SIZE - 1] = '\0';
}
else if ((CA_WIFI == info->connectivityType || CA_ETHERNET == info->connectivityType)
&& strlen(remoteEndpoint->addressInfo.IP.ipAddress))
{
strncpy(info->addressInfo.IP.ipAddress, remoteEndpoint->addressInfo.IP.ipAddress,
CA_IPADDR_SIZE - 1);
info->addressInfo.IP.ipAddress[CA_IPADDR_SIZE - 1] = '\0';
info->addressInfo.IP.port = remoteEndpoint->addressInfo.IP.port;
}
else
{
OIC_LOG(DEBUG, CA_ADAPTER_UTILS_TAG, "Its not matching. May be multicast.");
}
//For Multicast, remote address will be null while resourceUri will have the service UUID
if (remoteEndpoint->resourceUri && strlen(remoteEndpoint->resourceUri))
{
info->resourceUri = OICStrdup(remoteEndpoint->resourceUri);
}
info->isSecured = remoteEndpoint->isSecured;
return info;
}
uint16_t CALEServerGetMtuSize(const char* address)
{
OIC_LOG(DEBUG, TAG, "IN");
VERIFY_NON_NULL_RET(address, TAG, "address is null", CA_DEFAULT_BLE_MTU_SIZE);
unsigned int mtu;
int ret = bt_device_get_att_mtu(address, &mtu);
if (0 != ret)
{
OIC_LOG_V(ERROR, TAG,
"bt_device_get_att_mtu failed with return [%s]", CALEGetErrorMsg(ret));
return CA_DEFAULT_BLE_MTU_SIZE;
}
OIC_LOG_V(INFO, TAG, "mtu size(including header) from bt_device_get_att_mtu is %d", mtu);
OIC_LOG(DEBUG, TAG, "OUT");
return mtu - CA_BLE_MTU_HEADER_SIZE;
}
