#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)
{
}
}
+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
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)
{
{
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
{
/*
* 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
*/
#if defined(__WITH_DTLS__) || defined(__WITH_TLS__)
jbyte* trustCertChainBytes = env->GetByteArrayElements(trustCertChain, 0);
jsize arrayLength = env->GetArrayLength(trustCertChain);
- uint16_t credId;
+ uint16_t credId = -1;
unsigned char* trustedCertChar = new unsigned char[arrayLength];
try
{
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;
+ }
+}
projects / platform / upstream / iotivity.git / blobdiff