2 * //******************************************************************
4 * // Copyright 2015 Samsung Electronics All Rights Reserved.
6 * //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
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
12 * // http://www.apache.org/licenses/LICENSE-2.0
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.
20 * //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
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;
30 JniOcSecureResource::JniOcSecureResource(std::shared_ptr<OCSecureResource> device)
31 : m_sharedSecureResource(device)
34 JniOcSecureResource::~JniOcSecureResource()
36 LOGD("~JniOcSecureResource()");
37 m_sharedSecureResource = nullptr;
40 std::string JniOcSecureResource::getIpAddr()
42 return m_sharedSecureResource->getDevAddr();
45 std::string JniOcSecureResource::getDeviceID()
47 return m_sharedSecureResource->getDeviceID();
50 int JniOcSecureResource::getDeviceStatus()
52 return m_sharedSecureResource->getDeviceStatus();
55 bool JniOcSecureResource::getOwnedStatus()
57 return m_sharedSecureResource->getOwnedStatus();
60 OCSecureResource* JniOcSecureResource::getDevicePtr()
62 return m_sharedSecureResource.get();
65 JniOcSecureResource* JniOcSecureResource::getJniOcSecureResourcePtr(JNIEnv *env, jobject thiz)
67 JniOcSecureResource *secureResource = GetHandle<JniOcSecureResource>(env, thiz);
68 if (env->ExceptionCheck())
70 LOGE("Failed to get native handle from OcSecureResource");
74 ThrowOcException(JNI_NO_NATIVE_POINTER, "");
76 return secureResource;
79 JniProvisionResultListner* JniOcSecureResource::AddProvisionResultListener(JNIEnv* env,
82 JniProvisionResultListner *resultListener = NULL;
85 for (auto it = resultMap.begin(); it != resultMap.end(); ++it)
87 if (env->IsSameObject(jListener, it->first))
89 auto refPair = it->second;
90 resultListener = refPair.first;
93 resultMap.insert(*it);
94 LOGD("Provision resultListener: ref. count incremented");
100 resultListener = new JniProvisionResultListner(env, jListener,
101 RemoveCallback(std::bind(&JniOcSecureResource::RemoveProvisionResultListener,
102 this, PH::_1, PH::_2)));
103 jobject jgListener = env->NewGlobalRef(jListener);
105 resultMap.insert(std::pair < jobject, std::pair < JniProvisionResultListner*,
106 int >> (jgListener, std::pair<JniProvisionResultListner*, int>(resultListener, 1)));
107 LOGD("Provision resultListener: new listener");
109 resultMapLock.unlock();
110 return resultListener;
113 void JniOcSecureResource::RemoveProvisionResultListener(JNIEnv* env, jobject jListener)
115 resultMapLock.lock();
117 for (auto it = resultMap.begin(); it != resultMap.end(); ++it)
119 if (env->IsSameObject(jListener, it->first))
121 auto refPair = it->second;
122 if (refPair.second > 1)
125 it->second = refPair;
126 resultMap.insert(*it);
127 LOGI("Provision resultListener: ref. count decremented");
131 env->DeleteGlobalRef(it->first);
132 JniProvisionResultListner* listener = refPair.first;
135 LOGI("Provision resultListener removed");
140 resultMapLock.unlock();
143 OCStackResult JniOcSecureResource::doOwnershipTransfer(JNIEnv* env, jobject jListener)
145 JniProvisionResultListner *resultListener = AddProvisionResultListener(env, jListener);
147 ResultCallBack resultCallback = [resultListener](PMResultList_t *result, int hasError)
149 resultListener->ProvisionResultCallback(result, hasError, ListenerFunc::OWNERSHIPTRANSFER);
152 return m_sharedSecureResource->doOwnershipTransfer(resultCallback);
155 OCStackResult JniOcSecureResource::getLinkedDevices(JNIEnv *env, UuidList_t &uuidList)
157 return m_sharedSecureResource->getLinkedDevices(uuidList);
160 OCStackResult JniOcSecureResource::removeDevice(JNIEnv* env, jint timeout, jobject jListener)
162 JniProvisionResultListner *resultListener = AddProvisionResultListener(env, jListener);
164 ResultCallBack resultCallback = [resultListener](PMResultList_t *result, int hasError)
166 resultListener->ProvisionResultCallback(result, hasError, ListenerFunc::REMOVEDEVICE);
169 return m_sharedSecureResource->removeDevice((int)timeout, resultCallback);
172 OCStackResult JniOcSecureResource::unlinkDevices(JNIEnv* env, jobject _device2, jobject jListener)
174 JniProvisionResultListner *resultListener = AddProvisionResultListener(env, jListener);
176 ResultCallBack resultCallback = [resultListener](PMResultList_t *result, int hasError)
178 resultListener->ProvisionResultCallback(result, hasError, ListenerFunc::UNLINKDEVICES);
181 JniOcSecureResource *device2 = JniOcSecureResource::getJniOcSecureResourcePtr(env, _device2);
184 return OC_STACK_ERROR;
187 return m_sharedSecureResource->unlinkDevices(*device2->getDevicePtr(), resultCallback);
190 OCStackResult JniOcSecureResource::provisionCredentials(JNIEnv* env, jint type, jint keySize,
191 jobject _device2, jobject jListener)
193 JniProvisionResultListner *resultListener = AddProvisionResultListener(env, jListener);
195 ResultCallBack resultCallback = [resultListener](PMResultList_t *result, int hasError)
197 resultListener->ProvisionResultCallback(result, hasError, ListenerFunc::PROVISIONCREDENTIALS);
200 JniOcSecureResource *device2 = JniOcSecureResource::getJniOcSecureResourcePtr(env, _device2);
203 return OC_STACK_ERROR;
206 Credential cred((OicSecCredType_t)type, keySize);
208 return m_sharedSecureResource->provisionCredentials(cred, *device2->getDevicePtr(),
212 OCStackResult JniOcSecureResource::provisionACL(JNIEnv* env, jobject _acl, jobject jListener)
215 JniProvisionResultListner *resultListener = AddProvisionResultListener(env, jListener);
216 OicSecAcl_t *acl = (OicSecAcl_t*)OICCalloc(1, sizeof(OicSecAcl_t));
220 return OC_STACK_NO_MEMORY;
223 if (OC_STACK_OK != JniSecureUtils::convertJavaACLToOCAcl(env, _acl, acl))
226 return OC_STACK_ERROR;
229 ResultCallBack resultCallback = [acl, resultListener](PMResultList_t *result, int hasError)
232 resultListener->ProvisionResultCallback(result, hasError, ListenerFunc::PROVISIONACL);
234 ret = m_sharedSecureResource->provisionACL(acl, resultCallback);
236 if (ret != OC_STACK_OK)
243 OCStackResult JniOcSecureResource::provisionDirectPairing(JNIEnv* env, jobjectArray jpdacls,
244 jobject jListener, std::string pin, std::vector<int> prms, int edp)
247 JniProvisionResultListner *resultListener = AddProvisionResultListener(env, jListener);
249 jsize len = env->GetArrayLength(jpdacls);
251 OicSecPconf_t *pconf = nullptr;
252 OicSecPdAcl_t *head = nullptr;
254 for (jsize i = 0; i < len; ++i)
256 OicSecPdAcl_t *pdacl = new OicSecPdAcl_t;
259 return OC_STACK_NO_MEMORY;
262 memset(pdacl, 0, sizeof(OicSecPdAcl_t));
263 pdacl->next = nullptr;
265 jobject jpdacl = env->GetObjectArrayElement(jpdacls, i);
267 if (OC_STACK_OK != JniSecureUtils::convertJavaPdACLToOCAcl(env, jpdacl, pdacl))
270 return OC_STACK_ERROR;
277 pconf = new OicSecPconf_t;
278 memset(pconf, 0, sizeof(OicSecPconf_t));
280 pconf->prmLen = prms.size();
281 pconf->prm = new OicSecPrm_t[pconf->prmLen];
284 for (int i = 0 ; i < prms.size(); i++)
285 pconf->prm[i] = (OicSecPrm_t)prms[i];
287 memcpy(pconf->pin.val, pin.c_str(), DP_PIN_LENGTH);
288 pconf->pdacls = head;
290 ResultCallBack resultCallback = [head, resultListener, pconf, prms]
291 (PMResultList_t *result, int hasError)
293 OicSecPdAcl_t *tmp1, *tmp2;
304 resultListener->ProvisionResultCallback(result, hasError, ListenerFunc::PROVISIONDIRECTPAIRING);
307 ret = m_sharedSecureResource->provisionDirectPairing(pconf, resultCallback);
309 if (ret != OC_STACK_OK)
311 OicSecPdAcl_t *tmp1, *tmp2;
326 OCStackResult JniOcSecureResource::provisionPairwiseDevices(JNIEnv* env, jint type, jint keySize,
327 jobject _acl1, jobject _device2, jobject _acl2, jobject jListener)
331 JniProvisionResultListner *resultListener = AddProvisionResultListener(env, jListener);
332 JniOcSecureResource *device2 = JniOcSecureResource::getJniOcSecureResourcePtr(env, _device2);
335 return OC_STACK_ERROR;
338 Credential cred((OicSecCredType_t)type, keySize);
340 OicSecAcl_t *acl1 = nullptr;
341 OicSecAcl_t *acl2 = nullptr;
345 acl1 = (OicSecAcl_t*)OICCalloc(1, sizeof(OicSecAcl_t));
348 return OC_STACK_NO_MEMORY;
351 if (OC_STACK_OK != JniSecureUtils::convertJavaACLToOCAcl(env, _acl1, acl1))
354 return OC_STACK_ERROR;
360 acl2 = (OicSecAcl_t*)OICCalloc(1, sizeof(OicSecAcl_t));
364 return OC_STACK_NO_MEMORY;
367 if (OC_STACK_OK != JniSecureUtils::convertJavaACLToOCAcl(env, _acl2, acl2))
370 return OC_STACK_ERROR;
374 ResultCallBack resultCallback = [acl1, acl2, resultListener](PMResultList_t *result,
379 resultListener->ProvisionResultCallback(result, hasError,
380 ListenerFunc::PROVISIONPAIRWISEDEVICES);
384 ret = m_sharedSecureResource->provisionPairwiseDevices(cred, acl1,
385 *device2->getDevicePtr(), acl2, resultCallback);
386 if (ret != OC_STACK_OK)
395 * Class: org_iotivity_base_OcSecureResource
396 * Method: doOwnershipTransfer
397 * Signature: (Lorg/iotivity/base/OcSecureResource/doOwnershipTransferListener;)V
399 JNIEXPORT void JNICALL Java_org_iotivity_base_OcSecureResource_doOwnershipTransfer
400 (JNIEnv *env, jobject thiz, jobject jListener)
402 LOGD("OcSecureResource_doOwnershipTransfer");
405 ThrowOcException(OC_STACK_INVALID_PARAM, "provisionResultListener cannot be null");
409 JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
417 OCStackResult result = secureResource->doOwnershipTransfer(env, jListener);
418 if (OC_STACK_OK != result)
420 ThrowOcException(result, "OcSecureResource_doOwnershipTransfer");
424 catch (OCException& e)
426 LOGE("%s", e.reason().c_str());
427 ThrowOcException(e.code(), e.reason().c_str());
432 * Class: org_iotivity_base_OcSecureResource
433 * Method: removeDevice
434 * Signature: (ILorg/iotivity/base/OcSecureResource/removeDevice;)V
436 JNIEXPORT void JNICALL Java_org_iotivity_base_OcSecureResource_removeDevice
437 (JNIEnv *env, jobject thiz, jint timeout, jobject jListener)
439 LOGD("OcSecureResource_removeDevice");
442 ThrowOcException(OC_STACK_INVALID_PARAM, "Timeout value cannot be negative");
448 ThrowOcException(OC_STACK_INVALID_PARAM, "provisionResultListener cannot be null");
452 JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
460 OCStackResult result = secureResource->removeDevice(env, timeout, jListener);
461 if (OC_STACK_OK != result)
463 ThrowOcException(result, "OcSecureResource_removeDevice");
467 catch (OCException& e)
469 LOGE("%s", e.reason().c_str());
470 ThrowOcException(e.code(), e.reason().c_str());
475 * Class: org_iotivity_base_OcSecureResource
476 * Method: unlinkDevices
477 * Signature: (Lorg/iotivity/base/OcSecureResource/unlinkDevices;)V
479 JNIEXPORT void JNICALL Java_org_iotivity_base_OcSecureResource_unlinkDevices
480 (JNIEnv *env, jobject thiz, jobject device2, jobject jListener)
482 LOGD("OcSecureResource_unlinkDevices");
483 if (!jListener || !device2)
485 ThrowOcException(OC_STACK_INVALID_PARAM, "provisionResultListener or device2 cannot be null");
489 JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
497 OCStackResult result = secureResource->unlinkDevices(env, device2, jListener);
498 if (OC_STACK_OK != result)
500 ThrowOcException(result, "OcSecureResource_unlinkDevices");
504 catch (OCException& e)
506 LOGE("%s", e.reason().c_str());
507 ThrowOcException(e.code(), e.reason().c_str());
512 * Class: org_iotivity_base_OcSecureResource
513 * Method: provisionCredentials1
514 * Signature: (Lorg/iotivity/base/OcSecureResource/provisionCredentials;)V
516 JNIEXPORT void JNICALL Java_org_iotivity_base_OcSecureResource_provisionCredentials1
517 (JNIEnv *env, jobject thiz, jint type, jint keySize, jobject device2, jobject jListener)
519 LOGD("OcSecureResource_provisionCredentials");
520 if (!jListener || !device2)
522 ThrowOcException(OC_STACK_INVALID_PARAM, "provisionResultListener or device2 cannot be null");
526 JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
534 OCStackResult result = secureResource->provisionCredentials(env, type, keySize, device2,
536 if (OC_STACK_OK != result)
538 ThrowOcException(result, "OcSecureResource_provisionCredentials");
542 catch (OCException& e)
544 LOGE("%s", e.reason().c_str());
545 ThrowOcException(e.code(), e.reason().c_str());
550 * Class: org_iotivity_base_OcSecureResource
551 * Method: provisionACL
552 * Signature: (Lorg/iotivity/base/OcSecureResource/provisionACL;)V
554 JNIEXPORT void JNICALL Java_org_iotivity_base_OcSecureResource_provisionACL
555 (JNIEnv *env, jobject thiz, jobject acl, jobject jListener)
557 LOGD("OcSecureResource_provisionACL");
558 if (!jListener || !acl)
560 ThrowOcException(OC_STACK_INVALID_PARAM, "provisionResultListener or acl cannot be null");
564 JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
572 OCStackResult result = secureResource->provisionACL(env, acl, jListener);
573 if (OC_STACK_OK != result)
575 ThrowOcException(result, "OcSecureResource_provisionACL");
579 catch (OCException& e)
581 LOGE("%s", e.reason().c_str());
582 ThrowOcException(e.code(), e.reason().c_str());
587 * Class: org_iotivity_base_OcSecureResource
588 * Method: provisionPairwiseDevices1
589 * Signature: (Lorg/iotivity/base/OcSecureResource/provisionPairwiseDevices;)V
591 JNIEXPORT void JNICALL Java_org_iotivity_base_OcSecureResource_provisionPairwiseDevices1
592 (JNIEnv *env, jobject thiz, jint type, jint keySize, jobject acl1, jobject device2,
593 jobject acl2, jobject jListener)
595 LOGD("OcSecureResource_provisionPairwiseDevices");
596 if (!jListener || !device2)
598 ThrowOcException(OC_STACK_INVALID_PARAM, "Invalid Parameters");
602 JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
610 OCStackResult result = secureResource->provisionPairwiseDevices(env, type, keySize,
611 acl1, device2, acl2, jListener);
612 if (OC_STACK_OK != result)
614 ThrowOcException(result, "OcSecureResource_provisionPairwiseDevices");
618 catch (OCException& e)
620 LOGE("%s", e.reason().c_str());
621 ThrowOcException(e.code(), e.reason().c_str());
626 * Class: org_iotivity_base_OcSecureResource
627 * Method: provisionDirectPairing
628 * Signature: (Ljava/lang/String;[Lorg/iotivity/base/OicSecPdAcl;ILorg/iotivity/base/OcSecureResource/ProvisionDirectPairingListener;I)V
630 JNIEXPORT void JNICALL Java_org_iotivity_base_OcSecureResource_provisionDirectPairing
631 (JNIEnv *env, jobject thiz, jstring jpin, jobjectArray pdacls, jintArray jprmType,
632 jint jedp, jobject jListener)
634 LOGD("OcSecureResource_provisionDirectPairing");
635 if (!jListener || !pdacls || !jpin || ! jprmType)
637 ThrowOcException(OC_STACK_INVALID_PARAM, "Invalid Parameters");
640 std::string pin = env->GetStringUTFChars(jpin, nullptr);
642 JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
648 const jsize len = env->GetArrayLength(jprmType);
649 jint* ints = env->GetIntArrayElements(jprmType, nullptr);
650 std::vector<int> value;
651 for (jsize i = 0; i < len; ++i)
653 value.push_back(static_cast<int>(ints[i]));
655 env->ReleaseIntArrayElements(jprmType, ints, JNI_ABORT);
659 OCStackResult result = secureResource->provisionDirectPairing(env, pdacls, jListener,
660 pin, value, static_cast<int>(jedp));
661 if (OC_STACK_OK != result)
663 ThrowOcException(result, "OcSecureResource_provisionDirectPairing");
667 catch (OCException& e)
669 LOGE("%s", e.reason().c_str());
670 ThrowOcException(e.code(), e.reason().c_str());
675 * Class: org_iotivity_base_OcSecureResource
676 * Method: getLinkedDevices
677 * Signature: ()Ljava/util/List;
679 JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcSecureResource_getLinkedDevices
680 (JNIEnv *env, jobject thiz)
682 LOGD("OcSecureResource_getLinkedDevices");
685 JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
693 OCStackResult result = secureResource->getLinkedDevices(env, uuidList);
694 if (OC_STACK_OK != result)
696 ThrowOcException(result, "OcSecureResource_getLinkedDevices");
699 return JniSecureUtils::convertUUIDVectorToJavaStrList(env, uuidList);
701 catch (OCException& e)
703 LOGE("%s", e.reason().c_str());
704 ThrowOcException(e.code(), e.reason().c_str());
710 * Class: org_iotivity_base_OcSecureResource
712 * Signature: ()Ljava/lang/String;
714 JNIEXPORT jstring JNICALL Java_org_iotivity_base_OcSecureResource_getIpAddr
715 (JNIEnv *env, jobject thiz)
717 LOGD("OcSecureResource_getIpAddr");
718 JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
724 return env->NewStringUTF(secureResource->getIpAddr().c_str());
728 * Class: org_iotivity_base_OcSecureResource
729 * Method: getDeviceID
730 * Signature: ()Ljava/lang/String;
732 JNIEXPORT jstring JNICALL Java_org_iotivity_base_OcSecureResource_getDeviceID
733 (JNIEnv *env , jobject thiz)
735 LOGD("OcSecureResource_getDeviceID");
736 JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
742 return env->NewStringUTF(secureResource->getDeviceID().c_str());
746 * Class: org_iotivity_base_OcSecureResource
747 * Method: deviceStatus
750 JNIEXPORT jint JNICALL Java_org_iotivity_base_OcSecureResource_deviceStatus
751 (JNIEnv *env, jobject thiz)
753 LOGD("OcSecureResource_deviceStatus");
754 JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
760 return secureResource->getDeviceStatus();
764 * Class: org_iotivity_base_OcSecureResource
765 * Method: ownedStatus
768 JNIEXPORT jint JNICALL Java_org_iotivity_base_OcSecureResource_ownedStatus
769 (JNIEnv *env, jobject thiz)
771 LOGD("OcSecureResource_ownedStatus");
772 JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
778 return secureResource->getOwnedStatus();
782 * Class: org_iotivity_base_OcSecureResource
786 JNIEXPORT void JNICALL Java_org_iotivity_base_OcSecureResource_dispose
787 (JNIEnv *env, jobject thiz)
789 LOGD("OcSecureResource_dispose");
790 JniOcSecureResource *secureResource = JniOcSecureResource::getJniOcSecureResourcePtr(env, thiz);
791 delete secureResource;