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