2 #include <android/log.h>
8 #include "cainterface.h"
11 #include "org_iotivity_ca_service_RMInterface.h"
13 #define LOG_TAG "JNI_INTERFACE_SAMPLE"
14 #define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
15 #define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
21 #define IDENTITY ("1111111111111111")
25 #define RS_CLIENT_PSK ("AAAAAAAAAAAAAAAA")
28 #define SECURE_DEFAULT_PORT 5684
29 #define RESOURCE_URI_LENGTH 14
30 #define OPTION_INFO_LENGTH 1024
31 #define NETWORK_INFO_LENGTH 1024
33 uint16_t g_localSecurePort = SECURE_DEFAULT_PORT;
35 void request_handler(const CAEndpoint_t* object, const CARequestInfo_t* requestInfo);
36 void response_handler(const CAEndpoint_t* object, const CAResponseInfo_t* responseInfo);
37 void error_handler(const CAEndpoint_t *object, const CAErrorInfo_t* errorInfo);
38 void get_resource_uri(const char *URI, char *resourceURI, uint32_t length);
39 uint32_t get_secure_information(CAPayload_t payLoad);
40 CAResult_t get_network_type(uint32_t selectedNetwork);
41 void callback(char *subject, char *receivedData);
42 CAResult_t get_remote_address(CATransportAdapter_t transportType, const char *address);
44 CATransportAdapter_t g_selectedNwType = CA_ADAPTER_IP;
45 static CAToken_t g_lastRequestToken = NULL;
46 static uint8_t g_lastRequestTokenLength = 0;
48 static const char COAP_PREFIX[] = "coap://";
49 static const char COAPS_PREFIX[] = "coaps://";
50 static const uint16_t COAP_PREFIX_LEN = sizeof(COAP_PREFIX) - 1;
51 static const uint16_t COAPS_PREFIX_LEN = sizeof(COAPS_PREFIX) - 1;
53 static const char SECURE_INFO_DATA[]
54 = "{\"oc\":[{\"href\":\"%s\",\"prop\":{\"rt\":[\"core.led\"],"
55 "\"if\":[\"oic.if.baseline\"],\"obs\":1,\"sec\":1,\"port\":"
57 static const char NORMAL_INFO_DATA[]
58 = "{\"oc\":[{\"href\":\"%s\",\"prop\":{\"rt\":[\"core.led\"],"
59 "\"if\":[\"oic.if.baseline\"],\"obs\":1}}]}";
61 static jobject g_responseListenerObject = NULL;
64 static CAEndpoint_t *g_clientEndpoint = NULL;
65 static char *g_resourceUri = NULL;
66 static CAToken_t g_clientToken = NULL;
67 static uint8_t g_clientTokenLength = 0;
69 static uint16_t g_clientMsgId = 0;
70 static char *g_remoteAddress = NULL;
74 char ipAddress[CA_IPADDR_SIZE];
79 JNIEXPORT void JNICALL
80 Java_org_iotivity_ca_service_RMInterface_setNativeResponseListener(JNIEnv *env, jobject obj,
83 LOGI("setNativeResponseListener");
84 g_responseListenerObject = (*env)->NewGlobalRef(env, obj);
88 static CADtlsPskCredsBlob_t *pskCredsBlob = NULL;
90 void clearDtlsCredentialInfo()
92 LOGI("clearDtlsCredentialInfo IN");
95 // Initialize sensitive data to zeroes before freeing.
96 if (NULL != pskCredsBlob->creds)
98 memset(pskCredsBlob->creds, 0, sizeof(OCDtlsPskCreds)*(pskCredsBlob->num));
99 free(pskCredsBlob->creds);
102 memset(pskCredsBlob, 0, sizeof(CADtlsPskCredsBlob_t));
106 LOGI("clearDtlsCredentialInfo OUT");
109 // Internal API. Invoked by OC stack to retrieve credentials from this module
110 void CAGetDtlsPskCredentials(CADtlsPskCredsBlob_t **credInfo)
112 LOGI("CAGetDtlsPskCredentials IN");
113 *credInfo = (CADtlsPskCredsBlob_t *) malloc(sizeof(CADtlsPskCredsBlob_t));
114 if (NULL == *credInfo)
116 LOGE("Failed to allocate credential blob.");
120 int16_t credLen = sizeof(OCDtlsPskCreds) * (pskCredsBlob->num);
121 (*credInfo)->creds = (OCDtlsPskCreds *) malloc(credLen);
122 if (NULL == (*credInfo)->creds)
124 LOGE("Failed to allocate crentials.");
130 memcpy((*credInfo)->identity, pskCredsBlob->identity, DTLS_PSK_ID_LEN);
131 (*credInfo)->num = pskCredsBlob->num;
132 memcpy((*credInfo)->creds, pskCredsBlob->creds, credLen);
134 LOGI("CAGetDtlsPskCredentials OUT");
137 CAResult_t SetCredentials()
139 LOGI("SetCredentials IN");
140 pskCredsBlob = (CADtlsPskCredsBlob_t *)malloc(sizeof(CADtlsPskCredsBlob_t));
141 if (NULL == pskCredsBlob)
143 LOGE("Memory allocation failed!");
144 return CA_MEMORY_ALLOC_FAILED;
146 memcpy(pskCredsBlob->identity, IDENTITY, DTLS_PSK_ID_LEN);
148 pskCredsBlob->num = 1;
150 pskCredsBlob->creds = (OCDtlsPskCreds *)malloc(sizeof(OCDtlsPskCreds) *(pskCredsBlob->num));
151 if (NULL == pskCredsBlob->creds)
153 LOGE("Memory allocation failed!");
154 return CA_MEMORY_ALLOC_FAILED;
156 memcpy(pskCredsBlob->creds[0].id, IDENTITY, DTLS_PSK_ID_LEN);
157 memcpy(pskCredsBlob->creds[0].psk, RS_CLIENT_PSK, DTLS_PSK_PSK_LEN);
159 LOGI("SetCredentials OUT");
164 JNIEXPORT jint JNI_OnLoad(JavaVM *jvm, void *reserved)
169 if (JNI_OK != (*jvm)->GetEnv(jvm, (void**) &env, JNI_VERSION_1_6))
173 g_jvm = jvm; /* cache the JavaVM pointer */
175 CANativeJNISetJavaVM(g_jvm);
177 return JNI_VERSION_1_6;
180 void JNI_OnUnload(JavaVM *jvm, void *reserved)
182 LOGI("JNI_OnUnload");
185 if (JNI_OK != (*jvm)->GetEnv(jvm, (void**) &env, JNI_VERSION_1_6))
193 JNIEXPORT void JNICALL
194 Java_org_iotivity_ca_service_RMInterface_RMInitialize(JNIEnv *env, jobject obj, jobject context)
196 LOGI("RMInitialize");
198 //Currently set context for Android Platform
199 CANativeJNISetContext(env, context);
201 CAResult_t res = CAInitialize();
203 if (CA_STATUS_OK != res)
205 LOGE("Could not Initialize");
209 if (CA_STATUS_OK != SetCredentials())
211 LOGE("SetCredentials failed");
215 res = CARegisterDTLSCredentialsHandler(CAGetDtlsPskCredentials);
216 if(CA_STATUS_OK != res)
218 LOGE("Set credential handler fail");
224 JNIEXPORT void JNICALL
225 Java_org_iotivity_ca_service_RMInterface_RMTerminate(JNIEnv *env, jobject obj)
228 CADestroyToken(g_lastRequestToken);
232 JNIEXPORT void JNICALL
233 Java_org_iotivity_ca_service_RMInterface_RMStartListeningServer(JNIEnv *env, jobject obj)
235 LOGI("RMStartListeningServer");
237 if (CA_STATUS_OK != CAStartListeningServer())
239 LOGE("Could not start Listening server");
243 JNIEXPORT void JNICALL
244 Java_org_iotivity_ca_service_RMInterface_RMStartDiscoveryServer(JNIEnv *env, jobject obj)
246 LOGI("RMStartDiscoveryServer");
248 if (CA_STATUS_OK != CAStartDiscoveryServer())
250 LOGE("Could not start discovery server");
254 JNIEXPORT void JNICALL
255 Java_org_iotivity_ca_service_RMInterface_RMRegisterHandler(JNIEnv *env, jobject obj)
257 LOGI("RMRegisterHandler");
259 CARegisterHandler(request_handler, response_handler, error_handler);
262 JNIEXPORT void JNICALL
263 Java_org_iotivity_ca_service_RMInterface_RMSendRequest(JNIEnv *env, jobject obj, jstring uri,
264 jstring payload, jint selectedNetwork,
265 jint isSecured, jint msgType)
267 LOGI("selectedNetwork - %d", selectedNetwork);
268 CAResult_t res = get_network_type(selectedNetwork);
269 if (CA_STATUS_OK != res)
274 const char* strUri = (*env)->GetStringUTFChars(env, uri, NULL);
275 LOGI("RMSendRequest - %s", strUri);
277 addressSet_t address = {};
278 parsing_coap_uri(strUri, &address);
280 //create remote endpoint
281 CAEndpoint_t* endpoint = NULL;
282 res = CACreateEndpoint(CA_DEFAULT_FLAGS, g_selectedNwType, (const char*)address.ipAddress,
283 address.port, &endpoint);
284 if (CA_STATUS_OK != res)
286 LOGE("Could not create remote end point");
287 (*env)->ReleaseStringUTFChars(env, uri, strUri);
291 CAMessageType_t messageType = msgType;
294 CAToken_t token = NULL;
295 uint8_t tokenLength = CA_MAX_TOKEN_LEN;
297 res = CAGenerateToken(&token, tokenLength);
298 if ((CA_STATUS_OK != res) || (!token))
300 LOGE("token generate error!!");
301 // destroy remote endpoint
302 CADestroyEndpoint(endpoint);
303 (*env)->ReleaseStringUTFChars(env, uri, strUri);
307 char resourceURI[RESOURCE_URI_LENGTH + 1] = { 0 };
309 get_resource_uri((const CAURI_t) strUri, resourceURI, RESOURCE_URI_LENGTH);
310 (*env)->ReleaseStringUTFChars(env, uri, strUri);
312 CAInfo_t requestData = { 0 };
313 requestData.token = token;
314 requestData.tokenLength = tokenLength;
318 uint32_t length = sizeof(SECURE_INFO_DATA) + strlen(resourceURI);
319 requestData.payload = (CAPayload_t) malloc(length);
320 if (NULL == requestData.payload)
322 LOGE("Memory allocation failed!");
324 CADestroyToken(token);
325 // destroy remote endpoint
326 CADestroyEndpoint(endpoint);
329 snprintf(requestData.payload, length, SECURE_INFO_DATA, resourceURI, g_localSecurePort);
333 uint32_t length = sizeof(NORMAL_INFO_DATA) + strlen(resourceURI);
334 requestData.payload = (CAPayload_t) malloc(length);
335 if (NULL == requestData.payload)
337 LOGE("Memory allocation failed!");
339 CADestroyToken(token);
340 // destroy remote endpoint
341 CADestroyEndpoint(endpoint);
344 snprintf(requestData.payload, length, NORMAL_INFO_DATA, resourceURI);
347 requestData.type = messageType;
348 requestData.resourceUri = (CAURI_t) malloc(sizeof(resourceURI));
349 if (NULL == requestData.resourceUri)
351 LOGE("Memory allocation failed!");
353 CADestroyToken(token);
354 // destroy remote endpoint
355 CADestroyEndpoint(endpoint);
356 free(requestData.payload);
359 memcpy(requestData.resourceUri, resourceURI, sizeof(resourceURI));
361 CARequestInfo_t requestInfo = { 0 };
362 requestInfo.method = CA_GET;
363 requestInfo.isMulticast = false;
364 requestInfo.info = requestData;
367 if (CA_STATUS_OK != CASendRequest(endpoint, &requestInfo))
369 LOGE("Could not send request");
373 CADestroyToken(token);
375 // destroy remote endpoint
376 CADestroyEndpoint(endpoint);
378 free(requestData.payload);
379 free(requestData.resourceUri);
382 JNIEXPORT void JNICALL
383 Java_org_iotivity_ca_service_RMInterface_RMSendReqestToAll(JNIEnv *env, jobject obj, jstring uri,
384 jint selectedNetwork)
386 LOGI("selectedNetwork - %d", selectedNetwork);
387 CAResult_t res = get_network_type(selectedNetwork);
388 if (CA_STATUS_OK != res)
393 // create remote endpoint
394 CAEndpoint_t *endpoint = NULL;
395 res = CACreateEndpoint(CA_DEFAULT_FLAGS, g_selectedNwType, NULL, 0, &endpoint);
397 if (CA_STATUS_OK != res)
399 LOGE("create remote endpoint error, error code: %d", res);
404 CAToken_t token = NULL;
405 uint8_t tokenLength = CA_MAX_TOKEN_LEN;
407 res = CAGenerateToken(&token, tokenLength);
408 if ((CA_STATUS_OK != res) || (!token))
410 LOGE("token generate error!!");
411 // destroy remote endpoint
412 CADestroyEndpoint(endpoint);
416 LOGI("generated token %s", token);
418 CAInfo_t requestData = { 0 };
419 requestData.token = token;
420 requestData.tokenLength = tokenLength;
421 requestData.payload = "Temp Json Payload";
422 requestData.type = CA_MSG_NONCONFIRM;
424 const char* strUri = (*env)->GetStringUTFChars(env, uri, NULL);
425 LOGI("resourceUri - %s", strUri);
426 requestData.resourceUri = (CAURI_t)strUri;
428 uint8_t optionNum = 2;
429 CAHeaderOption_t *headerOpt = (CAHeaderOption_t*) calloc(1,
430 sizeof(CAHeaderOption_t) * optionNum);
431 if (NULL == headerOpt)
433 LOGE("Memory allocation failed");
437 char* FirstOptionData = "Hello";
438 headerOpt[0].optionID = 3000;
439 memcpy(headerOpt[0].optionData, FirstOptionData, strlen(FirstOptionData));
440 headerOpt[0].optionLength = (uint16_t) strlen(FirstOptionData);
442 char* SecondOptionData2 = "World";
443 headerOpt[1].optionID = 3001;
444 memcpy(headerOpt[1].optionData, SecondOptionData2, strlen(SecondOptionData2));
445 headerOpt[1].optionLength = (uint16_t) strlen(SecondOptionData2);
447 requestData.numOptions = optionNum;
448 requestData.options = headerOpt;
450 CARequestInfo_t requestInfo = { 0 };
451 requestInfo.method = CA_GET;
452 requestInfo.isMulticast = true;
453 requestInfo.info = requestData;
455 // send request to all
456 res = CASendRequest(endpoint, &requestInfo);
457 if (CA_STATUS_OK != res)
459 LOGE("Could not send request to all");
461 CADestroyToken(token);
465 CADestroyToken(g_lastRequestToken);
466 g_lastRequestToken = token;
467 g_lastRequestTokenLength = tokenLength;
470 //ReleaseStringUTFChars for strUri
471 (*env)->ReleaseStringUTFChars(env, uri, strUri);
475 // destroy remote endpoint
476 CADestroyEndpoint(endpoint);
479 JNIEXPORT void JNICALL
480 Java_org_iotivity_ca_service_RMInterface_RMSendResponse(JNIEnv *env, jobject obj,
481 jint selectedNetwork,
482 jint isSecured, jint msgType,
485 LOGI("RMSendResponse");
487 LOGI("selectedNetwork - %d", selectedNetwork);
489 CAResult_t res = get_network_type(selectedNetwork);
490 if (CA_STATUS_OK != res)
492 LOGE("Not supported network type");
496 if (NULL == g_clientEndpoint)
498 LOGE("No Request received");
502 CAMessageType_t messageType = msgType;
504 CAInfo_t responseData = { 0 };
505 responseData.type = messageType;
506 responseData.messageId = g_clientMsgId;
507 responseData.resourceUri = (CAURI_t)g_resourceUri;
509 CAResponseInfo_t responseInfo = { 0 };
511 if (msgType != CA_MSG_RESET)
513 responseData.token = g_clientToken;
514 responseData.tokenLength = g_clientTokenLength;
515 responseInfo.result = responseValue;
519 uint32_t length = strlen(SECURE_INFO_DATA) + strlen(g_resourceUri) + 1;
520 responseData.payload = (CAPayload_t) malloc(length);
521 sprintf(responseData.payload, SECURE_INFO_DATA, g_resourceUri,
526 uint32_t length = strlen(NORMAL_INFO_DATA) + strlen(g_resourceUri) + 1;
527 responseData.payload = (CAPayload_t) malloc(length);
528 sprintf(responseData.payload, NORMAL_INFO_DATA, g_resourceUri);
534 responseInfo.result = CA_EMPTY;
537 responseInfo.info = responseData;
540 res = CASendResponse(g_clientEndpoint, &responseInfo);
541 if (CA_STATUS_OK != res)
543 LOGE("Could not send response");
547 CADestroyToken(g_clientToken);
548 g_clientToken = NULL;
549 g_clientTokenLength = 0;
551 // destroy remote endpoint
552 CADestroyEndpoint(g_clientEndpoint);
553 g_clientEndpoint = NULL;
556 JNIEXPORT void JNICALL
557 Java_org_iotivity_ca_service_RMInterface_RMSendNotification(JNIEnv *env, jobject obj, jstring uri,
558 jstring payload, jint selectedNetwork,
559 jint isSecured, jint msgType,
562 LOGI("selectedNetwork - %d", selectedNetwork);
564 CAResult_t res = get_network_type(selectedNetwork);
565 if (CA_STATUS_OK != res)
567 LOGE("Not supported network type");
571 const char* strUri = (*env)->GetStringUTFChars(env, uri, NULL);
572 LOGI("RMSendNotification - %s", strUri);
574 addressSet_t address = {};
575 parsing_coap_uri(strUri, &address);
577 //create remote endpoint
578 CAEndpoint_t* endpoint = NULL;
579 if (CA_STATUS_OK != CACreateEndpoint(CA_DEFAULT_FLAGS, g_selectedNwType,
580 (const char*)address.ipAddress,
581 address.port, &endpoint))
583 //ReleaseStringUTFChars for strUri
584 (*env)->ReleaseStringUTFChars(env, uri, strUri);
585 LOGE("Could not create remote end point");
589 char resourceURI[RESOURCE_URI_LENGTH + 1] = { 0 };
590 get_resource_uri(strUri, resourceURI, RESOURCE_URI_LENGTH);
592 //ReleaseStringUTFChars for strUri
593 (*env)->ReleaseStringUTFChars(env, uri, strUri);
595 CAMessageType_t messageType = msgType;
598 CAToken_t token = NULL;
599 uint8_t tokenLength = CA_MAX_TOKEN_LEN;
601 res = CAGenerateToken(&token, tokenLength);
602 if ((CA_STATUS_OK != res) || (!token))
604 LOGE("token generate error!");
605 CADestroyEndpoint(endpoint);
609 CAInfo_t responseData = { 0 };
610 responseData.token = token;
611 responseData.tokenLength = tokenLength;
612 responseData.resourceUri = (CAURI_t) malloc(sizeof(resourceURI));
613 if (NULL == responseData.resourceUri)
615 LOGE("Memory allocation failed!");
617 CADestroyToken(token);
618 // destroy remote endpoint
619 CADestroyEndpoint(endpoint);
622 memcpy(responseData.resourceUri, resourceURI, sizeof(resourceURI));
626 uint32_t length = sizeof(SECURE_INFO_DATA) + strlen(resourceURI);
627 responseData.payload = (CAPayload_t) malloc(length);
628 if (NULL == responseData.payload)
630 LOGE("Memory allocation failed!");
632 CADestroyToken(token);
633 // destroy remote endpoint
634 CADestroyEndpoint(endpoint);
636 free(responseData.resourceUri);
639 snprintf(responseData.payload, length, SECURE_INFO_DATA, resourceURI, g_localSecurePort);
643 uint32_t length = sizeof(NORMAL_INFO_DATA) + strlen(resourceURI);
644 responseData.payload = (CAPayload_t) malloc(length);
645 if (NULL == responseData.payload)
647 LOGE("Memory allocation failed!");
649 CADestroyToken(token);
650 // destroy remote endpoint
651 CADestroyEndpoint(endpoint);
653 free(responseData.resourceUri);
656 snprintf(responseData.payload, length, NORMAL_INFO_DATA, resourceURI);
659 responseData.type = messageType;
661 CAResponseInfo_t responseInfo = { 0 };
662 responseInfo.result = responseValue;
663 responseInfo.info = responseData;
666 if (CA_STATUS_OK != CASendNotification(endpoint, &responseInfo))
668 LOGE("Could not send notification");
671 LOGI("Send Notification");
674 CADestroyToken(token);
676 // destroy remote endpoint
677 CADestroyEndpoint(endpoint);
679 free(responseData.payload);
680 free(responseData.resourceUri);
683 JNIEXPORT void JNICALL
684 Java_org_iotivity_ca_service_RMInterface_RMSelectNetwork(JNIEnv *env, jobject obj,
687 LOGI("RMSelectNetwork Type : %d", networkType);
689 if (CA_STATUS_OK != CASelectNetwork(networkType))
691 LOGE("Could not select network");
695 JNIEXPORT void JNICALL
696 Java_org_iotivity_ca_service_RMInterface_RMUnSelectNetwork(JNIEnv *env, jobject obj,
699 LOGI("RMUnSelectNetwork Type : %d", networkType);
701 if (CA_STATUS_OK != CAUnSelectNetwork(networkType))
703 LOGE("Could not unselect network");
707 JNIEXPORT void JNICALL
708 Java_org_iotivity_ca_service_RMInterface_RMGetNetworkInfomation(JNIEnv *env, jobject obj)
710 LOGI("RMGetNetworkInfomation");
712 CAEndpoint_t *tempInfo = NULL;
713 uint32_t tempSize = 0;
715 CAResult_t res = CAGetNetworkInformation(&tempInfo, &tempSize);
716 if (CA_STATUS_OK != res)
718 LOGE("Could not start get network information");
723 LOGI("################## Network Information #######################");
724 callback("######## Network Information", "#######");
725 LOGI("Network info total size is %d", tempSize);
728 for (index = 0; index < tempSize; index++)
730 res = get_remote_address(tempInfo[index].adapter, tempInfo[index].addr);
731 if (CA_STATUS_OK != res)
736 if (NULL != g_responseListenerObject)
738 char networkInfo[NETWORK_INFO_LENGTH];
739 LOGI("Type: %d", tempInfo[index].adapter);
740 sprintf(networkInfo, "%d",tempInfo[index].adapter);
741 callback("Type :", networkInfo);
742 if (CA_ADAPTER_IP == tempInfo[index].adapter)
744 LOGI("Port: %d", tempInfo[index].port);
745 sprintf(networkInfo, "%d",tempInfo[index].port);
746 callback("Port: ", networkInfo);
748 LOGI("Secured: %d", (tempInfo[index].flags & CA_SECURE));
749 LOGI("Address: %s", g_remoteAddress);
750 callback("Address: ", g_remoteAddress);
751 free(g_remoteAddress);
753 if (tempInfo[index].flags & CA_SECURE)
755 g_localSecurePort = tempInfo[index].port;
762 LOGI("##############################################################");
765 JNIEXPORT void JNICALL
766 Java_org_iotivity_ca_service_RMInterface_RMHandleRequestResponse(JNIEnv *env, jobject obj)
768 LOGI("RMHandleRequestResponse");
770 if (CA_STATUS_OK != CAHandleRequestResponse())
772 LOGE("Could not handle request and response");
776 void request_handler(const CAEndpoint_t* object, const CARequestInfo_t* requestInfo)
781 LOGE("Remote endpoint is NULL!");
787 LOGE("Request info is NULL!");
791 if ((NULL != g_lastRequestToken) && (NULL != requestInfo->info.token) &&
792 (strncmp(g_lastRequestToken, requestInfo->info.token,
793 requestInfo->info.tokenLength) == 0))
795 LOGI("token is same. received request of it's own. skip.. ");
799 CAResult_t res = get_remote_address(object->adapter, object->addr);
800 if (CA_STATUS_OK != res)
805 LOGI("##########received request from remote device #############");
806 LOGI("Remote Address: %s", g_remoteAddress);
807 LOGI("Uri: %s", requestInfo->info.resourceUri);
808 LOGI("Data: %s", requestInfo->info.payload);
809 LOGI("Token: %s", requestInfo->info.token);
810 LOGI("Code: %d", requestInfo->method);
811 LOGI("MessageType: %d", requestInfo->info.type);
813 if (NULL != g_responseListenerObject)
815 callback("received request from remote device", "#######");
816 char *cloneUri = NULL;
819 if (NULL != requestInfo->info.resourceUri)
821 len = strlen(requestInfo->info.resourceUri);
822 cloneUri = (char *)malloc(sizeof(char) * (len + 1));
824 if (NULL == cloneUri)
826 LOGE("cloneUri Out of memory");
827 free(g_remoteAddress);
831 memcpy(cloneUri, requestInfo->info.resourceUri, len + 1);
832 callback("Uri: ", cloneUri);
835 len = strlen(g_remoteAddress);
836 char *cloneRemoteAddress = (char *) malloc(sizeof(char) * (len + 1));
838 if (NULL == cloneRemoteAddress)
840 LOGE("cloneRemoteAddress Out of memory");
841 free(g_remoteAddress);
846 memcpy(cloneRemoteAddress, g_remoteAddress, len + 1);
848 callback("Remote Address: ", cloneRemoteAddress);
849 free(cloneRemoteAddress);
850 free(g_remoteAddress);
852 //clone g_clientEndpoint
853 g_clientEndpoint = (CAEndpoint_t *) malloc(sizeof(CAEndpoint_t));
854 if (NULL == g_clientEndpoint)
856 LOGE("g_clientEndpoint Out of memory");
860 memcpy(g_clientEndpoint, object, sizeof(CAEndpoint_t));
862 if (NULL != cloneUri)
864 len = strlen(cloneUri);
865 g_resourceUri = (char *) malloc(sizeof(char) * (len + 1));
866 if (NULL == g_resourceUri)
868 LOGE("g_clientEndpoint->resourceUri Out of memory");
869 free(g_clientEndpoint);
873 memcpy(g_resourceUri, cloneUri, len + 1);
876 //clone g_clientToken
877 len = requestInfo->info.tokenLength;
879 g_clientToken = (char *) malloc(sizeof(char) * len);
880 if (NULL == g_clientToken)
882 LOGE("g_clientToken Out of memory");
883 free(g_clientEndpoint);
887 if (NULL != requestInfo->info.token)
889 memcpy(g_clientToken, requestInfo->info.token, len);
890 g_clientTokenLength = len;
894 //clone g_clientMsgId
895 g_clientMsgId = requestInfo->info.messageId;
897 if (NULL != requestInfo->info.payload)
899 len = strlen(requestInfo->info.payload);
900 char *clonePayload = (char *) malloc(sizeof(char) * (len + 1));
902 if (NULL == clonePayload)
904 LOGE("clonePayload Out of memory");
905 free(g_clientEndpoint);
909 memcpy(clonePayload, requestInfo->info.payload, len + 1);
911 callback("Data: ", clonePayload);
916 if (requestInfo->info.options)
918 uint32_t len = requestInfo->info.numOptions;
921 LOGI("Option count: %d", requestInfo->info.numOptions);
923 for (i = 0; i < len; i++)
925 LOGI("Option %d", i + 1);
926 LOGI("ID : %d", requestInfo->info.options[i].optionID);
927 LOGI("Data[%d]: %s", requestInfo->info.options[i].optionLength,
928 requestInfo->info.options[i].optionData);
930 if (NULL != g_responseListenerObject)
932 char optionInfo[OPTION_INFO_LENGTH] = { 0, };
933 sprintf(optionInfo, "Num[%d] - ID : %d, Option Length : %d", i + 1,
934 requestInfo->info.options[i].optionID,
935 requestInfo->info.options[i].optionLength);
937 callback("Option info: ", optionInfo);
939 size_t optionDataLen = strlen(requestInfo->info.options[i].optionData);
940 char *cloneOptionData = (char *) malloc(sizeof(char) * (optionDataLen + 1));
941 if (NULL == cloneOptionData)
943 LOGE("cloneOptionData Out of memory");
944 free(g_clientEndpoint);
948 memcpy(cloneOptionData, requestInfo->info.options[i].optionData,
951 callback("Option Data: ", cloneOptionData);
952 free(cloneOptionData);
956 LOGI("############################################################");
958 //Check if this has secure communication information
959 if (requestInfo->info.payload && CA_ADAPTER_IP == object->adapter)
961 uint32_t securePort = get_secure_information(requestInfo->info.payload);
962 if (0 < securePort) //Set the remote endpoint secure details and send response
964 LOGI("This is secure resource...");
968 length = COAPS_PREFIX_LEN; //length of "coaps://"
969 // length of "ipaddress:port"
970 length += strlen(object->addr) + PORT_LENGTH;
971 length += strlen(requestInfo->info.resourceUri) + 1;
973 uri = calloc(1, sizeof(char) * length);
976 LOGE("Failed to create new uri");
980 sprintf(uri, "%s%s:%d/%s", COAPS_PREFIX, object->addr,
981 securePort, requestInfo->info.resourceUri);
983 CAEndpoint_t *endpoint = NULL;
984 if (CA_STATUS_OK != CACreateEndpoint(CA_SECURE,
985 object->adapter, object->addr, securePort, &endpoint))
987 LOGE("Failed to create duplicate of remote endpoint!");
998 void response_handler(const CAEndpoint_t* object, const CAResponseInfo_t* responseInfo)
1001 CAResult_t res = get_remote_address(object->adapter, object->addr);
1002 if (CA_STATUS_OK != res)
1007 LOGI("##########Received response from remote device #############");
1008 LOGI("Uri: %s", responseInfo->info.resourceUri);
1009 LOGI("Remote Address: %s", g_remoteAddress);
1010 LOGI("response result: %d", responseInfo->result);
1011 LOGI("Data: %s", responseInfo->info.payload);
1012 LOGI("Token: %s", responseInfo->info.token);
1013 LOGI("MessageType: %d", responseInfo->info.type);
1015 if (NULL != g_responseListenerObject)
1019 if (NULL != responseInfo->info.resourceUri)
1021 len = strlen(responseInfo->info.resourceUri);
1022 char *cloneUri = (char *) malloc(sizeof(char) * (len + 1));
1024 if (NULL == cloneUri)
1026 LOGE("cloneUri Out of memory");
1027 free(g_remoteAddress);
1031 memcpy(cloneUri, responseInfo->info.resourceUri, len + 1);
1033 callback("Uri: ", cloneUri);
1037 len = strlen(g_remoteAddress);
1038 char *cloneRemoteAddress = (char *) malloc(sizeof(char) * (len + 1));
1040 if (NULL == cloneRemoteAddress)
1042 LOGE("cloneRemoteAddress Out of memory");
1043 free(g_remoteAddress);
1047 memcpy(cloneRemoteAddress, g_remoteAddress, len + 1);
1049 callback("Remote Address: ", cloneRemoteAddress);
1050 free(cloneRemoteAddress);
1051 free(g_remoteAddress);
1053 if (NULL != responseInfo->info.payload)
1055 len = strlen(responseInfo->info.payload);
1056 char *clonePayload = (char *) malloc(sizeof(char) * (len + 1));
1058 if (NULL == clonePayload)
1060 LOGE("clonePayload Out of memory");
1064 memcpy(clonePayload, responseInfo->info.payload, len + 1);
1066 callback("Data: ", clonePayload);
1071 if (responseInfo->info.options)
1073 uint32_t len = responseInfo->info.numOptions;
1075 for (i = 0; i < len; i++)
1077 LOGI("Option %d", i + 1);
1078 LOGI("ID : %d", responseInfo->info.options[i].optionID);
1079 LOGI("Data[%d]: %s", responseInfo->info.options[i].optionLength,
1080 responseInfo->info.options[i].optionData);
1082 if (NULL != g_responseListenerObject)
1084 char optionInfo[OPTION_INFO_LENGTH] = { 0, };
1085 sprintf(optionInfo, "Num[%d] - ID : %d, Option Length : %d", i + 1,
1086 responseInfo->info.options[i].optionID,
1087 responseInfo->info.options[i].optionLength);
1089 callback("Option info: ", optionInfo);
1091 size_t optionDataLen = strlen(responseInfo->info.options[i].optionData);
1092 char *cloneOptionData = (char *) malloc(sizeof(char) * (optionDataLen + 1));
1093 if (NULL == cloneOptionData)
1095 LOGE("cloneOptionData Out of memory");
1098 memcpy(cloneOptionData, responseInfo->info.options[i].optionData,
1100 callback("Option Data: ", cloneOptionData);
1101 free(cloneOptionData);
1105 LOGI("############################################################");
1107 //Check if this has secure communication information
1108 if (responseInfo->info.payload && CA_ADAPTER_IP == object->adapter)
1110 uint32_t securePort = get_secure_information(responseInfo->info.payload);
1111 if (0 < securePort) //Set the remote endpoint secure details and send response
1113 LOGI("This is secure resource...");
1118 void error_handler(const CAEndpoint_t *rep, const CAErrorInfo_t* errorInfo)
1120 printf("+++++++++++++++++++++++++++++++++++ErrorInfo+++++++++++++++++++++++++++++++++++");
1124 const CAInfo_t *info = &errorInfo->info;
1125 LOGI("Error Handler, ErrorInfo :");
1126 LOGI("Error Handler result : %d", errorInfo->result);
1127 LOGI("Error Handler token : %s", info->token);
1128 LOGI("Error Handler messageId : %d", (uint16_t) info->messageId);
1129 LOGI("Error Handler resourceUri : %s", info->resourceUri);
1130 LOGI("Error Handler type : %d", info->type);
1131 LOGI("Error Handler payload : %s", info->payload);
1133 if(CA_ADAPTER_NOT_ENABLED == errorInfo->result)
1135 LOGE("CA_ADAPTER_NOT_ENABLED, enable the adapter");
1137 else if(CA_SEND_FAILED == errorInfo->result)
1139 LOGE("CA_SEND_FAILED, unable to send the message, check parameters");
1141 else if(CA_MEMORY_ALLOC_FAILED == errorInfo->result)
1143 LOGE("CA_MEMORY_ALLOC_FAILED, insufficient memory");
1145 else if(CA_SOCKET_OPERATION_FAILED == errorInfo->result)
1147 LOGE("CA_SOCKET_OPERATION_FAILED, socket operation failed");
1149 else if(CA_STATUS_FAILED == errorInfo->result)
1151 LOGE("CA_STATUS_FAILED, message could not be delivered, internal error");
1154 LOGI("++++++++++++++++++++++++++++++++End of ErrorInfo++++++++++++++++++++++++++++++++");
1159 void get_resource_uri(const char *URI, char *resourceURI, uint32_t length)
1161 const char *startPos = URI;
1162 const char *temp = strstr(URI, "://");
1165 startPos = strchr(temp + 3, '/');
1168 LOGE("Resource URI is missing");
1173 const char *endPos = strchr(startPos, '?');
1176 endPos = URI + strlen(URI);
1180 if (endPos - startPos <= length)
1182 memcpy(resourceURI, startPos + 1, endPos - startPos);
1185 LOGI("URI: %s, ResourceURI: %s", URI, resourceURI);
1188 uint32_t get_secure_information(CAPayload_t payLoad)
1190 LOGI("entering get_secure_information");
1194 LOGE("Payload is NULL");
1198 const char *subString = NULL;
1199 if (NULL == (subString = strstr(payLoad, "\"sec\":1")))
1201 LOGE("This is not secure resource");
1205 if (NULL == (subString = strstr(payLoad, "\"port\":")))
1207 LOGE("This secure resource does not have port information");
1211 const char *startPos = strstr(subString, ":");
1214 LOGE("Parsing failed !");
1218 const char *endPos = strstr(startPos, "}");
1221 LOGE("Parsing failed !");
1225 char portStr[6] = { 0 };
1226 memcpy(portStr, startPos + 1, (endPos - 1) - startPos);
1228 LOGI("secured port is: %s", portStr);
1229 return atoi(portStr);
1232 CAResult_t get_network_type(uint32_t selectedNetwork)
1235 uint32_t number = selectedNetwork;
1237 if (!(number & 0xf))
1239 return CA_NOT_SUPPORTED;
1241 if (number & CA_ADAPTER_IP)
1243 g_selectedNwType = CA_ADAPTER_IP;
1244 return CA_STATUS_OK;
1246 if (number & CA_ADAPTER_RFCOMM_BTEDR)
1248 g_selectedNwType = CA_ADAPTER_RFCOMM_BTEDR;
1249 return CA_STATUS_OK;
1251 if (number & CA_ADAPTER_GATT_BTLE)
1253 g_selectedNwType = CA_ADAPTER_GATT_BTLE;
1254 return CA_STATUS_OK;
1257 return CA_NOT_SUPPORTED;
1260 void callback(char *subject, char *receivedData)
1263 uint32_t status = (*g_jvm)->GetEnv(g_jvm, (void **) &env, JNI_VERSION_1_6);
1264 uint32_t res = (*g_jvm)->AttachCurrentThread(g_jvm, &env, NULL);
1266 jclass cls = (*env)->GetObjectClass(env, g_responseListenerObject);
1267 jmethodID mid = (*env)->GetMethodID(env, cls, "OnResponseReceived",
1268 "(Ljava/lang/String;Ljava/lang/String;)V");
1270 jstring jsubject = (*env)->NewStringUTF(env, (char*) subject);
1271 jstring jreceivedData = (*env)->NewStringUTF(env, (char*) receivedData);
1272 (*env)->CallVoidMethod(env, g_responseListenerObject, mid, jsubject, jreceivedData);
1276 CAResult_t get_remote_address(CATransportAdapter_t transportType, const char *address)
1278 uint32_t len = strlen(address);
1280 g_remoteAddress = (char *)malloc(sizeof (char) * (len + 1));
1281 if (NULL == g_remoteAddress)
1283 LOGE("g_remoteAddress Out of memory");
1284 return CA_MEMORY_ALLOC_FAILED;
1287 memcpy(g_remoteAddress, address, len + 1);
1289 return CA_STATUS_OK;
1293 void parsing_coap_uri(const char* uri, addressSet_t* address)
1295 if (NULL == uri || NULL == address)
1297 LOGE("parameter is null");
1303 uint8_t startIndex = 0;
1304 if (strncmp(COAPS_PREFIX, uri, COAPS_PREFIX_LEN) == 0)
1306 LOGI("uri has '%s' prefix", COAPS_PREFIX);
1307 startIndex = COAPS_PREFIX_LEN;
1309 else if (strncmp(COAP_PREFIX, uri, COAP_PREFIX_LEN) == 0)
1311 LOGI("uri has '%s' prefix", COAP_PREFIX);
1312 startIndex = COAP_PREFIX_LEN;
1315 // #2. copy uri for parse
1316 int32_t len = strlen(uri) - startIndex;
1320 LOGE("uri length is 0!");
1324 char *cloneUri = (char *) calloc(len + 1, sizeof(char));
1325 if (NULL == cloneUri)
1327 LOGE("Out of memory");
1331 memcpy(cloneUri, &uri[startIndex], sizeof(char) * len);
1332 cloneUri[len] = '\0';
1334 char *pAddress = cloneUri;
1335 char *pResourceUri = NULL;
1338 for (i = 0; i < len; i++)
1340 if (cloneUri[i] == '/')
1344 pResourceUri = &cloneUri[i + 1];
1348 LOGI("pAddress : %s", pAddress);
1350 int res = get_address_set(pAddress, address);
1353 LOGE("address parse error");
1361 int get_address_set(const char *pAddress, addressSet_t* outAddress)
1363 if (NULL == pAddress || NULL == outAddress)
1365 LOGE("parameter is null");
1369 int32_t len = strlen(pAddress);
1374 for (i = 0; i < len; i++)
1376 if (pAddress[i] == '.')
1381 // found port number start index
1382 if (isIp && pAddress[i] == ':')
1391 if(ipLen && ipLen < sizeof(outAddress->ipAddress))
1393 strncpy(outAddress->ipAddress, pAddress, ipLen);
1394 outAddress->ipAddress[ipLen] = '\0';
1396 else if (!ipLen && len < sizeof(outAddress->ipAddress))
1398 strncpy(outAddress->ipAddress, pAddress, len);
1399 outAddress->ipAddress[len] = '\0';
1403 LOGE("IP Address too long: %d", ipLen==0 ? len : ipLen);
1409 outAddress->port = atoi(pAddress + ipLen + 1);
1414 strncpy(outAddress->ipAddress, pAddress, len);
1415 outAddress->ipAddress[len] = '\0';