resource/csdk/security/provisioning/unittest/otmunittest.cpp

   1 /* *****************************************************************
   2  *
   3  * Copyright 2015 Samsung Electronics All Rights Reserved.
   4  *
   5  *
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *     http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  * *****************************************************************/
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22 #include <unistd.h>
  23 #include "gtest/gtest.h"
  24 #include "ocstack.h"
  25 #include "utlist.h"
  26 #include "logger.h"
  27 #include "oic_malloc.h"
  28 #include "oic_string.h"
  29 #include "ocprovisioningmanager.h"
  30 #include "oxmjustworks.h"
  31 #include "oxmrandompin.h"
  32 #include "securevirtualresourcetypes.h"
  33 #include "provisioningdatabasemanager.h"
  34 #include "srmutility.h"
  35 #include "doxmresource.h"
  36 #include "pmtypes.h"
  37 #include "pmutility.h"
  38
  39 using namespace std;
  40
  41 TEST(JustWorksOxMTest, NullParam)
  42 {
  43     OTMContext_t* otmCtx = NULL;
  44     OCStackResult res = OC_STACK_ERROR;
  45     uint8_t *payloadRes = NULL;
  46     size_t size = 0;
  47
  48     //LoadSecretJustWorksCallback always returns OC_STACK_OK.
  49     res = LoadSecretJustWorksCallback(otmCtx);
  50     EXPECT_TRUE(OC_STACK_OK == res);
  51
  52     res = CreateSecureSessionJustWorksCallback(otmCtx);
  53     EXPECT_TRUE(OC_STACK_INVALID_PARAM == res);
  54
  55     res = CreateJustWorksSelectOxmPayload(otmCtx, &payloadRes, &size);
  56     EXPECT_TRUE(OC_STACK_INVALID_PARAM == res);
  57
  58     res = CreateJustWorksOwnerTransferPayload(otmCtx, &payloadRes, &size);
  59     EXPECT_TRUE(OC_STACK_INVALID_PARAM == res);
  60
  61     OTMContext_t otmCtx2;
  62     otmCtx2.selectedDeviceInfo = NULL;
  63
  64     //LoadSecretJustWorksCallback always returns OC_STACK_OK.
  65     res = LoadSecretJustWorksCallback(&otmCtx2);
  66     EXPECT_TRUE(OC_STACK_OK == res);
  67
  68     res = CreateSecureSessionJustWorksCallback(&otmCtx2);
  69     EXPECT_TRUE(OC_STACK_INVALID_PARAM == res);
  70
  71     res = CreateJustWorksSelectOxmPayload(&otmCtx2, &payloadRes, &size);
  72     EXPECT_TRUE(OC_STACK_INVALID_PARAM == res);
  73
  74     res = CreateJustWorksOwnerTransferPayload(&otmCtx2, &payloadRes, &size);
  75     EXPECT_TRUE(OC_STACK_INVALID_PARAM == res);
  76 }
  77
  78 TEST(RandomPinOxMTest, NullParam)
  79 {
  80     OTMContext_t* otmCtx = NULL;
  81     OCStackResult res = OC_STACK_ERROR;
  82     uint8_t *payloadRes = NULL;
  83     size_t size = 0;
  84
  85     //LoadSecretJustWorksCallback always returns OC_STACK_OK.
  86     res = InputPinCodeCallback(otmCtx);
  87     EXPECT_TRUE(OC_STACK_INVALID_PARAM == res);
  88
  89     res = CreateSecureSessionRandomPinCallback(otmCtx);
  90     EXPECT_TRUE(OC_STACK_INVALID_PARAM == res);
  91
  92     res = CreatePinBasedSelectOxmPayload(otmCtx, &payloadRes, &size);
  93     EXPECT_TRUE(OC_STACK_INVALID_PARAM == res);
  94
  95     res = CreatePinBasedOwnerTransferPayload(otmCtx, &payloadRes, &size);
  96     EXPECT_TRUE(OC_STACK_INVALID_PARAM == res);
  97
  98     OTMContext_t otmCtx2;
  99     otmCtx2.selectedDeviceInfo = NULL;
 100
 101     //LoadSecretJustWorksCallback always returns OC_STACK_OK.
 102     res = InputPinCodeCallback(&otmCtx2);
 103     EXPECT_TRUE(OC_STACK_INVALID_PARAM == res);
 104
 105     res = CreateSecureSessionRandomPinCallback(&otmCtx2);
 106     EXPECT_TRUE(OC_STACK_INVALID_PARAM == res);
 107
 108     res = CreatePinBasedSelectOxmPayload(&otmCtx2, &payloadRes, &size);
 109     EXPECT_TRUE(OC_STACK_INVALID_PARAM == res);
 110
 111     res = CreatePinBasedOwnerTransferPayload(&otmCtx2, &payloadRes, &size);
 112     EXPECT_TRUE(OC_STACK_INVALID_PARAM == res);
 113 }
 114
 115
 116 /****************************************
 117  * Test the OTM modules with sample server
 118  ****************************************/
 119 #define TAG "JUSTWORKS_UNITTEST"
 120 #define OTM_TIMEOUT 5
 121 #define DISCOVERY_TIMEOUT 3
 122
 123 #define SVR_DB_PATH "oic_svr_db_client.dat"
 124 #define UT_PATH "resource/csdk/security/provisioning/unittest"
 125 char pdb_path[1024];
 126 char svr_path[1024];
 127
 128 static uint8_t DEFAULT_SVR_DB[] = {
 129     0xBF, 0x63, 0x61, 0x63, 0x6C, 0x59, 0x02, 0x57, 0xA2, 0x66, 0x61, 0x63, 0x6C, 0x69, 0x73, 0x74,
 130     0xA1, 0x64, 0x61, 0x63, 0x65, 0x73, 0x83, 0xA3, 0x6B, 0x73, 0x75, 0x62, 0x6A, 0x65, 0x63, 0x74,
 131     0x75, 0x75, 0x69, 0x64, 0x61, 0x2A, 0x69, 0x72, 0x65, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x73,
 132     0x83, 0xA4, 0x64, 0x68, 0x72, 0x65, 0x66, 0x68, 0x2F, 0x6F, 0x69, 0x63, 0x2F, 0x72, 0x65, 0x73,
 133     0x62, 0x72, 0x74, 0x81, 0x6A, 0x6F, 0x69, 0x63, 0x2E, 0x77, 0x6B, 0x2E, 0x72, 0x65, 0x73, 0x62,
 134     0x69, 0x66, 0x81, 0x69, 0x6F, 0x69, 0x63, 0x2E, 0x69, 0x66, 0x2E, 0x6C, 0x6C, 0x63, 0x72, 0x65,
 135     0x6C, 0x60, 0xA4, 0x64, 0x68, 0x72, 0x65, 0x66, 0x66, 0x2F, 0x6F, 0x69, 0x63, 0x2F, 0x64, 0x62,
 136     0x72, 0x74, 0x81, 0x68, 0x6F, 0x69, 0x63, 0x2E, 0x77, 0x6B, 0x2E, 0x64, 0x62, 0x69, 0x66, 0x82,
 137     0x6F, 0x6F, 0x69, 0x63, 0x2E, 0x69, 0x66, 0x2E, 0x62, 0x61, 0x73, 0x65, 0x6C, 0x69, 0x6E, 0x65,
 138     0x68, 0x6F, 0x69, 0x63, 0x2E, 0x69, 0x66, 0x2E, 0x72, 0x63, 0x72, 0x65, 0x6C, 0x60, 0xA4, 0x64,
 139     0x68, 0x72, 0x65, 0x66, 0x66, 0x2F, 0x6F, 0x69, 0x63, 0x2F, 0x70, 0x62, 0x72, 0x74, 0x81, 0x68,
 140     0x6F, 0x69, 0x63, 0x2E, 0x77, 0x6B, 0x2E, 0x70, 0x62, 0x69, 0x66, 0x82, 0x6F, 0x6F, 0x69, 0x63,
 141     0x2E, 0x69, 0x66, 0x2E, 0x62, 0x61, 0x73, 0x65, 0x6C, 0x69, 0x6E, 0x65, 0x68, 0x6F, 0x69, 0x63,
 142     0x2E, 0x69, 0x66, 0x2E, 0x72, 0x63, 0x72, 0x65, 0x6C, 0x60, 0x6A, 0x70, 0x65, 0x72, 0x6D, 0x69,
 143     0x73, 0x73, 0x69, 0x6F, 0x6E, 0x02, 0xA3, 0x6B, 0x73, 0x75, 0x62, 0x6A, 0x65, 0x63, 0x74, 0x75,
 144     0x75, 0x69, 0x64, 0x61, 0x2A, 0x69, 0x72, 0x65, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x73, 0x82,
 145     0xA4, 0x64, 0x68, 0x72, 0x65, 0x66, 0x6D, 0x2F, 0x6F, 0x69, 0x63, 0x2F, 0x73, 0x65, 0x63, 0x2F,
 146     0x64, 0x6F, 0x78, 0x6D, 0x62, 0x72, 0x74, 0x81, 0x6A, 0x6F, 0x69, 0x63, 0x2E, 0x72, 0x2E, 0x64,
 147     0x6F, 0x78, 0x6D, 0x62, 0x69, 0x66, 0x81, 0x6F, 0x6F, 0x69, 0x63, 0x2E, 0x69, 0x66, 0x2E, 0x62,
 148     0x61, 0x73, 0x65, 0x6C, 0x69, 0x6E, 0x65, 0x63, 0x72, 0x65, 0x6C, 0x60, 0xA4, 0x64, 0x68, 0x72,
 149     0x65, 0x66, 0x6E, 0x2F, 0x6F, 0x69, 0x63, 0x2F, 0x73, 0x65, 0x63, 0x2F, 0x70, 0x73, 0x74, 0x61,
 150     0x74, 0x62, 0x72, 0x74, 0x81, 0x6B, 0x6F, 0x69, 0x63, 0x2E, 0x72, 0x2E, 0x70, 0x73, 0x74, 0x61,
 151     0x74, 0x62, 0x69, 0x66, 0x81, 0x6F, 0x6F, 0x69, 0x63, 0x2E, 0x69, 0x66, 0x2E, 0x62, 0x61, 0x73,
 152     0x65, 0x6C, 0x69, 0x6E, 0x65, 0x63, 0x72, 0x65, 0x6C, 0x60, 0x6A, 0x70, 0x65, 0x72, 0x6D, 0x69,
 153     0x73, 0x73, 0x69, 0x6F, 0x6E, 0x02, 0xA3, 0x6B, 0x73, 0x75, 0x62, 0x6A, 0x65, 0x63, 0x74, 0x75,
 154     0x75, 0x69, 0x64, 0x61, 0x2A, 0x69, 0x72, 0x65, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x73, 0x82,
 155     0xA4, 0x64, 0x68, 0x72, 0x65, 0x66, 0x6E, 0x2F, 0x6F, 0x69, 0x63, 0x2F, 0x73, 0x65, 0x63, 0x2F,
 156     0x70, 0x63, 0x6F, 0x6E, 0x66, 0x62, 0x72, 0x74, 0x81, 0x6B, 0x6F, 0x69, 0x63, 0x2E, 0x72, 0x2E,
 157     0x70, 0x63, 0x6F, 0x6E, 0x66, 0x62, 0x69, 0x66, 0x81, 0x6F, 0x6F, 0x69, 0x63, 0x2E, 0x69, 0x66,
 158     0x2E, 0x62, 0x61, 0x73, 0x65, 0x6C, 0x69, 0x6E, 0x65, 0x63, 0x72, 0x65, 0x6C, 0x60, 0xA4, 0x64,
 159     0x68, 0x72, 0x65, 0x66, 0x71, 0x2F, 0x6F, 0x69, 0x63, 0x2F, 0x73, 0x65, 0x63, 0x2F, 0x64, 0x70,
 160     0x61, 0x69, 0x72, 0x69, 0x6E, 0x67, 0x62, 0x72, 0x74, 0x81, 0x6E, 0x6F, 0x69, 0x63, 0x2E, 0x72,
 161     0x2E, 0x64, 0x70, 0x61, 0x69, 0x72, 0x69, 0x6E, 0x67, 0x62, 0x69, 0x66, 0x81, 0x6F, 0x6F, 0x69,
 162     0x63, 0x2E, 0x69, 0x66, 0x2E, 0x62, 0x61, 0x73, 0x65, 0x6C, 0x69, 0x6E, 0x65, 0x63, 0x72, 0x65,
 163     0x6C, 0x60, 0x6A, 0x70, 0x65, 0x72, 0x6D, 0x69, 0x73, 0x73, 0x69, 0x6F, 0x6E, 0x02, 0x6A, 0x72,
 164     0x6F, 0x77, 0x6E, 0x65, 0x72, 0x75, 0x75, 0x69, 0x64, 0x78, 0x24, 0x36, 0x31, 0x36, 0x34, 0x36,
 165     0x64, 0x36, 0x39, 0x2D, 0x36, 0x65, 0x34, 0x34, 0x2D, 0x36, 0x35, 0x37, 0x36, 0x2D, 0x36, 0x39,
 166     0x36, 0x33, 0x2D, 0x36, 0x35, 0x35, 0x35, 0x37, 0x35, 0x36, 0x39, 0x36, 0x34, 0x33, 0x30, 0x65,
 167     0x70, 0x73, 0x74, 0x61, 0x74, 0x58, 0x79, 0xA7, 0x64, 0x69, 0x73, 0x6F, 0x70, 0xF5, 0x6A, 0x64,
 168     0x65, 0x76, 0x69, 0x63, 0x65, 0x75, 0x75, 0x69, 0x64, 0x78, 0x24, 0x36, 0x31, 0x36, 0x34, 0x36,
 169     0x64, 0x36, 0x39, 0x2D, 0x36, 0x65, 0x34, 0x34, 0x2D, 0x36, 0x35, 0x37, 0x36, 0x2D, 0x36, 0x39,
 170     0x36, 0x33, 0x2D, 0x36, 0x35, 0x35, 0x35, 0x37, 0x35, 0x36, 0x39, 0x36, 0x34, 0x33, 0x30, 0x62,
 171     0x63, 0x6D, 0x00, 0x62, 0x74, 0x6D, 0x00, 0x62, 0x6F, 0x6D, 0x03, 0x62, 0x73, 0x6D, 0x03, 0x6A,
 172     0x72, 0x6F, 0x77, 0x6E, 0x65, 0x72, 0x75, 0x75, 0x69, 0x64, 0x78, 0x24, 0x36, 0x31, 0x36, 0x34,
 173     0x36, 0x64, 0x36, 0x39, 0x2D, 0x36, 0x65, 0x34, 0x34, 0x2D, 0x36, 0x35, 0x37, 0x36, 0x2D, 0x36,
 174     0x39, 0x36, 0x33, 0x2D, 0x36, 0x35, 0x35, 0x35, 0x37, 0x35, 0x36, 0x39, 0x36, 0x34, 0x33, 0x30,
 175     0x64, 0x64, 0x6F, 0x78, 0x6D, 0x58, 0xC4, 0xA8, 0x64, 0x6F, 0x78, 0x6D, 0x73, 0x81, 0x00, 0x66,
 176     0x6F, 0x78, 0x6D, 0x73, 0x65, 0x6C, 0x00, 0x63, 0x73, 0x63, 0x74, 0x01, 0x65, 0x6F, 0x77, 0x6E,
 177     0x65, 0x64, 0xF5, 0x6A, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x75, 0x75, 0x69, 0x64, 0x78, 0x24,
 178     0x36, 0x31, 0x36, 0x34, 0x36, 0x64, 0x36, 0x39, 0x2D, 0x36, 0x65, 0x34, 0x34, 0x2D, 0x36, 0x35,
 179     0x37, 0x36, 0x2D, 0x36, 0x39, 0x36, 0x33, 0x2D, 0x36, 0x35, 0x35, 0x35, 0x37, 0x35, 0x36, 0x39,
 180     0x36, 0x34, 0x33, 0x30, 0x6C, 0x64, 0x65, 0x76, 0x6F, 0x77, 0x6E, 0x65, 0x72, 0x75, 0x75, 0x69,
 181     0x64, 0x78, 0x24, 0x36, 0x31, 0x36, 0x34, 0x36, 0x64, 0x36, 0x39, 0x2D, 0x36, 0x65, 0x34, 0x34,
 182     0x2D, 0x36, 0x35, 0x37, 0x36, 0x2D, 0x36, 0x39, 0x36, 0x33, 0x2D, 0x36, 0x35, 0x35, 0x35, 0x37,
 183     0x35, 0x36, 0x39, 0x36, 0x34, 0x33, 0x30, 0x6A, 0x72, 0x6F, 0x77, 0x6E, 0x65, 0x72, 0x75, 0x75,
 184     0x69, 0x64, 0x78, 0x24, 0x36, 0x31, 0x36, 0x34, 0x36, 0x64, 0x36, 0x39, 0x2D, 0x36, 0x65, 0x34,
 185     0x34, 0x2D, 0x36, 0x35, 0x37, 0x36, 0x2D, 0x36, 0x39, 0x36, 0x33, 0x2D, 0x36, 0x35, 0x35, 0x35,
 186     0x37, 0x35, 0x36, 0x39, 0x36, 0x34, 0x33, 0x30, 0x71, 0x78, 0x2E, 0x63, 0x6F, 0x6D, 0x2E, 0x73,
 187     0x61, 0x6D, 0x73, 0x75, 0x6E, 0x67, 0x2E, 0x64, 0x70, 0x63, 0xF4, 0xFF
 188 };
 189
 190 static bool g_doneCB;
 191 static bool g_callbackResult;
 192 static pid_t g_myPID1;
 193 static pid_t g_myPID2;
 194
 195 static const char* g_otmCtx = "Test User Context";
 196 static OCProvisionDev_t* g_unownedDevices = NULL;
 197 static OCProvisionDev_t* g_ownedDevices = NULL;
 198
 199 static void GetCurrentWorkingDirectory(char* buf, size_t bufsize)
 200 {
 201     char cwd[1024] = {0};
 202     const char* unittest_path = "resource/csdk/security/provisioning/unittest";
 203     if(getcwd(cwd, sizeof(cwd)) != NULL)
 204     {
 205         if(strstr(cwd, unittest_path) == NULL)
 206         {
 207 #if defined __linux__
 208 #if __x86_64__
 209         snprintf(buf, bufsize, "%s/out/linux/x86_64/release/%s/", cwd, unittest_path);
 210         snprintf(buf, bufsize, "%s/out/linux/x86_64/release/%s/", cwd, unittest_path);
 211 #else
 212         snprintf(buf, bufsize, "%s/out/linux/x86/release/%s/", cwd, unittest_path);
 213         snprintf(buf, bufsize, "%s/out/linux/x86/release/%s/", cwd, unittest_path);
 214 #endif //__x86_64__
 215 #endif //defined __linux__
 216         }
 217         else
 218         {
 219             snprintf(buf, bufsize, "%s/", cwd);
 220         }
 221     }
 222 }
 223
 224 static FILE* fopen_prvnMng(const char* path, const char* mode)
 225 {
 226     (void)path;  // unused |path| parameter
 227
 228     // input |g_svr_db_fname| internally by force, not using |path| parameter
 229     // because |OCPersistentStorage::open| is called |OCPersistentStorage| internally
 230     // with its own |SVR_DB_FILE_NAME|
 231     char cwd[1024] = {0};
 232     char svr_db_path[1024] = {0};
 233     GetCurrentWorkingDirectory(cwd, sizeof(cwd));
 234     snprintf(svr_db_path, sizeof(svr_db_path), "%s%s", cwd, SVR_DB_PATH);
 235     return fopen(svr_db_path, mode);
 236 }
 237
 238 // callback function(s) for provisioning client using C-level provisioning API
 239 static void ownershipTransferCB(void* ctx, int UNUSED1, OCProvisionResult_t* UNUSED2, bool hasError)
 240 {
 241     (void)UNUSED1;
 242     (void)UNUSED2;
 243     (void)ctx;
 244
 245     if(!hasError)
 246     {
 247         OIC_LOG_V(INFO, TAG, "Ownership Transfer SUCCEEDED - ctx: %s", (char*) ctx);
 248     }
 249     else
 250     {
 251         OIC_LOG_V(ERROR, TAG, "Ownership Transfer FAILED - ctx: %s", (char*) ctx);
 252     }
 253     g_callbackResult = !hasError;
 254     g_doneCB = true;
 255 }
 256
 257
 258 // callback function(s) for provisioning client using C-level provisioning API
 259 static void removeDeviceCB(void* ctx, int UNUSED1, OCProvisionResult_t* UNUSED2, bool hasError)
 260 {
 261     (void)UNUSED1;
 262     (void)UNUSED2;
 263     (void)ctx;
 264
 265     if(!hasError)
 266     {
 267         OIC_LOG_V(INFO, TAG, "Remove device request SUCCEEDED - ctx: %s", (char*) ctx);
 268     }
 269     else
 270     {
 271         OIC_LOG_V(ERROR, TAG, "Remove device request FAILED - ctx: %s", (char*) ctx);
 272     }
 273     g_callbackResult = !hasError;
 274     g_doneCB = true;
 275 }
 276
 277
 278 static int waitCallbackRet(void)
 279 {
 280     struct timespec timeout;
 281     timeout.tv_sec  = 0;
 282     timeout.tv_nsec = 100000000L;
 283
 284     for(long long i=0; !g_doneCB && OTM_TIMEOUT * 100000000L * 1000L > i; ++i)
 285     {
 286         nanosleep(&timeout, NULL);
 287         if(OC_STACK_OK != OCProcess())
 288         {
 289             OIC_LOG(ERROR, TAG, "OCStack process error");
 290             return -1;
 291         }
 292     }
 293
 294     return 0;
 295 }
 296
 297 TEST(InitForOTM, NullParam)
 298 {
 299     OCStackResult result = OC_STACK_ERROR;
 300
 301     OTMCallbackData_t otmcb;
 302     otmcb.loadSecretCB = LoadSecretJustWorksCallback;
 303     otmcb.createSecureSessionCB = CreateSecureSessionJustWorksCallback;
 304     otmcb.createSelectOxmPayloadCB = CreateJustWorksSelectOxmPayload;
 305     otmcb.createOwnerTransferPayloadCB = CreateJustWorksOwnerTransferPayload;
 306
 307     static OCPersistentStorage pstStr;
 308     pstStr.open = fopen_prvnMng;
 309     pstStr.read = fread;
 310     pstStr.write = fwrite;
 311     pstStr.close = fclose;
 312     pstStr.unlink = unlink;
 313
 314     //Get current path to execute the sample server.
 315     char cwd[1024] = {0};
 316     char server1_path[1024] = {0};
 317     char server2_path[1024] = {0};
 318     char pdb_path[1024] = {0};
 319     char del_cmd[1024] = {0};
 320     char svrdb_path[1024] = {0};
 321     FILE* fp = NULL;
 322
 323     GetCurrentWorkingDirectory(cwd, sizeof(cwd));
 324     EXPECT_TRUE(0 < strlen(cwd));
 325
 326     //Delete previous PDB, if exist.
 327     GetCurrentWorkingDirectory(cwd, sizeof(cwd));
 328     snprintf(del_cmd, sizeof(del_cmd), "rm -rf %stest.db", cwd);
 329     system(del_cmd);
 330
 331     //Delete previous SVR DB, if exist.
 332     snprintf(del_cmd, sizeof(del_cmd), "rm -rf %s%s", cwd, SVR_DB_PATH);
 333     system(del_cmd);
 334
 335     //Generate default SVR DB.
 336     snprintf(svrdb_path, sizeof(svrdb_path), "%s%s", cwd, SVR_DB_PATH);
 337     fp = fopen(svrdb_path, "w");
 338     if(NULL != fp)
 339     {
 340         size_t numberItems = fwrite(DEFAULT_SVR_DB, 1, sizeof(DEFAULT_SVR_DB), fp);
 341         fclose(fp);
 342         ASSERT_TRUE(sizeof(DEFAULT_SVR_DB) == numberItems);
 343     }
 344
 345     //Execute sample server to perform ownership transfer
 346     int status1 = 0;
 347     int status2 = 0;
 348     if(0 == (g_myPID1 = fork()))
 349     {
 350         snprintf(server1_path, sizeof(server1_path), "%ssample_server1", cwd);
 351         status1 = system(server1_path);
 352         (void)status1;
 353     }
 354     if(0 == (g_myPID2 = fork()))
 355     {
 356         snprintf(server2_path, sizeof(server2_path), "%ssample_server2", cwd);
 357         status2= system(server2_path);
 358         (void)status2;
 359     }
 360
 361     // register the persistent storage handler for SVR
 362     result = OCRegisterPersistentStorageHandler(&pstStr);
 363     EXPECT_EQ(OC_STACK_OK, result);
 364
 365     // initialize OC stack and provisioning manager
 366     result = OCInit(NULL, 0, OC_CLIENT_SERVER);
 367     EXPECT_EQ(OC_STACK_OK, result);
 368
 369     //initialize Provisioning DB Manager
 370
 371     snprintf(pdb_path, sizeof(pdb_path), "%stest.db", cwd);
 372     result = OCInitPM(pdb_path);
 373     EXPECT_EQ(OC_STACK_OK, result);
 374
 375     // register callback function(s) for Justworks OxM
 376     result = OCSetOwnerTransferCallbackData(OIC_JUST_WORKS, &otmcb);
 377     EXPECT_EQ(OC_STACK_OK, result);
 378
 379     g_doneCB = false;
 380     g_callbackResult = false;
 381 }
 382
 383
 384 TEST(PerformUnownedDeviceDiscovery, NullParam)
 385 {
 386     OCStackResult result = OC_STACK_ERROR;
 387
 388     OIC_LOG(INFO, TAG, "Discovering Only Unowned Devices on Network..\n");
 389     result = OCDiscoverUnownedDevices(DISCOVERY_TIMEOUT, &g_unownedDevices);
 390     EXPECT_EQ(OC_STACK_OK, result);
 391
 392     int NumOfUnownDevice = 0;
 393     OCProvisionDev_t* tempDev = g_unownedDevices;
 394     while(tempDev)
 395     {
 396         NumOfUnownDevice++;
 397         tempDev = tempDev->next;
 398     }
 399     EXPECT_EQ(2, NumOfUnownDevice);
 400 }
 401
 402 TEST(PerformJustWorksOxM, NullParam)
 403 {
 404     OCStackResult result = OC_STACK_ERROR;
 405
 406     OIC_LOG(INFO, TAG, "Try Ownership Transfer for Unowned Devices...\n");
 407     result = OCDoOwnershipTransfer((void*)g_otmCtx, g_unownedDevices, ownershipTransferCB);
 408     EXPECT_EQ(OC_STACK_OK, result);
 409
 410     if(waitCallbackRet())  // input |g_doneCB| flag implicitly
 411     {
 412         OIC_LOG(ERROR, TAG, "OCProvisionCredentials callback error");
 413         return;
 414     }
 415     OIC_LOG(INFO, TAG, "Registered Discovered Unowned Device...\n");
 416
 417     EXPECT_EQ(true, g_callbackResult);
 418     EXPECT_EQ(true, g_doneCB);
 419 }
 420
 421
 422 TEST(PerformOwnedDeviceDiscovery, NullParam)
 423 {
 424     OCStackResult result = OC_STACK_ERROR;
 425
 426     OIC_LOG(INFO, TAG, "Discovering Only Owned Devices on Network..\n");
 427     result = OCDiscoverOwnedDevices(DISCOVERY_TIMEOUT, &g_ownedDevices);
 428     EXPECT_EQ(OC_STACK_OK, result);
 429
 430     int NumOfOwnDevice = 0;
 431     OCProvisionDev_t* tempDev = g_ownedDevices;
 432     while(tempDev)
 433     {
 434         NumOfOwnDevice++;
 435         tempDev = tempDev->next;
 436     }
 437
 438     EXPECT_EQ(2/*Server*/ , NumOfOwnDevice);
 439 }
 440
 441 TEST(PerformLinkDevices, NullParam)
 442 {
 443     OicUuid_t myUuid;
 444     OCStackResult result = OC_STACK_ERROR;
 445     result = GetDoxmDeviceID(&myUuid);
 446     EXPECT_EQ(OC_STACK_OK, result);
 447
 448     //Extract target device except PT to perform link devices.
 449     OCProvisionDev_t* dev1 = NULL;
 450     OCProvisionDev_t* dev2 = NULL;
 451     OCProvisionDev_t* tempDev = g_ownedDevices;
 452
 453     while(tempDev)
 454     {
 455         if(memcmp(tempDev->doxm->deviceID.id, myUuid.id, UUID_LENGTH) != 0)
 456         {
 457             if(NULL == dev1)
 458             {
 459                 dev1 = tempDev;
 460             }
 461             else if(NULL == dev2)
 462             {
 463                 dev2 = tempDev;
 464                 break;
 465             }
 466             else
 467             {
 468                 break;
 469             }
 470         }
 471         tempDev = tempDev->next;
 472     }
 473     EXPECT_TRUE(NULL != dev1);
 474     EXPECT_TRUE(NULL != dev2);
 475
 476     // TODO: Pairwise provisioning (Cred & ACL)
 477     // TODO: This part will be updated after ACL and credential data-structure is updated.
 478
 479     EXPECT_EQ(OC_STACK_OK, result);
 480 }
 481
 482 TEST(PerformUnlinkDevices, NullParam)
 483 {
 484     OCStackResult result = OC_STACK_OK;
 485
 486     // TODO: Unlink devices
 487     // TODO: This part will be updated after ACL and credential data-structure is updated.
 488
 489     EXPECT_EQ(OC_STACK_OK, result);
 490 }
 491
 492 TEST(PerformRemoveDevice, NullParam)
 493 {
 494     OicUuid_t myUuid;
 495     OCStackResult result = OC_STACK_ERROR;
 496     result = GetDoxmDeviceID(&myUuid);
 497     EXPECT_EQ(OC_STACK_OK, result);
 498
 499     //Extract target device except PT to perform remove device.
 500     OCProvisionDev_t* removeDev = g_ownedDevices;
 501     while(removeDev)
 502     {
 503         if(memcmp(removeDev->doxm->deviceID.id, myUuid.id, UUID_LENGTH) != 0)
 504         {
 505             break;
 506         }
 507         removeDev = removeDev->next;
 508     }
 509     EXPECT_TRUE(NULL != removeDev);
 510
 511     g_doneCB = false;
 512     g_callbackResult = false;
 513
 514     result = OCRemoveDevice((void*)g_otmCtx, DISCOVERY_TIMEOUT, removeDev, removeDeviceCB);
 515     EXPECT_EQ(OC_STACK_OK, result);
 516     EXPECT_EQ(true, g_callbackResult);
 517     EXPECT_EQ(true, g_doneCB);
 518 }
 519
 520 TEST(FinalizeOTMTest, NullParam)
 521 {
 522     OCStackResult result = OCStop();
 523     EXPECT_EQ(OC_STACK_OK, result);
 524
 525     PMDeleteDeviceList(g_unownedDevices);
 526     PMDeleteDeviceList(g_ownedDevices);
 527     result = PDMClose();
 528     EXPECT_EQ(OC_STACK_OK, result);
 529
 530     kill(g_myPID2, SIGKILL);
 531     kill(g_myPID1, SIGKILL);
 532
 533     int interpreter_res1 = system("pkill -f \"sample_server1\"");
 534     EXPECT_TRUE(0 <= interpreter_res1);
 535     int interpreter_res2 = system("pkill -f \"sample_server2\"");
 536     EXPECT_TRUE(0 <= interpreter_res2);
 537 }
 538