resource/csdk/connectivity/samples/android/casample/sampleService/src/main/jni/ResourceModel.c

   1 #include <jni.h>
   2 #include <android/log.h>
   3 #include <stdio.h>
   4 #include <dlfcn.h>
   5 #include <stdlib.h>
   6 #include <string.h>
   7
   8 #include "cainterface.h"
   9 #include "cacommon.h"
  10
  11 #include "org_iotivity_ca_service_RMInterface.h"
  12
  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__)
  16
  17 /**
  18  * @def RS_IDENTITY
  19  * @brief
  20  */
  21 #define IDENTITY     ("1111111111111111")
  22 /* @def RS_CLIENT_PSK
  23  * @brief
  24  */
  25 #define RS_CLIENT_PSK   ("AAAAAAAAAAAAAAAA")
  26
  27 #define PORT_LENGTH 5
  28 #define SECURE_DEFAULT_PORT 5684
  29 #define RESOURCE_URI_LENGTH 14
  30 #define OPTION_INFO_LENGTH 1024
  31 #define NETWORK_INFO_LENGTH 1024
  32
  33 typedef struct
  34 {
  35     char ipAddress[CA_IPADDR_SIZE];
  36     uint16_t port;
  37 } addressSet_t;
  38
  39 void request_handler(const CAEndpoint_t* object, const CARequestInfo_t* requestInfo);
  40 void response_handler(const CAEndpoint_t* object, const CAResponseInfo_t* responseInfo);
  41 void error_handler(const CAEndpoint_t *object, const CAErrorInfo_t* errorInfo);
  42 void get_resource_uri(const char *URI, char *resourceURI, uint32_t length);
  43 uint32_t get_secure_information(CAPayload_t payLoad);
  44 CAResult_t get_network_type(uint32_t selectedNetwork);
  45 void callback(char *subject, char *receivedData);
  46 CAResult_t get_remote_address(CATransportAdapter_t transportType, const char *address);
  47 void parsing_coap_uri(const char* uri, addressSet_t* address, CATransportFlags_t *flags);
  48
  49 uint16_t g_localSecurePort = SECURE_DEFAULT_PORT;
  50 CATransportAdapter_t g_selectedNwType = CA_ADAPTER_IP;
  51 static CAToken_t g_lastRequestToken = NULL;
  52 static uint8_t g_lastRequestTokenLength = 0;
  53
  54 static const char COAP_PREFIX[] =  "coap://";
  55 static const char COAPS_PREFIX[] = "coaps://";
  56 static const uint16_t COAP_PREFIX_LEN = sizeof(COAP_PREFIX) - 1;
  57 static const uint16_t COAPS_PREFIX_LEN = sizeof(COAPS_PREFIX) - 1;
  58
  59 static const char SECURE_INFO_DATA[]
  60                                    = "{\"oc\":[{\"href\":\"%s\",\"prop\":{\"rt\":[\"core.led\"],"
  61                                      "\"if\":[\"oic.if.baseline\"],\"obs\":1,\"sec\":1,\"port\":"
  62                                      "%d}}]}";
  63 static const char NORMAL_INFO_DATA[]
  64                                    = "{\"oc\":[{\"href\":\"%s\",\"prop\":{\"rt\":[\"core.led\"],"
  65                                      "\"if\":[\"oic.if.baseline\"],\"obs\":1}}]}";
  66
  67 static jobject g_responseListenerObject = NULL;
  68 static JavaVM *g_jvm;
  69
  70 static CAEndpoint_t *g_clientEndpoint = NULL;
  71 static char *g_resourceUri = NULL;
  72 static CAToken_t g_clientToken = NULL;
  73 static uint8_t g_clientTokenLength = 0;
  74
  75 static uint16_t g_clientMsgId = 0;
  76 static char *g_remoteAddress = NULL;
  77
  78 // init
  79 JNIEXPORT void JNICALL
  80 Java_org_iotivity_ca_service_RMInterface_setNativeResponseListener(JNIEnv *env, jobject obj,
  81                                                                    jobject listener)
  82 {
  83     LOGI("setNativeResponseListener");
  84     g_responseListenerObject = (*env)->NewGlobalRef(env, obj);
  85 }
  86
  87 #ifdef __WITH_DTLS__
  88 static CADtlsPskCredsBlob_t *pskCredsBlob = NULL;
  89
  90 void clearDtlsCredentialInfo()
  91 {
  92     LOGI("clearDtlsCredentialInfo IN");
  93     if (pskCredsBlob)
  94     {
  95         // Initialize sensitive data to zeroes before freeing.
  96         if (NULL != pskCredsBlob->creds)
  97         {
  98             memset(pskCredsBlob->creds, 0, sizeof(OCDtlsPskCreds)*(pskCredsBlob->num));
  99             free(pskCredsBlob->creds);
 100         }
 101
 102         memset(pskCredsBlob, 0, sizeof(CADtlsPskCredsBlob_t));
 103         free(pskCredsBlob);
 104         pskCredsBlob = NULL;
 105     }
 106     LOGI("clearDtlsCredentialInfo OUT");
 107 }
 108
 109 // Internal API. Invoked by OC stack to retrieve credentials from this module
 110 void CAGetDtlsPskCredentials(CADtlsPskCredsBlob_t **credInfo)
 111 {
 112     LOGI("CAGetDtlsPskCredentials IN");
 113     *credInfo = (CADtlsPskCredsBlob_t *) malloc(sizeof(CADtlsPskCredsBlob_t));
 114     if (NULL == *credInfo)
 115     {
 116         LOGE("Failed to allocate credential blob.");
 117         return;
 118     }
 119
 120     int16_t credLen = sizeof(OCDtlsPskCreds) * (pskCredsBlob->num);
 121     (*credInfo)->creds = (OCDtlsPskCreds *) malloc(credLen);
 122     if (NULL == (*credInfo)->creds)
 123     {
 124         LOGE("Failed to allocate crentials.");
 125         free(*credInfo);
 126         *credInfo = NULL;
 127         return;
 128     }
 129
 130     memcpy((*credInfo)->identity, pskCredsBlob->identity, DTLS_PSK_ID_LEN);
 131     (*credInfo)->num = pskCredsBlob->num;
 132     memcpy((*credInfo)->creds, pskCredsBlob->creds, credLen);
 133
 134     LOGI("CAGetDtlsPskCredentials OUT");
 135 }
 136
 137 CAResult_t SetCredentials()
 138 {
 139     LOGI("SetCredentials IN");
 140     pskCredsBlob = (CADtlsPskCredsBlob_t *)malloc(sizeof(CADtlsPskCredsBlob_t));
 141     if (NULL == pskCredsBlob)
 142     {
 143         LOGE("Memory allocation failed!");
 144         return CA_MEMORY_ALLOC_FAILED;
 145     }
 146     memcpy(pskCredsBlob->identity, IDENTITY, DTLS_PSK_ID_LEN);
 147
 148     pskCredsBlob->num = 1;
 149
 150     pskCredsBlob->creds = (OCDtlsPskCreds *)malloc(sizeof(OCDtlsPskCreds) *(pskCredsBlob->num));
 151     if (NULL == pskCredsBlob->creds)
 152     {
 153         LOGE("Memory allocation failed!");
 154         return CA_MEMORY_ALLOC_FAILED;
 155     }
 156     memcpy(pskCredsBlob->creds[0].id, IDENTITY, DTLS_PSK_ID_LEN);
 157     memcpy(pskCredsBlob->creds[0].psk, RS_CLIENT_PSK, DTLS_PSK_PSK_LEN);
 158
 159     LOGI("SetCredentials OUT");
 160     return CA_STATUS_OK;
 161 }
 162 #endif
 163
 164 JNIEXPORT jint JNI_OnLoad(JavaVM *jvm, void *reserved)
 165 {
 166     LOGI("JNI_OnLoad");
 167
 168     JNIEnv* env;
 169     if (JNI_OK != (*jvm)->GetEnv(jvm, (void**) &env, JNI_VERSION_1_6))
 170     {
 171         return -1;
 172     }
 173     g_jvm = jvm; /* cache the JavaVM pointer */
 174
 175     CANativeJNISetJavaVM(g_jvm);
 176
 177     return JNI_VERSION_1_6;
 178 }
 179
 180 void JNI_OnUnload(JavaVM *jvm, void *reserved)
 181 {
 182     LOGI("JNI_OnUnload");
 183
 184     JNIEnv* env;
 185     if (JNI_OK != (*jvm)->GetEnv(jvm, (void**) &env, JNI_VERSION_1_6))
 186     {
 187         return;
 188     }
 189     g_jvm = 0;
 190     return;
 191 }
 192
 193 JNIEXPORT void JNICALL
 194 Java_org_iotivity_ca_service_RMInterface_RMInitialize(JNIEnv *env, jobject obj, jobject context)
 195 {
 196     LOGI("RMInitialize");
 197
 198     //Currently set context for Android Platform
 199     CANativeJNISetContext(env, context);
 200
 201     CAResult_t res = CAInitialize();
 202
 203     if (CA_STATUS_OK != res)
 204     {
 205         LOGE("Could not Initialize");
 206     }
 207
 208 #ifdef __WITH_DTLS__
 209     if (CA_STATUS_OK != SetCredentials())
 210     {
 211         LOGE("SetCredentials failed");
 212         return;
 213     }
 214
 215     res = CARegisterDTLSCredentialsHandler(CAGetDtlsPskCredentials);
 216     if(CA_STATUS_OK != res)
 217     {
 218         LOGE("Set credential handler fail");
 219         return;
 220     }
 221 #endif
 222 }
 223
 224 JNIEXPORT void JNICALL
 225 Java_org_iotivity_ca_service_RMInterface_RMTerminate(JNIEnv *env, jobject obj)
 226 {
 227     LOGI("RMTerminate");
 228     CADestroyToken(g_lastRequestToken);
 229     CATerminate();
 230 }
 231
 232 JNIEXPORT void JNICALL
 233 Java_org_iotivity_ca_service_RMInterface_RMStartListeningServer(JNIEnv *env, jobject obj)
 234 {
 235     LOGI("RMStartListeningServer");
 236
 237     if (CA_STATUS_OK != CAStartListeningServer())
 238     {
 239         LOGE("Could not start Listening server");
 240     }
 241 }
 242
 243 JNIEXPORT void JNICALL
 244 Java_org_iotivity_ca_service_RMInterface_RMStartDiscoveryServer(JNIEnv *env, jobject obj)
 245 {
 246     LOGI("RMStartDiscoveryServer");
 247
 248     if (CA_STATUS_OK != CAStartDiscoveryServer())
 249     {
 250         LOGE("Could not start discovery server");
 251     }
 252 }
 253
 254 JNIEXPORT void JNICALL
 255 Java_org_iotivity_ca_service_RMInterface_RMRegisterHandler(JNIEnv *env, jobject obj)
 256 {
 257     LOGI("RMRegisterHandler");
 258
 259     CARegisterHandler(request_handler, response_handler, error_handler);
 260 }
 261
 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)
 266 {
 267     LOGI("selectedNetwork - %d", selectedNetwork);
 268     CAResult_t res = get_network_type(selectedNetwork);
 269     if (CA_STATUS_OK != res)
 270     {
 271         return;
 272     }
 273
 274     const char* strUri = (*env)->GetStringUTFChars(env, uri, NULL);
 275     LOGI("RMSendRequest - %s", strUri);
 276
 277     CATransportFlags_t flags;
 278     addressSet_t address = {};
 279     parsing_coap_uri(strUri, &address, &flags);
 280
 281     //create remote endpoint
 282     CAEndpoint_t* endpoint = NULL;
 283     res = CACreateEndpoint(flags, g_selectedNwType, (const char*)address.ipAddress,
 284                            address.port, &endpoint);
 285     if (CA_STATUS_OK != res)
 286     {
 287         LOGE("Could not create remote end point");
 288         (*env)->ReleaseStringUTFChars(env, uri, strUri);
 289         return;
 290     }
 291
 292     CAMessageType_t messageType = msgType;
 293
 294     // create token
 295     CAToken_t token = NULL;
 296     uint8_t tokenLength = CA_MAX_TOKEN_LEN;
 297
 298     res = CAGenerateToken(&token, tokenLength);
 299     if ((CA_STATUS_OK != res) || (!token))
 300     {
 301         LOGE("token generate error!!");
 302         // destroy remote endpoint
 303         CADestroyEndpoint(endpoint);
 304         (*env)->ReleaseStringUTFChars(env, uri, strUri);
 305         return;
 306     }
 307
 308     char resourceURI[RESOURCE_URI_LENGTH + 1] = { 0 };
 309
 310     get_resource_uri((const CAURI_t) strUri, resourceURI, RESOURCE_URI_LENGTH);
 311     (*env)->ReleaseStringUTFChars(env, uri, strUri);
 312
 313     CAInfo_t requestData = { 0 };
 314     requestData.token = token;
 315     requestData.tokenLength = tokenLength;
 316
 317     if (1 == isSecured)
 318     {
 319         uint32_t length = sizeof(SECURE_INFO_DATA) + strlen(resourceURI);
 320         requestData.payload = (CAPayload_t) malloc(length);
 321         if (NULL == requestData.payload)
 322         {
 323             LOGE("Memory allocation failed!");
 324             // destroy token
 325             CADestroyToken(token);
 326             // destroy remote endpoint
 327             CADestroyEndpoint(endpoint);
 328             return;
 329         }
 330         snprintf(requestData.payload, length, SECURE_INFO_DATA, resourceURI, g_localSecurePort);
 331         requestData.payloadSize = length;
 332     }
 333     else
 334     {
 335         uint32_t length = sizeof(NORMAL_INFO_DATA) + strlen(resourceURI);
 336         requestData.payload = (CAPayload_t) malloc(length);
 337         if (NULL == requestData.payload)
 338         {
 339             LOGE("Memory allocation failed!");
 340             // destroy token
 341             CADestroyToken(token);
 342             // destroy remote endpoint
 343             CADestroyEndpoint(endpoint);
 344             return;
 345         }
 346         snprintf(requestData.payload, length, NORMAL_INFO_DATA, resourceURI);
 347         requestData.payloadSize = length;
 348     }
 349
 350     requestData.type = messageType;
 351     requestData.resourceUri = (CAURI_t) malloc(sizeof(resourceURI));
 352     if (NULL == requestData.resourceUri)
 353     {
 354         LOGE("Memory allocation failed!");
 355         // destroy token
 356         CADestroyToken(token);
 357         // destroy remote endpoint
 358         CADestroyEndpoint(endpoint);
 359         free(requestData.payload);
 360         return;
 361     }
 362     memcpy(requestData.resourceUri, resourceURI, sizeof(resourceURI));
 363
 364     CARequestInfo_t requestInfo = { 0 };
 365     requestInfo.method = CA_GET;
 366     requestInfo.isMulticast = false;
 367     requestInfo.info = requestData;
 368
 369     // send request
 370     if (CA_STATUS_OK != CASendRequest(endpoint, &requestInfo))
 371     {
 372         LOGE("Could not send request");
 373     }
 374
 375     // destroy token
 376     CADestroyToken(token);
 377
 378     // destroy remote endpoint
 379     CADestroyEndpoint(endpoint);
 380
 381     free(requestData.payload);
 382     free(requestData.resourceUri);
 383 }
 384
 385 JNIEXPORT void JNICALL
 386 Java_org_iotivity_ca_service_RMInterface_RMSendReqestToAll(JNIEnv *env, jobject obj, jstring uri,
 387                                                            jint selectedNetwork)
 388 {
 389     LOGI("selectedNetwork - %d", selectedNetwork);
 390     CAResult_t res = get_network_type(selectedNetwork);
 391     if (CA_STATUS_OK != res)
 392     {
 393         return;
 394     }
 395
 396     // create remote endpoint
 397     CAEndpoint_t *endpoint = NULL;
 398     res = CACreateEndpoint(CA_DEFAULT_FLAGS, g_selectedNwType, NULL, 0, &endpoint);
 399
 400     if (CA_STATUS_OK != res)
 401     {
 402         LOGE("create remote endpoint error, error code: %d", res);
 403         return;
 404     }
 405
 406     // create token
 407     CAToken_t token = NULL;
 408     uint8_t tokenLength = CA_MAX_TOKEN_LEN;
 409
 410     res = CAGenerateToken(&token, tokenLength);
 411     if ((CA_STATUS_OK != res) || (!token))
 412     {
 413         LOGE("token generate error!!");
 414         // destroy remote endpoint
 415         CADestroyEndpoint(endpoint);
 416         return;
 417     }
 418
 419     LOGI("generated token %s", token);
 420
 421     CAInfo_t requestData = { 0 };
 422     requestData.token = token;
 423     requestData.tokenLength = tokenLength;
 424     requestData.payload = (CAPayload_t) "TempJsonPayload";
 425     requestData.payloadSize = strlen((const char *) requestData.payload);
 426     requestData.type = CA_MSG_NONCONFIRM;
 427
 428     const char* strUri = (*env)->GetStringUTFChars(env, uri, NULL);
 429     LOGI("resourceUri - %s", strUri);
 430     requestData.resourceUri = (CAURI_t)strUri;
 431
 432     uint8_t optionNum = 2;
 433     CAHeaderOption_t *headerOpt = (CAHeaderOption_t*) calloc(1,
 434                                                              sizeof(CAHeaderOption_t) * optionNum);
 435     if (NULL == headerOpt)
 436     {
 437         LOGE("Memory allocation failed");
 438         // destroy remote endpoint
 439         CADestroyEndpoint(endpoint);
 440         return;
 441     }
 442
 443     char* FirstOptionData = "Hello";
 444     headerOpt[0].optionID = 3000;
 445     memcpy(headerOpt[0].optionData, FirstOptionData, strlen(FirstOptionData));
 446     headerOpt[0].optionLength = (uint16_t) strlen(FirstOptionData);
 447
 448     char* SecondOptionData2 = "World";
 449     headerOpt[1].optionID = 3001;
 450     memcpy(headerOpt[1].optionData, SecondOptionData2, strlen(SecondOptionData2));
 451     headerOpt[1].optionLength = (uint16_t) strlen(SecondOptionData2);
 452
 453     requestData.numOptions = optionNum;
 454     requestData.options = headerOpt;
 455
 456     CARequestInfo_t requestInfo = { 0 };
 457     requestInfo.method = CA_GET;
 458     requestInfo.isMulticast = true;
 459     requestInfo.info = requestData;
 460
 461     // send request to all
 462     res = CASendRequest(endpoint, &requestInfo);
 463     if (CA_STATUS_OK != res)
 464     {
 465         LOGE("Could not send request to all");
 466         //destroy token
 467         CADestroyToken(token);
 468     }
 469     else
 470     {
 471         CADestroyToken(g_lastRequestToken);
 472         g_lastRequestToken = token;
 473         g_lastRequestTokenLength = tokenLength;
 474     }
 475
 476     //ReleaseStringUTFChars for strUri
 477     (*env)->ReleaseStringUTFChars(env, uri, strUri);
 478
 479     free(headerOpt);
 480
 481     // destroy remote endpoint
 482     CADestroyEndpoint(endpoint);
 483 }
 484
 485 JNIEXPORT void JNICALL
 486 Java_org_iotivity_ca_service_RMInterface_RMSendResponse(JNIEnv *env, jobject obj,
 487                                                         jint selectedNetwork,
 488                                                         jint isSecured, jint msgType,
 489                                                         jint responseValue)
 490 {
 491     LOGI("RMSendResponse");
 492
 493     LOGI("selectedNetwork - %d", selectedNetwork);
 494
 495     CAResult_t res = get_network_type(selectedNetwork);
 496     if (CA_STATUS_OK != res)
 497     {
 498         LOGE("Not supported network type");
 499         return;
 500     }
 501
 502     if (NULL == g_clientEndpoint)
 503     {
 504         LOGE("No Request received");
 505         return;
 506     }
 507
 508     CAMessageType_t messageType = msgType;
 509
 510     CAInfo_t responseData = { 0 };
 511     responseData.type = messageType;
 512     responseData.messageId = g_clientMsgId;
 513     responseData.resourceUri = (CAURI_t)g_resourceUri;
 514
 515     CAResponseInfo_t responseInfo = { 0 };
 516
 517     if (msgType != CA_MSG_RESET)
 518     {
 519         responseData.token = g_clientToken;
 520         responseData.tokenLength = g_clientTokenLength;
 521         responseInfo.result = responseValue;
 522
 523         if (1 == isSecured)
 524         {
 525             uint32_t length = strlen(SECURE_INFO_DATA) + strlen(g_resourceUri) + 1;
 526             responseData.payload = (CAPayload_t) malloc(length);
 527             sprintf(responseData.payload, SECURE_INFO_DATA, g_resourceUri,
 528                     g_localSecurePort);
 529             responseData.payloadSize = length;
 530         }
 531         else
 532         {
 533             uint32_t length = strlen(NORMAL_INFO_DATA) + strlen(g_resourceUri) + 1;
 534             responseData.payload = (CAPayload_t) malloc(length);
 535             sprintf(responseData.payload, NORMAL_INFO_DATA, g_resourceUri);
 536             responseData.payloadSize = length;
 537         }
 538     }
 539     //msgType is RESET
 540     else
 541     {
 542         responseInfo.result = CA_EMPTY;
 543     }
 544
 545     responseInfo.info = responseData;
 546
 547     // send response
 548     res = CASendResponse(g_clientEndpoint, &responseInfo);
 549     if (CA_STATUS_OK != res)
 550     {
 551         LOGE("Could not send response");
 552     }
 553
 554     // destroy token
 555     CADestroyToken(g_clientToken);
 556     g_clientToken = NULL;
 557     g_clientTokenLength = 0;
 558
 559     // destroy remote endpoint
 560     CADestroyEndpoint(g_clientEndpoint);
 561     g_clientEndpoint = NULL;
 562 }
 563
 564 JNIEXPORT void JNICALL
 565 Java_org_iotivity_ca_service_RMInterface_RMSendNotification(JNIEnv *env, jobject obj, jstring uri,
 566                                                             jstring payload, jint selectedNetwork,
 567                                                             jint isSecured, jint msgType,
 568                                                             jint responseValue)
 569 {
 570     LOGI("selectedNetwork - %d", selectedNetwork);
 571
 572     CAResult_t res = get_network_type(selectedNetwork);
 573     if (CA_STATUS_OK != res)
 574     {
 575         LOGE("Not supported network type");
 576         return;
 577     }
 578
 579     const char* strUri = (*env)->GetStringUTFChars(env, uri, NULL);
 580     LOGI("RMSendNotification - %s", strUri);
 581
 582     CATransportFlags_t flags;
 583     addressSet_t address = {};
 584     parsing_coap_uri(strUri, &address, &flags);
 585
 586     //create remote endpoint
 587     CAEndpoint_t* endpoint = NULL;
 588     if (CA_STATUS_OK != CACreateEndpoint(flags, g_selectedNwType,
 589                                          (const char*)address.ipAddress,
 590                                          address.port, &endpoint))
 591     {
 592         //ReleaseStringUTFChars for strUri
 593         (*env)->ReleaseStringUTFChars(env, uri, strUri);
 594         LOGE("Could not create remote end point");
 595         return;
 596     }
 597
 598     char resourceURI[RESOURCE_URI_LENGTH + 1] = { 0 };
 599     get_resource_uri(strUri, resourceURI, RESOURCE_URI_LENGTH);
 600
 601     //ReleaseStringUTFChars for strUri
 602     (*env)->ReleaseStringUTFChars(env, uri, strUri);
 603
 604     CAMessageType_t messageType = msgType;
 605
 606     // create token
 607     CAToken_t token = NULL;
 608     uint8_t tokenLength = CA_MAX_TOKEN_LEN;
 609
 610     res = CAGenerateToken(&token, tokenLength);
 611     if ((CA_STATUS_OK != res) || (!token))
 612     {
 613         LOGE("token generate error!");
 614         CADestroyEndpoint(endpoint);
 615         return;
 616     }
 617
 618     CAInfo_t responseData = { 0 };
 619     responseData.token = token;
 620     responseData.tokenLength = tokenLength;
 621     responseData.resourceUri = (CAURI_t) malloc(sizeof(resourceURI));
 622     if (NULL == responseData.resourceUri)
 623     {
 624         LOGE("Memory allocation failed!");
 625         // destroy token
 626         CADestroyToken(token);
 627         // destroy remote endpoint
 628         CADestroyEndpoint(endpoint);
 629         return;
 630     }
 631     memcpy(responseData.resourceUri, resourceURI, sizeof(resourceURI));
 632
 633     if (1 == isSecured)
 634     {
 635         uint32_t length = sizeof(SECURE_INFO_DATA) + strlen(resourceURI);
 636         responseData.payload = (CAPayload_t) malloc(length);
 637         if (NULL == responseData.payload)
 638         {
 639             LOGE("Memory allocation failed!");
 640             // destroy token
 641             CADestroyToken(token);
 642             // destroy remote endpoint
 643             CADestroyEndpoint(endpoint);
 644
 645             free(responseData.resourceUri);
 646             return;
 647         }
 648         snprintf(responseData.payload, length, SECURE_INFO_DATA, resourceURI, g_localSecurePort);
 649     }
 650     else
 651     {
 652         uint32_t length = sizeof(NORMAL_INFO_DATA) + strlen(resourceURI);
 653         responseData.payload = (CAPayload_t) malloc(length);
 654         if (NULL == responseData.payload)
 655         {
 656             LOGE("Memory allocation failed!");
 657             // destroy token
 658             CADestroyToken(token);
 659             // destroy remote endpoint
 660             CADestroyEndpoint(endpoint);
 661
 662             free(responseData.resourceUri);
 663             return;
 664         }
 665         snprintf(responseData.payload, length, NORMAL_INFO_DATA, resourceURI);
 666     }
 667
 668     responseData.type = messageType;
 669
 670     CAResponseInfo_t responseInfo = { 0 };
 671     responseInfo.result = responseValue;
 672     responseInfo.info = responseData;
 673
 674     // send notification
 675     if (CA_STATUS_OK != CASendNotification(endpoint, &responseInfo))
 676     {
 677         LOGE("Could not send notification");
 678     }
 679
 680     LOGI("Send Notification");
 681
 682     // destroy token
 683     CADestroyToken(token);
 684
 685     // destroy remote endpoint
 686     CADestroyEndpoint(endpoint);
 687
 688     free(responseData.payload);
 689     free(responseData.resourceUri);
 690 }
 691
 692 JNIEXPORT void JNICALL
 693 Java_org_iotivity_ca_service_RMInterface_RMSelectNetwork(JNIEnv *env, jobject obj,
 694                                                          jint networkType)
 695 {
 696     LOGI("RMSelectNetwork Type : %d", networkType);
 697
 698     if (CA_STATUS_OK != CASelectNetwork(networkType))
 699     {
 700         LOGE("Could not select network");
 701     }
 702 }
 703
 704 JNIEXPORT void JNICALL
 705 Java_org_iotivity_ca_service_RMInterface_RMUnSelectNetwork(JNIEnv *env, jobject obj,
 706                                                            jint networkType)
 707 {
 708     LOGI("RMUnSelectNetwork Type : %d", networkType);
 709
 710     if (CA_STATUS_OK != CAUnSelectNetwork(networkType))
 711     {
 712         LOGE("Could not unselect network");
 713     }
 714 }
 715
 716 JNIEXPORT void JNICALL
 717 Java_org_iotivity_ca_service_RMInterface_RMGetNetworkInfomation(JNIEnv *env, jobject obj)
 718 {
 719     LOGI("RMGetNetworkInfomation");
 720
 721     CAEndpoint_t *tempInfo = NULL;
 722     uint32_t tempSize = 0;
 723
 724     CAResult_t res = CAGetNetworkInformation(&tempInfo, &tempSize);
 725     if (CA_STATUS_OK != res)
 726     {
 727         LOGE("Could not start get network information");
 728         free(tempInfo);
 729         return;
 730     }
 731
 732     LOGI("################## Network Information #######################");
 733     callback("######## Network Information", "#######");
 734     LOGI("Network info total size is %d", tempSize);
 735
 736     uint32_t index;
 737     for (index = 0; index < tempSize; index++)
 738     {
 739         res = get_remote_address(tempInfo[index].adapter, tempInfo[index].addr);
 740         if (CA_STATUS_OK != res)
 741         {
 742             free(tempInfo);
 743             return;
 744         }
 745         if (NULL != g_responseListenerObject)
 746         {
 747             char networkInfo[NETWORK_INFO_LENGTH];
 748             LOGI("Type: %d", tempInfo[index].adapter);
 749             sprintf(networkInfo, "%d",tempInfo[index].adapter);
 750             callback("Type :", networkInfo);
 751             if (CA_ADAPTER_IP == tempInfo[index].adapter)
 752             {
 753                 LOGI("Port: %d", tempInfo[index].port);
 754                 sprintf(networkInfo, "%d",tempInfo[index].port);
 755                 callback("Port: ", networkInfo);
 756             }
 757             LOGI("Secured: %d", (tempInfo[index].flags & CA_SECURE));
 758             LOGI("Address: %s", g_remoteAddress);
 759             callback("Address: ", g_remoteAddress);
 760             free(g_remoteAddress);
 761         }
 762         if (tempInfo[index].flags & CA_SECURE)
 763         {
 764             g_localSecurePort = tempInfo[index].port;
 765         }
 766     }
 767
 768     // free
 769     free(tempInfo);
 770
 771     LOGI("##############################################################");
 772 }
 773
 774 JNIEXPORT void JNICALL
 775 Java_org_iotivity_ca_service_RMInterface_RMHandleRequestResponse(JNIEnv *env, jobject obj)
 776 {
 777     LOGI("RMHandleRequestResponse");
 778
 779     if (CA_STATUS_OK != CAHandleRequestResponse())
 780     {
 781         LOGE("Could not handle request and response");
 782     }
 783 }
 784
 785 void request_handler(const CAEndpoint_t* object, const CARequestInfo_t* requestInfo)
 786 {
 787
 788     if (!object)
 789     {
 790         LOGE("Remote endpoint is NULL!");
 791         return;
 792     }
 793
 794     if (!requestInfo)
 795     {
 796         LOGE("Request info is NULL!");
 797         return;
 798     }
 799
 800     if ((NULL != g_lastRequestToken) && (NULL != requestInfo->info.token) &&
 801             (strncmp(g_lastRequestToken, requestInfo->info.token,
 802                      requestInfo->info.tokenLength) == 0))
 803     {
 804         LOGI("token is same. received request of it's own. skip.. ");
 805         return;
 806     }
 807
 808     CAResult_t res = get_remote_address(object->adapter, object->addr);
 809     if (CA_STATUS_OK != res)
 810     {
 811         return;
 812     }
 813
 814     LOGI("##########received request from remote device #############");
 815     LOGI("Remote Address: %s", g_remoteAddress);
 816     LOGI("Uri: %s", requestInfo->info.resourceUri);
 817     LOGI("Data: %s", requestInfo->info.payload);
 818     LOGI("Token: %s", requestInfo->info.token);
 819     LOGI("Code: %d", requestInfo->method);
 820     LOGI("MessageType: %d", requestInfo->info.type);
 821
 822     if (NULL != g_responseListenerObject)
 823     {
 824         char *cloneUri = NULL;
 825         uint32_t len = 0;
 826
 827         if (NULL != requestInfo->info.resourceUri)
 828         {
 829             len = strlen(requestInfo->info.resourceUri);
 830             cloneUri = (char *)malloc(sizeof(char) * (len + 1));
 831
 832             if (NULL == cloneUri)
 833             {
 834                 LOGE("cloneUri Out of memory");
 835                 free(g_remoteAddress);
 836                 return;
 837             }
 838
 839             memcpy(cloneUri, requestInfo->info.resourceUri, len + 1);
 840             callback("Uri: ", cloneUri);
 841         }
 842
 843         len = strlen(g_remoteAddress);
 844         char *cloneRemoteAddress = (char *) malloc(sizeof(char) * (len + 1));
 845
 846         if (NULL == cloneRemoteAddress)
 847         {
 848             LOGE("cloneRemoteAddress Out of memory");
 849             free(g_remoteAddress);
 850             free(cloneUri);
 851             return;
 852         }
 853
 854         memcpy(cloneRemoteAddress, g_remoteAddress, len + 1);
 855
 856         callback("Remote Address: ", cloneRemoteAddress);
 857         free(cloneRemoteAddress);
 858         free(g_remoteAddress);
 859
 860         //clone g_clientEndpoint
 861         g_clientEndpoint = (CAEndpoint_t *) malloc(sizeof(CAEndpoint_t));
 862         if (NULL == g_clientEndpoint)
 863         {
 864             LOGE("g_clientEndpoint Out of memory");
 865             free(cloneUri);
 866             return;
 867         }
 868         memcpy(g_clientEndpoint, object, sizeof(CAEndpoint_t));
 869
 870         if (NULL != cloneUri)
 871         {
 872             len = strlen(cloneUri);
 873             g_resourceUri = (char *) malloc(sizeof(char) * (len + 1));
 874             if (NULL == g_resourceUri)
 875             {
 876                 LOGE("g_clientEndpoint->resourceUri Out of memory");
 877                 free(g_clientEndpoint);
 878                 free(cloneUri);
 879                 return;
 880             }
 881             memcpy(g_resourceUri, cloneUri, len + 1);
 882             free(cloneUri);
 883         }
 884         //clone g_clientToken
 885         len = requestInfo->info.tokenLength;
 886
 887         g_clientToken = (char *) malloc(sizeof(char) * len);
 888         if (NULL == g_clientToken)
 889         {
 890             LOGE("g_clientToken Out of memory");
 891             free(g_clientEndpoint);
 892             return;
 893         }
 894
 895         if (NULL != requestInfo->info.token)
 896         {
 897             memcpy(g_clientToken, requestInfo->info.token, len);
 898             g_clientTokenLength = len;
 899
 900         }
 901
 902         //clone g_clientMsgId
 903         g_clientMsgId = requestInfo->info.messageId;
 904
 905         if (NULL != requestInfo->info.payload && requestInfo->info.payloadSize > 0)
 906         {
 907             len = requestInfo->info.payloadSize;
 908             char *clonePayload = (char *) malloc(len + 1);
 909             if (NULL == clonePayload)
 910             {
 911                 LOGE("clonePayload Out of memory");
 912                 free(g_clientEndpoint);
 913                 return;
 914             }
 915
 916             memcpy(clonePayload, requestInfo->info.payload, len);
 917             clonePayload[len] = '\0';
 918
 919             callback("Data: ", clonePayload);
 920             free(clonePayload);
 921         }
 922     }
 923
 924     if (requestInfo->info.options)
 925     {
 926         uint32_t len = requestInfo->info.numOptions;
 927         uint32_t i;
 928
 929         LOGI("Option count: %d", requestInfo->info.numOptions);
 930
 931         for (i = 0; i < len; i++)
 932         {
 933             LOGI("Option %d", i + 1);
 934             LOGI("ID : %d", requestInfo->info.options[i].optionID);
 935             LOGI("Data[%d]: %s", requestInfo->info.options[i].optionLength,
 936                  requestInfo->info.options[i].optionData);
 937
 938             if (NULL != g_responseListenerObject)
 939             {
 940                 char optionInfo[OPTION_INFO_LENGTH] = { 0, };
 941                 sprintf(optionInfo, "Num[%d] - ID : %d, Option Length : %d", i + 1,
 942                         requestInfo->info.options[i].optionID,
 943                         requestInfo->info.options[i].optionLength);
 944
 945                 callback("Option info: ", optionInfo);
 946
 947                 size_t optionDataLen = strlen(requestInfo->info.options[i].optionData);
 948                 char *cloneOptionData = (char *) malloc(sizeof(char) * (optionDataLen + 1));
 949                 if (NULL == cloneOptionData)
 950                 {
 951                     LOGE("cloneOptionData Out of memory");
 952                     free(g_clientEndpoint);
 953                     return;
 954                 }
 955
 956                 memcpy(cloneOptionData, requestInfo->info.options[i].optionData,
 957                        optionDataLen + 1);
 958
 959                 callback("Option Data: ", cloneOptionData);
 960                 free(cloneOptionData);
 961             }
 962         }
 963     }
 964     LOGI("############################################################");
 965
 966     //Check if this has secure communication information
 967     if (requestInfo->info.payload && CA_ADAPTER_IP == object->adapter)
 968     {
 969         uint32_t securePort = get_secure_information(requestInfo->info.payload);
 970         if (0 < securePort) //Set the remote endpoint secure details and send response
 971         {
 972             LOGI("This is secure resource...");
 973
 974             CAEndpoint_t *endpoint = NULL;
 975             if (CA_STATUS_OK != CACreateEndpoint(CA_SECURE,
 976                         object->adapter, object->addr, securePort, &endpoint))
 977             {
 978                 LOGE("Failed to create duplicate of remote endpoint!");
 979                 return;
 980             }
 981             object = endpoint;
 982         }
 983     }
 984 }
 985
 986 void response_handler(const CAEndpoint_t* object, const CAResponseInfo_t* responseInfo)
 987 {
 988
 989     CAResult_t res = get_remote_address(object->adapter, object->addr);
 990     if (CA_STATUS_OK != res)
 991     {
 992         return;
 993     }
 994
 995     LOGI("##########Received response from remote device #############");
 996     LOGI("Uri: %s", responseInfo->info.resourceUri);
 997     LOGI("Remote Address: %s", g_remoteAddress);
 998     LOGI("response result: %d", responseInfo->result);
 999     LOGI("Data: %s", responseInfo->info.payload);
1000     LOGI("Token: %s", responseInfo->info.token);
1001     LOGI("MessageType: %d", responseInfo->info.type);
1002
1003     if (NULL != g_responseListenerObject)
1004     {
1005         uint32_t len = 0;
1006
1007         if (NULL != responseInfo->info.resourceUri)
1008         {
1009             len = strlen(responseInfo->info.resourceUri);
1010             char *cloneUri = (char *) malloc(sizeof(char) * (len + 1));
1011
1012             if (NULL == cloneUri)
1013             {
1014                 LOGE("cloneUri Out of memory");
1015                 free(g_remoteAddress);
1016                 return;
1017             }
1018
1019             memcpy(cloneUri, responseInfo->info.resourceUri, len + 1);
1020
1021             callback("Uri: ", cloneUri);
1022             free(cloneUri);
1023         }
1024
1025         len = strlen(g_remoteAddress);
1026         char *cloneRemoteAddress = (char *) malloc(sizeof(char) * (len + 1));
1027
1028         if (NULL == cloneRemoteAddress)
1029         {
1030             LOGE("cloneRemoteAddress Out of memory");
1031             free(g_remoteAddress);
1032             return;
1033         }
1034
1035         memcpy(cloneRemoteAddress, g_remoteAddress, len + 1);
1036
1037         callback("Remote Address: ", cloneRemoteAddress);
1038         free(cloneRemoteAddress);
1039         free(g_remoteAddress);
1040
1041         if (NULL != responseInfo->info.payload && responseInfo->info.payloadSize)
1042         {
1043             len = responseInfo->info.payloadSize;
1044             char *clonePayload = (char *) malloc(len + 1);
1045             if (NULL == clonePayload)
1046             {
1047                 LOGE("clonePayload Out of memory");
1048                 return;
1049             }
1050
1051             memcpy(clonePayload, responseInfo->info.payload, len);
1052             clonePayload[len] = '\0';
1053
1054             callback("Data: ", clonePayload);
1055             free(clonePayload);
1056         }
1057     }
1058
1059     if (responseInfo->info.options)
1060     {
1061         uint32_t len = responseInfo->info.numOptions;
1062         uint32_t i;
1063         for (i = 0; i < len; i++)
1064         {
1065             LOGI("Option %d", i + 1);
1066             LOGI("ID : %d", responseInfo->info.options[i].optionID);
1067             LOGI("Data[%d]: %s", responseInfo->info.options[i].optionLength,
1068                  responseInfo->info.options[i].optionData);
1069
1070             if (NULL != g_responseListenerObject)
1071             {
1072                 char optionInfo[OPTION_INFO_LENGTH] = { 0, };
1073                 sprintf(optionInfo, "Num[%d] - ID : %d, Option Length : %d", i + 1,
1074                         responseInfo->info.options[i].optionID,
1075                         responseInfo->info.options[i].optionLength);
1076
1077                 callback("Option info: ", optionInfo);
1078
1079                 size_t optionDataLen = strlen(responseInfo->info.options[i].optionData);
1080                 char *cloneOptionData = (char *) malloc(sizeof(char) * (optionDataLen + 1));
1081                 if (NULL == cloneOptionData)
1082                 {
1083                     LOGE("cloneOptionData Out of memory");
1084                     return;
1085                 }
1086                 memcpy(cloneOptionData, responseInfo->info.options[i].optionData,
1087                        optionDataLen + 1);
1088                 callback("Option Data: ", cloneOptionData);
1089                 free(cloneOptionData);
1090             }
1091         }
1092     }
1093     LOGI("############################################################");
1094
1095     //Check if this has secure communication information
1096     if (responseInfo->info.payload && CA_ADAPTER_IP == object->adapter)
1097     {
1098         uint32_t securePort = get_secure_information(responseInfo->info.payload);
1099         if (0 < securePort) //Set the remote endpoint secure details and send response
1100         {
1101             LOGI("This is secure resource...");
1102         }
1103     }
1104 }
1105
1106 void error_handler(const CAEndpoint_t *rep, const CAErrorInfo_t* errorInfo)
1107 {
1108     printf("+++++++++++++++++++++++++++++++++++ErrorInfo+++++++++++++++++++++++++++++++++++");
1109
1110     if(errorInfo)
1111     {
1112         const CAInfo_t *info = &errorInfo->info;
1113         LOGI("Error Handler, ErrorInfo :");
1114         LOGI("Error Handler result    : %d", errorInfo->result);
1115         LOGI("Error Handler token     : %s", info->token);
1116         LOGI("Error Handler messageId : %d", (uint16_t) info->messageId);
1117         LOGI("Error Handler resourceUri : %s", info->resourceUri);
1118         LOGI("Error Handler type      : %d", info->type);
1119         LOGI("Error Handler payload   : %s", info->payload);
1120
1121         if(CA_ADAPTER_NOT_ENABLED == errorInfo->result)
1122         {
1123             LOGE("CA_ADAPTER_NOT_ENABLED, enable the adapter");
1124         }
1125         else if(CA_SEND_FAILED == errorInfo->result)
1126         {
1127             LOGE("CA_SEND_FAILED, unable to send the message, check parameters");
1128         }
1129         else if(CA_MEMORY_ALLOC_FAILED == errorInfo->result)
1130         {
1131             LOGE("CA_MEMORY_ALLOC_FAILED, insufficient memory");
1132         }
1133         else if(CA_SOCKET_OPERATION_FAILED == errorInfo->result)
1134         {
1135             LOGE("CA_SOCKET_OPERATION_FAILED, socket operation failed");
1136         }
1137         else if(CA_STATUS_FAILED == errorInfo->result)
1138         {
1139             LOGE("CA_STATUS_FAILED, message could not be delivered, internal error");
1140         }
1141     }
1142     LOGI("++++++++++++++++++++++++++++++++End of ErrorInfo++++++++++++++++++++++++++++++++");
1143
1144     return;
1145 }
1146
1147 void get_resource_uri(const char *URI, char *resourceURI, uint32_t length)
1148 {
1149     const char *startPos = URI;
1150     const char *temp = strstr(URI, "://");
1151     if (NULL != temp)
1152     {
1153         startPos = strchr(temp + 3, '/');
1154         if (!startPos)
1155         {
1156             LOGE("Resource URI is missing");
1157             return;
1158         }
1159     }
1160
1161     const char *endPos = strchr(startPos, '?');
1162     if (!endPos)
1163     {
1164         endPos = URI + strlen(URI);
1165     }
1166     --endPos;
1167
1168     if (endPos - startPos <= length)
1169     {
1170         memcpy(resourceURI, startPos + 1, endPos - startPos);
1171     }
1172
1173     LOGI("URI: %s, ResourceURI: %s", URI, resourceURI);
1174 }
1175
1176 uint32_t get_secure_information(CAPayload_t payLoad)
1177 {
1178     LOGI("entering get_secure_information");
1179
1180     if (!payLoad)
1181     {
1182         LOGE("Payload is NULL");
1183         return -1;
1184     }
1185
1186     const char *subString = NULL;
1187     if (NULL == (subString = strstr(payLoad, "\"sec\":1")))
1188     {
1189         LOGE("This is not secure resource");
1190         return -1;
1191     }
1192
1193     if (NULL == (subString = strstr(payLoad, "\"port\":")))
1194     {
1195         LOGE("This secure resource does not have port information");
1196         return -1;
1197     }
1198
1199     const char *startPos = strstr(subString, ":");
1200     if (!startPos)
1201     {
1202         LOGE("Parsing failed !");
1203         return -1;
1204     }
1205
1206     const char *endPos = strstr(startPos, "}");
1207     if (!endPos)
1208     {
1209         LOGE("Parsing failed !");
1210         return -1;
1211     }
1212
1213     char portStr[6] = { 0 };
1214     memcpy(portStr, startPos + 1, (endPos - 1) - startPos);
1215
1216     LOGI("secured port is: %s", portStr);
1217     return atoi(portStr);
1218 }
1219
1220 CAResult_t get_network_type(uint32_t selectedNetwork)
1221 {
1222
1223     uint32_t number = selectedNetwork;
1224
1225     if (!(number & 0xf))
1226     {
1227         return CA_NOT_SUPPORTED;
1228     }
1229     if (number & CA_ADAPTER_IP)
1230     {
1231         g_selectedNwType = CA_ADAPTER_IP;
1232         return CA_STATUS_OK;
1233     }
1234     if (number & CA_ADAPTER_RFCOMM_BTEDR)
1235     {
1236         g_selectedNwType = CA_ADAPTER_RFCOMM_BTEDR;
1237         return CA_STATUS_OK;
1238     }
1239     if (number & CA_ADAPTER_GATT_BTLE)
1240     {
1241         g_selectedNwType = CA_ADAPTER_GATT_BTLE;
1242         return CA_STATUS_OK;
1243     }
1244
1245     return CA_NOT_SUPPORTED;
1246 }
1247
1248 void callback(char *subject, char *receivedData)
1249 {
1250     JNIEnv* env = NULL;
1251     uint32_t status = (*g_jvm)->GetEnv(g_jvm, (void **) &env, JNI_VERSION_1_6);
1252     uint32_t res = (*g_jvm)->AttachCurrentThread(g_jvm, &env, NULL);
1253
1254     jclass cls = (*env)->GetObjectClass(env, g_responseListenerObject);
1255     jmethodID mid = (*env)->GetMethodID(env, cls, "OnResponseReceived",
1256                                         "(Ljava/lang/String;Ljava/lang/String;)V");
1257
1258     jstring jsubject = (*env)->NewStringUTF(env, (char*) subject);
1259     jstring jreceivedData = (*env)->NewStringUTF(env, (char*) receivedData);
1260     (*env)->CallVoidMethod(env, g_responseListenerObject, mid, jsubject, jreceivedData);
1261
1262 }
1263
1264 CAResult_t get_remote_address(CATransportAdapter_t transportType, const char *address)
1265 {
1266     uint32_t len = strlen(address);
1267
1268     g_remoteAddress = (char *)malloc(sizeof (char) * (len + 1));
1269     if (NULL == g_remoteAddress)
1270     {
1271         LOGE("g_remoteAddress Out of memory");
1272         return CA_MEMORY_ALLOC_FAILED;
1273     }
1274
1275     memcpy(g_remoteAddress, address, len + 1);
1276
1277     return CA_STATUS_OK;
1278 }
1279
1280
1281 void parsing_coap_uri(const char* uri, addressSet_t* address, CATransportFlags_t *flags)
1282 {
1283     if (NULL == uri || NULL == address)
1284     {
1285         LOGE("parameter is null");
1286         return;
1287     }
1288
1289     // parse uri
1290     // #1. check prefix
1291     uint8_t startIndex = 0;
1292     if (strncmp(COAPS_PREFIX, uri, COAPS_PREFIX_LEN) == 0)
1293     {
1294         LOGI("uri has '%s' prefix", COAPS_PREFIX);
1295         startIndex = COAPS_PREFIX_LEN;
1296         *flags = CA_SECURE;
1297     }
1298     else if (strncmp(COAP_PREFIX, uri, COAP_PREFIX_LEN) == 0)
1299     {
1300         LOGI("uri has '%s' prefix", COAP_PREFIX);
1301         startIndex = COAP_PREFIX_LEN;
1302         *flags = CA_DEFAULT_FLAGS;
1303     }
1304
1305     // #2. copy uri for parse
1306     int32_t len = strlen(uri) - startIndex;
1307
1308     if (len <= 0)
1309     {
1310         LOGE("uri length is 0!");
1311         return;
1312     }
1313
1314     char *cloneUri = (char *) calloc(len + 1, sizeof(char));
1315     if (NULL == cloneUri)
1316     {
1317         LOGE("Out of memory");
1318         return;
1319     }
1320
1321     memcpy(cloneUri, &uri[startIndex], sizeof(char) * len);
1322     cloneUri[len] = '\0';
1323
1324     char *pAddress = cloneUri;
1325     char *pResourceUri = NULL;
1326
1327     int32_t i = 0;
1328     for (i = 0; i < len; i++)
1329     {
1330         if (cloneUri[i] == '/')
1331         {
1332             // separate
1333             cloneUri[i] = 0;
1334             pResourceUri = &cloneUri[i + 1];
1335             break;
1336         }
1337     }
1338     LOGI("pAddress : %s", pAddress);
1339
1340     int res = get_address_set(pAddress, address);
1341     if (res == -1)
1342     {
1343         LOGE("address parse error");
1344
1345         free(cloneUri);
1346         return;
1347     }
1348     return;
1349 }
1350
1351 int get_address_set(const char *pAddress, addressSet_t* outAddress)
1352 {
1353     if (NULL == pAddress || NULL == outAddress)
1354     {
1355         LOGE("parameter is null");
1356         return -1;
1357     }
1358
1359     int32_t len = strlen(pAddress);
1360     int32_t isIp = 0;
1361     int32_t ipLen = 0;
1362
1363     int32_t i = 0;
1364     for (i = 0; i < len; i++)
1365     {
1366         if (pAddress[i] == '.')
1367         {
1368             isIp = 1;
1369         }
1370
1371         // found port number start index
1372         if (isIp && pAddress[i] == ':')
1373         {
1374             ipLen = i;
1375             break;
1376         }
1377     }
1378
1379     if (isIp)
1380     {
1381         if(ipLen && ipLen < sizeof(outAddress->ipAddress))
1382         {
1383             strncpy(outAddress->ipAddress, pAddress, ipLen);
1384             outAddress->ipAddress[ipLen] = '\0';
1385         }
1386         else if (!ipLen && len < sizeof(outAddress->ipAddress))
1387         {
1388             strncpy(outAddress->ipAddress, pAddress, len);
1389             outAddress->ipAddress[len] = '\0';
1390         }
1391         else
1392         {
1393             LOGE("IP Address too long: %d", ipLen==0 ? len : ipLen);
1394             return -1;
1395         }
1396
1397         if (ipLen > 0)
1398         {
1399             outAddress->port = atoi(pAddress + ipLen + 1);
1400         }
1401     }
1402     else
1403     {
1404         strncpy(outAddress->ipAddress, pAddress, len);
1405         outAddress->ipAddress[len] = '\0';
1406     }
1407
1408     return isIp;
1409 }