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