Apply the resece updates from 'master' branch into 'resource-manipulation' branch
This update includes the fix of current 'presence' issues.
Change-Id: I4417164bd31285e80d9dd4b655e6f828ee1b6fe0
Signed-off-by: hunje.yeon <hunje.yeon@samsung.com>
{
}
+Middle::~Middle()
+{
+ delete m_client;
+ delete m_server;
+ delete m_lineInput;
+ delete m_restInput;
+}
+
void Middle::init()
{
{
public:
Middle();
+ ~Middle();
void init();
void run(int argc, char* argv[]);
using namespace std;
#define BUFLEN 10000
-#define MAX_CONNS 5
static bool enableDebug = false; // set to true to print debug messages
RestInput::RestInput(LineInput *lineInput) : m_lineInput(lineInput)
{
m_data = (char*)malloc(BUFLEN);
- m_thread = new std::thread[MAX_CONNS];
m_threadCount = 0;
}
+RestInput::~RestInput()
+{
+ free(m_data);
+ close(m_sockfd);
+}
+
bool RestInput::init()
{
m_sockfd = socket(AF_INET, SOCK_STREAM, 0);
class RestInput
{
+ static const int MAX_CONNS = 5;
public:
RestInput(LineInput *lineInput);
+ ~RestInput();
bool init();
void startAccept(int &sockfd);
void startThread();
int m_sockfd, m_port, m_threadCount;
struct sockaddr_in m_serverAddr;
char *m_data;
- std::thread *m_thread;
+ std::thread m_thread[MAX_CONNS];
};
#endif // RESTINPUT_H
env.AppendUnique(TINYDTLS_SRC = tinydtls_src)
if not env.get('RELEASE'):
- if(target_os) not in ['android', 'arduino']:
+ if(target_os) not in ['arduino']:
env.AppendUnique(TINYDTLS_SRC = ['debug.c'])
+ else:
+ env.AppendUnique(CPPDEFINES = ['NDEBUG'])
else:
env.AppendUnique(CPPDEFINES = ['NDEBUG'])
readInput[len] = '\0';
Serial.flush();
- Serial.print("PD:");
+ Serial.print("PD: ");
Serial.println(readInput);
(*dataLength) = len;
}
free(tempInfo);
return;
}
- printf("=========");
- printf("Network info total size is %d\n\n", tempSize);
+ Serial.println("=========");
+ Serial.print("Network info total size is ");
+ Serial.println(tempSize);
int index;
for (index = 0; index < tempSize; index++)
{
- Serial.println("Type:");
+ Serial.print("Type: ");
Serial.println(tempInfo[index].adapter);
if (CA_ADAPTER_IP == tempInfo[index].adapter)
{
- Serial.println("Address:");
+ Serial.print("Address: ");
Serial.println(tempInfo[index].addr);
- Serial.println("Port:");
+ Serial.print("Port: ");
Serial.println(tempInfo[index].port);
}
}
return;
}
- Serial.println("RAddr: ");
+ Serial.print("RAddr: ");
Serial.println(object->addr);
- Serial.println("Port: ");
+ Serial.print("Port: ");
Serial.println(object->port);
- Serial.println("uri: ");
+ Serial.print("uri: ");
Serial.println(requestInfo->info.resourceUri);
- Serial.println("data: ");
+ Serial.print("data: ");
Serial.println(requestInfo->info.payload);
- Serial.println("Type: ");
+ Serial.print("Type: ");
Serial.println(requestInfo->info.type);
if (requestInfo->info.options)
uint32_t i;
for (i = 0; i < len; i++)
{
- Serial.println("Option:");
+ Serial.print("Option: ");
Serial.println(i+1);
- Serial.println("ID:");
+ Serial.print("ID: ");
Serial.println(requestInfo->info.options[i].optionID);
- Serial.println("Data:");
+ Serial.print("Data: ");
Serial.println((char*)requestInfo->info.options[i].optionData);
}
}
void ErrorHandler(const CAEndpoint_t *rep, const CAErrorInfo_t* errorInfo)
{
- printf("+++++++++++++++++++++++++++++++++++ErrorInfo+++++++++++++++++++++++++++++++++++\n");
+ Serial.println("ErrorInfo");
if(errorInfo)
{
const CAInfo_t *info = &errorInfo->info;
- printf("Error Handler, ErrorInfo :\n");
- printf("Error Handler result : %d\n", errorInfo->result);
- printf("Error Handler token : %s\n", info->token);
- printf("Error Handler messageId : %d\n", (uint16_t) info->messageId);
- printf("Error Handler type : %d\n", info->type);
- printf("Error Handler resourceUri : %s\n", info->resourceUri);
- printf("Error Handler payload : %s\n", info->payload);
-
- if(CA_ADAPTER_NOT_ENABLED == errorInfo->result)
- {
- printf("CA_ADAPTER_NOT_ENABLED, enable the adapter\n");
- }
- else if(CA_SEND_FAILED == errorInfo->result)
- {
- printf("CA_SEND_FAILED, unable to send the message, check parameters\n");
- }
- else if(CA_MEMORY_ALLOC_FAILED == errorInfo->result)
- {
- printf("CA_MEMORY_ALLOC_FAILED, insufficient memory\n");
- }
- else if(CA_SOCKET_OPERATION_FAILED == errorInfo->result)
- {
- printf("CA_SOCKET_OPERATION_FAILED, socket operation failed\n");
- }
- else if(CA_STATUS_FAILED == errorInfo->result)
- {
- printf("CA_STATUS_FAILED, message could not be delivered, internal error\n");
- }
+ Serial.print("result: ");
+ Serial.println(errorInfo->result);
+ Serial.print("token: ");
+ Serial.println(info->token);
+ Serial.print("messageId: ");
+ Serial.println(info->messageId);
+ Serial.print("type: ");
+ Serial.println(info->type);
+ Serial.print("resourceUri: ");
+ Serial.println(info->resourceUri);
+ Serial.print("payload: ");
+ Serial.println(info->payload);
}
- printf("++++++++++++++++++++++++++++++++End of ErrorInfo++++++++++++++++++++++++++++++++\n");
return;
}
}
(*env)->ReleaseStringUTFChars(env, jni_address, address);
+ CAResult_t res = CALEClientGattClose(env, gatt);
+ if (CA_STATUS_OK != res)
+ {
+ OIC_LOG(ERROR, TAG, "CALEClientGattClose has failed");
+ }
+
goto error_exit;
}
return;
goto error_exit;
}
}
+
(*env)->ReleaseStringUTFChars(env, jni_address, address);
return;
jfieldID jni_fid_readProperties = (*env)->GetStaticFieldID(env,
jni_cid_bluetoothGattCharacteristic,
- "PROPERTY_READ", "I");
+ "PROPERTY_NOTIFY", "I");
if (!jni_fid_readProperties)
{
OIC_LOG(ERROR, TAG, "jni_fid_readProperties is null");
jni_cid_bluetoothGattCharacteristic,
jni_fid_readPermissions);
+ jint jni_int_writePermissions = (*env)->GetStaticIntField(env,
+ jni_cid_bluetoothGattCharacteristic,
+ jni_fid_writePermissions);
+
jobject jni_readCharacteristic = (*env)->NewObject(env, jni_cid_bluetoothGattCharacteristic,
jni_mid_bluetoothGattCharacteristic,
jni_obj_readUuid, jni_int_readProperties,
- jni_int_readPermissions);
+ jni_int_readPermissions|
+ jni_int_writePermissions);
if (!jni_readCharacteristic)
{
OIC_LOG(ERROR, TAG, "jni_readCharacteristic is null");
return NULL;
}
- CAResult_t res = CALEServerAddDescriptor(env, jni_readCharacteristic);
- if (CA_STATUS_OK != res)
- {
- OIC_LOG(ERROR, TAG, "CALEServerAddDescriptor has failed");
- return NULL;
- }
-
jboolean jni_boolean_addReadCharacteristic = (*env)->CallBooleanMethod(
env, jni_bluetoothGattService, jni_mid_addCharacteristic, jni_readCharacteristic);
if (!jni_boolean_addReadCharacteristic)
jni_cid_bluetoothGattCharacteristic,
jni_fid_writeProperties);
- jint jni_int_writePermissions = (*env)->GetStaticIntField(env,
- jni_cid_bluetoothGattCharacteristic,
- jni_fid_writePermissions);
-
jobject jni_writeCharacteristic = (*env)->NewObject(env, jni_cid_bluetoothGattCharacteristic,
jni_mid_bluetoothGattCharacteristic,
jni_obj_writeUuid, jni_int_writeProperties,
return jni_bluetoothGattService;
}
-CAResult_t CALEServerAddDescriptor(JNIEnv *env, jobject characteristic)
-{
- OIC_LOG(DEBUG, TAG, "IN - CALEServerAddDescriptor");
- VERIFY_NON_NULL(env, TAG, "env is null");
- VERIFY_NON_NULL(characteristic, TAG, "characteristic is null");
-
- jclass jni_cid_bluetoothGattDescriptor = (*env)->FindClass(env, "android/bluetooth/"
- "BluetoothGattDescriptor");
- if (!jni_cid_bluetoothGattDescriptor)
- {
- OIC_LOG(ERROR, TAG, "jni_cid_bluetoothGattDescriptor is null");
- return CA_STATUS_FAILED;
- }
-
- jmethodID jni_mid_bluetoothGattDescriptor = (*env)->GetMethodID(env,
- jni_cid_bluetoothGattDescriptor,
- "<init>",
- "(Ljava/util/UUID;I)V");
- if (!jni_mid_bluetoothGattDescriptor)
- {
- OIC_LOG(ERROR, TAG, "jni_mid_bluetoothGattDescriptor is null");
- return CA_STATUS_FAILED;
- }
-
- jfieldID jni_fid_readPermissions = (*env)->GetStaticFieldID(env,
- jni_cid_bluetoothGattDescriptor,
- "PERMISSION_READ", "I");
- if (!jni_fid_readPermissions)
- {
- OIC_LOG(ERROR, TAG, "jni_fid_readPermissions is null");
- return CA_STATUS_FAILED;
- }
-
- jobject jni_obj_readUuid = CALEGetUuidFromString(env, OIC_GATT_CHARACTERISTIC_CONFIG_UUID);
- if (!jni_obj_readUuid)
- {
- OIC_LOG(ERROR, TAG, "jni_obj_readUuid is null");
- return CA_STATUS_FAILED;
- }
-
- jint jni_int_readPermissions = (*env)->GetStaticIntField(env, jni_cid_bluetoothGattDescriptor,
- jni_fid_readPermissions);
-
- OIC_LOG(DEBUG, TAG, "initialize new Descriptor");
-
- jobject jni_readDescriptor = (*env)->NewObject(env, jni_cid_bluetoothGattDescriptor,
- jni_mid_bluetoothGattDescriptor,
- jni_obj_readUuid, jni_int_readPermissions);
- if (!jni_readDescriptor)
- {
- OIC_LOG(ERROR, TAG, "jni_readDescriptor is null");
- return CA_STATUS_FAILED;
- }
-
- jclass jni_cid_GattCharacteristic = (*env)->FindClass(env, "android/bluetooth/"
- "BluetoothGattCharacteristic");
- if (!jni_cid_GattCharacteristic)
- {
- OIC_LOG(ERROR, TAG, "jni_cid_GattCharacteristic is null");
- return CA_STATUS_FAILED;
- }
-
- jmethodID jni_mid_addDescriptor = (*env)->GetMethodID(env, jni_cid_GattCharacteristic,
- "addDescriptor",
- "(Landroid/bluetooth/"
- "BluetoothGattDescriptor;)Z");
- if (!jni_mid_addDescriptor)
- {
- OIC_LOG(ERROR, TAG, "jni_mid_addDescriptor is null");
- return CA_STATUS_FAILED;
- }
-
- jboolean jni_boolean_addDescriptor = (*env)->CallBooleanMethod(env, characteristic,
- jni_mid_addDescriptor,
- jni_readDescriptor);
-
- if (JNI_FALSE == jni_boolean_addDescriptor)
- {
- OIC_LOG(ERROR, TAG, "addDescriptor has failed");
- return CA_STATUS_FAILED;
- }
- else
- {
- OIC_LOG(DEBUG, TAG, "addDescriptor success");
- }
-
- OIC_LOG(DEBUG, TAG, "OUT - CALEServerAddDescriptor");
- return CA_STATUS_OK;
-}
-
CAResult_t CALEServerAddGattService(JNIEnv *env, jobject bluetoothGattServer,
jobject bluetoothGattService)
{
return CA_STATUS_OK;
}
+CAResult_t CALEServerGattClose(JNIEnv *env, jobject bluetoothGattServer)
+{
+ // GATT CLOSE
+ OIC_LOG(DEBUG, TAG, "GattServer Close");
+ VERIFY_NON_NULL(bluetoothGattServer, TAG, "bluetoothGattServer is null");
+ VERIFY_NON_NULL(env, TAG, "env is null");
+
+ // get BluetoothGatt class
+ OIC_LOG(DEBUG, TAG, "get BluetoothGatt class");
+ jclass jni_cid_BluetoothGatt = (*env)->FindClass(env, "android/bluetooth/BluetoothGattServer");
+ if (!jni_cid_BluetoothGatt)
+ {
+ OIC_LOG(ERROR, TAG, "jni_cid_BluetoothGatt is null");
+ return CA_STATUS_FAILED;
+ }
+
+ jmethodID jni_mid_closeGatt = (*env)->GetMethodID(env, jni_cid_BluetoothGatt, "close", "()V");
+ if (!jni_mid_closeGatt)
+ {
+ OIC_LOG(ERROR, TAG, "jni_mid_closeGatt is null");
+ return CA_STATUS_OK;
+ }
+
+ // call disconnect gatt method
+ OIC_LOG(DEBUG, TAG, "request to close GATT");
+ (*env)->CallVoidMethod(env, bluetoothGattServer, jni_mid_closeGatt);
+
+ if ((*env)->ExceptionCheck(env))
+ {
+ OIC_LOG(ERROR, TAG, "closeGATT has failed");
+ (*env)->ExceptionDescribe(env);
+ (*env)->ExceptionClear(env);
+ return CA_STATUS_FAILED;
+ }
+
+ return CA_STATUS_OK;
+}
+
CAResult_t CALEServerSend(JNIEnv *env, jobject bluetoothDevice, jbyteArray responseData)
{
OIC_LOG(DEBUG, TAG, "IN - CALEServerSend");
else if (newState == jni_int_state_disconnected)
{
OIC_LOG(DEBUG, TAG, "LE DISCONNECTED");
+ CAResult_t res = CALEServerGattClose(env, g_bluetoothGattServer);
+ if (CA_STATUS_OK != res)
+ {
+ OIC_LOG(ERROR, TAG, "CALEServerGattClose has failed");
+ }
}
else
{
jobject CALEServerCreateGattService(JNIEnv *env);
/**
- * @brief add a descriptor to the characteristic
- * @param env [IN] JNI interface pointer
- * @param characteristic [IN] Characteristic object
- * @return CA_STATUS_OK or ERROR CODES (CAResult_t error codes in cacommon.h)
- */
-CAResult_t CALEServerAddDescriptor(JNIEnv *env, jobject characteristic);
-
-/**
* @brief create gatt service
* @param env [IN] JNI interface pointer
* @param bluetoothGattServer [IN] Bluetooth Gatt Server object
CAResult_t CALEServerStartGattServer(JNIEnv *env, jobject gattServerCallback);
/**
+ * @brief close gatt server
+ * @param env [IN] JNI interface pointer
+ * @param bluetoothGattServer [IN] Gatt Server object
+ * @return CA_STATUS_OK or ERROR CODES (CAResult_t error codes in cacommon.h)
+ */
+CAResult_t CALEServerGattClose(JNIEnv *env, jobject bluetoothGattServer);
+/**
* @brief send data
* @param env [IN] JNI interface pointer
* @param bluetoothDevice [IN] bluetooth device object
void CAFreeLEData(CALEData_t *bleData)
{
- VERIFY_NON_NULL_VOID(bleData, NULL, "Param bleData is NULL");
+ VERIFY_NON_NULL_VOID(bleData, CALEADAPTER_TAG, "Param bleData is NULL");
CAFreeEndpoint(bleData->remoteEndpoint);
OICFree(bleData->data);
OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN");
//Input validation
- VERIFY_NON_NULL(registerCallback, NULL, "RegisterConnectivity callback is null");
- VERIFY_NON_NULL(reqRespCallback, NULL, "PacketReceived Callback is null");
- VERIFY_NON_NULL(netCallback, NULL, "NetworkChange Callback is null");
+ VERIFY_NON_NULL(registerCallback, CALEADAPTER_TAG, "RegisterConnectivity callback is null");
+ VERIFY_NON_NULL(reqRespCallback, CALEADAPTER_TAG, "PacketReceived Callback is null");
+ VERIFY_NON_NULL(netCallback, CALEADAPTER_TAG, "NetworkChange Callback is null");
CAResult_t result = CA_STATUS_OK;
result = CAInitLEAdapterMutex();
OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN");
//Input validation
- VERIFY_NON_NULL_RET(endpoint, NULL, "Remote endpoint is null", -1);
- VERIFY_NON_NULL_RET(data, NULL, "Data is null", -1);
+ VERIFY_NON_NULL_RET(endpoint, CALEADAPTER_TAG, "Remote endpoint is null", -1);
+ VERIFY_NON_NULL_RET(data, CALEADAPTER_TAG, "Data is null", -1);
CAResult_t result = CA_STATUS_FAILED;
OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN");
//Input validation
- VERIFY_NON_NULL_RET(data, NULL, "Data is null", -1);
+ VERIFY_NON_NULL_RET(data, CALEADAPTER_TAG, "Data is null", -1);
if (0 >= dataLen)
{
{
OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN");
- VERIFY_NON_NULL(info, NULL, "CALocalConnectivity info is null");
+ VERIFY_NON_NULL(info, CALEADAPTER_TAG, "CALocalConnectivity info is null");
char *local_address = NULL;
{
OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN");
- VERIFY_NON_NULL_VOID(g_localBLEAddress, NULL, "g_localBLEAddress is null");
+ VERIFY_NON_NULL_VOID(g_localBLEAddress, CALEADAPTER_TAG, "g_localBLEAddress is null");
CAEndpoint_t localEndpoint = {};
ca_mutex_lock(g_bleLocalAddressMutex);
{
OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN");
- VERIFY_NON_NULL(data, NULL, "Param data is NULL");
+ VERIFY_NON_NULL(data, CALEADAPTER_TAG, "Param data is NULL");
#ifndef SINGLE_THREAD
VERIFY_NON_NULL_RET(g_bleClientSendQueueHandle, CALEADAPTER_TAG,
"g_bleClientSendQueueHandle is NULL",
{
OIC_LOG(DEBUG, CALEADAPTER_TAG, "IN");
- VERIFY_NON_NULL(data, NULL, "Param data is NULL");
+ VERIFY_NON_NULL(data, CALEADAPTER_TAG, "Param data is NULL");
#ifdef SINGLE_THREAD
char header[CA_HEADER_LENGTH] = {0};
{
OIC_LOG(DEBUG, TZ_BLE_CLIENT_TAG, "IN");
- VERIFY_NON_NULL_RET(service, NULL, "service is NULL", CA_STATUS_FAILED);
+ VERIFY_NON_NULL_RET(service, TZ_BLE_CLIENT_TAG, "service is NULL", CA_STATUS_FAILED);
- VERIFY_NON_NULL_RET(remoteAddress, NULL, "remoteAddress 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);
{
OIC_LOG(DEBUG, TZ_BLE_CLIENT_TAG, "IN");
- VERIFY_NON_NULL_RET(service, NULL, "service is NULL", CA_STATUS_FAILED);
+ VERIFY_NON_NULL_RET(service, TZ_BLE_CLIENT_TAG, "service is NULL", CA_STATUS_FAILED);
int ret = bt_gatt_discover_characteristic_descriptor(service,
CABleGattDescriptorDiscoveredCb, NULL);
{
OIC_LOG(DEBUG, TZ_BLE_CLIENT_TAG, "IN");
- VERIFY_NON_NULL(data, NULL, "data is NULL");
+ VERIFY_NON_NULL(data, TZ_BLE_CLIENT_TAG, "data is NULL");
if (0 >= dataLen)
{
ca_mutex_lock(g_bleServiceListMutex);
if ( LE_UNICAST == type)
{
- VERIFY_NON_NULL(remoteAddress, NULL, "remoteAddress is NULL");
+ VERIFY_NON_NULL(remoteAddress, TZ_BLE_CLIENT_TAG, "remoteAddress is NULL");
ret = CAGetBLEServiceInfo(g_bLEServiceList, remoteAddress, &bleServiceInfo);
}
return CA_STATUS_FAILED;
}
- VERIFY_NON_NULL(bleServiceInfo, NULL, "bleServiceInfo is NULL");
+ VERIFY_NON_NULL(bleServiceInfo, TZ_BLE_CLIENT_TAG, "bleServiceInfo is NULL");
OIC_LOG_V(DEBUG, TZ_BLE_CLIENT_TAG, "Updating the data of length [%d] to [%s] ", dataLen,
bleServiceInfo->bdAddress);
{
OIC_LOG(DEBUG, TZ_BLE_CLIENT_TAG, "IN");
- VERIFY_NON_NULL(data, NULL, "data is NULL");
+ VERIFY_NON_NULL(data, TZ_BLE_CLIENT_TAG, "data is NULL");
if (0 >= dataLen)
{
{
OIC_LOG(DEBUG, TZ_BLE_SERVER_TAG, "IN");
- VERIFY_NON_NULL(serviceUUID, NULL, "Param serviceUUID is NULL");
+ VERIFY_NON_NULL(serviceUUID, TZ_BLE_SERVER_TAG, "Param serviceUUID is NULL");
OIC_LOG_V(DEBUG, TZ_BLE_SERVER_TAG, "service uuid %s", serviceUUID);
{
OIC_LOG(DEBUG, TZ_BLE_SERVER_TAG, "IN");
- VERIFY_NON_NULL(svcPath, NULL, "Param svcPath is NULL");
+ VERIFY_NON_NULL(svcPath, TZ_BLE_SERVER_TAG, "Param svcPath is NULL");
int ret = bt_gatt_remove_service(svcPath);
{
OIC_LOG(DEBUG, TZ_BLE_SERVER_TAG, "IN");
- VERIFY_NON_NULL(svcPath, NULL, "Param svcPath is NULL");
+ VERIFY_NON_NULL(svcPath, TZ_BLE_SERVER_TAG, "Param svcPath is NULL");
OIC_LOG_V(DEBUG, TZ_BLE_SERVER_TAG, "svcPath:%s", svcPath);
{
OIC_LOG(DEBUG, TZ_BLE_SERVER_TAG, "IN");
- VERIFY_NON_NULL(charValue, NULL, "Param charValue is NULL");
+ VERIFY_NON_NULL(charValue, TZ_BLE_SERVER_TAG, "Param charValue is NULL");
- VERIFY_NON_NULL(address, NULL, "Param address is NULL");
+ VERIFY_NON_NULL(address, TZ_BLE_SERVER_TAG, "Param address is NULL");
OIC_LOG_V(DEBUG, TZ_BLE_SERVER_TAG, "Client's Unicast address for sending data [%s]", address);
{
OIC_LOG(DEBUG, TZ_BLE_SERVER_TAG, "IN");
- VERIFY_NON_NULL(charValue, NULL, "Param charValue is NULL");
+ VERIFY_NON_NULL(charValue, TZ_BLE_SERVER_TAG, "Param charValue is NULL");
ca_mutex_lock(g_bleCharacteristicMutex);
{
OIC_LOG(DEBUG, TZ_BLE_CLIENT_UTIL_TAG, "IN");
- VERIFY_NON_NULL(bdAddress, NULL, "Param bdAddress is NULL");
- VERIFY_NON_NULL(service, NULL, "Param service is NULL");
- VERIFY_NON_NULL(bleServiceInfo, NULL, "Param bleServiceInfo is NULL");
+ VERIFY_NON_NULL(bdAddress, TZ_BLE_CLIENT_UTIL_TAG, "Param bdAddress is NULL");
+ VERIFY_NON_NULL(service, TZ_BLE_CLIENT_UTIL_TAG, "Param service is NULL");
+ VERIFY_NON_NULL(bleServiceInfo, TZ_BLE_CLIENT_UTIL_TAG, "Param bleServiceInfo is NULL");
*bleServiceInfo = (BLEServiceInfo *) OICCalloc(1, sizeof(BLEServiceInfo));
if (NULL == *bleServiceInfo)
{
OIC_LOG(DEBUG, TZ_BLE_CLIENT_UTIL_TAG, "IN");
- VERIFY_NON_NULL(characteristic, NULL, "Param characteristic is NULL");
- VERIFY_NON_NULL(bleServiceInfo, NULL, "Param bleServiceInfo is NULL");
+ VERIFY_NON_NULL(characteristic, TZ_BLE_CLIENT_UTIL_TAG, "Param characteristic is NULL");
+ VERIFY_NON_NULL(bleServiceInfo, TZ_BLE_CLIENT_UTIL_TAG, "Param bleServiceInfo is NULL");
if (BLE_GATT_READ_CHAR == type )
{
OIC_LOG(DEBUG, TZ_BLE_CLIENT_UTIL_TAG, "IN");
- VERIFY_NON_NULL(serviceList, NULL, "Param serviceList is NULL");
- VERIFY_NON_NULL(bleServiceInfo, NULL, "Param bleServiceInfo is NULL");
+ VERIFY_NON_NULL(serviceList, TZ_BLE_CLIENT_UTIL_TAG, "Param serviceList is NULL");
+ VERIFY_NON_NULL(bleServiceInfo, TZ_BLE_CLIENT_UTIL_TAG, "Param bleServiceInfo is NULL");
BLEServiceList *node = (BLEServiceList *) OICCalloc(1, sizeof(BLEServiceList));
if (NULL == node)
OIC_LOG(DEBUG, TZ_BLE_CLIENT_UTIL_TAG, "IN");
- VERIFY_NON_NULL(serviceList, NULL, "Param serviceList is NULL");
- VERIFY_NON_NULL(*serviceList, NULL, "Param *serviceList is NULL");
- VERIFY_NON_NULL(bdAddress, NULL, "Param bdAddress is NULL");
+ VERIFY_NON_NULL(serviceList, TZ_BLE_CLIENT_UTIL_TAG, "Param serviceList is NULL");
+ VERIFY_NON_NULL(*serviceList, TZ_BLE_CLIENT_UTIL_TAG, "Param *serviceList is NULL");
+ VERIFY_NON_NULL(bdAddress, TZ_BLE_CLIENT_UTIL_TAG, "Param bdAddress is NULL");
BLEServiceList *prev = NULL;
BLEServiceList *cur = *serviceList;
OIC_LOG(DEBUG, TZ_BLE_CLIENT_UTIL_TAG, "IN");
- VERIFY_NON_NULL(serviceList, NULL, "Param serviceList is NULL");
- VERIFY_NON_NULL(bleServiceInfo, NULL, "Param bleServiceInfo is NULL");
- VERIFY_NON_NULL(bdAddress, NULL, "Param bdAddress is NULL");
+ VERIFY_NON_NULL(serviceList, TZ_BLE_CLIENT_UTIL_TAG, "Param serviceList is NULL");
+ VERIFY_NON_NULL(bleServiceInfo, TZ_BLE_CLIENT_UTIL_TAG, "Param bleServiceInfo is NULL");
+ VERIFY_NON_NULL(bdAddress, TZ_BLE_CLIENT_UTIL_TAG, "Param bdAddress is NULL");
BLEServiceList *cur = serviceList;
{
OIC_LOG(DEBUG, TZ_BLE_CLIENT_UTIL_TAG, "IN");
- VERIFY_NON_NULL(serviceList, NULL, "Param serviceList is NULL");
- VERIFY_NON_NULL(bleServiceInfo, NULL, "Param bleServiceInfo is NULL");
+ VERIFY_NON_NULL(serviceList, TZ_BLE_CLIENT_UTIL_TAG, "Param serviceList is NULL");
+ VERIFY_NON_NULL(bleServiceInfo, TZ_BLE_CLIENT_UTIL_TAG, "Param bleServiceInfo is NULL");
if (0 > position)
{
{
OIC_LOG(DEBUG, TZ_BLE_CLIENT_UTIL_TAG, "IN");
- VERIFY_NON_NULL(serviceUUID, NULL, "Param serviceHandle is NULL");
+ VERIFY_NON_NULL(serviceUUID, TZ_BLE_CLIENT_UTIL_TAG, "Param serviceHandle is NULL");
if (strcasecmp(serviceUUID, OIC_BLE_SERVICE_ID) != 0)
{
{
OIC_LOG(DEBUG, TZ_BLE_CLIENT_UTIL_TAG, "IN");
- VERIFY_NON_NULL(serviceHandle, NULL, "Param serviceHandle is NULL");
+ VERIFY_NON_NULL(serviceHandle, TZ_BLE_CLIENT_UTIL_TAG, "Param serviceHandle is NULL");
char *uuid = NULL;
int ret = bt_gatt_get_service_uuid(serviceHandle, &uuid);
CAEndpoint_t ep;
strncpy(ep.addr, srcIPAddress, MAX_ADDR_STR_SIZE_CA);
ep.port = srcPort;
- ep.flags = CA_IPV4;
+ ep.flags = (CATransportFlags_t)CA_IPV4 | CA_IPV6;
ep.adapter = CA_ADAPTER_IP;
if (info->endpoint.flags & CA_SECURE)
if(jsonObj)
{
VERIFY_SUCCESS(TAG, cJSON_String == jsonObj->type, ERROR);
- if(jsonObj && cJSON_String == jsonObj->type)
+ if(cJSON_String == jsonObj->type)
{
//Check for empty string, in case DeviceId field has not been set yet
if (jsonObj->valuestring[0])
char * jsonStr2 = BinToAclJSON(acl);
EXPECT_TRUE(NULL != jsonStr2);
- if (jsonStr1 && jsonStr2)
- {
- EXPECT_STREQ(jsonStr1, jsonStr2);
- }
+ EXPECT_STREQ(jsonStr1, jsonStr2);
OICFree(jsonStr1);
OICFree(jsonStr2);
// These provide backward compatibility - their use is deprecated
#ifndef GOING_AWAY
#define OC_MULTICAST_PREFIX "224.0.1.187:5683"
-#define OC_MULTICAST_IP "224.0.1.187:5683"
+#define OC_MULTICAST_IP "224.0.1.187"
#define OC_MULTICAST_PORT 5683
#endif // GOING_AWAY
static int TEST_CASE = 0;
static int CONNECTIVITY = 0;
-static const char * UNICAST_DEVICE_DISCOVERY_QUERY = "coap://%s:6298/oic/d";
+static const char * UNICAST_DEVICE_DISCOVERY_QUERY = "coap://%s/oic/d";
static const char * MULTICAST_DEVICE_DISCOVERY_QUERY = "/oic/d";
-static const char * UNICAST_PLATFORM_DISCOVERY_QUERY = "coap://%s:6298/oic/p";
+static const char * UNICAST_PLATFORM_DISCOVERY_QUERY = "coap://%s/oic/p";
static const char * MULTICAST_PLATFORM_DISCOVERY_QUERY = "/oic/p";
-static const char * UNICAST_RESOURCE_DISCOVERY_QUERY = "coap://%s:6298/oic/res";
+static const char * UNICAST_RESOURCE_DISCOVERY_QUERY = "coap://%s/oic/res";
static const char * MULTICAST_RESOURCE_DISCOVERY_QUERY = "/oic/res";
//The following variable determines the interface protocol (IPv4, IPv6, etc)
//to be used for sending unicast messages. Default set to IPv4.
static std::string coapServerIP = "255.255.255.255";
static std::string coapServerPort = "5683";
static std::string coapServerResource = "/a/light";
-static const int IPV4_ADDR_SIZE = 16;
+// Size to hold IPV4_ADDRESS:PORT
+static const int IPV4_ADDR_SIZE = 24;
//Use ipv4addr for both InitDiscovery and InitPlatformOrDeviceDiscovery
char ipv4addr[IPV4_ADDR_SIZE];
void StripNewLineChar(char* str);
static void PrintUsage()
{
- OC_LOG(INFO, TAG, "Usage : occlient -u <0|1> -t <1..17> -c <0|1|2>");
+ OC_LOG(INFO, TAG, "Usage : occlient -u <0|1> -t <1..17> -c <0|1>");
OC_LOG(INFO, TAG, "-u <0|1> : Perform multicast/unicast discovery of resources");
- OC_LOG(INFO, TAG, "-c 0 : Default IPv4 and IPv6 auto-selection");
- OC_LOG(INFO, TAG, "-c 1 : IPv4 Connectivity Type");
- OC_LOG(INFO, TAG, "-c 2 : IPv6 Connectivity Type (IPv6 not currently supported)");
+ OC_LOG(INFO, TAG, "-c 0 : Use Default connectivity(IP)");
+ OC_LOG(INFO, TAG, "-c 1 : IP Connectivity Type");
OC_LOG(INFO, TAG, "-t 1 : Discover Resources");
OC_LOG(INFO, TAG, "-t 2 : Discover Resources and Initiate Nonconfirmable Get Request");
OC_LOG(INFO, TAG, "-t 3 : Discover Resources and Initiate Nonconfirmable Get Request"
OC_LOG(ERROR, TAG, "OCStack init error");
return 0;
}
+
+ if(CONNECTIVITY == CT_ADAPTER_DEFAULT || CONNECTIVITY == CT_IP)
+ {
+ OC_CONNTYPE = CT_ADAPTER_IP;
+ }
+ else
+ {
+ OC_LOG(INFO, TAG, "Default Connectivity type selected...");
+ PrintUsage();
+ }
+
if (UNICAST_DISCOVERY)
{
- OC_LOG(INFO, TAG, "Enter IPv4 address of the Server hosting resource (Ex: 192.168.0.15)\n");
- OC_LOG(INFO, TAG, "Ipv6 is currently not supported...");
+ OC_LOG(INFO, TAG, "Enter IP address with port number of the Server hosting resource");
+ OC_LOG(INFO, TAG, "as follows - eg: 192.168.0.15:45454 (IP:Port) \n");
if (fgets(ipv4addr, IPV4_ADDR_SIZE, stdin))
{
return OC_STACK_INVALID_PARAM;
}
}
- if(CONNECTIVITY == CT_ADAPTER_DEFAULT)
- {
- OC_CONNTYPE = CT_DEFAULT;
- }
- else if(CONNECTIVITY == CT_IPV4)
- {
- OC_CONNTYPE = CT_IP_USE_V4;
- }
- else if(CONNECTIVITY == CT_IPV6)
- {
- OC_CONNTYPE = CT_IP_USE_V6;
-
- //TODO: Remove when IPv6 is available.
- OC_LOG(ERROR, TAG, "IPv6 is currently not supported !!!!");
- PrintUsage();
- return -1;
- }
- else
- {
- OC_LOG(INFO, TAG, "Default Connectivity type selected...");
- PrintUsage();
- }
if(UNICAST_DISCOVERY == 0 && TEST_CASE == TEST_DISCOVER_DEV_REQ)
{
*/
typedef enum {
CT_ADAPTER_DEFAULT = 0,
- CT_IPV4,
- CT_IPV6,
+ CT_IP,
MAX_CT
} CLIENT_CONNECTIVITY_TYPE;
#define MAX_IP_ADDR_ST_SZ 16 //string size of "155.255.255.255" (15 + 1)
#define MAX_PORT_ST_SZ 6 //string size of "65535" (5 + 1)
-static int IPV4_ADDR_SIZE = 16;
+static int IPV4_ADDR_SIZE = 24;
static int UNICAST_DISCOVERY = 0;
static int TEST_CASE = 0;
static int CONNECTIVITY = 0;
-static const char UNICAST_DISCOVERY_QUERY[] = "coap://%s:6298/oic/res";
+static const char UNICAST_DISCOVERY_QUERY[] = "coap://%s/oic/res";
static std::string putPayload = "{\"oic\":[{\"rep\":{\"power\":15,\"state\":true}}]}";
//The following variable determines the interface protocol (IP, etc)
static void PrintUsage()
{
- OC_LOG(INFO, TAG, "Usage : occlient -u <0|1> -t <1|2|3> -c <0|1|2>");
+ OC_LOG(INFO, TAG, "Usage : occlient -u <0|1> -t <1|2|3> -c <0|1>");
OC_LOG(INFO, TAG, "-u <0|1> : Perform multicast/unicast discovery of resources");
OC_LOG(INFO, TAG, "-t 1 : Discover Resources");
OC_LOG(INFO, TAG, "-t 2 : Discover Resources and"
" Initiate Nonconfirmable Get/Put/Post Requests");
OC_LOG(INFO, TAG, "-t 3 : Discover Resources and Initiate "
"Confirmable Get/Put/Post Requests");
- OC_LOG(INFO, TAG, "-c 0 : Default IPv4 and IPv6 auto-selection");
- OC_LOG(INFO, TAG, "-c 1 : IPv4 Connectivity Type");
- OC_LOG(INFO, TAG, "-c 2 : IPv6 Connectivity Type (IPv6 not currently supported)");
+ OC_LOG(INFO, TAG, "-c 0 : Default auto-selection");
+ OC_LOG(INFO, TAG, "-c 1 : IP Connectivity Type");
}
/*
if (UNICAST_DISCOVERY)
{
char ipv4addr[IPV4_ADDR_SIZE];
- OC_LOG(INFO, TAG, "Enter IPv4 address of the Server hosting resource (Ex: 192.168.0.15) ");
+ OC_LOG(INFO, TAG, "Enter IP address with port of the Server hosting resource"\
+ "(Ex: 192.168.0.15:1234) ");
if (fgets(ipv4addr, IPV4_ADDR_SIZE, stdin))
{
void queryResource()
{
- printf("\n");
switch(TEST_CASE)
{
case TEST_DISCOVER_REQ:
PrintUsage();
break;
}
- printf("\n");
}
{
ResourceNode * iter;
iter = resourceList;
- printf("\nResource List\n");
+ OC_LOG(INFO, TAG, "Resource List: ");
while(iter)
{
- printf("*****************************************************\n");
- printf("sid = %s \n",iter->sid);
- printf("uri = %s\n", iter->uri);
- printf("ip = %s\n", iter->ip);
- printf("port = %s\n", iter->port);
+ OC_LOG(INFO, TAG, "*****************************************************");
+ OC_LOG_V(INFO, TAG, "sid = %s",iter->sid);
+ OC_LOG_V(INFO, TAG, "uri = %s", iter->uri);
+ OC_LOG_V(INFO, TAG, "ip = %s", iter->ip);
+ OC_LOG_V(INFO, TAG, "port = %s", iter->port);
switch (iter->connType & CT_MASK_ADAPTER)
{
case CT_ADAPTER_IP:
- printf("connType = %s\n","Default (IPv4) ");
- break;
- case CT_IP_USE_V4:
- printf("connType = %s\n","IPv4");
- break;
- case CT_IP_USE_V6:
- printf("connType = %s\n","IPv6");
+ OC_LOG(INFO, TAG, "connType = Default (IPv4)");
break;
case OC_ADAPTER_GATT_BTLE:
- printf("connType = %s\n","BLE");
+ OC_LOG(INFO, TAG, "connType = BLE");
break;
case OC_ADAPTER_RFCOMM_BTEDR:
- printf("connType = %s\n","BT");
+ OC_LOG(INFO, TAG, "connType = BT");
break;
default:
- printf("connType = %s\n","Invalid connType");
+ OC_LOG(INFO, TAG, "connType = Invalid connType");
break;
}
- printf("*****************************************************\n");
+ OC_LOG(INFO, TAG, "*****************************************************");
iter = iter->next;
}
}
ResourceNode * temp;
while(resourceList)
{
+
temp = resourceList;
resourceList = resourceList->next;
OICFree((void *)temp->sid);
TEST_CASE = atoi(optarg);
break;
case 'c':
+
CONNECTIVITY = atoi(optarg);
break;
default:
return 0;
}
- if(CONNECTIVITY == CT_ADAPTER_DEFAULT)
+ if(CONNECTIVITY == CT_ADAPTER_DEFAULT || CONNECTIVITY == CT_IP)
{
OC_CONNTYPE = CT_ADAPTER_IP;//CT_DEFAULT;
}
- else if(CONNECTIVITY == CT_IPV4)
- {
- OC_CONNTYPE = CT_IP_USE_V4;
- }
- else if(CONNECTIVITY == CT_IPV6)
- {
- OC_CONNTYPE = CT_IP_USE_V6;
-
- //TODO: Remove when IPv6 is available.
- printf("\n\nIPv6 is currently not supported !!!!\n");
- PrintUsage();
- return -1;
- }
else
{
- printf("Default Connectivity type selected \n\n");
- OC_CONNTYPE = CT_ADAPTER_IP;
+ OC_LOG(INFO, TAG, "Default Connectivity type selected");
+ PrintUsage();
}
InitDiscovery();
*/
typedef enum {
CT_ADAPTER_DEFAULT = 0,
- CT_IPV4,
- CT_IPV6,
+ CT_IP,
MAX_CT
} CLIENT_CONNECTIVITY_TYPE;
*/
typedef enum {
CT_ADAPTER_DEFAULT = 0,
- CT_IPV4,
- CT_IPV6,
+ CT_IP,
MAX_CT
} CLIENT_CONNECTIVITY_TYPE;
void PrintUsage()
{
OC_LOG(INFO, TAG, "Usage : occlientcoll -t <Test Case> -c <CA connectivity Type>");
- OC_LOG(INFO, TAG, "-c 0 : Default IPv4 and IPv6 auto-selection");
- OC_LOG(INFO, TAG, "-c 1 : IPv4 Connectivity Type");
- OC_LOG(INFO, TAG, "-c 2 : IPv6 Connectivity Type (IPv6 not currently supported)");
+ OC_LOG(INFO, TAG, "-c 0 : Default auto-selection");
+ OC_LOG(INFO, TAG, "-c 1 : IP Connectivity Type");
OC_LOG(INFO, TAG, "Test Case 1 : Discover Resources && Initiate GET Request on an "\
"available resource using default interface.");
OC_LOG(INFO, TAG, "Test Case 2 : Discover Resources && Initiate GET Request on an "\
return 0;
}
- if(CONNECTIVITY == CT_ADAPTER_DEFAULT)
+ if(CONNECTIVITY == CT_ADAPTER_DEFAULT || CONNECTIVITY == CT_IP)
{
- OC_CONNTYPE = CT_DEFAULT;
- }
- else if(CONNECTIVITY == CT_IPV4)
- {
- OC_CONNTYPE = CT_IP_USE_V4;
- }
- else if(CONNECTIVITY == CT_IPV6)
- {
- OC_CONNTYPE = CT_IP_USE_V6;
-
- //TODO: Remove when IPv6 is available.
- OC_LOG(INFO, TAG, "Ipv6 is currently not supported...");
- PrintUsage();
- return -1;
+ OC_CONNTYPE = CT_ADAPTER_IP;
}
else
{
OC_LOG(INFO, TAG, "Default Connectivity type selected...");
OC_CONNTYPE = CT_ADAPTER_IP;
}
+
InitDiscovery();
// Break from loop with Ctrl+C
static int TEST_CASE = 0;
static int CONNECTIVITY = 0;
-static const char * UNICAST_DISCOVERY_QUERY = "coap://%s:6298/oic/res";
+static const char * UNICAST_DISCOVERY_QUERY = "coap://%s/oic/res";
static std::string putPayload = "{\"state\":\"off\",\"power\":10}";
static std::string coapServerIP = "255.255.255.255";
static std::string coapServerPort = "5683";
//to be used for sending unicast messages. Default set to IP.
static OCConnectivityType OC_CONNTYPE = CT_ADAPTER_IP;
static const char * MULTICAST_RESOURCE_DISCOVERY_QUERY = "/oic/res";
-static int IPV4_ADDR_SIZE = 16;
+static int IPV4_ADDR_SIZE = 24;
void StripNewLineChar(char* str);
int gQuitFlag = 0;
static void PrintUsage()
{
OC_LOG(INFO, TAG, "Usage : occlient -c <0|1|2> -u <0|1> -t <1|2|3>");
- OC_LOG(INFO, TAG, "-c 0 : Default IPv4 and IPv6 auto-selection");
- OC_LOG(INFO, TAG, "-c 1 : IPv4 Connectivity Type");
- OC_LOG(INFO, TAG, "-c 2 : IPv6 Connectivity Type (IPv6 not currently supported)");
+ OC_LOG(INFO, TAG, "-c 0 : Default auto-selection");
+ OC_LOG(INFO, TAG, "-c 1 : IP Connectivity Type");
OC_LOG(INFO, TAG, "-u <0|1> : Perform multicast/unicast discovery of resources");
OC_LOG(INFO, TAG, "-t 1 : Discover Resources");
OC_LOG(INFO, TAG, "-t 2 : Discover Resources and Initiate Nonconfirmable Get Request");
if (UNICAST_DISCOVERY)
{
char ipv4addr[IPV4_ADDR_SIZE];
- OC_LOG(INFO, TAG, "Enter IPv4 address of the Server hosting resource (Ex: 192.168.0.15)");
+ OC_LOG(INFO, TAG, "Enter IPv4:port of the Server hosting resource"\
+ "(Ex: 192.168.0.15:1234)");
if (fgets(ipv4addr, IPV4_ADDR_SIZE, stdin))
{
//Strip newline char from ipv4addr
return 0;
}
- if(CONNECTIVITY == CT_ADAPTER_DEFAULT)
+ if(CONNECTIVITY == CT_ADAPTER_DEFAULT || CONNECTIVITY == CT_IP)
{
OC_CONNTYPE = CT_ADAPTER_IP;
}
- else if(CONNECTIVITY == CT_IPV4)
- {
- OC_CONNTYPE = CT_IP_USE_V4;
- }
- else if(CONNECTIVITY == CT_IPV6)
- {
- OC_CONNTYPE = CT_IP_USE_V6;
-
- //TODO: Remove when IPv6 is available.
- OC_LOG(INFO, TAG, "Ipv6 is currently not supported...");
- PrintUsage();
- return -1;
- }
else
{
OC_LOG(INFO, TAG, "Default Connectivity type selected...");
*/
typedef enum {
CT_ADAPTER_DEFAULT = 0,
- CT_IPV4,
- CT_IPV6,
+ CT_IP,
MAX_CT
} CLIENT_CONNECTIVITY_TYPE;
static int TEST_CASE = 0;
static int CONN_TYPE = 0;
-static int IPV4_ADDR_SIZE = 16;
-static char UNICAST_DISCOVERY_QUERY[] = "coap://%s:6298/oic/res";
+static int IPV4_ADDR_SIZE = 24;
+static char UNICAST_DISCOVERY_QUERY[] = "coap://%s/oic/res";
static char MULTICAST_DISCOVERY_QUERY[] = "/oic/res";
OCConnectivityType discoveryReqConnType = CT_ADAPTER_IP;
static void PrintUsage()
{
- OC_LOG(INFO, TAG, "Usage : occlient -u <0|1> -t <1|2|3> -c <0|1|2>");
+ OC_LOG(INFO, TAG, "Usage : occlient -u <0|1> -t <1|2|3> -c <0|1>");
OC_LOG(INFO, TAG, "-u <0|1> : Perform multicast/unicast discovery of resources");
OC_LOG(INFO, TAG, "-t 1 : Discover Resources");
OC_LOG(INFO, TAG, "-t 2 : Discover Resources and"
" Initiate Nonconfirmable Get/Put/Post Requests");
OC_LOG(INFO, TAG, "-t 3 : Discover Resources and Initiate Confirmable Get/Put/Post Requests");
- OC_LOG(INFO, TAG, "-c 0 : Default IPv4 and IPv6 auto-selection");
+ OC_LOG(INFO, TAG, "-c 0 : Default auto-selection");
OC_LOG(INFO, TAG, "-c 1 : IPv4 Connectivity Type");
- OC_LOG(INFO, TAG, "-c 2 : IPv6 Connectivity Type (IPv6 not currently supported)");
}
OCStackResult InvokeOCDoResource(std::ostringstream &query,
if (UNICAST_DISCOVERY)
{
char ipv4addr[IPV4_ADDR_SIZE];
- printf("Enter IPv4 address of the Server hosting secure resource (Ex: 11.12.13.14)\n");
+ OC_LOG(INFO, TAG, "Enter IPv4 address:port of the Server hosting secure resource"\
+ "(Ex: 11.12.13.14:1234)\n");
if (fgets(ipv4addr, IPV4_ADDR_SIZE, stdin))
{
//Strip newline char from ipv4addr
}
- if(CONN_TYPE == CT_ADAPTER_DEFAULT)
+ if(CONN_TYPE == CT_ADAPTER_DEFAULT || CONN_TYPE == CT_IP)
{
discoveryReqConnType = CT_DEFAULT;
}
- else if(CONN_TYPE == CT_IPV4)
- {
- discoveryReqConnType = CT_IP_USE_V4;
- }
- else if(CONN_TYPE == CT_IPV6)
- {
- //TODO: Remove when IPv6 is available.
- //discoveryReqConnType = CT_IP_USE_V6;
- OC_LOG(ERROR, TAG, "IPv6 is currently not supported !!!!");
- PrintUsage();
- return -1;
- }
else
{
- printf("Using Default Connectivity type\n\n");
+ OC_LOG(INFO, TAG, "Using Default Connectivity type");
PrintUsage();
}
}
oc = cJSON_GetObjectItem(root,"oic");
- if (!oc)
+ if (!oc || oc->type != cJSON_Array)
+ {
+ cJSON_Delete(root);
+ return -1;
+ }
+
+ cJSON * firstDevice = cJSON_GetArrayItem(oc, 0);
+ if (!firstDevice)
+ {
+ cJSON_Delete(root);
+ return -1;
+ }
+
+ cJSON * links = cJSON_GetObjectItem(firstDevice,"links");
+ if (!links)
{
+ cJSON_Delete(root);
return -1;
}
- if (oc->type == cJSON_Array)
+ if (links->type == cJSON_Array)
{
- int numRsrcs = cJSON_GetArraySize(oc);
+ int numRsrcs = cJSON_GetArraySize(links);
for(int i = 0; i < numRsrcs; i++)
{
- cJSON * resource = cJSON_GetArrayItem(oc, i);
+ cJSON * resource = cJSON_GetArrayItem(links, i);
if (cJSON_GetObjectItem(resource, "href"))
{
coapServerResource.assign(cJSON_GetObjectItem(resource, "href")->valuestring);
}
OC_LOG_V(INFO, TAG, "Uri -- %s", coapServerResource.c_str());
- cJSON * prop = cJSON_GetObjectItem(resource,"prop");
- if (prop)
{
- cJSON * policy = cJSON_GetObjectItem(prop,"p");
+ cJSON * policy = cJSON_GetObjectItem(resource,"p");
if (policy)
{
// If this is a secure resource, the info about the port at which the
*/
typedef enum {
CT_ADAPTER_DEFAULT = 0,
- CT_IPV4,
- CT_IPV6,
+ CT_IP,
MAX_CT
} CLIENT_CONNECTIVITY_TYPE;
#ifdef WITH_PRESENCE
//TODO: Add other connectivity types to CAConnTypes[] when enabled
CATransportAdapter_t CAConnTypes[] = {CA_ADAPTER_IP};
- const char * connTypes[] = {"ip transport"};
+ const char * connTypes[] = {"IP"};
int size = sizeof(CAConnTypes)/ sizeof(CATransportAdapter_t);
CATransportAdapter_t adapter = responseEndpoint.adapter;
CAResult_t caResult = CA_STATUS_FAILED;
result = OC_STACK_OK;
- //Sending response on all n/w interfaces
+ // Default adapter, try to send response out on all adapters.
+ if (adapter == CA_DEFAULT_ADAPTER)
+ {
+ adapter =
+ (CATransportAdapter_t)(CA_ADAPTER_IP | CA_ADAPTER_GATT_BTLE | CA_ADAPTER_RFCOMM_BTEDR);
+ }
+
for(int i = 0; i < size; i++ )
{
responseEndpoint.adapter = (CATransportAdapter_t)(adapter & CAConnTypes[i]);
{
CATransportFlags_t caFlags = (CATransportFlags_t)ocFlags;
- // supply default behavior
+ // supply default behavior.
if ((caFlags & (CA_IPV6|CA_IPV4)) == 0)
{
caFlags = (CATransportFlags_t)(caFlags|CA_IPV6|CA_IPV4);
*/
static int FormCanonicalPresenceUri(const CAEndpoint_t *endpoint, char *resourceUri, char *presenceUri)
{
- VERIFY_NON_NULL(endpoint, FATAL, OC_STACK_INVALID_PARAM);
+ VERIFY_NON_NULL(endpoint , FATAL, OC_STACK_INVALID_PARAM);
VERIFY_NON_NULL(resourceUri, FATAL, OC_STACK_INVALID_PARAM);
VERIFY_NON_NULL(presenceUri, FATAL, OC_STACK_INVALID_PARAM);
}
else
{
- strncpy(presenceUri, responseInfo->info.resourceUri, CA_MAX_URI_LENGTH);
+ snprintf (presenceUri, MAX_URI_LENGTH, "coap://[%s]:%u%s", OC_MULTICAST_IP,
+ OC_MULTICAST_PORT, OC_PRESENCE_URI);
cbNode = GetClientCB(NULL, 0, NULL, presenceUri);
if (cbNode)
{
flags = (OCTransportFlags)(connectivityType & CT_MASK_FLAGS);
result = ParseRequestUri(requestUri, adapter, flags, &devAddr, &resourceUri, &resourceType);
+
if (result != OC_STACK_OK)
{
OC_LOG_V(DEBUG, TAG, "Unable to parse uri: %s", requestUri);
{
goto exit;
}
- OICFree(resourceUri);
+
+ // Assign full presence uri as coap://ip:port/oic/ad to add to callback list.
+ // Presence notification will form a canonical uri to
+ // look for callbacks into the application.
resourceUri = presenceUri;
}
#endif
requestData.type = CA_MSG_NONCONFIRM;
requestData.token = cbNode->token;
requestData.tokenLength = cbNode->tokenLength;
+ requestData.resourceUri = OC_PRESENCE_URI;
requestInfo.method = CA_GET;
requestInfo.info = requestData;
* ModeType : indicate whether we want to do server, client or both
* ServerConnectivity : default flags for server
* ClientConnectivity : default flags for client
- * QoS : Quality of Service : CONFIRMABLE or NON CONFIRMABLE.
+ * QoS : indicate Quality of Service : LowQos, MidQos,HighQos and NaQos(No quality Defined).
*/
struct PlatformConfig
{
auto cLock = m_csdkLock.lock();
std::ostringstream os;
- os << host << "/oc/presence";
+ os << host << OC_PRESENCE_URI;;
if(!resourceType.empty())
{
static_cast<uint16_t>(it->getOptionID());
response.sendVendorSpecificHeaderOptions[i].optionLength =
(it->getOptionData()).length() + 1;
- std::copy(it->getOptionData().begin(),
- it->getOptionData().end(),
+ std::string optionData = it->getOptionData();
+ std::copy(optionData.begin(),
+ optionData.end(),
response.sendVendorSpecificHeaderOptions[i].optionData);
response.sendVendorSpecificHeaderOptions[i].optionData[it->getOptionData().length()]
= '\0';
projects / platform / upstream / iotivity.git / commitdiff