X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=android%2Fandroid_api%2Fbase%2Fjni%2FJniOcProvisioning.cpp;h=e66a8731ad76d9e048dacd32fce1c00841427e47;hb=refs%2Ftags%2Faccepted%2Ftizen%2Funified%2F20171010.063815;hp=02ee9b25dfa7f8cfba03256872e545d13d327487;hpb=cabfc3fc3acaac398459892ce001b7f29ff0f83a;p=platform%2Fupstream%2Fiotivity.git

diff --git a/android/android_api/base/jni/JniOcProvisioning.cpp b/android/android_api/base/jni/JniOcProvisioning.cpp
index 02ee9b2..e66a873 100644
--- a/android/android_api/base/jni/JniOcProvisioning.cpp
+++ b/android/android_api/base/jni/JniOcProvisioning.cpp
@@ -23,12 +23,19 @@
 #include "JniOcProvisioning.h"
 #include "JniPinCheckListener.h"
 #include "JniDisplayPinListener.h"
+#include "oic_malloc.h"
+#include "aclresource.h"
+#include "oxmverifycommon.h"
+#include "JniDisplayVerifyNumListener.h"
+#include "JniConfirmNumListener.h"
 
 using namespace OC;
 namespace PH = std::placeholders;
 
 static JniPinCheckListener *jniPinListener = nullptr;
 static JniDisplayPinListener *jniDisplayPinListener = nullptr;
+static JniDisplayVerifyNumListener *jniDisplayMutualVerifyNumListener = nullptr;
+static JniConfirmNumListener *jniConfirmMutualVerifyNumListener = nullptr;
 
 void Callback(char *buf, size_t size)
 {
@@ -54,6 +61,38 @@ void displayPinCB(char *pinBuf, size_t pinSize)
     }
 }
 
+OCStackResult displayMutualVerifNumCB(uint8_t *verifyNum)
+{
+    OCStackResult res;
+
+    if (jniDisplayMutualVerifyNumListener)
+    {
+        res = jniDisplayMutualVerifyNumListener->displayMutualVerifNumCallback(verifyNum);
+    }
+    else
+    {
+        res = OC_STACK_ERROR;
+        LOGE("DisplayMutualVerifyNumListener is null");
+    }
+    return res;
+}
+
+OCStackResult confirmMutualVerifNumCB()
+{
+    OCStackResult res;
+
+    if (jniConfirmMutualVerifyNumListener)
+    {
+        res = jniConfirmMutualVerifyNumListener->confirmMutualVerifNumCallback();
+    }
+    else
+    {
+        res = OC_STACK_ERROR;
+        LOGE("ConfirmMutualVerifyNumListener is null");
+    }
+    return res;
+}
+
 /*
  * Class:     org_iotivity_base_OcProvisioning
  * Method:    ownershipTransferCDdata
@@ -70,13 +109,8 @@ JNIEXPORT void JNICALL Java_org_iotivity_base_OcProvisioning_ownershipTransferCB
         OTMCallbackData_t CBData = {0};
         if (OIC_JUST_WORKS == (OicSecOxm_t)OxmType)
         {
-            CBData.loadSecretCB = LoadSecretJustWorksCallback;
-            CBData.createSecureSessionCB = CreateSecureSessionJustWorksCallback;
-            CBData.createSelectOxmPayloadCB = CreateJustWorksSelectOxmPayload;
-            CBData.createOwnerTransferPayloadCB = CreateJustWorksOwnerTransferPayload;
-
-            result = OCSecure::setOwnerTransferCallbackData((OicSecOxm_t)OxmType,
-                    &CBData, NULL);
+            /*NO callback required for JUST_WORKS*/
+            result = OCSecure::setInputPinCallback(NULL);
         }
         if (OIC_RANDOM_DEVICE_PIN == (OicSecOxm_t)OxmType)
         {
@@ -84,12 +118,7 @@ JNIEXPORT void JNICALL Java_org_iotivity_base_OcProvisioning_ownershipTransferCB
             {
                 delete jniPinListener;
                 jniPinListener = new JniPinCheckListener(env, jListener);
-                CBData.loadSecretCB = InputPinCodeCallback;
-                CBData.createSecureSessionCB = CreateSecureSessionRandomPinCallback;
-                CBData.createSelectOxmPayloadCB = CreatePinBasedSelectOxmPayload;
-                CBData.createOwnerTransferPayloadCB = CreatePinBasedOwnerTransferPayload;
-                result = OCSecure::setOwnerTransferCallbackData((OicSecOxm_t)OxmType,
-                        &CBData, Callback);
+                result = OCSecure::setInputPinCallback(Callback);
             }
             else
             {
@@ -256,6 +285,163 @@ JNIEXPORT jobjectArray JNICALL Java_org_iotivity_base_OcProvisioning_getDeviceSt
 
 /*
  * Class:     org_iotivity_base_OcProvisioning
+ * Method:    setDisplayNumListener
+ * Signature: (Lorg/iotivity/base/OcProvisioning/DisplayNumListener;)V
+ */
+JNIEXPORT void JNICALL Java_org_iotivity_base_OcProvisioning_setDisplayNumListener
+  (JNIEnv *env, jclass clazz, jobject jListener)
+{
+    LOGI("OcProvisioning_setDisplayNumListener");
+
+    if (!jListener)
+    {
+        ThrowOcException(OC_STACK_INVALID_CALLBACK, "Listner can't be null");
+        return;
+    }
+    delete jniDisplayMutualVerifyNumListener;
+    jniDisplayMutualVerifyNumListener = new JniDisplayVerifyNumListener(env, jListener);
+
+    try
+    {
+        OCStackResult result = OCSecure::registerDisplayNumCallback(displayMutualVerifNumCB);
+        if (OC_STACK_OK != result)
+        {
+            ThrowOcException(result, "Failed to set Listner");
+            return;
+        }
+    }
+    catch (OCException& e)
+    {
+        LOGE("%s", e.reason().c_str());
+        ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
+        return;
+    }
+}
+
+/*
+ * Class:     org_iotivity_base_OcProvisioning
+ * Method:    unsetDisplayNumListener
+ * Signature: ()I
+ */
+JNIEXPORT jint JNICALL Java_org_iotivity_base_OcProvisioning_unsetDisplayNumListener
+  (JNIEnv * env, jclass clazz)
+{
+    LOGI("OcProvisioning_unsetDisplayNumListener");
+
+    OCStackResult result = OCSecure::deregisterDisplayNumCallback();
+
+    if (OC_STACK_OK != result)
+    {
+        ThrowOcException(OC_STACK_INVALID_CALLBACK, "Failed to unset Listener");
+    }
+
+    return result;
+}
+
+/*
+ * Class:     org_iotivity_base_OcProvisioning
+ * Method:    setPinType0
+ * Signature: (II)I
+ */
+JNIEXPORT jint JNICALL Java_org_iotivity_base_OcProvisioning_setPinType0
+  (JNIEnv *env, jclass thiz, jint pinSize, jint pinType)
+{
+    LOGI("OcProvisioning_setPinType0");
+
+    OCStackResult result = OC_STACK_ERROR;
+    try
+    {
+        result = OCSecure::setRandomPinPolicy((size_t)pinSize, (OicSecPinType_t)pinType);
+        if (OC_STACK_OK != result)
+        {
+            ThrowOcException(result, "Failed to set PinType");
+        }
+    }
+    catch (OCException& e)
+    {
+        LOGE("%s", e.reason().c_str());
+        ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
+    }
+    return result;
+}
+
+/*
+ * Class:     org_iotivity_base_OcProvisioning
+ * Method:    setConfirmNumListener
+ * Signature: (Lorg/iotivity/base/OcProvisioning/ConfirmNumListener;)V
+ */
+JNIEXPORT void JNICALL Java_org_iotivity_base_OcProvisioning_setConfirmNumListener
+  (JNIEnv *env, jclass clazz, jobject jListener)
+{
+    LOGI("OcProvisioning_setConfirmNumListener");
+
+    if (!jListener)
+    {
+        ThrowOcException(OC_STACK_INVALID_CALLBACK, "Listner can't be null");
+        return;
+    }
+    delete jniConfirmMutualVerifyNumListener;
+    jniConfirmMutualVerifyNumListener = new JniConfirmNumListener(env, jListener);
+
+    try
+    {
+        OCStackResult result = OCSecure::registerUserConfirmCallback(confirmMutualVerifNumCB);
+        if (OC_STACK_OK != result)
+        {
+            ThrowOcException(result, "Failed to set Listner");
+            return;
+        }
+    }
+    catch (OCException& e)
+    {
+        LOGE("%s", e.reason().c_str());
+        ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
+        return;
+    }
+}
+
+/*
+ * Class:     org_iotivity_base_OcProvisioning
+ * Method:    unsetConfirmNumListener
+ * Signature: ()I
+ */
+JNIEXPORT jint JNICALL Java_org_iotivity_base_OcProvisioning_unsetConfirmNumListener
+  (JNIEnv *env, jclass clazz)
+{
+    LOGI("OcProvisioning_unsetConfirmNumListener");
+
+    OCStackResult result = OCSecure::deregisterUserConfirmCallback();
+
+    if (OC_STACK_OK != result)
+    {
+        ThrowOcException(OC_STACK_INVALID_CALLBACK, "Failed to unser Listener");
+    }
+
+    return result;
+}
+/*
+ * Class:     org_iotivity_base_OcProvisioning
+ * Method:    setMVJustWorksOptions0
+ * Signature: (I)I
+ */
+JNIEXPORT jint JNICALL Java_org_iotivity_base_OcProvisioning_setMVJustWorksOptions0
+  (JNIEnv *env, jclass clazz, jint options)
+{
+    LOGI("OcProvisioning_setMVJustWorksOptions0");
+
+    OCStackResult result = OCSecure::setVerifyOptionMask((VerifyOptionBitmask_t)options);
+
+    if (OC_STACK_OK != result)
+    {
+        ThrowOcException(OC_STACK_INVALID_CALLBACK, "setMVJustWorksOptions Failed");
+    }
+
+    return result;
+}
+
+
+/*
+ * Class:     org_iotivity_base_OcProvisioning
  * Method:    setDisplayPinListener
  * Signature: (Lorg/iotivity/base/OcProvisioning/DisplayPinListener;)V
  */
@@ -288,3 +474,146 @@ JNIEXPORT void JNICALL Java_org_iotivity_base_OcProvisioning_setDisplayPinListen
         ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
     }
 }
+/*
+ * Class:     org_iotivity_base_OcProvisioning
+ * Method:    saveTrustCertChain1
+ * Signature: (Lorg/iotivity/base/OcProvisioning/provisionTrustCertChain1;)V
+ */
+    JNIEXPORT jint JNICALL Java_org_iotivity_base_OcProvisioning_saveTrustCertChain1
+(JNIEnv *env, jobject thiz, jbyteArray trustCertChain, jint encodingType)
+{
+    LOGD("OcProvisioning_saveTrustCertChain1");
+#if defined(__WITH_DTLS__) || defined(__WITH_TLS__)
+    jbyte* trustCertChainBytes = env->GetByteArrayElements(trustCertChain, 0);
+    jsize arrayLength = env->GetArrayLength(trustCertChain);
+    uint16_t credId = -1;
+    unsigned char* trustedCertChar = new unsigned char[arrayLength];
+    try
+    {
+        env->GetByteArrayRegion (trustCertChain, 0, arrayLength, reinterpret_cast<jbyte*>(trustedCertChar));
+        OCStackResult result = OCSecure::saveTrustCertChain((uint8_t*)trustedCertChar, arrayLength,
+                (OicEncodingType_t)encodingType, &credId);
+        if (OC_STACK_OK != result)
+        {
+            ThrowOcException(result, "OcProvisioning_saveTrustCertChain1");
+            return -1;
+        }
+    }
+    catch (OCException& e)
+    {
+        LOGE("%s", e.reason().c_str());
+        ThrowOcException(e.code(), e.reason().c_str());
+    }
+    return (jint)credId;
+#else
+    ThrowOcException(OC_STACK_INVALID_PARAM, "WITH_TLS not enabled");
+    return -1;
+#endif // __WITH_DTLS__ || __WITH_TLS__
+}
+
+/*
+ * Class:     org_iotivity_base_OcProvisioning
+ * Method:    setDeviceIdSeed1
+ * Signature: (Lorg/iotivity/base/OcProvisioning/provisionTrustCertChain1;)V
+ */
+    JNIEXPORT jint JNICALL Java_org_iotivity_base_OcProvisioning_setDeviceIdSeed1
+(JNIEnv *env, jobject thiz, jbyteArray seed)
+{
+  LOGD("OcProvisioning_setDeviceIdSeed1");
+#if defined(__WITH_DTLS__) || defined(__WITH_TLS__)
+	jbyte* byteSeed = env->GetByteArrayElements(seed, 0);
+	jsize arrayLength = env->GetArrayLength(seed);
+	try
+	{
+    env->GetByteArrayRegion (seed, 0, arrayLength, byteSeed);
+		OCStackResult result = OCSecure::setDeviceIdSeed((uint8_t*)byteSeed, arrayLength);
+		if (OC_STACK_OK != result)
+		{
+		  ThrowOcException(result, "OcProvisioning_setDeviceIdSeed");
+			return -1;
+		}
+	}
+	catch (OCException& e)
+	{
+					LOGE("%s", e.reason().c_str());
+					ThrowOcException(e.code(), e.reason().c_str());
+	}
+	return 0;
+#else
+	ThrowOcException(OC_STACK_INVALID_PARAM, "WITH_TLS not enabled");
+	return -1;
+#endif // __WITH_DTLS__ || __WITH_TLS__
+}
+
+/*
+ * Class:     org_iotivity_base_OcProvisioning
+ * Method:    saveACL
+ * Signature: (Ljava/lang/Object;)V
+ */
+JNIEXPORT void JNICALL Java_org_iotivity_base_OcProvisioning_saveACL
+  (JNIEnv *env , jclass thiz, jobject jacl)
+{
+    LOGD("OcProvisioning_saveACL");
+
+    if (!jacl)
+    {
+        ThrowOcException(OC_STACK_INVALID_PARAM, "acl can't be null");
+    }
+
+    OicSecAcl_t *acl = (OicSecAcl_t*)OICCalloc(1, sizeof(OicSecAcl_t));
+    if (!acl)
+    {
+        ThrowOcException(OC_STACK_NO_MEMORY, "acl allocation failed");
+        return;
+    }
+
+    if (OC_STACK_OK != JniSecureUtils::convertJavaACLToOCAcl(env, jacl, acl))
+    {
+        DeleteACLList(acl);
+        ThrowOcException(OC_STACK_INVALID_PARAM, "Failed to convert Java acl to OC acl");
+        return ;
+    }
+
+    try
+    {
+        OCStackResult result = OCSecure::saveACL(acl);
+        if (OC_STACK_OK != result)
+        {
+            ThrowOcException(result, "OCSecure::saveACL Failed");
+            return;
+        }
+    }
+    catch (OCException& e)
+    {
+        LOGE("%s", e.reason().c_str());
+	ThrowOcException(OC_STACK_ERROR, e.reason().c_str());
+    }
+}
+
+/*
+ * Class:     org_iotivity_base_OcProvisioning
+ * Method:    doSelfOwnershiptransfer
+ * Signature: ()V
+ */
+	JNIEXPORT void JNICALL Java_org_iotivity_base_OcProvisioning_doSelfOwnershiptransfer
+(JNIEnv *env, jclass thiz)
+{
+
+  LOGD("OcProvisioning_doSelfOwnershiptransfer");
+
+  try
+  {
+	  OCStackResult result = OCSecure::configSelfOwnership();
+	  if (OC_STACK_OK != result)
+	  {
+		  ThrowOcException(result, "OCSecure::configSelfOwnership Failed");
+		  return;
+	  }
+  }
+  catch (OCException& e)
+  {
+	  LOGE("%s", e.reason().c_str());
+	  ThrowOcException(e.code(), e.reason().c_str());
+	  return;
+  }
+}