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 5
 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, 0x79, 0xA4, 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, 0x62,
 167     0x72, 0x74, 0x81, 0x69, 0x6F, 0x69, 0x63, 0x2E, 0x72, 0x2E, 0x61, 0x63, 0x6C, 0x62, 0x69, 0x66,
 168     0x81, 0x6F, 0x6F, 0x69, 0x63, 0x2E, 0x69, 0x66, 0x2E, 0x62, 0x61, 0x73, 0x65, 0x6C, 0x69, 0x6E,
 169     0x65, 0x65, 0x70, 0x73, 0x74, 0x61, 0x74, 0x58, 0x9D, 0xA9, 0x64, 0x69, 0x73, 0x6F, 0x70, 0xF5,
 170     0x6A, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x75, 0x75, 0x69, 0x64, 0x78, 0x24, 0x36, 0x31, 0x36,
 171     0x34, 0x36, 0x64, 0x36, 0x39, 0x2D, 0x36, 0x65, 0x34, 0x34, 0x2D, 0x36, 0x35, 0x37, 0x36, 0x2D,
 172     0x36, 0x39, 0x36, 0x33, 0x2D, 0x36, 0x35, 0x35, 0x35, 0x37, 0x35, 0x36, 0x39, 0x36, 0x34, 0x33,
 173     0x30, 0x62, 0x63, 0x6D, 0x00, 0x62, 0x74, 0x6D, 0x00, 0x62, 0x6F, 0x6D, 0x03, 0x62, 0x73, 0x6D,
 174     0x03, 0x6A, 0x72, 0x6F, 0x77, 0x6E, 0x65, 0x72, 0x75, 0x75, 0x69, 0x64, 0x78, 0x24, 0x36, 0x31,
 175     0x36, 0x34, 0x36, 0x64, 0x36, 0x39, 0x2D, 0x36, 0x65, 0x34, 0x34, 0x2D, 0x36, 0x35, 0x37, 0x36,
 176     0x2D, 0x36, 0x39, 0x36, 0x33, 0x2D, 0x36, 0x35, 0x35, 0x35, 0x37, 0x35, 0x36, 0x39, 0x36, 0x34,
 177     0x33, 0x30, 0x62, 0x72, 0x74, 0x81, 0x6B, 0x6F, 0x69, 0x63, 0x2E, 0x72, 0x2E, 0x70, 0x73, 0x74,
 178     0x61, 0x74, 0x62, 0x69, 0x66, 0x81, 0x6F, 0x6F, 0x69, 0x63, 0x2E, 0x69, 0x66, 0x2E, 0x62, 0x61,
 179     0x73, 0x65, 0x6C, 0x69, 0x6E, 0x65, 0x64, 0x64, 0x6F, 0x78, 0x6D, 0x58, 0xE8, 0xAA, 0x64, 0x6F,
 180     0x78, 0x6D, 0x73, 0x81, 0x00, 0x66, 0x6F, 0x78, 0x6D, 0x73, 0x65, 0x6C, 0x00, 0x63, 0x73, 0x63,
 181     0x74, 0x01, 0x65, 0x6F, 0x77, 0x6E, 0x65, 0x64, 0xF5, 0x6A, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65,
 182     0x75, 0x75, 0x69, 0x64, 0x78, 0x24, 0x36, 0x31, 0x36, 0x34, 0x36, 0x64, 0x36, 0x39, 0x2D, 0x36,
 183     0x65, 0x34, 0x34, 0x2D, 0x36, 0x35, 0x37, 0x36, 0x2D, 0x36, 0x39, 0x36, 0x33, 0x2D, 0x36, 0x35,
 184     0x35, 0x35, 0x37, 0x35, 0x36, 0x39, 0x36, 0x34, 0x33, 0x30, 0x6C, 0x64, 0x65, 0x76, 0x6F, 0x77,
 185     0x6E, 0x65, 0x72, 0x75, 0x75, 0x69, 0x64, 0x78, 0x24, 0x36, 0x31, 0x36, 0x34, 0x36, 0x64, 0x36,
 186     0x39, 0x2D, 0x36, 0x65, 0x34, 0x34, 0x2D, 0x36, 0x35, 0x37, 0x36, 0x2D, 0x36, 0x39, 0x36, 0x33,
 187     0x2D, 0x36, 0x35, 0x35, 0x35, 0x37, 0x35, 0x36, 0x39, 0x36, 0x34, 0x33, 0x30, 0x6A, 0x72, 0x6F,
 188     0x77, 0x6E, 0x65, 0x72, 0x75, 0x75, 0x69, 0x64, 0x78, 0x24, 0x36, 0x31, 0x36, 0x34, 0x36, 0x64,
 189     0x36, 0x39, 0x2D, 0x36, 0x65, 0x34, 0x34, 0x2D, 0x36, 0x35, 0x37, 0x36, 0x2D, 0x36, 0x39, 0x36,
 190     0x33, 0x2D, 0x36, 0x35, 0x35, 0x35, 0x37, 0x35, 0x36, 0x39, 0x36, 0x34, 0x33, 0x30, 0x72, 0x78,
 191     0x2E, 0x6F, 0x72, 0x67, 0x2E, 0x69, 0x6F, 0x74, 0x69, 0x76, 0x69, 0x74, 0x79, 0x2E, 0x64, 0x70,
 192     0x63, 0xF4, 0x62, 0x72, 0x74, 0x81, 0x6A, 0x6F, 0x69, 0x63, 0x2E, 0x72, 0x2E, 0x64, 0x6F, 0x78,
 193     0x6D, 0x62, 0x69, 0x66, 0x81, 0x6F, 0x6F, 0x69, 0x63, 0x2E, 0x69, 0x66, 0x2E, 0x62, 0x61, 0x73,
 194     0x65, 0x6C, 0x69, 0x6E, 0x65, 0xFF
 195 };
 196
 197 static bool g_doneCB;
 198 static bool g_callbackResult;
 199 static pid_t g_myPID1;
 200 static pid_t g_myPID2;
 201
 202 static const char* g_otmCtx = "Test User Context";
 203 static OCProvisionDev_t* g_unownedDevices = NULL;
 204 static OCProvisionDev_t* g_ownedDevices = NULL;
 205
 206 static void GetCurrentWorkingDirectory(char* buf, size_t bufsize)
 207 {
 208     char cwd[1024] = {0};
 209     const char* unittest_path = "resource/csdk/security/provisioning/unittest";
 210     if(getcwd(cwd, sizeof(cwd)) != NULL)
 211     {
 212         if(strstr(cwd, unittest_path) == NULL)
 213         {
 214 #if defined __linux__
 215 #if __x86_64__
 216         snprintf(buf, bufsize, "%s/out/linux/x86_64/release/%s/", cwd, unittest_path);
 217         snprintf(buf, bufsize, "%s/out/linux/x86_64/release/%s/", cwd, unittest_path);
 218 #else
 219         snprintf(buf, bufsize, "%s/out/linux/x86/release/%s/", cwd, unittest_path);
 220         snprintf(buf, bufsize, "%s/out/linux/x86/release/%s/", cwd, unittest_path);
 221 #endif //__x86_64__
 222 #endif //defined __linux__
 223         }
 224         else
 225         {
 226             snprintf(buf, bufsize, "%s/", cwd);
 227         }
 228     }
 229 }
 230
 231 static FILE* fopen_prvnMng(const char* path, const char* mode)
 232 {
 233     (void)path;  // unused |path| parameter
 234
 235     // input |g_svr_db_fname| internally by force, not using |path| parameter
 236     // because |OCPersistentStorage::open| is called |OCPersistentStorage| internally
 237     // with its own |SVR_DB_FILE_NAME|
 238     char cwd[1024] = {0};
 239     char svr_db_path[1024] = {0};
 240     GetCurrentWorkingDirectory(cwd, sizeof(cwd));
 241     snprintf(svr_db_path, sizeof(svr_db_path), "%s%s", cwd, SVR_DB_PATH);
 242     return fopen(svr_db_path, mode);
 243 }
 244
 245 // callback function(s) for provisioning client using C-level provisioning API
 246 static void ownershipTransferCB(void* ctx, int UNUSED1, OCProvisionResult_t* UNUSED2, bool hasError)
 247 {
 248     (void)UNUSED1;
 249     (void)UNUSED2;
 250     (void)ctx;
 251
 252     if(!hasError)
 253     {
 254         OIC_LOG_V(INFO, TAG, "Ownership Transfer SUCCEEDED - ctx: %s", (char*) ctx);
 255     }
 256     else
 257     {
 258         OIC_LOG_V(ERROR, TAG, "Ownership Transfer FAILED - ctx: %s", (char*) ctx);
 259     }
 260     g_callbackResult = !hasError;
 261     g_doneCB = true;
 262 }
 263
 264
 265 // callback function(s) for provisioning client using C-level provisioning API
 266 static void removeDeviceCB(void* ctx, int UNUSED1, OCProvisionResult_t* UNUSED2, bool hasError)
 267 {
 268     (void)UNUSED1;
 269     (void)UNUSED2;
 270     (void)ctx;
 271
 272     if(!hasError)
 273     {
 274         OIC_LOG_V(INFO, TAG, "Remove device request SUCCEEDED - ctx: %s", (char*) ctx);
 275     }
 276     else
 277     {
 278         OIC_LOG_V(ERROR, TAG, "Remove device request FAILED - ctx: %s", (char*) ctx);
 279     }
 280     g_callbackResult = !hasError;
 281     g_doneCB = true;
 282 }
 283
 284
 285 static int waitCallbackRet(void)
 286 {
 287     struct timespec timeout;
 288     timeout.tv_sec  = 0;
 289     timeout.tv_nsec = 100000000L;
 290
 291     for(long long i=0; !g_doneCB && OTM_TIMEOUT * 100000000L * 1000L > i; ++i)
 292     {
 293         nanosleep(&timeout, NULL);
 294         if(OC_STACK_OK != OCProcess())
 295         {
 296             OIC_LOG(ERROR, TAG, "OCStack process error");
 297             return -1;
 298         }
 299     }
 300
 301     return 0;
 302 }
 303
 304 static void RemoveUnknownDeviceFromDevList(OCProvisionDev_t* devList)
 305 {
 306     OicUuid_t uuid1;
 307     OicUuid_t uuid2;
 308     memset(uuid1.id, 0x11, sizeof(uuid1.id));
 309     memset(uuid2.id, 0x22, sizeof(uuid2.id));
 310
 311     OCProvisionDev_t* unknowDev = NULL;
 312     OCProvisionDev_t* tempDev1 = NULL;
 313     OCProvisionDev_t* tempDev2 =NULL;
 314     LL_FOREACH_SAFE(devList, tempDev1, tempDev2)
 315     {
 316
 317         if(!(memcmp(tempDev1->doxm->deviceID.id, uuid1.id, sizeof(uuid1.id)) == 0 ||
 318              memcmp(tempDev1->doxm->deviceID.id, uuid2.id, sizeof(uuid2.id)) == 0))
 319         {
 320             LL_DELETE(devList, tempDev1);
 321             LL_APPEND(unknowDev, tempDev1);
 322         }
 323     }
 324     OCDeleteDiscoveredDevices(unknowDev);
 325 }
 326
 327 TEST(InitForOTM, NullParam)
 328 {
 329     OCStackResult result = OC_STACK_ERROR;
 330
 331     OTMCallbackData_t otmcb;
 332     otmcb.loadSecretCB = LoadSecretJustWorksCallback;
 333     otmcb.createSecureSessionCB = CreateSecureSessionJustWorksCallback;
 334     otmcb.createSelectOxmPayloadCB = CreateJustWorksSelectOxmPayload;
 335     otmcb.createOwnerTransferPayloadCB = CreateJustWorksOwnerTransferPayload;
 336
 337     static OCPersistentStorage pstStr;
 338     pstStr.open = fopen_prvnMng;
 339     pstStr.read = fread;
 340     pstStr.write = fwrite;
 341     pstStr.close = fclose;
 342     pstStr.unlink = unlink;
 343
 344     //Get current path to execute the sample server.
 345     char cwd[1024] = {0};
 346     char server1_path[1024] = {0};
 347     char server2_path[1024] = {0};
 348     char pdb_path[1024] = {0};
 349     char del_cmd[1024] = {0};
 350     char svrdb_path[1024] = {0};
 351     FILE* fp = NULL;
 352
 353     GetCurrentWorkingDirectory(cwd, sizeof(cwd));
 354     EXPECT_TRUE(0 < strlen(cwd));
 355
 356     //Delete previous PDB, if exist.
 357     GetCurrentWorkingDirectory(cwd, sizeof(cwd));
 358     snprintf(del_cmd, sizeof(del_cmd), "rm -rf %stest.db", cwd);
 359     system(del_cmd);
 360
 361     //Delete previous SVR DB, if exist.
 362     snprintf(del_cmd, sizeof(del_cmd), "rm -rf %s%s", cwd, SVR_DB_PATH);
 363     system(del_cmd);
 364
 365     //Generate default SVR DB.
 366     snprintf(svrdb_path, sizeof(svrdb_path), "%s%s", cwd, SVR_DB_PATH);
 367     fp = fopen(svrdb_path, "w");
 368     if(NULL != fp)
 369     {
 370         size_t numberItems = fwrite(DEFAULT_SVR_DB, 1, sizeof(DEFAULT_SVR_DB), fp);
 371         fclose(fp);
 372         ASSERT_TRUE(sizeof(DEFAULT_SVR_DB) == numberItems);
 373     }
 374
 375     //Execute sample server to perform ownership transfer
 376     int status1 = 0;
 377     int status2 = 0;
 378     if(0 == (g_myPID1 = fork()))
 379     {
 380         snprintf(server1_path, sizeof(server1_path), "%ssample_server1", cwd);
 381         status1 = system(server1_path);
 382         (void)status1;
 383     }
 384     if(0 == (g_myPID2 = fork()))
 385     {
 386         snprintf(server2_path, sizeof(server2_path), "%ssample_server2", cwd);
 387         status2= system(server2_path);
 388         (void)status2;
 389     }
 390
 391     //Waiting for sample server initialization.
 392     sleep(3);
 393
 394     // register the persistent storage handler for SVR
 395     result = OCRegisterPersistentStorageHandler(&pstStr);
 396     EXPECT_EQ(OC_STACK_OK, result);
 397
 398     // initialize OC stack and provisioning manager
 399     result = OCInit(NULL, 0, OC_CLIENT_SERVER);
 400     EXPECT_EQ(OC_STACK_OK, result);
 401
 402     //initialize Provisioning DB Manager
 403
 404     snprintf(pdb_path, sizeof(pdb_path), "%stest.db", cwd);
 405     result = OCInitPM(pdb_path);
 406     EXPECT_EQ(OC_STACK_OK, result);
 407
 408     // register callback function(s) for Justworks OxM
 409     result = OCSetOwnerTransferCallbackData(OIC_JUST_WORKS, &otmcb);
 410     EXPECT_EQ(OC_STACK_OK, result);
 411
 412     g_doneCB = false;
 413     g_callbackResult = false;
 414 }
 415
 416
 417 TEST(PerformUnownedDeviceDiscovery, NullParam)
 418 {
 419     OCStackResult result = OC_STACK_ERROR;
 420
 421     OIC_LOG(INFO, TAG, "Discovering Only Unowned Devices on Network..\n");
 422     result = OCDiscoverUnownedDevices(DISCOVERY_TIMEOUT, &g_unownedDevices);
 423     EXPECT_EQ(OC_STACK_OK, result);
 424
 425     RemoveUnknownDeviceFromDevList(g_unownedDevices);
 426
 427     int NumOfUnownDevice = 0;
 428     OCProvisionDev_t* tempDev = g_unownedDevices;
 429     while(tempDev)
 430     {
 431         NumOfUnownDevice++;
 432         tempDev = tempDev->next;
 433     }
 434
 435     //if two more devices are running on the subnet,
 436     //stop the unittest process in order to prevent unittest failure.
 437     if(2 < NumOfUnownDevice)
 438     {
 439         printf("%c[1;33;40m ******************************************************************\n", 0x1B);
 440         printf("%c[1;33;40m   [%d] devices are running on the your sub-network.\n", 0x1B, NumOfUnownDevice);
 441         printf("%c[1;33;40m   Please turn off the other devices, and then try once again.\n", 0x1B);
 442         printf("%c[1;33;40m ******************************************************************", 0x1B);
 443         printf("%c[1;0;40m \n", 0x1B);
 444
 445         OCStackResult result = OCStop();
 446         EXPECT_EQ(OC_STACK_OK, result);
 447
 448         PMDeleteDeviceList(g_unownedDevices);
 449         PMDeleteDeviceList(g_ownedDevices);
 450         result = PDMClose();
 451         EXPECT_EQ(OC_STACK_OK, result);
 452
 453         kill(g_myPID2, SIGKILL);
 454         kill(g_myPID1, SIGKILL);
 455
 456         int interpreter_res1 = system("pkill -f \"sample_server1\"");
 457         EXPECT_TRUE(0 <= interpreter_res1);
 458         int interpreter_res2 = system("pkill -f \"sample_server2\"");
 459         EXPECT_TRUE(0 <= interpreter_res2);
 460
 461         exit(0);
 462     }
 463
 464     EXPECT_EQ(2, NumOfUnownDevice);
 465 }
 466
 467 TEST(PerformJustWorksOxM, NullParam)
 468 {
 469     OCStackResult result = OC_STACK_ERROR;
 470
 471     OIC_LOG(INFO, TAG, "Try Ownership Transfer for Unowned Devices...\n");
 472     result = OCDoOwnershipTransfer((void*)g_otmCtx, g_unownedDevices, ownershipTransferCB);
 473     EXPECT_EQ(OC_STACK_OK, result);
 474
 475     if(waitCallbackRet())  // input |g_doneCB| flag implicitly
 476     {
 477         OIC_LOG(ERROR, TAG, "OCProvisionCredentials callback error");
 478         return;
 479     }
 480     OIC_LOG(INFO, TAG, "Registered Discovered Unowned Device...\n");
 481
 482     EXPECT_EQ(true, g_callbackResult);
 483     EXPECT_EQ(true, g_doneCB);
 484 }
 485
 486
 487 TEST(PerformOwnedDeviceDiscovery, NullParam)
 488 {
 489     OCStackResult result = OC_STACK_ERROR;
 490
 491     OIC_LOG(INFO, TAG, "Discovering Only Owned Devices on Network..\n");
 492     result = OCDiscoverOwnedDevices(DISCOVERY_TIMEOUT, &g_ownedDevices);
 493     EXPECT_EQ(OC_STACK_OK, result);
 494
 495     RemoveUnknownDeviceFromDevList(g_ownedDevices);
 496
 497     int NumOfOwnDevice = 0;
 498     OCProvisionDev_t* tempDev = g_ownedDevices;
 499     while(tempDev)
 500     {
 501         NumOfOwnDevice++;
 502         tempDev = tempDev->next;
 503     }
 504
 505     EXPECT_EQ(2 , NumOfOwnDevice);
 506 }
 507
 508 TEST(PerformLinkDevices, NullParam)
 509 {
 510     OicUuid_t myUuid;
 511     OCStackResult result = OC_STACK_ERROR;
 512     result = GetDoxmDeviceID(&myUuid);
 513     EXPECT_EQ(OC_STACK_OK, result);
 514
 515     //Extract target device except PT to perform link devices.
 516     OCProvisionDev_t* dev1 = NULL;
 517     OCProvisionDev_t* dev2 = NULL;
 518     OCProvisionDev_t* tempDev = g_ownedDevices;
 519
 520     while(tempDev)
 521     {
 522         if(memcmp(tempDev->doxm->deviceID.id, myUuid.id, UUID_LENGTH) != 0)
 523         {
 524             if(NULL == dev1)
 525             {
 526                 dev1 = tempDev;
 527             }
 528             else if(NULL == dev2)
 529             {
 530                 dev2 = tempDev;
 531                 break;
 532             }
 533             else
 534             {
 535                 break;
 536             }
 537         }
 538         tempDev = tempDev->next;
 539     }
 540     EXPECT_TRUE(NULL != dev1);
 541     EXPECT_TRUE(NULL != dev2);
 542
 543     // TODO: Pairwise provisioning (Cred & ACL)
 544     // TODO: This part will be updated after ACL and credential data-structure is updated.
 545
 546     EXPECT_EQ(OC_STACK_OK, result);
 547 }
 548
 549 TEST(PerformUnlinkDevices, NullParam)
 550 {
 551     OCStackResult result = OC_STACK_OK;
 552
 553     // TODO: Unlink devices
 554     // TODO: This part will be updated after ACL and credential data-structure is updated.
 555
 556     EXPECT_EQ(OC_STACK_OK, result);
 557 }
 558
 559 TEST(PerformRemoveDevice, NullParam)
 560 {
 561     OicUuid_t myUuid;
 562     OCStackResult result = OC_STACK_ERROR;
 563     result = GetDoxmDeviceID(&myUuid);
 564     EXPECT_EQ(OC_STACK_OK, result);
 565
 566     //Extract target device except PT to perform remove device.
 567     OCProvisionDev_t* removeDev = g_ownedDevices;
 568     while(removeDev)
 569     {
 570         if(memcmp(removeDev->doxm->deviceID.id, myUuid.id, UUID_LENGTH) != 0)
 571         {
 572             break;
 573         }
 574         removeDev = removeDev->next;
 575     }
 576     EXPECT_TRUE(NULL != removeDev);
 577
 578     g_doneCB = false;
 579     g_callbackResult = false;
 580
 581     result = OCRemoveDevice((void*)g_otmCtx, DISCOVERY_TIMEOUT, removeDev, removeDeviceCB);
 582     EXPECT_EQ(OC_STACK_OK, result);
 583     EXPECT_EQ(true, g_callbackResult);
 584     EXPECT_EQ(true, g_doneCB);
 585 }
 586
 587 TEST(FinalizeOTMTest, NullParam)
 588 {
 589     OCStackResult result = OCStop();
 590     EXPECT_EQ(OC_STACK_OK, result);
 591
 592     PMDeleteDeviceList(g_unownedDevices);
 593     PMDeleteDeviceList(g_ownedDevices);
 594     result = PDMClose();
 595     EXPECT_EQ(OC_STACK_OK, result);
 596
 597     kill(g_myPID2, SIGKILL);
 598     kill(g_myPID1, SIGKILL);
 599
 600     int interpreter_res1 = system("pkill -f \"sample_server1\"");
 601     EXPECT_TRUE(0 <= interpreter_res1);
 602     int interpreter_res2 = system("pkill -f \"sample_server2\"");
 603     EXPECT_TRUE(0 <= interpreter_res2);
 604 }
 605