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 #ifdef _ENABLE_MULTIPLE_OWNER_
  35 #include "multipleownershiptransfermanager.h"
  36 #endif //_ENABLE_MULTIPLE_OWNER_
  37 #include "srmutility.h"
  38 #include "doxmresource.h"
  39 #include "pmtypes.h"
  40 #include "pmutility.h"
  41
  42 using namespace std;
  43
  44 TEST(JustWorksOxMTest, NullParam)
  45 {
  46     OTMContext_t* otmCtx = NULL;
  47     OCStackResult res = OC_STACK_ERROR;
  48     uint8_t *payloadRes = NULL;
  49     size_t size = 0;
  50
  51     //LoadSecretJustWorksCallback always returns OC_STACK_OK.
  52     res = LoadSecretJustWorksCallback(otmCtx);
  53     EXPECT_TRUE(OC_STACK_OK == res);
  54
  55     res = CreateSecureSessionJustWorksCallback(otmCtx);
  56     EXPECT_TRUE(OC_STACK_INVALID_PARAM == res);
  57
  58     res = CreateJustWorksSelectOxmPayload(otmCtx, &payloadRes, &size);
  59     EXPECT_TRUE(OC_STACK_INVALID_PARAM == res);
  60
  61     res = CreateJustWorksOwnerTransferPayload(otmCtx, &payloadRes, &size);
  62     EXPECT_TRUE(OC_STACK_INVALID_PARAM == res);
  63
  64     OTMContext_t otmCtx2;
  65     otmCtx2.selectedDeviceInfo = NULL;
  66
  67     //LoadSecretJustWorksCallback always returns OC_STACK_OK.
  68     res = LoadSecretJustWorksCallback(&otmCtx2);
  69     EXPECT_TRUE(OC_STACK_OK == res);
  70
  71     res = CreateSecureSessionJustWorksCallback(&otmCtx2);
  72     EXPECT_TRUE(OC_STACK_INVALID_PARAM == res);
  73
  74     res = CreateJustWorksSelectOxmPayload(&otmCtx2, &payloadRes, &size);
  75     EXPECT_TRUE(OC_STACK_INVALID_PARAM == res);
  76
  77     res = CreateJustWorksOwnerTransferPayload(&otmCtx2, &payloadRes, &size);
  78     EXPECT_TRUE(OC_STACK_INVALID_PARAM == res);
  79 }
  80
  81 TEST(RandomPinOxMTest, NullParam)
  82 {
  83     OTMContext_t* otmCtx = NULL;
  84     OCStackResult res = OC_STACK_ERROR;
  85     uint8_t *payloadRes = NULL;
  86     size_t size = 0;
  87
  88     //LoadSecretJustWorksCallback always returns OC_STACK_OK.
  89     res = InputPinCodeCallback(otmCtx);
  90     EXPECT_TRUE(OC_STACK_INVALID_PARAM == res);
  91
  92     res = CreateSecureSessionRandomPinCallback(otmCtx);
  93     EXPECT_TRUE(OC_STACK_INVALID_PARAM == res);
  94
  95     res = CreatePinBasedSelectOxmPayload(otmCtx, &payloadRes, &size);
  96     EXPECT_TRUE(OC_STACK_INVALID_PARAM == res);
  97
  98     res = CreatePinBasedOwnerTransferPayload(otmCtx, &payloadRes, &size);
  99     EXPECT_TRUE(OC_STACK_INVALID_PARAM == res);
 100
 101     OTMContext_t otmCtx2;
 102     otmCtx2.selectedDeviceInfo = NULL;
 103
 104     //LoadSecretJustWorksCallback always returns OC_STACK_OK.
 105     res = InputPinCodeCallback(&otmCtx2);
 106     EXPECT_TRUE(OC_STACK_INVALID_PARAM == res);
 107
 108     res = CreateSecureSessionRandomPinCallback(&otmCtx2);
 109     EXPECT_TRUE(OC_STACK_INVALID_PARAM == res);
 110
 111     res = CreatePinBasedSelectOxmPayload(&otmCtx2, &payloadRes, &size);
 112     EXPECT_TRUE(OC_STACK_INVALID_PARAM == res);
 113
 114     res = CreatePinBasedOwnerTransferPayload(&otmCtx2, &payloadRes, &size);
 115     EXPECT_TRUE(OC_STACK_INVALID_PARAM == res);
 116 }
 117
 118
 119 /****************************************
 120  * Test the OTM modules with sample server
 121  ****************************************/
 122 #define TAG "JUSTWORKS_UNITTEST"
 123 #define OTM_TIMEOUT 5
 124 #define DISCOVERY_TIMEOUT 5
 125
 126 #define SVR_DB_PATH "oic_svr_db_client.dat"
 127 #define UT_PATH "resource/csdk/security/provisioning/unittest"
 128 char pdb_path[1024];
 129 char svr_path[1024];
 130
 131 static uint8_t DEFAULT_SVR_DB[] = {
 132     0xBF, 0x63, 0x61, 0x63, 0x6C, 0x59, 0x02, 0x79, 0xA4, 0x66, 0x61, 0x63, 0x6C, 0x69, 0x73, 0x74,
 133     0xA1, 0x64, 0x61, 0x63, 0x65, 0x73, 0x83, 0xA3, 0x6B, 0x73, 0x75, 0x62, 0x6A, 0x65, 0x63, 0x74,
 134     0x75, 0x75, 0x69, 0x64, 0x61, 0x2A, 0x69, 0x72, 0x65, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x73,
 135     0x83, 0xA4, 0x64, 0x68, 0x72, 0x65, 0x66, 0x68, 0x2F, 0x6F, 0x69, 0x63, 0x2F, 0x72, 0x65, 0x73,
 136     0x62, 0x72, 0x74, 0x81, 0x6A, 0x6F, 0x69, 0x63, 0x2E, 0x77, 0x6B, 0x2E, 0x72, 0x65, 0x73, 0x62,
 137     0x69, 0x66, 0x81, 0x69, 0x6F, 0x69, 0x63, 0x2E, 0x69, 0x66, 0x2E, 0x6C, 0x6C, 0x63, 0x72, 0x65,
 138     0x6C, 0x60, 0xA4, 0x64, 0x68, 0x72, 0x65, 0x66, 0x66, 0x2F, 0x6F, 0x69, 0x63, 0x2F, 0x64, 0x62,
 139     0x72, 0x74, 0x81, 0x68, 0x6F, 0x69, 0x63, 0x2E, 0x77, 0x6B, 0x2E, 0x64, 0x62, 0x69, 0x66, 0x82,
 140     0x6F, 0x6F, 0x69, 0x63, 0x2E, 0x69, 0x66, 0x2E, 0x62, 0x61, 0x73, 0x65, 0x6C, 0x69, 0x6E, 0x65,
 141     0x68, 0x6F, 0x69, 0x63, 0x2E, 0x69, 0x66, 0x2E, 0x72, 0x63, 0x72, 0x65, 0x6C, 0x60, 0xA4, 0x64,
 142     0x68, 0x72, 0x65, 0x66, 0x66, 0x2F, 0x6F, 0x69, 0x63, 0x2F, 0x70, 0x62, 0x72, 0x74, 0x81, 0x68,
 143     0x6F, 0x69, 0x63, 0x2E, 0x77, 0x6B, 0x2E, 0x70, 0x62, 0x69, 0x66, 0x82, 0x6F, 0x6F, 0x69, 0x63,
 144     0x2E, 0x69, 0x66, 0x2E, 0x62, 0x61, 0x73, 0x65, 0x6C, 0x69, 0x6E, 0x65, 0x68, 0x6F, 0x69, 0x63,
 145     0x2E, 0x69, 0x66, 0x2E, 0x72, 0x63, 0x72, 0x65, 0x6C, 0x60, 0x6A, 0x70, 0x65, 0x72, 0x6D, 0x69,
 146     0x73, 0x73, 0x69, 0x6F, 0x6E, 0x02, 0xA3, 0x6B, 0x73, 0x75, 0x62, 0x6A, 0x65, 0x63, 0x74, 0x75,
 147     0x75, 0x69, 0x64, 0x61, 0x2A, 0x69, 0x72, 0x65, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x73, 0x82,
 148     0xA4, 0x64, 0x68, 0x72, 0x65, 0x66, 0x6D, 0x2F, 0x6F, 0x69, 0x63, 0x2F, 0x73, 0x65, 0x63, 0x2F,
 149     0x64, 0x6F, 0x78, 0x6D, 0x62, 0x72, 0x74, 0x81, 0x6A, 0x6F, 0x69, 0x63, 0x2E, 0x72, 0x2E, 0x64,
 150     0x6F, 0x78, 0x6D, 0x62, 0x69, 0x66, 0x81, 0x6F, 0x6F, 0x69, 0x63, 0x2E, 0x69, 0x66, 0x2E, 0x62,
 151     0x61, 0x73, 0x65, 0x6C, 0x69, 0x6E, 0x65, 0x63, 0x72, 0x65, 0x6C, 0x60, 0xA4, 0x64, 0x68, 0x72,
 152     0x65, 0x66, 0x6E, 0x2F, 0x6F, 0x69, 0x63, 0x2F, 0x73, 0x65, 0x63, 0x2F, 0x70, 0x73, 0x74, 0x61,
 153     0x74, 0x62, 0x72, 0x74, 0x81, 0x6B, 0x6F, 0x69, 0x63, 0x2E, 0x72, 0x2E, 0x70, 0x73, 0x74, 0x61,
 154     0x74, 0x62, 0x69, 0x66, 0x81, 0x6F, 0x6F, 0x69, 0x63, 0x2E, 0x69, 0x66, 0x2E, 0x62, 0x61, 0x73,
 155     0x65, 0x6C, 0x69, 0x6E, 0x65, 0x63, 0x72, 0x65, 0x6C, 0x60, 0x6A, 0x70, 0x65, 0x72, 0x6D, 0x69,
 156     0x73, 0x73, 0x69, 0x6F, 0x6E, 0x02, 0xA3, 0x6B, 0x73, 0x75, 0x62, 0x6A, 0x65, 0x63, 0x74, 0x75,
 157     0x75, 0x69, 0x64, 0x61, 0x2A, 0x69, 0x72, 0x65, 0x73, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x73, 0x82,
 158     0xA4, 0x64, 0x68, 0x72, 0x65, 0x66, 0x6E, 0x2F, 0x6F, 0x69, 0x63, 0x2F, 0x73, 0x65, 0x63, 0x2F,
 159     0x70, 0x63, 0x6F, 0x6E, 0x66, 0x62, 0x72, 0x74, 0x81, 0x6B, 0x6F, 0x69, 0x63, 0x2E, 0x72, 0x2E,
 160     0x70, 0x63, 0x6F, 0x6E, 0x66, 0x62, 0x69, 0x66, 0x81, 0x6F, 0x6F, 0x69, 0x63, 0x2E, 0x69, 0x66,
 161     0x2E, 0x62, 0x61, 0x73, 0x65, 0x6C, 0x69, 0x6E, 0x65, 0x63, 0x72, 0x65, 0x6C, 0x60, 0xA4, 0x64,
 162     0x68, 0x72, 0x65, 0x66, 0x71, 0x2F, 0x6F, 0x69, 0x63, 0x2F, 0x73, 0x65, 0x63, 0x2F, 0x64, 0x70,
 163     0x61, 0x69, 0x72, 0x69, 0x6E, 0x67, 0x62, 0x72, 0x74, 0x81, 0x6E, 0x6F, 0x69, 0x63, 0x2E, 0x72,
 164     0x2E, 0x64, 0x70, 0x61, 0x69, 0x72, 0x69, 0x6E, 0x67, 0x62, 0x69, 0x66, 0x81, 0x6F, 0x6F, 0x69,
 165     0x63, 0x2E, 0x69, 0x66, 0x2E, 0x62, 0x61, 0x73, 0x65, 0x6C, 0x69, 0x6E, 0x65, 0x63, 0x72, 0x65,
 166     0x6C, 0x60, 0x6A, 0x70, 0x65, 0x72, 0x6D, 0x69, 0x73, 0x73, 0x69, 0x6F, 0x6E, 0x02, 0x6A, 0x72,
 167     0x6F, 0x77, 0x6E, 0x65, 0x72, 0x75, 0x75, 0x69, 0x64, 0x78, 0x24, 0x36, 0x31, 0x36, 0x34, 0x36,
 168     0x64, 0x36, 0x39, 0x2D, 0x36, 0x65, 0x34, 0x34, 0x2D, 0x36, 0x35, 0x37, 0x36, 0x2D, 0x36, 0x39,
 169     0x36, 0x33, 0x2D, 0x36, 0x35, 0x35, 0x35, 0x37, 0x35, 0x36, 0x39, 0x36, 0x34, 0x33, 0x30, 0x62,
 170     0x72, 0x74, 0x81, 0x69, 0x6F, 0x69, 0x63, 0x2E, 0x72, 0x2E, 0x61, 0x63, 0x6C, 0x62, 0x69, 0x66,
 171     0x81, 0x6F, 0x6F, 0x69, 0x63, 0x2E, 0x69, 0x66, 0x2E, 0x62, 0x61, 0x73, 0x65, 0x6C, 0x69, 0x6E,
 172     0x65, 0x65, 0x70, 0x73, 0x74, 0x61, 0x74, 0x58, 0x9D, 0xA9, 0x64, 0x69, 0x73, 0x6F, 0x70, 0xF5,
 173     0x6A, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x75, 0x75, 0x69, 0x64, 0x78, 0x24, 0x36, 0x31, 0x36,
 174     0x34, 0x36, 0x64, 0x36, 0x39, 0x2D, 0x36, 0x65, 0x34, 0x34, 0x2D, 0x36, 0x35, 0x37, 0x36, 0x2D,
 175     0x36, 0x39, 0x36, 0x33, 0x2D, 0x36, 0x35, 0x35, 0x35, 0x37, 0x35, 0x36, 0x39, 0x36, 0x34, 0x33,
 176     0x30, 0x62, 0x63, 0x6D, 0x00, 0x62, 0x74, 0x6D, 0x00, 0x62, 0x6F, 0x6D, 0x03, 0x62, 0x73, 0x6D,
 177     0x03, 0x6A, 0x72, 0x6F, 0x77, 0x6E, 0x65, 0x72, 0x75, 0x75, 0x69, 0x64, 0x78, 0x24, 0x36, 0x31,
 178     0x36, 0x34, 0x36, 0x64, 0x36, 0x39, 0x2D, 0x36, 0x65, 0x34, 0x34, 0x2D, 0x36, 0x35, 0x37, 0x36,
 179     0x2D, 0x36, 0x39, 0x36, 0x33, 0x2D, 0x36, 0x35, 0x35, 0x35, 0x37, 0x35, 0x36, 0x39, 0x36, 0x34,
 180     0x33, 0x30, 0x62, 0x72, 0x74, 0x81, 0x6B, 0x6F, 0x69, 0x63, 0x2E, 0x72, 0x2E, 0x70, 0x73, 0x74,
 181     0x61, 0x74, 0x62, 0x69, 0x66, 0x81, 0x6F, 0x6F, 0x69, 0x63, 0x2E, 0x69, 0x66, 0x2E, 0x62, 0x61,
 182     0x73, 0x65, 0x6C, 0x69, 0x6E, 0x65, 0x64, 0x64, 0x6F, 0x78, 0x6D, 0x58, 0xE8, 0xAA, 0x64, 0x6F,
 183     0x78, 0x6D, 0x73, 0x81, 0x00, 0x66, 0x6F, 0x78, 0x6D, 0x73, 0x65, 0x6C, 0x00, 0x63, 0x73, 0x63,
 184     0x74, 0x01, 0x65, 0x6F, 0x77, 0x6E, 0x65, 0x64, 0xF5, 0x6A, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65,
 185     0x75, 0x75, 0x69, 0x64, 0x78, 0x24, 0x36, 0x31, 0x36, 0x34, 0x36, 0x64, 0x36, 0x39, 0x2D, 0x36,
 186     0x65, 0x34, 0x34, 0x2D, 0x36, 0x35, 0x37, 0x36, 0x2D, 0x36, 0x39, 0x36, 0x33, 0x2D, 0x36, 0x35,
 187     0x35, 0x35, 0x37, 0x35, 0x36, 0x39, 0x36, 0x34, 0x33, 0x30, 0x6C, 0x64, 0x65, 0x76, 0x6F, 0x77,
 188     0x6E, 0x65, 0x72, 0x75, 0x75, 0x69, 0x64, 0x78, 0x24, 0x36, 0x31, 0x36, 0x34, 0x36, 0x64, 0x36,
 189     0x39, 0x2D, 0x36, 0x65, 0x34, 0x34, 0x2D, 0x36, 0x35, 0x37, 0x36, 0x2D, 0x36, 0x39, 0x36, 0x33,
 190     0x2D, 0x36, 0x35, 0x35, 0x35, 0x37, 0x35, 0x36, 0x39, 0x36, 0x34, 0x33, 0x30, 0x6A, 0x72, 0x6F,
 191     0x77, 0x6E, 0x65, 0x72, 0x75, 0x75, 0x69, 0x64, 0x78, 0x24, 0x36, 0x31, 0x36, 0x34, 0x36, 0x64,
 192     0x36, 0x39, 0x2D, 0x36, 0x65, 0x34, 0x34, 0x2D, 0x36, 0x35, 0x37, 0x36, 0x2D, 0x36, 0x39, 0x36,
 193     0x33, 0x2D, 0x36, 0x35, 0x35, 0x35, 0x37, 0x35, 0x36, 0x39, 0x36, 0x34, 0x33, 0x30, 0x72, 0x78,
 194     0x2E, 0x6F, 0x72, 0x67, 0x2E, 0x69, 0x6F, 0x74, 0x69, 0x76, 0x69, 0x74, 0x79, 0x2E, 0x64, 0x70,
 195     0x63, 0xF4, 0x62, 0x72, 0x74, 0x81, 0x6A, 0x6F, 0x69, 0x63, 0x2E, 0x72, 0x2E, 0x64, 0x6F, 0x78,
 196     0x6D, 0x62, 0x69, 0x66, 0x81, 0x6F, 0x6F, 0x69, 0x63, 0x2E, 0x69, 0x66, 0x2E, 0x62, 0x61, 0x73,
 197     0x65, 0x6C, 0x69, 0x6E, 0x65, 0xFF
 198 };
 199
 200 static bool g_doneCB;
 201 static bool g_callbackResult;
 202 static pid_t g_myPID1;
 203 static pid_t g_myPID2;
 204
 205 static const char* g_otmCtx = "Test User Context";
 206 static OCProvisionDev_t* g_unownedDevices = NULL;
 207 static OCProvisionDev_t* g_ownedDevices = NULL;
 208 #ifdef _ENABLE_MULTIPLE_OWNER_
 209 static OCProvisionDev_t* g_motEnabledDevices = NULL;
 210 static OCProvisionDev_t* g_multiplOwnedDevices = NULL;
 211 #endif //_ENABLE_MULTIPLE_OWNER_
 212
 213 static void GetCurrentWorkingDirectory(char* buf, size_t bufsize)
 214 {
 215     char cwd[1024] = {0};
 216     const char* unittest_path = "resource/csdk/security/provisioning/unittest";
 217     if(getcwd(cwd, sizeof(cwd)) != NULL)
 218     {
 219         if(strstr(cwd, unittest_path) == NULL)
 220         {
 221 #if defined __linux__
 222 #if __x86_64__
 223         snprintf(buf, bufsize, "%s/out/linux/x86_64/release/%s/", cwd, unittest_path);
 224         snprintf(buf, bufsize, "%s/out/linux/x86_64/release/%s/", cwd, unittest_path);
 225 #else
 226         snprintf(buf, bufsize, "%s/out/linux/x86/release/%s/", cwd, unittest_path);
 227         snprintf(buf, bufsize, "%s/out/linux/x86/release/%s/", cwd, unittest_path);
 228 #endif //__x86_64__
 229 #endif //defined __linux__
 230         }
 231         else
 232         {
 233             snprintf(buf, bufsize, "%s/", cwd);
 234         }
 235     }
 236 }
 237
 238 static FILE* fopen_prvnMng(const char* path, const char* mode)
 239 {
 240     (void)path;  // unused |path| parameter
 241
 242     // input |g_svr_db_fname| internally by force, not using |path| parameter
 243     // because |OCPersistentStorage::open| is called |OCPersistentStorage| internally
 244     // with its own |SVR_DB_FILE_NAME|
 245     char cwd[1024] = {0};
 246     char svr_db_path[1024] = {0};
 247     GetCurrentWorkingDirectory(cwd, sizeof(cwd));
 248     snprintf(svr_db_path, sizeof(svr_db_path), "%s%s", cwd, SVR_DB_PATH);
 249     return fopen(svr_db_path, mode);
 250 }
 251
 252 // callback function(s) for provisioning client using C-level provisioning API
 253 static void ownershipTransferCB(void* ctx, int UNUSED1, OCProvisionResult_t* UNUSED2, bool hasError)
 254 {
 255     (void)UNUSED1;
 256     (void)UNUSED2;
 257     (void)ctx;
 258
 259     if(!hasError)
 260     {
 261         OIC_LOG_V(INFO, TAG, "Ownership Transfer SUCCEEDED - ctx: %s", (char*) ctx);
 262     }
 263     else
 264     {
 265         OIC_LOG_V(ERROR, TAG, "Ownership Transfer FAILED - ctx: %s", (char*) ctx);
 266     }
 267     g_callbackResult = !hasError;
 268     g_doneCB = true;
 269 }
 270
 271 #ifdef _ENABLE_MULTIPLE_OWNER_
 272 static void updateDoxmForMOTCB(void* ctx, int nOfRes, OCProvisionResult_t* arr, bool hasError)
 273 {
 274     if(!hasError)
 275     {
 276         OIC_LOG_V(INFO, TAG, "POST 'doxm' SUCCEEDED - ctx: %s", (char*) ctx);
 277     }
 278     else
 279     {
 280         OIC_LOG_V(ERROR, TAG, "POST 'doxm'  FAILED - ctx: %s", (char*) ctx);
 281     }
 282     g_callbackResult = !hasError;
 283     g_doneCB = true;
 284 }
 285
 286 static void provisionPreconfiguredPinCB(void* ctx, int nOfRes, OCProvisionResult_t* arr, bool hasError)
 287 {
 288     if(!hasError)
 289     {
 290         OIC_LOG_V(INFO, TAG, "Provision Preconfigured-PIN SUCCEEDED - ctx: %s", (char*) ctx);
 291     }
 292     else
 293     {
 294         OIC_LOG_V(ERROR, TAG, "Provision Preconfigured-PIN FAILED - ctx: %s", (char*) ctx);
 295     }
 296     g_callbackResult = !hasError;
 297     g_doneCB = true;
 298 }
 299 #endif //_ENABLE_MULTIPLE_OWNER_
 300
 301 // callback function(s) for provisioning client using C-level provisioning API
 302 static void removeDeviceCB(void* ctx, int UNUSED1, OCProvisionResult_t* UNUSED2, bool hasError)
 303 {
 304     (void)UNUSED1;
 305     (void)UNUSED2;
 306     (void)ctx;
 307
 308     if(!hasError)
 309     {
 310         OIC_LOG_V(INFO, TAG, "Remove device request SUCCEEDED - ctx: %s", (char*) ctx);
 311     }
 312     else
 313     {
 314         OIC_LOG_V(ERROR, TAG, "Remove device request FAILED - ctx: %s", (char*) ctx);
 315     }
 316     g_callbackResult = !hasError;
 317     g_doneCB = true;
 318 }
 319
 320
 321 static int waitCallbackRet(void)
 322 {
 323     struct timespec timeout;
 324     timeout.tv_sec  = 0;
 325     timeout.tv_nsec = 100000000L;
 326
 327     for(long long i=0; !g_doneCB && OTM_TIMEOUT * 100000000L * 1000L > i; ++i)
 328     {
 329         nanosleep(&timeout, NULL);
 330         if(OC_STACK_OK != OCProcess())
 331         {
 332             OIC_LOG(ERROR, TAG, "OCStack process error");
 333             return -1;
 334         }
 335     }
 336
 337     return 0;
 338 }
 339
 340 static void RemoveUnknownDeviceFromDevList(OCProvisionDev_t* devList)
 341 {
 342     OicUuid_t uuid1;
 343     OicUuid_t uuid2;
 344     memset(uuid1.id, 0x11, sizeof(uuid1.id));
 345     memset(uuid2.id, 0x22, sizeof(uuid2.id));
 346
 347     OCProvisionDev_t* unknowDev = NULL;
 348     OCProvisionDev_t* tempDev1 = NULL;
 349     OCProvisionDev_t* tempDev2 =NULL;
 350     LL_FOREACH_SAFE(devList, tempDev1, tempDev2)
 351     {
 352
 353         if(!(memcmp(tempDev1->doxm->deviceID.id, uuid1.id, sizeof(uuid1.id)) == 0 ||
 354              memcmp(tempDev1->doxm->deviceID.id, uuid2.id, sizeof(uuid2.id)) == 0))
 355         {
 356             LL_DELETE(devList, tempDev1);
 357             LL_APPEND(unknowDev, tempDev1);
 358         }
 359     }
 360     OCDeleteDiscoveredDevices(unknowDev);
 361 }
 362
 363 TEST(InitForOTM, NullParam)
 364 {
 365     OCStackResult result = OC_STACK_ERROR;
 366
 367     OTMCallbackData_t otmcb;
 368     otmcb.loadSecretCB = LoadSecretJustWorksCallback;
 369     otmcb.createSecureSessionCB = CreateSecureSessionJustWorksCallback;
 370     otmcb.createSelectOxmPayloadCB = CreateJustWorksSelectOxmPayload;
 371     otmcb.createOwnerTransferPayloadCB = CreateJustWorksOwnerTransferPayload;
 372
 373     static OCPersistentStorage pstStr;
 374     pstStr.open = fopen_prvnMng;
 375     pstStr.read = fread;
 376     pstStr.write = fwrite;
 377     pstStr.close = fclose;
 378     pstStr.unlink = unlink;
 379
 380     //Get current path to execute the sample server.
 381     char cwd[1024] = {0};
 382     char server1_path[1024] = {0};
 383     char server2_path[1024] = {0};
 384     char pdb_path[1024] = {0};
 385     char del_cmd[1024] = {0};
 386     char svrdb_path[1024] = {0};
 387     FILE* fp = NULL;
 388
 389     GetCurrentWorkingDirectory(cwd, sizeof(cwd));
 390     EXPECT_TRUE(0 < strlen(cwd));
 391
 392     //Delete previous PDB, if exist.
 393     GetCurrentWorkingDirectory(cwd, sizeof(cwd));
 394     snprintf(del_cmd, sizeof(del_cmd), "rm -rf %stest.db", cwd);
 395     system(del_cmd);
 396
 397     //Delete previous SVR DB, if exist.
 398     snprintf(del_cmd, sizeof(del_cmd), "rm -rf %s%s", cwd, SVR_DB_PATH);
 399     system(del_cmd);
 400
 401     //Generate default SVR DB.
 402     snprintf(svrdb_path, sizeof(svrdb_path), "%s%s", cwd, SVR_DB_PATH);
 403     fp = fopen(svrdb_path, "w");
 404     if(NULL != fp)
 405     {
 406         size_t numberItems = fwrite(DEFAULT_SVR_DB, 1, sizeof(DEFAULT_SVR_DB), fp);
 407         fclose(fp);
 408         ASSERT_TRUE(sizeof(DEFAULT_SVR_DB) == numberItems);
 409     }
 410
 411     //Execute sample server to perform ownership transfer
 412     int status1 = 0;
 413     int status2 = 0;
 414     if(0 == (g_myPID1 = fork()))
 415     {
 416         snprintf(server1_path, sizeof(server1_path), "%ssample_server1", cwd);
 417         status1 = system(server1_path);
 418         (void)status1;
 419     }
 420     if(0 == (g_myPID2 = fork()))
 421     {
 422         snprintf(server2_path, sizeof(server2_path), "%ssample_server2", cwd);
 423         status2= system(server2_path);
 424         (void)status2;
 425     }
 426
 427     //Waiting for sample server initialization.
 428     sleep(3);
 429
 430     // register the persistent storage handler for SVR
 431     result = OCRegisterPersistentStorageHandler(&pstStr);
 432     EXPECT_EQ(OC_STACK_OK, result);
 433
 434     // initialize OC stack and provisioning manager
 435     result = OCInit(NULL, 0, OC_CLIENT_SERVER);
 436     EXPECT_EQ(OC_STACK_OK, result);
 437
 438     //initialize Provisioning DB Manager
 439
 440     snprintf(pdb_path, sizeof(pdb_path), "%stest.db", cwd);
 441     result = OCInitPM(pdb_path);
 442     EXPECT_EQ(OC_STACK_OK, result);
 443
 444     // register callback function(s) for Justworks OxM
 445     result = OCSetOwnerTransferCallbackData(OIC_JUST_WORKS, &otmcb);
 446     EXPECT_EQ(OC_STACK_OK, result);
 447
 448     g_doneCB = false;
 449     g_callbackResult = false;
 450 }
 451
 452 TEST(PerformSecureResourceDiscovery, NullParam)
 453 {
 454     OCStackResult result = OC_STACK_ERROR;
 455     OCProvisionDev_t* foundDevice = NULL;
 456
 457     OicUuid_t uuid;
 458     ConvertStrToUuid("11111111-1111-1111-1111-111111111111", &uuid);
 459
 460     OIC_LOG(INFO, TAG, "Discovering Owned/Unowned Device using multicast\n");
 461     result = OCDiscoverSingleDevice(DISCOVERY_TIMEOUT, &uuid, &foundDevice);
 462     EXPECT_EQ(OC_STACK_OK, result);
 463
 464     int NumOfFoundDevice = 0;
 465     OCProvisionDev_t* tempDev = foundDevice;
 466     while(tempDev)
 467     {
 468         NumOfFoundDevice++;
 469         tempDev = tempDev->next;
 470     }
 471     PMDeleteDeviceList(foundDevice);
 472
 473     EXPECT_EQ(true, NumOfFoundDevice > 0);
 474 }
 475
 476 TEST(PerformUnownedDeviceDiscovery, NullParam)
 477 {
 478     OCStackResult result = OC_STACK_ERROR;
 479
 480     OIC_LOG(INFO, TAG, "Discovering Only Unowned Devices on Network..\n");
 481     result = OCDiscoverUnownedDevices(DISCOVERY_TIMEOUT, &g_unownedDevices);
 482     EXPECT_EQ(OC_STACK_OK, result);
 483
 484     RemoveUnknownDeviceFromDevList(g_unownedDevices);
 485
 486     int NumOfUnownDevice = 0;
 487     OCProvisionDev_t* tempDev = g_unownedDevices;
 488     while(tempDev)
 489     {
 490         NumOfUnownDevice++;
 491         tempDev = tempDev->next;
 492     }
 493
 494     //if two more devices are running on the subnet,
 495     //stop the unittest process in order to prevent unittest failure.
 496     if(2 < NumOfUnownDevice)
 497     {
 498         printf("%c[1;33;40m ******************************************************************\n", 0x1B);
 499         printf("%c[1;33;40m   [%d] devices are running on the your sub-network.\n", 0x1B, NumOfUnownDevice);
 500         printf("%c[1;33;40m   Please turn off the other devices, and then try once again.\n", 0x1B);
 501         printf("%c[1;33;40m ******************************************************************", 0x1B);
 502         printf("%c[1;0;40m \n", 0x1B);
 503
 504         OCStackResult result = OCStop();
 505         EXPECT_EQ(OC_STACK_OK, result);
 506
 507         PMDeleteDeviceList(g_unownedDevices);
 508         PMDeleteDeviceList(g_ownedDevices);
 509         result = PDMClose();
 510         EXPECT_EQ(OC_STACK_OK, result);
 511
 512         kill(g_myPID2, SIGKILL);
 513         kill(g_myPID1, SIGKILL);
 514
 515         int interpreter_res1 = system("pkill -f \"sample_server1\"");
 516         EXPECT_TRUE(0 <= interpreter_res1);
 517         int interpreter_res2 = system("pkill -f \"sample_server2\"");
 518         EXPECT_TRUE(0 <= interpreter_res2);
 519
 520         exit(0);
 521     }
 522
 523     EXPECT_EQ(2, NumOfUnownDevice);
 524 }
 525
 526 TEST(PerformJustWorksOxM, NullParam)
 527 {
 528     OCStackResult result = OC_STACK_ERROR;
 529
 530     OIC_LOG(INFO, TAG, "Try Ownership Transfer for Unowned Devices...\n");
 531     result = OCDoOwnershipTransfer((void*)g_otmCtx, g_unownedDevices, ownershipTransferCB);
 532     EXPECT_EQ(OC_STACK_OK, result);
 533
 534     if(waitCallbackRet())  // input |g_doneCB| flag implicitly
 535     {
 536         OIC_LOG(ERROR, TAG, "OCProvisionCredentials callback error");
 537         return;
 538     }
 539     OIC_LOG(INFO, TAG, "Registered Discovered Unowned Device...\n");
 540
 541     EXPECT_EQ(true, g_callbackResult);
 542     EXPECT_EQ(true, g_doneCB);
 543 }
 544
 545
 546 TEST(PerformOwnedDeviceDiscovery, NullParam)
 547 {
 548     OCStackResult result = OC_STACK_ERROR;
 549
 550     OIC_LOG(INFO, TAG, "Discovering Only Owned Devices on Network..\n");
 551     result = OCDiscoverOwnedDevices(DISCOVERY_TIMEOUT, &g_ownedDevices);
 552     EXPECT_EQ(OC_STACK_OK, result);
 553
 554     RemoveUnknownDeviceFromDevList(g_ownedDevices);
 555
 556     int NumOfOwnDevice = 0;
 557     OCProvisionDev_t* tempDev = g_ownedDevices;
 558     while(tempDev)
 559     {
 560         NumOfOwnDevice++;
 561         tempDev = tempDev->next;
 562     }
 563
 564     EXPECT_EQ(2 , NumOfOwnDevice);
 565 }
 566
 567 TEST(PerformLinkDevices, NullParam)
 568 {
 569     OicUuid_t myUuid;
 570     OCStackResult result = OC_STACK_ERROR;
 571     result = GetDoxmDeviceID(&myUuid);
 572     EXPECT_EQ(OC_STACK_OK, result);
 573
 574     //Extract target device except PT to perform link devices.
 575     OCProvisionDev_t* dev1 = NULL;
 576     OCProvisionDev_t* dev2 = NULL;
 577     OCProvisionDev_t* tempDev = g_ownedDevices;
 578
 579     while(tempDev)
 580     {
 581         if(memcmp(tempDev->doxm->deviceID.id, myUuid.id, UUID_LENGTH) != 0)
 582         {
 583             if(NULL == dev1)
 584             {
 585                 dev1 = tempDev;
 586             }
 587             else if(NULL == dev2)
 588             {
 589                 dev2 = tempDev;
 590                 break;
 591             }
 592         }
 593         tempDev = tempDev->next;
 594     }
 595     EXPECT_TRUE(NULL != dev1);
 596     EXPECT_TRUE(NULL != dev2);
 597
 598     // TODO: Pairwise provisioning (Cred & ACL)
 599     // TODO: This part will be updated after ACL and credential data-structure is updated.
 600
 601     EXPECT_EQ(OC_STACK_OK, result);
 602 }
 603
 604 TEST(PerformUnlinkDevices, NullParam)
 605 {
 606     OCStackResult result = OC_STACK_OK;
 607
 608     // TODO: Unlink devices
 609     // TODO: This part will be updated after ACL and credential data-structure is updated.
 610
 611     EXPECT_EQ(OC_STACK_OK, result);
 612 }
 613
 614 #ifdef _ENABLE_MULTIPLE_OWNER_
 615 TEST(RegisterPreconfiguredPIN, NullParam)
 616 {
 617     OCStackResult result = SetPreconfigPin("12341234", strlen("12341234"));
 618     EXPECT_EQ(OC_STACK_OK, result);
 619 }
 620
 621 TEST(EnableMOT, NullParam)
 622 {
 623     OCStackResult result = OC_STACK_OK;
 624
 625     if(NULL == g_ownedDevices)
 626     {
 627         OIC_LOG(INFO, TAG, "Discovering Only Owned Devices on Network..\n");
 628         result = OCDiscoverOwnedDevices(DISCOVERY_TIMEOUT, &g_ownedDevices);
 629         EXPECT_EQ(OC_STACK_OK, result);
 630         RemoveUnknownDeviceFromDevList(g_ownedDevices);
 631     }
 632     EXPECT_NE((OCProvisionDev_t*)NULL, g_ownedDevices);
 633
 634     g_doneCB = false;
 635     result = MOTChangeMode(NULL, g_ownedDevices, OIC_MULTIPLE_OWNER_ENABLE, updateDoxmForMOTCB);
 636     EXPECT_EQ(OC_STACK_OK, result);
 637     if(waitCallbackRet())  // input |g_doneCB| flag implicitly
 638     {
 639         OIC_LOG(ERROR, TAG, "OCChangeMOTMode callback error");
 640         return;
 641     }
 642
 643     EXPECT_TRUE(g_callbackResult);
 644 }
 645
 646 TEST(DiscoverMOTEnabledDevices, NullParam)
 647 {
 648     OCStackResult result = OC_STACK_OK;
 649
 650     if(g_motEnabledDevices)
 651     {
 652         PMDeleteDeviceList(g_motEnabledDevices);
 653     }
 654
 655     OIC_LOG(INFO, TAG, "Discovering MOT Enabled Devices on Network..\n");
 656     result = OCDiscoverMultipleOwnerEnabledDevices(DISCOVERY_TIMEOUT, &g_motEnabledDevices);
 657     EXPECT_EQ(OC_STACK_OK, result);
 658     RemoveUnknownDeviceFromDevList(g_motEnabledDevices);
 659     EXPECT_NE((OCProvisionDev_t*)NULL, g_motEnabledDevices);
 660 }
 661
 662 TEST(ProvisonPreconfiguredPIN, NullParam)
 663 {
 664     OCStackResult result = OC_STACK_OK;
 665
 666     g_doneCB = false;
 667     result = OCProvisionPreconfPin(NULL, g_motEnabledDevices, "12341234", strlen("12341234"), provisionPreconfiguredPinCB);
 668     EXPECT_EQ(OC_STACK_OK, result);
 669     if(waitCallbackRet())  // input |g_doneCB| flag implicitly
 670     {
 671         OIC_LOG(ERROR, TAG, "OCProvisionPreconfPin callback error");
 672         return;
 673     }
 674
 675     EXPECT_EQ(true, g_callbackResult);
 676 }
 677
 678 TEST(SelectMOTMethod, NullParam)
 679 {
 680     OCStackResult result = OC_STACK_OK;
 681
 682     g_doneCB = false;
 683     result = MOTSelectMOTMethod(NULL, g_motEnabledDevices, OIC_PRECONFIG_PIN, updateDoxmForMOTCB);
 684     EXPECT_EQ(OC_STACK_OK, result);
 685     if(waitCallbackRet())  // input |g_doneCB| flag implicitly
 686     {
 687         OIC_LOG(ERROR, TAG, "OCSelectMOTMethod callback error");
 688         return;
 689     }
 690
 691     EXPECT_EQ(true, g_callbackResult);
 692 }
 693
 694 // TODO: Need to new server to perform MOT
 695 /*
 696 TEST(PerformMOT, NullParam)
 697 {
 698     OCStackResult result = OC_STACK_OK;
 699
 700     g_doneCB = false;
 701     result = OCDoMultipleOwnershipTransfer(NULL, g_motEnabledDevices, ownershipTransferCB);
 702     EXPECT_EQ(OC_STACK_OK, result);
 703     if(waitCallbackRet())  // input |g_doneCB| flag implicitly
 704     {
 705         OIC_LOG(ERROR, TAG, "OCDoMultipleOwnershipTransfer callback error");
 706         return;
 707     }
 708     EXPECT_EQ(true, g_callbackResult);
 709 }
 710
 711 TEST(DiscoverMultipleOwnedDevices, NullParam)
 712 {
 713     OCStackResult result = OC_STACK_OK;
 714
 715     if(g_multiplOwnedDevices)
 716     {
 717         PMDeleteDeviceList(g_multiplOwnedDevices);
 718     }
 719
 720     OIC_LOG(INFO, TAG, "Discovering MOT Enabled Devices on Network..\n");
 721     result = OCDiscoverMultipleOwnedDevices(DISCOVERY_TIMEOUT, &g_multiplOwnedDevices);
 722     EXPECT_EQ(OC_STACK_OK, result);
 723     RemoveUnknownDeviceFromDevList(g_multiplOwnedDevices);
 724     EXPECT_TRUE(NULL != g_multiplOwnedDevices);
 725 }*/
 726
 727 #endif //_ENABLE_MULTIPLE_OWNER_
 728
 729 TEST(PerformRemoveDevice, NullParam)
 730 {
 731     OicUuid_t myUuid;
 732     OCStackResult result = OC_STACK_ERROR;
 733     result = GetDoxmDeviceID(&myUuid);
 734     EXPECT_EQ(OC_STACK_OK, result);
 735
 736     //Extract target device except PT to perform remove device.
 737     OCProvisionDev_t* removeDev = g_ownedDevices;
 738     while(removeDev)
 739     {
 740         if(memcmp(removeDev->doxm->deviceID.id, myUuid.id, UUID_LENGTH) != 0)
 741         {
 742             break;
 743         }
 744         removeDev = removeDev->next;
 745     }
 746     EXPECT_TRUE(NULL != removeDev);
 747
 748     g_doneCB = false;
 749     g_callbackResult = false;
 750
 751     result = OCRemoveDevice((void*)g_otmCtx, DISCOVERY_TIMEOUT, removeDev, removeDeviceCB);
 752     EXPECT_EQ(OC_STACK_OK, result);
 753     EXPECT_EQ(true, g_callbackResult);
 754     EXPECT_EQ(true, g_doneCB);
 755 }
 756
 757 TEST(FinalizeOTMTest, NullParam)
 758 {
 759     OCStackResult result = OCStop();
 760     EXPECT_EQ(OC_STACK_OK, result);
 761
 762     PMDeleteDeviceList(g_unownedDevices);
 763     PMDeleteDeviceList(g_ownedDevices);
 764     result = PDMClose();
 765     EXPECT_EQ(OC_STACK_OK, result);
 766
 767     kill(g_myPID2, SIGKILL);
 768     kill(g_myPID1, SIGKILL);
 769
 770     int interpreter_res1 = system("pkill -f \"sample_server1\"");
 771     EXPECT_TRUE(0 <= interpreter_res1);
 772     int interpreter_res2 = system("pkill -f \"sample_server2\"");
 773     EXPECT_TRUE(0 <= interpreter_res2);
 774 }
 775