#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
-/**
- * @def RS_IDENTITY
- * @brief
- */
-#define IDENTITY ("1111111111111111")
-/* @def RS_CLIENT_PSK
- * @brief
- */
-#define RS_CLIENT_PSK ("AAAAAAAAAAAAAAAA")
+// Iotivity Device Identity.
+const unsigned char IDENTITY[] = ("1111111111111111");
+
+// PSK between this device and peer device.
+const unsigned char RS_CLIENT_PSK[] = ("AAAAAAAAAAAAAAAA");
#define PORT_LENGTH 5
#define SECURE_DEFAULT_PORT 5684
static void error_handler(const CAEndpoint_t *object, const CAErrorInfo_t* errorInfo);
static void get_resource_uri(const char *URI, char *resourceURI, int32_t length);
static uint32_t get_secure_information(CAPayload_t payLoad);
-static CAResult_t get_network_type(uint32_t selectedNetwork);
+static CAResult_t get_network_type(uint32_t selectedNetwork, CATransportFlags_t *flags);
static void callback(char *subject, char *receivedData);
static CAResult_t get_remote_address(const char *address);
static void parsing_coap_uri(const char* uri, addressSet_t* address, CATransportFlags_t *flags);
static const char COAP_PREFIX[] = "coap://";
static const char COAPS_PREFIX[] = "coaps://";
+static const char COAP_TCP_PREFIX[] = "coap+tcp://";
+
static const uint16_t COAP_PREFIX_LEN = sizeof(COAP_PREFIX) - 1;
static const uint16_t COAPS_PREFIX_LEN = sizeof(COAPS_PREFIX) - 1;
+static const uint16_t COAP_TCP_PREFIX_LEN = sizeof(COAP_TCP_PREFIX) - 1;
static const char RECEIVED_FILE_PATH[] = "/storage/emulated/0/Download/%d%s.txt";
}
#ifdef __WITH_DTLS__
-static CADtlsPskCredsBlob_t *pskCredsBlob = NULL;
-
-void clearDtlsCredentialInfo()
-{
- LOGI("clearDtlsCredentialInfo IN");
- if (pskCredsBlob)
- {
- // Initialize sensitive data to zeroes before freeing.
- if (NULL != pskCredsBlob->creds)
- {
- memset(pskCredsBlob->creds, 0, sizeof(OCDtlsPskCreds)*(pskCredsBlob->num));
- free(pskCredsBlob->creds);
- }
-
- memset(pskCredsBlob, 0, sizeof(CADtlsPskCredsBlob_t));
- free(pskCredsBlob);
- pskCredsBlob = NULL;
- }
- LOGI("clearDtlsCredentialInfo OUT");
-}
-
// Internal API. Invoked by OC stack to retrieve credentials from this module
-void CAGetDtlsPskCredentials(CADtlsPskCredsBlob_t **credInfo)
+int32_t CAGetDtlsPskCredentials( CADtlsPskCredType_t type,
+ const unsigned char *desc, size_t desc_len,
+ unsigned char *result, size_t result_length)
{
LOGI("CAGetDtlsPskCredentials IN");
- *credInfo = (CADtlsPskCredsBlob_t *) malloc(sizeof(CADtlsPskCredsBlob_t));
- if (NULL == *credInfo)
+
+ int32_t ret = -1;
+
+ if (NULL == result)
{
- LOGE("Failed to allocate credential blob.");
- return;
+ return ret;
}
- int16_t credLen = sizeof(OCDtlsPskCreds) * (pskCredsBlob->num);
- (*credInfo)->creds = (OCDtlsPskCreds *) malloc(credLen);
- if (NULL == (*credInfo)->creds)
+ switch (type)
{
- LOGE("Failed to allocate crentials.");
- free(*credInfo);
- *credInfo = NULL;
- return;
- }
+ case CA_DTLS_PSK_HINT:
+ case CA_DTLS_PSK_IDENTITY:
- memcpy((*credInfo)->identity, pskCredsBlob->identity, DTLS_PSK_ID_LEN);
- (*credInfo)->num = pskCredsBlob->num;
- memcpy((*credInfo)->creds, pskCredsBlob->creds, credLen);
+ if (result_length < sizeof(IDENTITY))
+ {
+ LOGE("ERROR : Wrong value for result for storing IDENTITY");
+ return ret;
+ }
- LOGI("CAGetDtlsPskCredentials OUT");
-}
+ memcpy(result, IDENTITY, sizeof(IDENTITY));
+ ret = sizeof(IDENTITY);
+ break;
-CAResult_t SetCredentials()
-{
- LOGI("SetCredentials IN");
- pskCredsBlob = (CADtlsPskCredsBlob_t *)malloc(sizeof(CADtlsPskCredsBlob_t));
- if (NULL == pskCredsBlob)
- {
- LOGE("Memory allocation failed!");
- return CA_MEMORY_ALLOC_FAILED;
- }
- memcpy(pskCredsBlob->identity, IDENTITY, DTLS_PSK_ID_LEN);
+ case CA_DTLS_PSK_KEY:
- pskCredsBlob->num = 1;
+ if ((desc_len == sizeof(IDENTITY)) &&
+ memcmp(desc, IDENTITY, sizeof(IDENTITY)) == 0)
+ {
+ if (result_length < sizeof(RS_CLIENT_PSK))
+ {
+ LOGE("ERROR : Wrong value for result for storing RS_CLIENT_PSK");
+ return ret;
+ }
- pskCredsBlob->creds = (OCDtlsPskCreds *)malloc(sizeof(OCDtlsPskCreds) *(pskCredsBlob->num));
- if (NULL == pskCredsBlob->creds)
- {
- LOGE("Memory allocation failed!");
- return CA_MEMORY_ALLOC_FAILED;
+ memcpy(result, RS_CLIENT_PSK, sizeof(RS_CLIENT_PSK));
+ ret = sizeof(RS_CLIENT_PSK);
+ }
+ break;
+
+ default:
+
+ LOGE("Wrong value passed for PSK_CRED_TYPE.");
+ ret = -1;
}
- memcpy(pskCredsBlob->creds[0].id, IDENTITY, DTLS_PSK_ID_LEN);
- memcpy(pskCredsBlob->creds[0].psk, RS_CLIENT_PSK, DTLS_PSK_PSK_LEN);
- LOGI("SetCredentials OUT");
- return CA_STATUS_OK;
+ LOGI("CAGetDtlsPskCredentials OUT\n");
+ return ret;
}
+
#endif
JNIEXPORT jint JNI_OnLoad(JavaVM *jvm, void *reserved)
}
JNIEXPORT void JNICALL
-Java_org_iotivity_ca_service_RMInterface_RMInitialize(JNIEnv *env, jobject obj, jobject context)
+Java_org_iotivity_ca_service_RMInterface_RMInitialize(JNIEnv *env, jobject obj, jobject context,
+ jobject activity)
{
LOGI("RMInitialize");
- if (!env || !obj || !context)
+ if (!env || !obj || !context || !activity)
{
LOGI("Invalid input parameter");
return;
//Currently set context for Android Platform
CANativeJNISetContext(env, context);
+ CANativeSetActivity(env, activity);
CAResult_t res = CAInitialize();
}
#ifdef __WITH_DTLS__
- if (CA_STATUS_OK != SetCredentials())
- {
- LOGE("SetCredentials failed");
- return;
- }
-
res = CARegisterDTLSCredentialsHandler(CAGetDtlsPskCredentials);
if(CA_STATUS_OK != res)
{
return;
}
- CAResult_t res = get_network_type(selectedNetwork);
+ CATransportFlags_t flags = CA_DEFAULT_FLAGS;
+ CAResult_t res = get_network_type(selectedNetwork, &flags);
if (CA_STATUS_OK != res)
{
return;
const char* strUri = (*env)->GetStringUTFChars(env, uri, NULL);
LOGI("RMSendRequest - %s", strUri);
- CATransportFlags_t flags;
addressSet_t address = {{0}, 0};
parsing_coap_uri(strUri, &address, &flags);
{
LOGE("read has failed");
(*env)->ReleaseStringUTFChars(env, payload, path);
+ CADestroyToken(token);
+ CADestroyEndpoint(endpoint);
return;
}
(*env)->ReleaseStringUTFChars(env, payload, path);
free(requestData.payload);
free(requestData.resourceUri);
+ LOGI("send request success");
}
JNIEXPORT void JNICALL
return;
}
- CAResult_t res = get_network_type(selectedNetwork);
+ CATransportFlags_t flags = CA_DEFAULT_FLAGS;
+ CAResult_t res = get_network_type(selectedNetwork, &flags);
if (CA_STATUS_OK != res)
{
+ LOGE("Not supported network type");
return;
}
// create remote endpoint
CAEndpoint_t *endpoint = NULL;
- res = CACreateEndpoint(CA_IPV4, g_selectedNwType, NULL, 0, &endpoint);
+ res = CACreateEndpoint(flags, g_selectedNwType, NULL, 0, &endpoint);
if (CA_STATUS_OK != res)
{
LOGI("selectedNetwork - %d", selectedNetwork);
- CAResult_t res = get_network_type(selectedNetwork);
+ CATransportFlags_t flags = CA_DEFAULT_FLAGS;
+ CAResult_t res = get_network_type(selectedNetwork, &flags);
if (CA_STATUS_OK != res)
{
LOGE("Not supported network type");
CAResponseInfo_t responseInfo = { 0 };
- if (msgType != CA_MSG_RESET)
+ if (CA_MSG_RESET == msgType ||
+ (CA_MSG_ACKNOWLEDGE == msgType && CA_EMPTY == responseValue))
+ {
+ printf("RESET or ACK/EMPTY. there will be not payload/option\n");
+ responseInfo.result = CA_EMPTY;
+ }
+ else
{
responseData.token = g_clientToken;
responseData.tokenLength = g_clientTokenLength;
{
uint32_t length = strlen(SECURE_INFO_DATA) + strlen(g_resourceUri) + 1;
responseData.payload = (CAPayload_t) malloc(length);
- sprintf((char *) responseData.payload, SECURE_INFO_DATA, g_resourceUri,
- g_localSecurePort);
+ snprintf((char *) responseData.payload, length, SECURE_INFO_DATA,
+ g_resourceUri, g_localSecurePort);
responseData.payloadSize = length;
}
else
{
uint32_t length = strlen(NORMAL_INFO_DATA) + strlen(g_resourceUri) + 1;
responseData.payload = (CAPayload_t) malloc(length);
- sprintf((char *) responseData.payload, NORMAL_INFO_DATA, g_resourceUri);
+ snprintf((char *) responseData.payload, length, NORMAL_INFO_DATA, g_resourceUri);
responseData.payloadSize = length;
}
}
- //msgType is RESET
- else
- {
- responseInfo.result = CA_EMPTY;
- }
responseInfo.info = responseData;
// destroy remote endpoint
CADestroyEndpoint(g_clientEndpoint);
g_clientEndpoint = NULL;
+ free(responseData.payload);
}
JNIEXPORT void JNICALL
Java_org_iotivity_ca_service_RMInterface_RMSendNotification(JNIEnv *env, jobject obj, jstring uri,
jstring payload, jint selectedNetwork,
- jint isSecured, jint msgType,
- jint responseValue)
+ jint isSecured, jint msgType)
{
LOGI("selectedNetwork - %d", selectedNetwork);
if (!env || !obj)
return;
}
- CAResult_t res = get_network_type(selectedNetwork);
+ CATransportFlags_t flags = CA_DEFAULT_FLAGS;
+ CAResult_t res = get_network_type(selectedNetwork, &flags);
if (CA_STATUS_OK != res)
{
LOGE("Not supported network type");
const char* strUri = (*env)->GetStringUTFChars(env, uri, NULL);
LOGI("RMSendNotification - %s", strUri);
- CATransportFlags_t flags;
addressSet_t address = {{0}, 0};
parsing_coap_uri(strUri, &address, &flags);
return;
}
- CAInfo_t responseData = { 0 };
- responseData.token = token;
- responseData.tokenLength = tokenLength;
- responseData.resourceUri = (CAURI_t) malloc(sizeof(resourceURI));
- if (NULL == responseData.resourceUri)
+ CAInfo_t requestData = { 0 };
+ requestData.token = token;
+ requestData.tokenLength = tokenLength;
+ requestData.resourceUri = (CAURI_t) malloc(sizeof(resourceURI));
+ if (NULL == requestData.resourceUri)
{
LOGE("Memory allocation failed!");
// destroy token
CADestroyEndpoint(endpoint);
return;
}
- memcpy(responseData.resourceUri, resourceURI, sizeof(resourceURI));
+ memcpy(requestData.resourceUri, resourceURI, sizeof(resourceURI));
if (1 == isSecured)
{
uint32_t length = sizeof(SECURE_INFO_DATA) + strlen(resourceURI);
- responseData.payload = (CAPayload_t) malloc(length);
- if (NULL == responseData.payload)
+ requestData.payload = (CAPayload_t) malloc(length);
+ if (NULL == requestData.payload)
{
LOGE("Memory allocation failed!");
// destroy token
// destroy remote endpoint
CADestroyEndpoint(endpoint);
- free(responseData.resourceUri);
+ free(requestData.resourceUri);
return;
}
- snprintf((char *) responseData.payload, length, SECURE_INFO_DATA, resourceURI, g_localSecurePort);
- responseData.payloadSize = length;
+ snprintf((char *) requestData.payload, length, SECURE_INFO_DATA,
+ resourceURI, g_localSecurePort);
+ requestData.payloadSize = length;
}
else
{
uint32_t length = sizeof(NORMAL_INFO_DATA) + strlen(resourceURI);
- responseData.payload = (CAPayload_t) malloc(length);
- if (NULL == responseData.payload)
+ requestData.payload = (CAPayload_t) malloc(length);
+ if (NULL == requestData.payload)
{
LOGE("Memory allocation failed!");
// destroy token
// destroy remote endpoint
CADestroyEndpoint(endpoint);
- free(responseData.resourceUri);
+ free(requestData.resourceUri);
return;
}
- snprintf((char *) responseData.payload, length, NORMAL_INFO_DATA, resourceURI);
- responseData.payloadSize = length;
+ snprintf((char *) requestData.payload, length, NORMAL_INFO_DATA, resourceURI);
+ requestData.payloadSize = length;
}
- responseData.type = messageType;
+ requestData.type = messageType;
- CAResponseInfo_t responseInfo = { 0 };
- responseInfo.result = responseValue;
- responseInfo.info = responseData;
+ CARequestInfo_t requestInfo = { 0 };
+ requestInfo.method = CA_GET;
+ requestInfo.info = requestData;
// send notification
- if (CA_STATUS_OK != CASendNotification(endpoint, &responseInfo))
+ if (CA_STATUS_OK != CASendRequest(endpoint, &requestInfo))
{
LOGE("Could not send notification");
}
// destroy remote endpoint
CADestroyEndpoint(endpoint);
- free(responseData.payload);
- free(responseData.resourceUri);
+ free(requestData.payload);
+ free(requestData.resourceUri);
}
JNIEXPORT void JNICALL
{
char networkInfo[NETWORK_INFO_LENGTH];
LOGI("Type: %d", tempInfo[index].adapter);
- sprintf(networkInfo, "%d",tempInfo[index].adapter);
+ snprintf(networkInfo, NETWORK_INFO_LENGTH, "%d",tempInfo[index].adapter);
callback("Type :", networkInfo);
if (CA_ADAPTER_IP == tempInfo[index].adapter)
{
LOGI("Port: %d", tempInfo[index].port);
- sprintf(networkInfo, "%d",tempInfo[index].port);
+ snprintf(networkInfo, NETWORK_INFO_LENGTH, "%d",tempInfo[index].port);
callback("Port: ", networkInfo);
}
LOGI("Secured: %d", (tempInfo[index].flags & CA_SECURE));
free(g_remoteAddress);
char portInfo[PORT_LENGTH] = { 0, };
- sprintf(portInfo, "%d", object->port);
+ snprintf(portInfo, PORT_LENGTH, "%d", object->port);
callback("Remote Port: ", portInfo);
//clone g_clientEndpoint
if (NULL != g_responseListenerObject)
{
char optionInfo[OPTION_INFO_LENGTH] = { 0, };
- sprintf(optionInfo, "Num[%d] - ID : %d, Option Length : %d", i + 1,
- requestInfo->info.options[i].optionID,
- requestInfo->info.options[i].optionLength);
+ snprintf(optionInfo, OPTION_INFO_LENGTH,
+ "Num[%d] - ID : %d, Option Length : %d", i + 1,
+ requestInfo->info.options[i].optionID,
+ requestInfo->info.options[i].optionLength);
callback("Option info: ", optionInfo);
free(g_remoteAddress);
char portInfo[PORT_LENGTH] = { 0, };
- sprintf(portInfo, "%d", object->port);
+ snprintf(portInfo, PORT_LENGTH, "%d", object->port);
callback("Remote Port: ", portInfo);
if (NULL != responseInfo->info.payload && responseInfo->info.payloadSize)
if (NULL != g_responseListenerObject)
{
char optionInfo[OPTION_INFO_LENGTH] = { 0, };
- sprintf(optionInfo, "Num[%d] - ID : %d, Option Length : %d", i + 1,
- responseInfo->info.options[i].optionID,
- responseInfo->info.options[i].optionLength);
+ snprintf(optionInfo, OPTION_INFO_LENGTH,
+ "Num[%d] - ID : %d, Option Length : %d", i + 1,
+ responseInfo->info.options[i].optionID,
+ responseInfo->info.options[i].optionLength);
callback("Option info: ", optionInfo);
return atoi(portStr);
}
-CAResult_t get_network_type(uint32_t selectedNetwork)
+CAResult_t get_network_type(uint32_t selectedNetwork, CATransportFlags_t *flags)
{
uint32_t number = selectedNetwork;
- if (!(number & 0xf))
+ if (!(number & CA_ALL_ADAPTERS))
{
+ LOGE("get_network_type Out of range");
return CA_NOT_SUPPORTED;
}
- if (number & CA_ADAPTER_IP)
+ if ((number & CA_ADAPTER_IP) == CA_ADAPTER_IP)
{
+ *flags = CA_IPV4;
g_selectedNwType = CA_ADAPTER_IP;
return CA_STATUS_OK;
}
- if (number & CA_ADAPTER_RFCOMM_BTEDR)
+ if ((number & CA_ADAPTER_RFCOMM_BTEDR) == CA_ADAPTER_RFCOMM_BTEDR)
{
g_selectedNwType = CA_ADAPTER_RFCOMM_BTEDR;
return CA_STATUS_OK;
}
- if (number & CA_ADAPTER_GATT_BTLE)
+ if ((number & CA_ADAPTER_GATT_BTLE) == CA_ADAPTER_GATT_BTLE)
{
g_selectedNwType = CA_ADAPTER_GATT_BTLE;
return CA_STATUS_OK;
}
+ if ((number & CA_ADAPTER_TCP) == CA_ADAPTER_TCP)
+ {
+ g_selectedNwType = CA_ADAPTER_TCP;
+ return CA_STATUS_OK;
+ }
+ if ((number & CA_ADAPTER_NFC) == CA_ADAPTER_NFC)
+ {
+ g_selectedNwType = CA_ADAPTER_NFC;
+ return CA_STATUS_OK;
+ }
- return CA_NOT_SUPPORTED;
+ LOGE("Invalid transport");
+ return CA_NOT_SUPPORTED;
}
void callback(char *subject, char *receivedData)
{
LOGI("uri has '%s' prefix", COAP_PREFIX);
startIndex = COAP_PREFIX_LEN;
+ }
+ else if (strncmp(COAP_TCP_PREFIX, uri, COAP_TCP_PREFIX_LEN) == 0)
+ {
+ LOGI("uri has '%s' prefix\n", COAP_TCP_PREFIX);
+ startIndex = COAP_TCP_PREFIX_LEN;
*flags = CA_IPV4;
}
if (res == -1)
{
LOGE("address parse error");
-
return;
}
}
return;
}
+ CADeleteGlobalReferences(env);
(*env)->DeleteGlobalRef(env, g_responseListenerObject);
}
FILE* file;
char* buffer;
- size_t fileLen;
+ long fileLen;
// Open file
file = fopen(name, "rt");
// Get file length
fseek(file, 0, SEEK_END);
fileLen = ftell(file);
+ if (-1 == fileLen)
+ {
+ fprintf(stderr, "Failed to read file length");
+ fclose(file);
+ return false;
+ }
fseek(file, 0, SEEK_SET);
- LOGI("file size: %d", fileLen);
+ LOGI("file size: %ld", fileLen);
// Allocate memory
buffer = calloc(1, sizeof(char) * fileLen + 1);
}
// Read file contents into buffer
- fread(buffer, fileLen, 1, file);
+ size_t ret = fread(buffer, fileLen, 1, file);
+ if (ret != 1)
+ {
+ printf("Failed to read data from file, %s\n", name);
+ fclose(file);
+ free(buffer);
+ return false;
+ }
+
fclose(file);
LOGI("file bytes: %s", buffer);
char* path = calloc(1, sizeof(char) * path_length);
if (path != NULL)
{
- sprintf(path, RECEIVED_FILE_PATH, day, timeString);
+ snprintf(path, path_length, RECEIVED_FILE_PATH, day, timeString);
LOGI("received file path: %s", path);
FILE *fp = fopen(path, "wt");
projects / platform / upstream / iotivity.git / blobdiff