/**\r
* Start direct-pairing processes.\r
*\r
+ * @param[in] ctx user context passed back with resultCallback.\r
* @param[in] peer target device to establish direct-pairing.\r
* @param[in] pmSel selected pairing method.\r
* @param[in] pinNumber secret value for dtls connection.\r
*\r
* @return OC_STACK_OK on success otherwise error.\r
*/\r
-OCStackResult DPDirectPairing(OCDirectPairingDev_t* peer, OicSecPrm_t pmSel, char *pinNumber,\r
- OCDirectPairingResultCB resultCallback);\r
+OCStackResult DPDirectPairing(void *ctx, OCDirectPairingDev_t* peer, OicSecPrm_t pmSel,\r
+ char *pinNumber, OCDirectPairingResultCB resultCallback);\r
\r
/**\r
* This function returns discovered devices list in direct-pairing discovery\r
/**
* Callback function definition of direct-pairing
*
+ * @param[OUT] ctx - User context which will be returned wth callback
* @param[OUT] peer - pairing device info.
* @param[OUT} result - It's returned with 'OC_STACK_XXX'. It will return 'OC_STACK_OK'
* if D2D pairing is success without error
*/
-typedef void (*OCDirectPairingResultCB)(OCDirectPairingDev_t *peer, OCStackResult result);
+typedef void (*OCDirectPairingResultCB)(void *ctx, OCDirectPairingDev_t *peer, OCStackResult result);
#ifdef __cplusplus
OCDirectPairingDev_t *peer; /**< Pointer to pairing target info.**/\r
char pin[DP_PIN_LENGTH]; /**< PIN **/\r
OCDirectPairingResultCB resultCallback; /**< Pointer to result callback.**/\r
+ void *userCtx; /** < user context to pass in callback **/\r
} DPairData_t;\r
\r
static OCDirectPairingDev_t *g_dp_paired = NULL;\r
if (OC_STACK_OK != GetDoxmDeviceID(&ptDeviceID))\r
{\r
OIC_LOG(ERROR, TAG, "Error while retrieving provisioning tool's device ID");\r
- resultCallback(peer, OC_STACK_ERROR);\r
+ resultCallback(dpairData->userCtx, peer, OC_STACK_ERROR);\r
return OC_STACK_DELETE_TRANSACTION;\r
}\r
\r
if(OC_STACK_OK != res)\r
{\r
OIC_LOG(ERROR, TAG, "Failed to PairingPSK generation");\r
- resultCallback(peer, res);\r
+ resultCallback(dpairData->userCtx, peer, res);\r
return OC_STACK_DELETE_TRANSACTION;\r
}\r
\r
OIC_LOG(ERROR, TAG, "Error while adding a device to paired list.");\r
}\r
\r
- resultCallback(peer, OC_STACK_OK);\r
+ resultCallback(dpairData->userCtx, peer, OC_STACK_OK);\r
\r
return OC_STACK_DELETE_TRANSACTION;\r
}\r
OIC_LOG(ERROR, TAG, "DirectPairingFinalizeHandler received Null clientResponse");\r
}\r
\r
- resultCallback(peer, OC_STACK_ERROR);\r
+ resultCallback(dpairData->userCtx, peer, OC_STACK_ERROR);\r
OICFree(dpairData);\r
return OC_STACK_DELETE_TRANSACTION;\r
}\r
*\r
* @return OC_STACK_OK on success otherwise error.\r
*/\r
-OCStackResult FinalizeDirectPairing(OCDirectPairingDev_t* peer,\r
+OCStackResult FinalizeDirectPairing(void *ctx, OCDirectPairingDev_t* peer,\r
OCDirectPairingResultCB resultCallback)\r
{\r
if(NULL == peer)\r
}\r
dpairData->peer = peer;\r
dpairData->resultCallback = resultCallback;\r
+ dpairData->userCtx = ctx;\r
\r
OCCallbackData cbData = {.context=NULL, .cb=NULL, .cd=NULL};\r
cbData.cb = DirectPairingFinalizeHandler;\r
{\r
OIC_LOG(INFO, TAG, "Now, finalize Direct-Pairing procedure.");\r
\r
- res = FinalizeDirectPairing(peer, resultCallback);\r
+ res = FinalizeDirectPairing(g_dp_proceed_ctx->userCtx, peer, resultCallback);\r
if(OC_STACK_OK != res)\r
{\r
OIC_LOG(ERROR, TAG, "Failed to finalize direct-pairing");\r
- resultCallback(peer, res);\r
+ resultCallback(g_dp_proceed_ctx->userCtx, peer, res);\r
}\r
}\r
else if(CA_DTLS_AUTHENTICATION_FAILURE == info->result)\r
{\r
OIC_LOG(INFO, TAG, "DirectPairingDTLSHandshakeCB - Authentication failed");\r
- resultCallback(peer, OC_STACK_AUTHENTICATION_FAILURE);\r
+ resultCallback(g_dp_proceed_ctx->userCtx, peer, OC_STACK_AUTHENTICATION_FAILURE);\r
}\r
\r
#ifdef __WITH_DTLS__\r
g_dp_proceed_ctx = NULL;\r
}\r
\r
- resultCallback(dpairData->peer, res);\r
+ resultCallback(dpairData->userCtx, dpairData->peer, res);\r
}\r
OIC_LOG_V(INFO, TAG, "OUT DirectPairingHandler.");\r
return OC_STACK_DELETE_TRANSACTION;\r
*\r
* @return OC_STACK_OK on success otherwise error.\r
*/\r
-OCStackResult DPDirectPairing(OCDirectPairingDev_t* peer, OicSecPrm_t pmSel, char *pinNumber,\r
- OCDirectPairingResultCB resultCallback)\r
+OCStackResult DPDirectPairing(void *ctx, OCDirectPairingDev_t* peer, OicSecPrm_t pmSel,\r
+ char *pinNumber, OCDirectPairingResultCB resultCallback)\r
{\r
if(NULL == peer || NULL == pinNumber)\r
{\r
dpairData->peer = peer;\r
memcpy(dpairData->pin, pinNumber, DP_PIN_LENGTH);\r
dpairData->resultCallback = resultCallback;\r
+ dpairData->userCtx = ctx;\r
\r
OCCallbackData cbData = {.context=NULL, .cb=NULL, .cd=NULL};\r
cbData.cb = DirectPairingHandler;\r
static OicSecPrm_t pmSel;
static char pinNumber;
-static void ResultCB(OCDirectPairingDev_t *UNUSED1, OCStackResult UNUSED2)
+static void ResultCB(void *UNUSED1, OCDirectPairingDev_t *UNUSED2, OCStackResult UNUSED3)
{
//dummy callback
(void) UNUSED1;
(void) UNUSED2;
+ (void) UNUSED3;
}
TEST(DPDirectPairingTest, NullPeer)
{
- EXPECT_EQ(OC_STACK_INVALID_PARAM, DPDirectPairing(NULL, pmSel, &pinNumber, &ResultCB));
+ EXPECT_EQ(OC_STACK_INVALID_PARAM, DPDirectPairing(NULL, NULL, pmSel, &pinNumber, &ResultCB));
}
TEST(DPDirectPairingTest, NullPinNumber)
{
- EXPECT_EQ(OC_STACK_INVALID_PARAM, DPDirectPairing(&peer, pmSel, NULL, &ResultCB));
+ EXPECT_EQ(OC_STACK_INVALID_PARAM, DPDirectPairing(NULL, &peer, pmSel, NULL, &ResultCB));
}
* @param[in] resultCallback Callback fucntion to event status of process.
* @return OTM_SUCCESS in case of success and other value otherwise.
*/
-OCStackResult OCDoDirectPairing(OCDPDev_t* peer, OCPrm_t pmSel, char *pinNumber,
+OCStackResult OCDoDirectPairing(void *ctx, OCDPDev_t* peer, OCPrm_t pmSel, char *pinNumber,
OCDirectPairingCB resultCallback);
//#endif // DIRECT_PAIRING
/**
* Callback function definition of direct-pairing
*
+ * @param[OUT] ctx - user context returned in the callback.
* @param[OUT] peer - pairing device info.
* @param[OUT} result - It's returned with 'OC_STACK_XXX'. It will return 'OC_STACK_OK'
* if D2D pairing is success without error
*/
-typedef void (*OCDirectPairingCB)(OCDPDev_t *peer, OCStackResult result);
+typedef void (*OCDirectPairingCB)(void *ctx, OCDPDev_t *peer, OCStackResult result);
//#endif // DIRECT_PAIRING
#ifdef __cplusplus
}\r
\r
// This is a function called back when direct-pairing status is changed\r
-void pairingReqCB(OCDPDev_t* peer, OCStackResult result)\r
+void pairingReqCB(void *ctx, OCDPDev_t* peer, OCStackResult result)\r
{\r
OIC_LOG(INFO, TAG, "Callback Context for Direct-Pairing establishment\n");\r
\r
+ (void) ctx;\r
if (OC_STACK_OK == result)\r
{\r
OIC_LOG_V(INFO, TAG,\r
\r
// start direct pairing\r
OIC_LOG(INFO, TAG, " Start Direct Pairing..");\r
- if(OC_STACK_OK != OCDoDirectPairing(peer, pmSel, pinNumber, pairingReqCB))\r
+ if(OC_STACK_OK != OCDoDirectPairing(NULL, peer, pmSel, pinNumber, pairingReqCB))\r
{\r
OIC_LOG(ERROR, TAG, "OCDoDirectPairing API error");\r
return OC_STACK_ERROR;\r
static const char COAP_TCP[] = "coap+tcp:";
static const char CORESPEC[] = "core";
-//#ifdef DIRECT_PAIRING
-OCDirectPairingCB gDirectpairingCallback = NULL;
-//#endif
-
//-----------------------------------------------------------------------------
// Macros
//-----------------------------------------------------------------------------
return (const OCDPDev_t*)DPGetPairedDevices();
}
-void DirectPairingCB (OCDirectPairingDev_t * peer, OCStackResult result)
-{
- if (gDirectpairingCallback)
- {
- gDirectpairingCallback((OCDPDev_t*)peer, result);
- gDirectpairingCallback = NULL;
- }
-}
-
-OCStackResult OCDoDirectPairing(OCDPDev_t* peer, OCPrm_t pmSel, char *pinNumber,
+OCStackResult OCDoDirectPairing(void *ctx, OCDPDev_t* peer, OCPrm_t pmSel, char *pinNumber,
OCDirectPairingCB resultCallback)
{
OIC_LOG(INFO, TAG, "Start OCDoDirectPairing");
return OC_STACK_INVALID_CALLBACK;
}
- gDirectpairingCallback = resultCallback;
- return DPDirectPairing((OCDirectPairingDev_t*)peer, (OicSecPrm_t)pmSel,
- pinNumber, DirectPairingCB);
+ return DPDirectPairing(ctx, (OCDirectPairingDev_t*)peer, (OicSecPrm_t)pmSel,
+ pinNumber, (OCDirectPairingResultCB)resultCallback);
}
//#endif // DIRECT_PAIRING
return OC_STACK_KEEP_TRANSACTION;
}
-static void resultCallback(OCDPDev_t *UNUSED1, OCStackResult UNUSED2)
+static void resultCallback(void *UNUSED1, OCDPDev_t *UNUSED2, OCStackResult UNUSED3)
{
(void) (UNUSED1);
(void) (UNUSED2);
+ (void) (UNUSED3);
}
extern "C" OCStackApplicationResult discoveryCallback(void* ctx,
TEST(OCDoDirectPairingTests, Nullpeer)
{
- EXPECT_EQ(OC_STACK_INVALID_PARAM,OCDoDirectPairing(NULL, pmSel, &pinNumber, &resultCallback));
+ EXPECT_EQ(OC_STACK_INVALID_PARAM,OCDoDirectPairing(NULL, NULL, pmSel, &pinNumber, &resultCallback));
}
TEST(OCDoDirectPairingTests, NullCallback)
{
- EXPECT_EQ(OC_STACK_INVALID_CALLBACK,OCDoDirectPairing(&peer, pmSel, &pinNumber, NULL));
+ EXPECT_EQ(OC_STACK_INVALID_CALLBACK,OCDoDirectPairing(NULL, &peer, pmSel, &pinNumber, NULL));
}
TEST(OCDoDirectPairingTests, NullpinNumber)
{
- EXPECT_EQ(OC_STACK_INVALID_PARAM,OCDoDirectPairing(&peer, pmSel, NULL, &resultCallback));
+ EXPECT_EQ(OC_STACK_INVALID_PARAM,OCDoDirectPairing(NULL, &peer, pmSel, NULL, &resultCallback));
}
TEST(StackResource, MultipleResourcesDiscovery)