android/android_api/base/jni/JniOcSecureResource.cpp

   1 /*
   2 * //******************************************************************
   3 * //
   4 * // Copyright 2015 Samsung Electronics All Rights Reserved.
   5 * //
   6 * //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
   7 * //
   8 * // Licensed under the Apache License, Version 2.0 (the "License");
   9 * // you may not use this file except in compliance with the License.
  10 * // You may obtain a copy of the License at
  11 * //
  12 * //      http://www.apache.org/licenses/LICENSE-2.0
  13 * //
  14 * // Unless required by applicable law or agreed to in writing, software
  15 * // distributed under the License is distributed on an "AS IS" BASIS,
  16 * // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17 * // See the License for the specific language governing permissions and
  18 * // limitations under the License.
  19 * //
  20 * //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  21 */
  22
  23 #include "JniOcSecureResource.h"
  24 #include "JniSecureUtils.h"
  25 #include "aclresource.h"
  26 #include "oic_malloc.h"
  27 #include "oic_string.h"
  28 namespace PH = std::placeholders;
  29
  30 JniOcSecureResource::JniOcSecureResource(std::shared_ptr<OCSecureResource> device)
  31     : m_sharedSecureResource(device)
  32 {}
  33
  34 JniOcSecureResource::~JniOcSecureResource()
  35 {
  36     LOGD("~JniOcSecureResource()");
  37     m_sharedSecureResource = nullptr;
  38 }
  39
  40 std::string JniOcSecureResource::getIpAddr()
  41 {
  42     return m_sharedSecureResource->getDevAddr();
  43 }
  44
  45 std::string JniOcSecureResource::getDeviceID()
  46 {
  47     return m_sharedSecureResource->getDeviceID();
  48 }
  49
  50 int JniOcSecureResource::getDeviceStatus()
  51 {
  52     return m_sharedSecureResource->getDeviceStatus();
  53 }
  54
  55 bool JniOcSecureResource::getOwnedStatus()
  56 {
  57     return m_sharedSecureResource->getOwnedStatus();
  58 }
  59
  60 OCSecureResource* JniOcSecureResource::getDevicePtr()
  61 {
  62     return m_sharedSecureResource.get();
  63 }
  64
  65 JniOcSecureResource* JniOcSecureResource::getJniOcSecureResourcePtr(JNIEnv *env, jobject thiz)
  66 {
  67     JniOcSecureResource *secureResource = GetHandle<JniOcSecureResource>(env, thiz);
  68     if (env->ExceptionCheck())
  69     {
  70         LOGE("Failed to get native handle from OcSecureResource");
  71     }
  72     if (!secureResource)
  73     {
  74         ThrowOcException(JNI_NO_NATIVE_POINTER, "");
  75     }
  76     return secureResource;
  77 }
  78
  79 JniProvisionResultListner* JniOcSecureResource::AddProvisionResultListener(JNIEnv* env,
  80         jobject jListener)
  81 {
  82     JniProvisionResultListner *resultListener = NULL;
  83     resultMapLock.lock();
  84
  85     for (auto it = resultMap.begin(); it != resultMap.end(); ++it)
  86     {
  87         if (env->IsSameObject(jListener, it->first))
  88         {
  89             auto refPair = it->second;
  90             resultListener = refPair.first;
  91             refPair.second++;
  92             it->second = refPair;
  93             resultMap.insert(*it);
  94             LOGD("Provision resultListener: ref. count incremented");
  95             break;
  96         }
  97     }
  98     if (!resultListener)
  99     {
 100         resultListener = new JniProvisionResultListner(env, jListener,
 101             RemoveCallback(std::bind(&JniOcSecureResource::RemoveProvisionResultListener,
 102                     this, PH::_1, PH::_2)));
 103         jobject jgListener = env->NewGlobalRef(jListener);
 104
 105         resultMap.insert(std::pair < jobject, std::pair < JniProvisionResultListner*,
 106                 int >> (jgListener, std::pair<JniProvisionResultListner*, int>(resultListener, 1)));
 107         LOGD("Provision resultListener: new listener");
 108     }
 109     resultMapLock.unlock();
 110     return resultListener;
 111 }
 112
 113 void JniOcSecureResource::RemoveProvisionResultListener(JNIEnv* env, jobject jListener)
 114 {
 115     resultMapLock.lock();
 116
 117     for (auto it = resultMap.begin(); it != resultMap.end(); ++it)
 118     {
 119         if (env->IsSameObject(jListener, it->first))
 120         {
 121             auto refPair = it->second;
 122             if (refPair.second > 1)
 123             {
 124                 refPair.second--;
 125                 it->second = refPair;
 126                 resultMap.insert(*it);
 127                 LOGI("Provision resultListener: ref. count decremented");
 128             }
 129             else
 130             {
 131                 env->DeleteGlobalRef(it->first);
 132                 JniProvisionResultListner* listener = refPair.first;
 133                 delete listener;
 134                 resultMap.erase(it);
 135                 LOGI("Provision resultListener removed");
 136             }
 137             break;
 138         }
 139     }
 140     resultMapLock.unlock();
 141 }
 142
 143 OCStackResult JniOcSecureResource::doOwnershipTransfer(JNIEnv* env, jobject jListener)
 144 {
 145     JniProvisionResultListner *resultListener = AddProvisionResultListener(env, jListener);
 146
 147     ResultCallBack resultCallback = [resultListener](PMResultList_t *result, int hasError)
 148     {
 149         resultListener->ProvisionResultCallback(result, hasError, ListenerFunc::OWNERSHIPTRANSFER);
 150     };
 151
 152     return m_sharedSecureResource->doOwnershipTransfer(resultCallback);
 153 }
 154
 155 OCStackResult JniOcSecureResource::getLinkedDevices(JNIEnv *env, UuidList_t &uuidList)
 156 {
 157     return m_sharedSecureResource->getLinkedDevices(uuidList);
 158 }
 159
 160 OCStackResult JniOcSecureResource::removeDevice(JNIEnv* env, jint timeout, jobject jListener)
 161 {
 162     JniProvisionResultListner *resultListener = AddProvisionResultListener(env, jListener);
 163
 164     ResultCallBack resultCallback = [resultListener](PMResultList_t *result, int hasError)
 165     {
 166         resultListener->ProvisionResultCallback(result, hasError, ListenerFunc::REMOVEDEVICE);
 167     };
 168
 169     return m_sharedSecureResource->removeDevice((int)timeout, resultCallback);
 170 }
 171
 172 OCStackResult JniOcSecureResource::unlinkDevices(JNIEnv* env, jobject _device2, jobject jListener)
 173 {
 174     JniProvisionResultListner *resultListener = AddProvisionResultListener(env, jListener);
 175
 176     ResultCallBack resultCallback = [resultListener](PMResultList_t *result, int hasError)
 177     {
 178         resultListener->ProvisionResultCallback(result, hasError, ListenerFunc::UNLINKDEVICES);
 179     };
 180
 181     JniOcSecureResource *device2 = JniOcSecureResource::getJniOcSecureResourcePtr(env, _device2);
 182     if (!device2)
 183     {
 184         return OC_STACK_ERROR;
 185     }
 186
 187     return m_sharedSecureResource->unlinkDevices(*device2->getDevicePtr(), resultCallback);
 188 }
 189
 190 OCStackResult JniOcSecureResource::provisionCredentials(JNIEnv* env, jint type, jint keySize,
 191         jobject _device2, jobject jListener)
 192 {
 193     JniProvisionResultListner *resultListener = AddProvisionResultListener(env, jListener);
 194
 195     ResultCallBack resultCallback = [resultListener](PMResultList_t *result, int hasError)
 196     {
 197         resultListener->ProvisionResultCallback(result, hasError, ListenerFunc::PROVISIONCREDENTIALS);
 198     };
 199
 200     JniOcSecureResource *device2 = JniOcSecureResource::getJniOcSecureResourcePtr(env, _device2);
 201     if (!device2)
 202     {
 203         return OC_STACK_ERROR;
 204     }
 205
 206     Credential cred((OicSecCredType_t)type, keySize);
 207
 208     return m_sharedSecureResource->provisionCredentials(cred, *device2->getDevicePtr(),
 209             resultCallback);
 210 }
 211
 212 #if defined(__WITH_TLS__)
 213 OCStackResult JniOcSecureResource::provisionTrustCertChain(JNIEnv* env, jint type, jint credId,
 214         jobject jListener)
 215 {
 216     JniProvisionResultListner *resultListener = AddProvisionResultListener(env, jListener);
 217
 218     ResultCallBack resultCallback = [resultListener](PMResultList_t *result, int hasError)
 219     {
 220         resultListener->ProvisionResultCallback(result, hasError, ListenerFunc::PROVISIONTRUSTCERTCHAIN);
 221     };
 222
 223     return m_sharedSecureResource->provisionTrustCertChain((OicSecCredType_t)type, credId,
 224             resultCallback);
 225 }
 226 #endif
 227
 228 OCStackResult JniOcSecureResource::provisionACL(JNIEnv* env, jobject _acl, jobject jListener)
 229 {
 230     OCStackResult ret;
 231     JniProvisionResultListner *resultListener = AddProvisionResultListener(env, jListener);
 232     OicSecAcl_t *acl = (OicSecAcl_t*)OICCalloc(1, sizeof(OicSecAcl_t));
 233
 234     if (!acl)
 235     {
 236         return OC_STACK_NO_MEMORY;
 237     }
 238
 239     if (OC_STACK_OK != JniSecureUtils::convertJavaACLToOCAcl(env, _acl, acl))
 240     {
 241         DeleteACLList(acl);
 242         return OC_STACK_ERROR;
 243     }
 244
 245     ResultCallBack resultCallback = [acl, resultListener](PMResultList_t *result, int hasError)
 246     {
 247         DeleteACLList(acl);
 248         resultListener->ProvisionResultCallback(result, hasError, ListenerFunc::PROVISIONACL);
 249     };
 250     ret = m_sharedSecureResource->provisionACL(acl, resultCallback);
 251
 252     if (ret != OC_STACK_OK)
 253     {
 254         DeleteACLList(acl);
 255     }
 256     return ret;
 257 }
 258
 259 OCStackResult JniOcSecureResource::provisionDirectPairing(JNIEnv* env, jobjectArray jpdacls,
 260         jobject jListener, std::string pin, std::vector<int> prms, int edp)
 261 {
 262     OCStackResult ret;
 263     JniProvisionResultListner *resultListener = AddProvisionResultListener(env, jListener);
 264
 265     jsize len = env->GetArrayLength(jpdacls);
 266
 267     OicSecPconf_t *pconf = nullptr;
 268     OicSecPdAcl_t *head = nullptr;
 269
 270     for (jsize i = 0; i < len; ++i)
 271     {
 272         OicSecPdAcl_t *pdacl = new OicSecPdAcl_t;
 273         if (!pdacl)
 274         {
 275             return OC_STACK_NO_MEMORY;
 276         }
 277
 278         memset(pdacl, 0, sizeof(OicSecPdAcl_t));
 279         pdacl->next = nullptr;
 280
 281         jobject jpdacl  = env->GetObjectArrayElement(jpdacls, i);
 282
 283         if (OC_STACK_OK != JniSecureUtils::convertJavaPdACLToOCAcl(env, jpdacl, pdacl))
 284         {
 285             delete pdacl;
 286             return OC_STACK_ERROR;
 287         }
 288
 289         pdacl->next = head;
 290         head = pdacl;
 291     }
 292
 293     pconf = new OicSecPconf_t;
 294     memset(pconf, 0, sizeof(OicSecPconf_t));
 295     pconf->edp = edp;
 296     pconf->prmLen = prms.size();
 297     pconf->prm = new OicSecPrm_t[pconf->prmLen];
 298     pconf->pddevLen = 0;
 299
 300     for (int i = 0 ; i < prms.size(); i++)
 301         pconf->prm[i] = (OicSecPrm_t)prms[i];
 302
 303     memcpy(pconf->pin.val, pin.c_str(), DP_PIN_LENGTH);
 304     pconf->pdacls = head;
 305
 306     ResultCallBack resultCallback = [head, resultListener, pconf, prms]
 307         (PMResultList_t *result, int hasError)
 308         {
 309             OicSecPdAcl_t *tmp1, *tmp2;
 310             tmp1 = head;
 311             while (tmp1)
 312             {
 313                 tmp2 = tmp1->next;
 314                 delete tmp1;
 315                 tmp1 = tmp2;
 316             }
 317
 318             delete[] pconf->prm;
 319             delete pconf;
 320             resultListener->ProvisionResultCallback(result, hasError, ListenerFunc::PROVISIONDIRECTPAIRING);
 321         };
 322
 323     ret = m_sharedSecureResource->provisionDirectPairing(pconf, resultCallback);
 324
 325     if (ret != OC_STACK_OK)
 326     {
 327         OicSecPdAcl_t *tmp1, *tmp2;
 328         tmp1 = head;
 329         while (tmp1)
 330         {
 331             tmp2 = tmp1->next;
 332             delete tmp1;
 333             tmp1 = tmp2;
 334         }
 335
 336         delete[] pconf->prm;
 337         delete pconf;
 338     }
 339     return ret;
 340 }
 341
 342 OCStackResult JniOcSecureResource::provisionPairwiseDevices(JNIEnv* env, jint type, jint keySize,
 343         jobject _acl1, jobject _device2, jobject _acl2, jobject jListener)
 344 {
 345     OCStackResult ret;
 346     if(!jListener)
 347     {
 348         return OC_STACK_INVALID_CALLBACK;
 349     }
 350     JniProvisionResultListner *resultListener = AddProvisionResultListener(env, jListener);
 351     JniOcSecureResource *device2 = JniOcSecureResource::getJniOcSecureResourcePtr(env, _device2);
 352     if (!device2)
 353     {
 354         return OC_STACK_ERROR;
 355     }
 356
 357     Credential cred((OicSecCredType_t)type, keySize);
 358
 359     OicSecAcl_t *acl1 = nullptr;
 360     OicSecAcl_t *acl2 = nullptr;
 361
 362     if (_acl1)
 363     {
 364         acl1 = (OicSecAcl_t*)OICCalloc(1, sizeof(OicSecAcl_t));
 365         if (!acl1)
 366         {
 367             return OC_STACK_NO_MEMORY;
 368         }
 369
 370         if (OC_STACK_OK != JniSecureUtils::convertJavaACLToOCAcl(env, _acl1, acl1))
 371         {
 372             DeleteACLList(acl1);
 373             return OC_STACK_ERROR;
 374         }
 375     }
 376
 377     if (_acl2)
 378     {
 379         acl2 = (OicSecAcl_t*)OICCalloc(1, sizeof(OicSecAcl_t));
 380         if (!acl2)
 381         {
 382             DeleteACLList(acl1);
 383             return OC_STACK_NO_MEMORY;
 384         }
 385
 386         if (OC_STACK_OK != JniSecureUtils::convertJavaACLToOCAcl(env, _acl2, acl2))
 387         {
 388             DeleteACLList(acl2);
 389             return OC_STACK_ERROR;
 390         }
 391     }
 392
 393     ResultCallBack resultCallback = [acl1, acl2, resultListener](PMResultList_t *result,
 394             int hasError)
 395     {
 396         DeleteACLList(acl1);
 397         DeleteACLList(acl2);
 398         resultListener->ProvisionResultCallback(result, hasError,
 399                 ListenerFunc::PROVISIONPAIRWISEDEVICES);
 400     };
 401
 402
 403     ret = m_sharedSecureResource->provisionPairwiseDevices(cred, acl1,
 404             *device2->getDevicePtr(), acl2, resultCallback);
 405     if (ret != OC_STACK_OK)
 406     {
 407         DeleteACLList(acl1);
 408         DeleteACLList(acl2);
 409     }
 410     return ret;
 411 }
 412
 413 /*
 414  * Class:     org_iotivity_base_OcSecureResource
 415  * Method:    doOwnershipTransfer
 416  * Signature: (Lorg/iotivity/base/OcSecureResource/doOwnershipTransferListener;)V
 417  */
 418 JNIEXPORT void JNICALL Java_org_iotivity_base_OcSecureResource_doOwnershipTransfer
 419 (JNIEnv *env, jobject thiz, jobject jListener)
 420 {
 421     LOGD("OcSecureResource_doOwnershipTransfer");
 422     if (!jListener)
 423     {
 424         ThrowOcException(OC_STACK_INVALID_CALLBACK, "provisionResultListener cannot be null");
 425         return;
 426     }
 427
 428     JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
 429     if (!secureResource)
 430     {
 431         ThrowOcException(OC_STACK_ERROR, "getJniOcSecureResourcePtr failed");
 432         return;
 433     }
 434
 435     try
 436     {
 437         OCStackResult result = secureResource->doOwnershipTransfer(env, jListener);
 438         if (OC_STACK_OK != result)
 439         {
 440             ThrowOcException(result, "OcSecureResource_doOwnershipTransfer");
 441             return;
 442         }
 443     }
 444     catch (OCException& e)
 445     {
 446         LOGE("%s", e.reason().c_str());
 447         ThrowOcException(e.code(), e.reason().c_str());
 448     }
 449 }
 450
 451 /*
 452  * Class:     org_iotivity_base_OcSecureResource
 453  * Method:    removeDevice
 454  * Signature: (ILorg/iotivity/base/OcSecureResource/removeDevice;)V
 455  */
 456 JNIEXPORT void JNICALL Java_org_iotivity_base_OcSecureResource_removeDevice
 457 (JNIEnv *env, jobject thiz, jint timeout, jobject jListener)
 458 {
 459     LOGD("OcSecureResource_removeDevice");
 460     if (timeout < 0)
 461     {
 462         ThrowOcException(OC_STACK_INVALID_PARAM, "Timeout value cannot be negative");
 463         return;
 464     }
 465
 466     if (!jListener)
 467     {
 468         ThrowOcException(OC_STACK_INVALID_CALLBACK, "provisionResultListener cannot be null");
 469         return;
 470     }
 471
 472     JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
 473     if (!secureResource)
 474     {
 475         ThrowOcException(OC_STACK_ERROR, "getJniOcSecureResourcePtr failed");
 476         return;
 477     }
 478
 479     try
 480     {
 481         OCStackResult result = secureResource->removeDevice(env, timeout, jListener);
 482         if (OC_STACK_OK != result)
 483         {
 484             ThrowOcException(result, "OcSecureResource_removeDevice");
 485             return;
 486         }
 487     }
 488     catch (OCException& e)
 489     {
 490         LOGE("%s", e.reason().c_str());
 491         ThrowOcException(e.code(), e.reason().c_str());
 492     }
 493 }
 494
 495 /*
 496  * Class:     org_iotivity_base_OcSecureResource
 497  * Method:    unlinkDevices
 498  * Signature: (Lorg/iotivity/base/OcSecureResource/unlinkDevices;)V
 499  */
 500 JNIEXPORT void JNICALL Java_org_iotivity_base_OcSecureResource_unlinkDevices
 501 (JNIEnv *env, jobject thiz, jobject device2, jobject jListener)
 502 {
 503     LOGD("OcSecureResource_unlinkDevices");
 504     if (!jListener)
 505     {
 506         ThrowOcException(OC_STACK_INVALID_CALLBACK, "provisionResultListener cannot be null");
 507         return;
 508     }
 509     if (!device2)
 510     {
 511         ThrowOcException(OC_STACK_INVALID_PARAM, "device2 cannot be null");
 512         return;
 513     }
 514
 515     JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
 516     if (!secureResource)
 517     {
 518         ThrowOcException(OC_STACK_ERROR, "getJniOcSecureResourcePtr failed");
 519         return;
 520     }
 521
 522     try
 523     {
 524         OCStackResult result = secureResource->unlinkDevices(env, device2, jListener);
 525         if (OC_STACK_OK != result)
 526         {
 527             ThrowOcException(result, "OcSecureResource_unlinkDevices");
 528             return;
 529         }
 530     }
 531     catch (OCException& e)
 532     {
 533         LOGE("%s", e.reason().c_str());
 534         ThrowOcException(e.code(), e.reason().c_str());
 535     }
 536 }
 537
 538 /*
 539  * Class:     org_iotivity_base_OcSecureResource
 540  * Method:    provisionCredentials1
 541  * Signature: (Lorg/iotivity/base/OcSecureResource/provisionCredentials;)V
 542  */
 543     JNIEXPORT void JNICALL Java_org_iotivity_base_OcSecureResource_provisionCredentials1
 544 (JNIEnv *env, jobject thiz, jint type, jint keySize, jobject device2, jobject jListener)
 545 {
 546     LOGD("OcSecureResource_provisionCredentials");
 547     if (!jListener)
 548     {
 549         ThrowOcException(OC_STACK_INVALID_CALLBACK, "provisionResultListener cannot be null");
 550         return;
 551     }
 552     if (!device2)
 553     {
 554         ThrowOcException(OC_STACK_INVALID_PARAM, "device2 cannot be null");
 555         return;
 556     }
 557
 558     JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
 559     if (!secureResource)
 560     {
 561         ThrowOcException(OC_STACK_ERROR, "getJniOcSecureResourcePtr failed");
 562         return;
 563     }
 564
 565     try
 566     {
 567         OCStackResult result = secureResource->provisionCredentials(env, type, keySize, device2,
 568                 jListener);
 569         if (OC_STACK_OK != result)
 570         {
 571             ThrowOcException(result, "OcSecureResource_provisionCredentials");
 572             return;
 573         }
 574     }
 575     catch (OCException& e)
 576     {
 577         LOGE("%s", e.reason().c_str());
 578         ThrowOcException(e.code(), e.reason().c_str());
 579     }
 580 }
 581
 582 /*
 583  * Class:     org_iotivity_base_OcSecureResource
 584  * Method:    provisionTrustCertChain1
 585  * Signature: (Lorg/iotivity/base/OcSecureResource/provisionTrustCertChain1;)V
 586  */
 587     JNIEXPORT void JNICALL Java_org_iotivity_base_OcSecureResource_provisionTrustCertChain1
 588 (JNIEnv *env, jobject thiz, jint type, jint credId, jobject jListener)
 589 {
 590     LOGD("OcSecureResource_provisionTrustCertChain1");
 591 #if defined(__WITH_DTLS__) || defined(__WITH_TLS__)
 592     if (!jListener)
 593     {
 594         ThrowOcException(OC_STACK_INVALID_CALLBACK, "provisionTrustCertChainListener cannot be null");
 595         return;
 596     }
 597
 598     JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
 599     if (!secureResource)
 600     {
 601         return;
 602     }
 603
 604     try
 605     {
 606         OCStackResult result = secureResource->provisionTrustCertChain(env, type, credId,
 607                 jListener);
 608         if (OC_STACK_OK != result)
 609         {
 610             ThrowOcException(result, "OcSecureResource_provisionTrustCertChain1");
 611             return;
 612         }
 613     }
 614     catch (OCException& e)
 615     {
 616         LOGE("%s", e.reason().c_str());
 617         ThrowOcException(e.code(), e.reason().c_str());
 618     }
 619 #else
 620     ThrowOcException(OC_STACK_INVALID_PARAM, "WITH_TLS not enabled");
 621     return;
 622 #endif // __WITH_DTLS__ || __WITH_TLS__
 623 }
 624
 625 /*
 626  * Class:     org_iotivity_base_OcSecureResource
 627  * Method:    provisionACL
 628  * Signature: (Lorg/iotivity/base/OcSecureResource/provisionACL;)V
 629  */
 630 JNIEXPORT void JNICALL Java_org_iotivity_base_OcSecureResource_provisionACL
 631 (JNIEnv *env, jobject thiz, jobject acl, jobject jListener)
 632 {
 633     LOGD("OcSecureResource_provisionACL");
 634     if (!jListener)
 635     {
 636         ThrowOcException(OC_STACK_INVALID_CALLBACK, "provisionResultListener cannot be null");
 637         return;
 638     }
 639     if (!acl)
 640     {
 641         ThrowOcException(OC_STACK_INVALID_PARAM, "acl cannot be null");
 642         return;
 643     }
 644
 645     JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
 646     if (!secureResource)
 647     {
 648         ThrowOcException(OC_STACK_ERROR, "getJniOcSecureResourcePtr failed");
 649         return;
 650     }
 651
 652     try
 653     {
 654         OCStackResult result = secureResource->provisionACL(env, acl, jListener);
 655         if (OC_STACK_OK != result)
 656         {
 657             ThrowOcException(result, "OcSecureResource_provisionACL");
 658             return;
 659         }
 660     }
 661     catch (OCException& e)
 662     {
 663         LOGE("%s", e.reason().c_str());
 664         ThrowOcException(e.code(), e.reason().c_str());
 665     }
 666 }
 667
 668 /*
 669  * Class:     org_iotivity_base_OcSecureResource
 670  * Method:    provisionPairwiseDevices1
 671  * Signature: (Lorg/iotivity/base/OcSecureResource/provisionPairwiseDevices;)V
 672  */
 673 JNIEXPORT void JNICALL Java_org_iotivity_base_OcSecureResource_provisionPairwiseDevices1
 674 (JNIEnv *env, jobject thiz, jint type, jint keySize, jobject acl1, jobject device2,
 675         jobject acl2, jobject jListener)
 676 {
 677     LOGD("OcSecureResource_provisionPairwiseDevices");
 678     if (!jListener)
 679     {
 680         ThrowOcException(OC_STACK_INVALID_CALLBACK, "Invalid Callback");
 681         return;
 682     }
 683     if (!device2)
 684     {
 685         ThrowOcException(OC_STACK_INVALID_PARAM, "device2 cannot be null");
 686         return;
 687     }
 688
 689     JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
 690     if (!secureResource)
 691     {
 692         ThrowOcException(OC_STACK_ERROR, "getJniOcSecureResourcePtr failed");
 693         return;
 694     }
 695
 696     try
 697     {
 698         OCStackResult result = secureResource->provisionPairwiseDevices(env, type, keySize,
 699                 acl1, device2, acl2, jListener);
 700         if (OC_STACK_OK != result)
 701         {
 702             ThrowOcException(result, "OcSecureResource_provisionPairwiseDevices");
 703             return;
 704         }
 705     }
 706     catch (OCException& e)
 707     {
 708         LOGE("%s", e.reason().c_str());
 709         ThrowOcException(e.code(), e.reason().c_str());
 710     }
 711 }
 712
 713 /*
 714  * Class:     org_iotivity_base_OcSecureResource
 715  * Method:    provisionDirectPairing
 716  * Signature: (Ljava/lang/String;[Lorg/iotivity/base/OicSecPdAcl;ILorg/iotivity/base/OcSecureResource/ProvisionDirectPairingListener;I)V
 717  */
 718 JNIEXPORT void JNICALL Java_org_iotivity_base_OcSecureResource_provisionDirectPairing
 719 (JNIEnv *env, jobject thiz, jstring jpin, jobjectArray pdacls, jintArray jprmType,
 720     jint jedp, jobject jListener)
 721 {
 722     LOGD("OcSecureResource_provisionDirectPairing");
 723     if (!jListener)
 724     {
 725         ThrowOcException(OC_STACK_INVALID_CALLBACK, "Invalid Callback");
 726         return;
 727     }
 728     if (!pdacls || !jpin || ! jprmType)
 729     {
 730         ThrowOcException(OC_STACK_INVALID_PARAM, "Invalid Parameters");
 731         return;
 732     }
 733     std::string pin = env->GetStringUTFChars(jpin, nullptr);
 734
 735     JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
 736     if (!secureResource)
 737     {
 738         ThrowOcException(OC_STACK_ERROR, "getJniOcSecureResourcePtr failed");
 739         return;
 740     }
 741
 742     const jsize len = env->GetArrayLength(jprmType);
 743     jint* ints = env->GetIntArrayElements(jprmType, nullptr);
 744     std::vector<int> value;
 745     for (jsize i = 0; i < len; ++i)
 746     {
 747         value.push_back(static_cast<int>(ints[i]));
 748     }
 749     env->ReleaseIntArrayElements(jprmType, ints, JNI_ABORT);
 750
 751     try
 752     {
 753         OCStackResult result = secureResource->provisionDirectPairing(env, pdacls, jListener,
 754                 pin, value, static_cast<int>(jedp));
 755         if (OC_STACK_OK != result)
 756         {
 757             ThrowOcException(result, "OcSecureResource_provisionDirectPairing");
 758             return;
 759         }
 760     }
 761     catch (OCException& e)
 762     {
 763         LOGE("%s", e.reason().c_str());
 764         ThrowOcException(e.code(), e.reason().c_str());
 765     }
 766 }
 767
 768 /*
 769  * Class:     org_iotivity_base_OcSecureResource
 770  * Method:    getLinkedDevices
 771  * Signature: ()Ljava/util/List;
 772  */
 773 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcSecureResource_getLinkedDevices
 774 (JNIEnv *env, jobject thiz)
 775 {
 776     LOGD("OcSecureResource_getLinkedDevices");
 777     UuidList_t uuidList;
 778
 779     JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
 780     if (!secureResource)
 781     {
 782         ThrowOcException(OC_STACK_ERROR, "getJniOcSecureResourcePtr failed");
 783         return nullptr;
 784     }
 785
 786     try
 787     {
 788         OCStackResult result = secureResource->getLinkedDevices(env, uuidList);
 789         if (OC_STACK_OK != result)
 790         {
 791             ThrowOcException(result, "OcSecureResource_getLinkedDevices");
 792             return nullptr;
 793         }
 794         return JniSecureUtils::convertUUIDVectorToJavaStrList(env, uuidList);
 795     }
 796     catch (OCException& e)
 797     {
 798         LOGE("%s", e.reason().c_str());
 799         ThrowOcException(e.code(), e.reason().c_str());
 800         return nullptr;
 801     }
 802 }
 803
 804 /*
 805  * Class:     org_iotivity_base_OcSecureResource
 806  * Method:    getIpAddr
 807  * Signature: ()Ljava/lang/String;
 808  */
 809 JNIEXPORT jstring JNICALL Java_org_iotivity_base_OcSecureResource_getIpAddr
 810   (JNIEnv *env, jobject thiz)
 811 {
 812     LOGD("OcSecureResource_getIpAddr");
 813     JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
 814     if (!secureResource)
 815     {
 816         LOGD("getJniOcSecureResourcePtr failed");
 817         return nullptr;
 818     }
 819
 820     return env->NewStringUTF(secureResource->getIpAddr().c_str());
 821 }
 822
 823 /*
 824  * Class:     org_iotivity_base_OcSecureResource
 825  * Method:    getDeviceID
 826  * Signature: ()Ljava/lang/String;
 827  */
 828 JNIEXPORT jstring JNICALL Java_org_iotivity_base_OcSecureResource_getDeviceID
 829   (JNIEnv *env , jobject thiz)
 830 {
 831     LOGD("OcSecureResource_getDeviceID");
 832     JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
 833     if (!secureResource)
 834     {
 835         LOGD("getJniOcSecureResourcePtr failed");
 836         return nullptr;
 837     }
 838
 839     return env->NewStringUTF(secureResource->getDeviceID().c_str());
 840 }
 841
 842 /*
 843  * Class:     org_iotivity_base_OcSecureResource
 844  * Method:    deviceStatus
 845  * Signature: ()I
 846  */
 847 JNIEXPORT jint JNICALL Java_org_iotivity_base_OcSecureResource_deviceStatus
 848   (JNIEnv *env, jobject thiz)
 849 {
 850     LOGD("OcSecureResource_deviceStatus");
 851     JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
 852     if (!secureResource)
 853     {
 854         LOGD("getJniOcSecureResourcePtr failed");
 855         return -1;
 856     }
 857
 858     return secureResource->getDeviceStatus();
 859 }
 860
 861 /*
 862  * Class:     org_iotivity_base_OcSecureResource
 863  * Method:    ownedStatus
 864  * Signature: ()I
 865  */
 866 JNIEXPORT jint JNICALL Java_org_iotivity_base_OcSecureResource_ownedStatus
 867   (JNIEnv *env, jobject thiz)
 868 {
 869     LOGD("OcSecureResource_ownedStatus");
 870     JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
 871     if (!secureResource)
 872     {
 873         LOGD("getJniOcSecureResourcePtr failed");
 874         return -1;
 875     }
 876
 877     return secureResource->getOwnedStatus();
 878 }
 879
 880 /*
 881  * Class:     org_iotivity_base_OcSecureResource
 882  * Method:    dispose
 883  * Signature: ()V
 884  */
 885 JNIEXPORT void JNICALL Java_org_iotivity_base_OcSecureResource_dispose
 886   (JNIEnv *env, jobject thiz)
 887 {
 888     LOGD("OcSecureResource_dispose");
 889     JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
 890     delete secureResource;
 891 }