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 TEST(PerformSecureResourceDiscovery, NullParam)
 417 {
 418     OCStackResult result = OC_STACK_ERROR;
 419     OCProvisionDev_t* foundDevice = NULL;
 420
 421     OIC_LOG(INFO, TAG, "Discovering Owned/Unowned Device using multicast\n");
 422     result = OCDiscoverSecureResource(DISCOVERY_TIMEOUT, "", CT_DEFAULT, &foundDevice);
 423     EXPECT_EQ(OC_STACK_OK, result);
 424
 425     int NumOfFoundDevice = 0;
 426     OCProvisionDev_t* tempDev = foundDevice;
 427     while(tempDev)
 428     {
 429         NumOfFoundDevice++;
 430         tempDev = tempDev->next;
 431     }
 432     PMDeleteDeviceList(foundDevice);
 433
 434     EXPECT_EQ(true, NumOfFoundDevice > 0);
 435 }
 436
 437 TEST(PerformUnownedDeviceDiscovery, NullParam)
 438 {
 439     OCStackResult result = OC_STACK_ERROR;
 440
 441     OIC_LOG(INFO, TAG, "Discovering Only Unowned Devices on Network..\n");
 442     result = OCDiscoverUnownedDevices(DISCOVERY_TIMEOUT, &g_unownedDevices);
 443     EXPECT_EQ(OC_STACK_OK, result);
 444
 445     RemoveUnknownDeviceFromDevList(g_unownedDevices);
 446
 447     int NumOfUnownDevice = 0;
 448     OCProvisionDev_t* tempDev = g_unownedDevices;
 449     while(tempDev)
 450     {
 451         NumOfUnownDevice++;
 452         tempDev = tempDev->next;
 453     }
 454
 455     //if two more devices are running on the subnet,
 456     //stop the unittest process in order to prevent unittest failure.
 457     if(2 < NumOfUnownDevice)
 458     {
 459         printf("%c[1;33;40m ******************************************************************\n", 0x1B);
 460         printf("%c[1;33;40m   [%d] devices are running on the your sub-network.\n", 0x1B, NumOfUnownDevice);
 461         printf("%c[1;33;40m   Please turn off the other devices, and then try once again.\n", 0x1B);
 462         printf("%c[1;33;40m ******************************************************************", 0x1B);
 463         printf("%c[1;0;40m \n", 0x1B);
 464
 465         OCStackResult result = OCStop();
 466         EXPECT_EQ(OC_STACK_OK, result);
 467
 468         PMDeleteDeviceList(g_unownedDevices);
 469         PMDeleteDeviceList(g_ownedDevices);
 470         result = PDMClose();
 471         EXPECT_EQ(OC_STACK_OK, result);
 472
 473         kill(g_myPID2, SIGKILL);
 474         kill(g_myPID1, SIGKILL);
 475
 476         int interpreter_res1 = system("pkill -f \"sample_server1\"");
 477         EXPECT_TRUE(0 <= interpreter_res1);
 478         int interpreter_res2 = system("pkill -f \"sample_server2\"");
 479         EXPECT_TRUE(0 <= interpreter_res2);
 480
 481         exit(0);
 482     }
 483
 484     EXPECT_EQ(2, NumOfUnownDevice);
 485 }
 486
 487 TEST(PerformJustWorksOxM, NullParam)
 488 {
 489     OCStackResult result = OC_STACK_ERROR;
 490
 491     OIC_LOG(INFO, TAG, "Try Ownership Transfer for Unowned Devices...\n");
 492     result = OCDoOwnershipTransfer((void*)g_otmCtx, g_unownedDevices, ownershipTransferCB);
 493     EXPECT_EQ(OC_STACK_OK, result);
 494
 495     if(waitCallbackRet())  // input |g_doneCB| flag implicitly
 496     {
 497         OIC_LOG(ERROR, TAG, "OCProvisionCredentials callback error");
 498         return;
 499     }
 500     OIC_LOG(INFO, TAG, "Registered Discovered Unowned Device...\n");
 501
 502     EXPECT_EQ(true, g_callbackResult);
 503     EXPECT_EQ(true, g_doneCB);
 504 }
 505
 506
 507 TEST(PerformOwnedDeviceDiscovery, NullParam)
 508 {
 509     OCStackResult result = OC_STACK_ERROR;
 510
 511     OIC_LOG(INFO, TAG, "Discovering Only Owned Devices on Network..\n");
 512     result = OCDiscoverOwnedDevices(DISCOVERY_TIMEOUT, &g_ownedDevices);
 513     EXPECT_EQ(OC_STACK_OK, result);
 514
 515     RemoveUnknownDeviceFromDevList(g_ownedDevices);
 516
 517     int NumOfOwnDevice = 0;
 518     OCProvisionDev_t* tempDev = g_ownedDevices;
 519     while(tempDev)
 520     {
 521         NumOfOwnDevice++;
 522         tempDev = tempDev->next;
 523     }
 524
 525     EXPECT_EQ(2 , NumOfOwnDevice);
 526 }
 527
 528 TEST(PerformLinkDevices, NullParam)
 529 {
 530     OicUuid_t myUuid;
 531     OCStackResult result = OC_STACK_ERROR;
 532     result = GetDoxmDeviceID(&myUuid);
 533     EXPECT_EQ(OC_STACK_OK, result);
 534
 535     //Extract target device except PT to perform link devices.
 536     OCProvisionDev_t* dev1 = NULL;
 537     OCProvisionDev_t* dev2 = NULL;
 538     OCProvisionDev_t* tempDev = g_ownedDevices;
 539
 540     while(tempDev)
 541     {
 542         if(memcmp(tempDev->doxm->deviceID.id, myUuid.id, UUID_LENGTH) != 0)
 543         {
 544             if(NULL == dev1)
 545             {
 546                 dev1 = tempDev;
 547             }
 548             else if(NULL == dev2)
 549             {
 550                 dev2 = tempDev;
 551                 break;
 552             }
 553             else
 554             {
 555                 break;
 556             }
 557         }
 558         tempDev = tempDev->next;
 559     }
 560     EXPECT_TRUE(NULL != dev1);
 561     EXPECT_TRUE(NULL != dev2);
 562
 563     // TODO: Pairwise provisioning (Cred & ACL)
 564     // TODO: This part will be updated after ACL and credential data-structure is updated.
 565
 566     EXPECT_EQ(OC_STACK_OK, result);
 567 }
 568
 569 TEST(PerformUnlinkDevices, NullParam)
 570 {
 571     OCStackResult result = OC_STACK_OK;
 572
 573     // TODO: Unlink devices
 574     // TODO: This part will be updated after ACL and credential data-structure is updated.
 575
 576     EXPECT_EQ(OC_STACK_OK, result);
 577 }
 578
 579 TEST(PerformRemoveDevice, NullParam)
 580 {
 581     OicUuid_t myUuid;
 582     OCStackResult result = OC_STACK_ERROR;
 583     result = GetDoxmDeviceID(&myUuid);
 584     EXPECT_EQ(OC_STACK_OK, result);
 585
 586     //Extract target device except PT to perform remove device.
 587     OCProvisionDev_t* removeDev = g_ownedDevices;
 588     while(removeDev)
 589     {
 590         if(memcmp(removeDev->doxm->deviceID.id, myUuid.id, UUID_LENGTH) != 0)
 591         {
 592             break;
 593         }
 594         removeDev = removeDev->next;
 595     }
 596     EXPECT_TRUE(NULL != removeDev);
 597
 598     g_doneCB = false;
 599     g_callbackResult = false;
 600
 601     result = OCRemoveDevice((void*)g_otmCtx, DISCOVERY_TIMEOUT, removeDev, removeDeviceCB);
 602     EXPECT_EQ(OC_STACK_OK, result);
 603     EXPECT_EQ(true, g_callbackResult);
 604     EXPECT_EQ(true, g_doneCB);
 605 }
 606
 607 TEST(FinalizeOTMTest, NullParam)
 608 {
 609     OCStackResult result = OCStop();
 610     EXPECT_EQ(OC_STACK_OK, result);
 611
 612     PMDeleteDeviceList(g_unownedDevices);
 613     PMDeleteDeviceList(g_ownedDevices);
 614     result = PDMClose();
 615     EXPECT_EQ(OC_STACK_OK, result);
 616
 617     kill(g_myPID2, SIGKILL);
 618     kill(g_myPID1, SIGKILL);
 619
 620     int interpreter_res1 = system("pkill -f \"sample_server1\"");
 621     EXPECT_TRUE(0 <= interpreter_res1);
 622     int interpreter_res2 = system("pkill -f \"sample_server2\"");
 623     EXPECT_TRUE(0 <= interpreter_res2);
 624 }
 625