resource/csdk/connectivity/test/ca_api_unittest.cpp

   1 /* ****************************************************************
   2  *
   3  * Copyright 2014 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
  21 #include "platform_features.h"
  22 #include "gtest/gtest.h"
  23 #include "cainterface.h"
  24 #include "cautilinterface.h"
  25 #include "cacommon.h"
  26 #include "oic_string.h"
  27 #include "oic_malloc.h"
  28 #include "cafragmentation.h"
  29 #include "caleinterface.h"
  30
  31 #define CA_TRANSPORT_ADAPTER_SCOPE  1000
  32 #define CA_BLE_FIRST_SEGMENT_PAYLOAD_SIZE (((CA_DEFAULT_BLE_MTU_SIZE) - (CA_BLE_HEADER_SIZE)) \
  33                                            - (CA_BLE_LENGTH_HEADER_SIZE))
  34
  35
  36 class CATests : public testing::Test {
  37     protected:
  38     virtual void SetUp()
  39     {
  40         CAInitialize(CA_DEFAULT_ADAPTER);
  41     }
  42
  43     virtual void TearDown()
  44     {
  45         CATerminate();
  46     }
  47 };
  48
  49 void request_handler(CAEndpoint_t* object, CARequestInfo_t* requestInfo);
  50 void response_handler(CAEndpoint_t* object, CAResponseInfo_t* responseInfo);
  51 void error_handler(const CAEndpoint_t *object, const CAErrorInfo_t* errorInfo);
  52 void adapter_handler(CATransportAdapter_t adapter, bool enabled);
  53 void connection_handler(CATransportAdapter_t adapter, const char *remote_address, bool connected);
  54 CAResult_t checkSelectNetwork();
  55
  56 void request_handler(const CAEndpoint_t * /*object*/,
  57                      const CARequestInfo_t * /*requestInfo*/)
  58 {
  59
  60 }
  61
  62 void response_handler(const CAEndpoint_t * /*object*/,
  63                       const CAResponseInfo_t * /*responseInfo*/)
  64 {
  65
  66 }
  67
  68 void error_handler(const CAEndpoint_t *object, const CAErrorInfo_t* errorInfo)
  69 {
  70     if(!object || !errorInfo)
  71     {
  72         return;
  73     }
  74
  75     //error handling shall be added
  76     return;
  77 }
  78
  79 void adapter_handler(CATransportAdapter_t /*adapter*/,
  80                      bool /*enabled*/)
  81 {
  82 }
  83
  84 void connection_handler(const CAEndpoint_t * /*endpoint*/,
  85                         bool /*connected*/)
  86 {
  87 }
  88
  89 static char* addr = NULL;
  90 static CAEndpoint_t* tempRep = NULL;
  91 static CARequestInfo_t requestInfo;
  92 static CAInfo_t requestData;
  93 static CAInfo_t responseData;
  94 static CAResponseInfo_t responseInfo;
  95 static CAToken_t tempToken = NULL;
  96 static uint8_t tokenLength = CA_MAX_TOKEN_LEN;
  97 static const char ADDRESS[] = "10.11.12.13";
  98 static const uint16_t PORT = 4545;
  99
 100 static const char NORMAL_INFO_DATA[] =
 101                                     "{\"oc\":[{\"href\":\"%s\",\"prop\":{\"rt\":[\"core.led\"],"
 102                                      "\"if\":[\"oc.mi.def\"],\"obs\":1}}]}";
 103
 104 #ifdef __WITH_DTLS__
 105
 106 // Iotivity Device Identity.
 107 const unsigned char IDENTITY[] = ("1111111111111111");
 108
 109 // PSK between this device and peer device.
 110 const unsigned char RS_CLIENT_PSK[] = ("AAAAAAAAAAAAAAAA");
 111
 112 // Internal API. Invoked by CA stack to retrieve credentials from this module
 113 int32_t CAGetDtlsPskCredentials( CADtlsPskCredType_t type,
 114               const unsigned char *desc, size_t desc_len,
 115               unsigned char *result, size_t result_length)
 116 {
 117     printf("CAGetDtlsPskCredentials IN\n");
 118
 119     int32_t ret = -1;
 120
 121     if (NULL == result)
 122     {
 123         return ret;
 124     }
 125
 126     switch (type)
 127     {
 128         case CA_DTLS_PSK_HINT:
 129         case CA_DTLS_PSK_IDENTITY:
 130
 131             if (result_length < sizeof(IDENTITY))
 132             {
 133                 printf("ERROR : Wrong value for result for storing IDENTITY");
 134                 return ret;
 135             }
 136
 137             memcpy(result, IDENTITY, sizeof(IDENTITY));
 138             ret = sizeof(IDENTITY);
 139             break;
 140
 141         case CA_DTLS_PSK_KEY:
 142
 143             if ((desc_len == sizeof(IDENTITY)) &&
 144                 memcmp(desc, IDENTITY, sizeof(IDENTITY)) == 0)
 145             {
 146                 if (result_length < sizeof(RS_CLIENT_PSK))
 147                 {
 148                     printf("ERROR : Wrong value for result for storing RS_CLIENT_PSK");
 149                     return ret;
 150                 }
 151
 152                 memcpy(result, RS_CLIENT_PSK, sizeof(RS_CLIENT_PSK));
 153                 ret = sizeof(RS_CLIENT_PSK);
 154             }
 155             break;
 156
 157         default:
 158
 159             printf("Wrong value passed for PSK_CRED_TYPE.");
 160             ret = -1;
 161     }
 162
 163
 164     printf("CAGetDtlsPskCredentials OUT\n");
 165     return ret;
 166 }
 167 #endif  //__WITH_DTLS__
 168
 169 // CAInitialize TC
 170 TEST(InitializeTest, CAInitializeTest)
 171 {
 172     EXPECT_EQ(CA_STATUS_OK, CAInitialize(CA_DEFAULT_ADAPTER));
 173     CATerminate();
 174 }
 175
 176 //CATerminate TC
 177 TEST_F(CATests, TerminateTest)
 178 {
 179     CATerminate();
 180
 181     char* check = (char *) "terminate success";
 182     EXPECT_STREQ(check, "terminate success");
 183
 184     CAInitialize(CA_DEFAULT_ADAPTER);
 185 }
 186
 187 // CAStartListeningServer TC
 188 TEST_F(CATests, StartListeningServerTestWithNonSelect)
 189 {
 190     EXPECT_EQ(CA_STATUS_FAILED, CAStartListeningServer());
 191 }
 192
 193 // CAStartListeningServer TC
 194 TEST_F(CATests, StartListeningServerTest)
 195 {
 196     EXPECT_EQ(CA_STATUS_OK, CASelectNetwork(CA_ADAPTER_IP));
 197     EXPECT_EQ(CA_STATUS_OK, CAStartListeningServer());
 198 }
 199
 200 // CAStopListeningServer TC
 201 TEST_F(CATests, CAStopListeningServerTestWithNonSelect)
 202 {
 203     EXPECT_EQ(CA_STATUS_FAILED, CAStopListeningServer());
 204 }
 205
 206 // CAStopListeningServer TC
 207 TEST_F(CATests, CAStopListeningServerTest)
 208 {
 209     EXPECT_EQ(CA_STATUS_OK, CASelectNetwork(CA_ADAPTER_IP));
 210     EXPECT_EQ(CA_STATUS_OK, CAStopListeningServer());
 211 }
 212
 213 // CARegisterHandlerTest TC
 214 TEST_F(CATests, RegisterHandlerTest)
 215 {
 216     CARegisterHandler(request_handler, response_handler, error_handler);
 217     char* check = (char *) "registerHandler success";
 218     EXPECT_STREQ(check, "registerHandler success");
 219 }
 220
 221 // CACreateRemoteEndpoint TC
 222 TEST_F(CATests, CreateRemoteEndpointTestGood)
 223 {
 224     addr = (char *) ADDRESS;
 225
 226     EXPECT_EQ(CA_STATUS_OK, CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, addr,
 227                                              PORT, &tempRep));
 228
 229     CADestroyEndpoint(tempRep);
 230     tempRep = NULL;
 231 }
 232
 233 // check remoteEndpoint and values of remoteEndpoint
 234 TEST_F(CATests, CreateRemoteEndpointTestValues)
 235 {
 236     addr = (char *) ADDRESS;
 237
 238     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, addr, PORT, &tempRep);
 239
 240     EXPECT_TRUE(tempRep != NULL);
 241
 242     CADestroyEndpoint(tempRep);
 243     tempRep = NULL;
 244 }
 245
 246 // CAGerateToken TC
 247 TEST_F(CATests, GenerateTokenTestGood)
 248 {
 249     EXPECT_EQ(CA_STATUS_OK, CAGenerateToken(&tempToken, tokenLength));
 250
 251     CADestroyToken(tempToken);
 252 }
 253
 254 // check return value when CAGenerateToken is passed a NULL instead a valid pointer
 255 TEST_F(CATests, GenerateTokenTestBad)
 256 {
 257     EXPECT_EQ(CA_STATUS_INVALID_PARAM, CAGenerateToken(NULL, tokenLength));
 258 }
 259
 260 // CADestroyToken TC
 261 // check destroyed token
 262 TEST_F(CATests, DestroyTokenTest)
 263 {
 264     CAGenerateToken(&tempToken, tokenLength);
 265     CADestroyToken(tempToken);
 266
 267     char * check = (char *) "destroy success";
 268     EXPECT_STREQ(check, "destroy success");
 269 }
 270
 271 TEST_F(CATests, SendRequestTestWithInvalidAddress)
 272 {
 273     CARegisterHandler(request_handler, response_handler, error_handler);
 274
 275     EXPECT_EQ(CA_STATUS_OK, CASelectNetwork(CA_ADAPTER_IP));
 276     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "10.11.13.13.14", PORT, &tempRep);
 277
 278     memset(&requestData, 0, sizeof(CAInfo_t));
 279     CAGenerateToken(&tempToken, tokenLength);
 280     requestData.token = tempToken;
 281     requestData.tokenLength = tokenLength;
 282     requestData.type = CA_MSG_CONFIRM;
 283
 284     memset(&requestInfo, 0, sizeof(CARequestInfo_t));
 285     requestInfo.method = CA_GET;
 286     requestInfo.info = requestData;
 287
 288     EXPECT_EQ(CA_STATUS_OK, CASendRequest(tempRep, &requestInfo));
 289
 290     CADestroyToken(tempToken);
 291     CADestroyEndpoint(tempRep);
 292     free(requestData.payload);
 293     tempRep = NULL;
 294 }
 295
 296 // CASendRequest TC
 297 // check return value when a NULL is passed instead of a valid CARequestInfo_t address
 298 TEST_F(CATests, SendRequestTestWithNullAddr)
 299 {
 300     addr = (char *) ADDRESS;
 301     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, addr, PORT, &tempRep);
 302
 303     EXPECT_EQ(CA_STATUS_INVALID_PARAM, CASendRequest(tempRep, NULL));
 304
 305     CADestroyEndpoint(tempRep);
 306     tempRep = NULL;
 307 }
 308
 309 // CASendResponse TC
 310 TEST_F(CATests, SendResponseTestWithInvalidCode)
 311 {
 312     EXPECT_EQ(CA_STATUS_OK, CASelectNetwork(CA_ADAPTER_IP));
 313
 314     addr = (char *) ADDRESS;
 315     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, addr, PORT, &tempRep);
 316
 317     memset(&responseData, 0, sizeof(CAInfo_t));
 318     responseData.type = CA_MSG_RESET;
 319     responseData.messageId = 1;
 320     responseData.payload = (CAPayload_t)OICMalloc(sizeof("response payload"));
 321     responseData.dataType = CA_RESPONSE_DATA;
 322
 323     EXPECT_TRUE(responseData.payload != NULL);
 324
 325     if (responseData.payload)
 326     {
 327         CAGenerateToken(&tempToken, tokenLength);
 328         requestData.token = tempToken;
 329         requestData.tokenLength = tokenLength;
 330
 331         memset(&responseInfo, 0, sizeof(CAResponseInfo_t));
 332         responseInfo.result = CA_CONTENT;
 333         responseInfo.info = responseData;
 334
 335         EXPECT_EQ(CA_STATUS_OK, CASendResponse(tempRep, &responseInfo));
 336
 337         CADestroyToken(tempToken);
 338         CADestroyEndpoint(tempRep);
 339         OICFree(responseData.payload);
 340         tempRep = NULL;
 341     }
 342 }
 343
 344 // check return value NULL is passed instead of a valid CAResponseInfo_t address
 345 TEST_F(CATests, SendResponseTest)
 346 {
 347     addr = (char *) ADDRESS;
 348     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, addr, PORT, &tempRep);
 349
 350     EXPECT_EQ(CA_STATUS_INVALID_PARAM, CASendResponse(tempRep, NULL));
 351
 352     CADestroyEndpoint(tempRep);
 353     tempRep = NULL;
 354 }
 355
 356 // CASelectNewwork TC
 357 TEST_F(CATests, SelectNetworkTestGood)
 358 {
 359     EXPECT_EQ(CA_STATUS_OK, checkSelectNetwork());
 360 }
 361
 362 CAResult_t checkSelectNetwork()
 363 {
 364     CAResult_t res = CASelectNetwork(CA_ADAPTER_IP);
 365
 366     if (CA_STATUS_OK == res)
 367     {
 368         EXPECT_EQ(CA_STATUS_OK, CAUnSelectNetwork(CA_ADAPTER_IP));
 369         return CA_STATUS_OK;
 370     }
 371     if (CA_NOT_SUPPORTED == res)
 372     {
 373         EXPECT_EQ(CA_STATUS_FAILED, CAUnSelectNetwork(CA_ADAPTER_IP));
 374         return CA_STATUS_OK;
 375     }
 376
 377     return res;
 378 }
 379
 380 // check return value when selected network is disable
 381 TEST_F(CATests, SelectNetworkTestBad)
 382 {
 383     //Select disable network
 384     EXPECT_EQ(CA_NOT_SUPPORTED, CASelectNetwork((CATransportAdapter_t)
 385                                                 CA_TRANSPORT_ADAPTER_SCOPE));
 386 }
 387
 388 // check return value when selected network is disable
 389 TEST_F(CATests, UnSelectNetworkTest)
 390 {
 391     //UnSelect disable network
 392     EXPECT_EQ(CA_STATUS_FAILED, CAUnSelectNetwork((CATransportAdapter_t)
 393                                                   CA_TRANSPORT_ADAPTER_SCOPE));
 394 }
 395
 396 // CAHandlerRequestResponse TC
 397 TEST_F(CATests, HandlerRequestResponseTest)
 398 {
 399     EXPECT_EQ(CA_STATUS_OK, CAHandleRequestResponse());
 400 }
 401
 402 // CAGetNetworkInformation TC
 403 TEST_F (CATests, GetNetworkInformationTest)
 404 {
 405     size_t tempSize = 0;
 406     CAEndpoint_t *tempInfo = NULL;
 407
 408     EXPECT_EQ(CA_STATUS_OK, CASelectNetwork(CA_ADAPTER_IP));
 409     EXPECT_EQ(CA_STATUS_OK, CAGetNetworkInformation(&tempInfo, &tempSize));
 410
 411 // @todo: if this api is supported on windows platform, it should be changed.
 412 #if !defined(_WIN32)
 413     for (size_t index = 0; index < tempSize; index++)
 414     {
 415         EXPECT_TRUE(tempInfo[index].adapter != 0);
 416         EXPECT_TRUE(strlen(tempInfo[index].addr) != 0);
 417     }
 418 #endif
 419
 420     free(tempInfo);
 421 }
 422
 423 TEST_F(CATests, GetSelectecNetwork)
 424 {
 425     CATransportAdapter_t SelectedNetwork = CA_DEFAULT_ADAPTER;
 426
 427 #ifdef IP_ADAPTER
 428     SelectedNetwork = (CATransportAdapter_t)(SelectedNetwork | CA_ADAPTER_IP) ;
 429     EXPECT_EQ(CA_STATUS_OK, CASelectNetwork(CA_ADAPTER_IP));
 430     EXPECT_EQ(SelectedNetwork, CAGetSelectedNetwork());
 431 #endif
 432 #ifdef LE_ADAPTER
 433     SelectedNetwork = (CATransportAdapter_t)(SelectedNetwork | CA_ADAPTER_GATT_BTLE);
 434     EXPECT_EQ(CA_STATUS_OK, CASelectNetwork(CA_ADAPTER_GATT_BTLE));
 435     EXPECT_EQ(SelectedNetwork, CAGetSelectedNetwork());
 436 #endif
 437 #ifdef EDR_ADAPTER
 438     SelectedNetwork = (CATransportAdapter_t)(SelectedNetwork | CA_ADAPTER_RFCOMM_BTEDR);
 439     EXPECT_EQ(CA_STATUS_OK, CASelectNetwork(CA_ADAPTER_RFCOMM_BTEDR));
 440     EXPECT_EQ(SelectedNetwork, CAGetSelectedNetwork());
 441 #endif
 442 #ifdef TCP_ADAPTER
 443     SelectedNetwork = (CATransportAdapter_t)(SelectedNetwork | CA_ADAPTER_TCP);
 444     EXPECT_EQ(CA_STATUS_OK, CASelectNetwork(CA_ADAPTER_TCP));
 445     EXPECT_EQ(SelectedNetwork, CAGetSelectedNetwork());
 446 #endif
 447 #ifdef NFC_ADAPTER
 448     SelectedNetwork = (CATransportAdapter_t)(SelectedNetwork | CA_ADAPTER_NFC);
 449     EXPECT_EQ(CA_STATUS_OK, CASelectNetwork(CA_ADAPTER_NFC));
 450     EXPECT_EQ(SelectedNetwork, CAGetSelectedNetwork());
 451 #endif
 452
 453 #ifdef IP_ADAPTER
 454     SelectedNetwork = (CATransportAdapter_t)(SelectedNetwork & ~CA_ADAPTER_IP) ;
 455     EXPECT_EQ(CA_STATUS_OK, CAUnSelectNetwork(CA_ADAPTER_IP));
 456     EXPECT_EQ(SelectedNetwork, CAGetSelectedNetwork());
 457 #endif
 458 #ifdef LE_ADAPTER
 459     SelectedNetwork = (CATransportAdapter_t)(SelectedNetwork & ~CA_ADAPTER_GATT_BTLE);
 460     EXPECT_EQ(CA_STATUS_OK, CAUnSelectNetwork(CA_ADAPTER_GATT_BTLE));
 461     EXPECT_EQ(SelectedNetwork, CAGetSelectedNetwork());
 462 #endif
 463 #ifdef EDR_ADAPTER
 464     SelectedNetwork = (CATransportAdapter_t)(SelectedNetwork & ~CA_ADAPTER_RFCOMM_BTEDR);
 465     EXPECT_EQ(CA_STATUS_OK, CAUnSelectNetwork(CA_ADAPTER_RFCOMM_BTEDR));
 466     EXPECT_EQ(SelectedNetwork, CAGetSelectedNetwork());
 467 #endif
 468 #ifdef TCP_ADAPTER
 469     SelectedNetwork = (CATransportAdapter_t)(SelectedNetwork & ~CA_ADAPTER_TCP);
 470     EXPECT_EQ(CA_STATUS_OK, CAUnSelectNetwork(CA_ADAPTER_TCP));
 471     EXPECT_EQ(SelectedNetwork, CAGetSelectedNetwork());
 472 #endif
 473 #ifdef NFC_ADAPTER
 474     SelectedNetwork = (CATransportAdapter_t)(SelectedNetwork & ~CA_ADAPTER_NFC);
 475     EXPECT_EQ(CA_STATUS_OK, CAUnSelectNetwork(CA_ADAPTER_NFC));
 476     EXPECT_EQ(SelectedNetwork, CAGetSelectedNetwork());
 477 #endif
 478 }
 479
 480 TEST_F(CATests, RegisterDTLSCredentialsHandlerTest)
 481 {
 482 #ifdef __WITH_DTLS__
 483     EXPECT_EQ(CA_STATUS_OK, CAregisterPskCredentialsHandler(CAGetDtlsPskCredentials));
 484 #endif
 485 }
 486
 487 // CARegisterNetworkMonitorHandler TC
 488 TEST_F(CATests, RegisterNetworkMonitorHandler)
 489 {
 490     EXPECT_EQ(CA_STATUS_OK, CARegisterNetworkMonitorHandler(adapter_handler,
 491                                                             connection_handler));
 492 }
 493
 494 // CASetAutoConnectionDeviceInfo TC
 495 TEST_F(CATests, SetAutoConnectionDeviceInfo)
 496 {
 497     addr = (char *) ADDRESS;
 498
 499 #if defined(__ANDROID__) && defined(LE_ADAPTER)
 500     EXPECT_EQ(CA_STATUS_OK, CASetAutoConnectionDeviceInfo(addr));
 501 #else
 502     EXPECT_EQ(CA_NOT_SUPPORTED, CASetAutoConnectionDeviceInfo(addr));
 503 #endif
 504 }
 505
 506 // CAUnsetAutoConnectionDeviceInfo TC
 507 TEST_F(CATests, UnsetAutoConnectionDeviceInfo)
 508 {
 509     addr = (char *) ADDRESS;
 510
 511 #if defined(__ANDROID__) && defined(LE_ADAPTER)
 512     EXPECT_EQ(CA_STATUS_OK, CAUnsetAutoConnectionDeviceInfo(addr));
 513 #else
 514     EXPECT_EQ(CA_NOT_SUPPORTED, CAUnsetAutoConnectionDeviceInfo(addr));
 515 #endif
 516 }
 517
 518 TEST(CASetPortNumberTest, CASetPortNumberToAssign)
 519 {
 520     EXPECT_EQ(CA_STATUS_OK, CASetPortNumberToAssign(CA_ADAPTER_IP, CA_IPV4, 5683));
 521     EXPECT_EQ(CA_STATUS_OK, CASetPortNumberToAssign(CA_ADAPTER_IP, CA_IPV6, 5683));
 522     EXPECT_EQ(CA_STATUS_OK,
 523               CASetPortNumberToAssign(CA_ADAPTER_IP,
 524                                       static_cast<CATransportFlags_t>(CA_IPV4|CA_SECURE), 5683));
 525     EXPECT_EQ(CA_STATUS_OK,
 526               CASetPortNumberToAssign(CA_ADAPTER_IP,
 527                                       static_cast<CATransportFlags_t>(CA_IPV6|CA_SECURE), 5683));
 528
 529 #ifdef TCP_ADAPTER
 530     EXPECT_EQ(CA_STATUS_OK, CASetPortNumberToAssign(CA_ADAPTER_TCP, CA_IPV4, 5683));
 531     EXPECT_EQ(CA_STATUS_OK, CASetPortNumberToAssign(CA_ADAPTER_TCP, CA_IPV6, 5683));
 532 #endif
 533 }
 534
 535 TEST(CAGetPortNumberTest, CAGetPortNumberToAssign)
 536 {
 537     ASSERT_EQ(static_cast<uint16_t>(0),
 538               CAGetAssignedPortNumber(CA_ADAPTER_IP, CA_IPV4));
 539     ASSERT_EQ(static_cast<uint16_t>(0),
 540               CAGetAssignedPortNumber(CA_ADAPTER_IP, CA_IPV6));
 541     ASSERT_EQ(static_cast<uint16_t>(0),
 542               CAGetAssignedPortNumber(CA_ADAPTER_IP,
 543                                       static_cast<CATransportFlags_t>(CA_IPV4|CA_SECURE)));
 544     ASSERT_EQ(static_cast<uint16_t>(0),
 545               CAGetAssignedPortNumber(CA_ADAPTER_IP,
 546                                       static_cast<CATransportFlags_t>(CA_IPV6|CA_SECURE)));
 547 #ifdef TCP_ADAPTER
 548     ASSERT_EQ(static_cast<uint16_t>(0), CAGetAssignedPortNumber(CA_ADAPTER_TCP, CA_IPV4));
 549     ASSERT_EQ(static_cast<uint16_t>(0), CAGetAssignedPortNumber(CA_ADAPTER_TCP, CA_IPV6));
 550 #endif
 551 }
 552
 553 TEST(CAfragmentationTest, FragmentTest)
 554 {
 555 #if defined(LE_ADAPTER)
 556     const size_t dataLen = 30;
 557     uint8_t *data = (uint8_t *) malloc(dataLen*sizeof(uint8_t));
 558     memset(data, 'a', dataLen);
 559
 560     uint32_t midPacketCount = 0;
 561     size_t remainingLen = 0;
 562     size_t totalLength = 0;
 563
 564     EXPECT_EQ(CA_STATUS_OK, CAGenerateVariableForFragmentation(dataLen,
 565                                                                &midPacketCount,
 566                                                                &remainingLen,
 567                                                                &totalLength,
 568                                                                CA_DEFAULT_BLE_MTU_SIZE));
 569
 570     uint8_t dataHeader[CA_BLE_HEADER_SIZE] = {0};
 571     const uint8_t tmpSourcePort = 1;
 572     const uint8_t tmpDestPort = 1;
 573
 574     EXPECT_EQ(CA_STATUS_OK, CAGenerateHeader(dataHeader,
 575                                              CA_BLE_PACKET_START,
 576                                              tmpSourcePort,
 577                                              CA_BLE_PACKET_NON_SECURE,
 578                                              tmpDestPort));
 579     EXPECT_TRUE(dataHeader != NULL);
 580
 581     uint8_t lengthHeader[CA_BLE_LENGTH_HEADER_SIZE] = {0};
 582
 583     EXPECT_EQ(CA_STATUS_OK, CAGenerateHeaderPayloadLength(lengthHeader,
 584                                                           CA_BLE_LENGTH_HEADER_SIZE,
 585                                                           dataLen));
 586     EXPECT_TRUE(lengthHeader != NULL);
 587
 588     uint8_t dataSegment[CA_SUPPORTED_BLE_MTU_SIZE] = {0};
 589
 590     EXPECT_EQ(CA_STATUS_OK, CAMakeFirstDataSegment(dataSegment,
 591                                                    data,
 592                                                    CA_BLE_FIRST_SEGMENT_PAYLOAD_SIZE,
 593                                                    dataHeader,
 594                                                    lengthHeader));
 595     EXPECT_TRUE(dataSegment != NULL);
 596
 597     EXPECT_EQ(CA_STATUS_OK, CAGenerateHeader(dataHeader,
 598                                              CA_BLE_PACKET_NOT_START,
 599                                              tmpSourcePort,
 600                                              CA_BLE_PACKET_NON_SECURE,
 601                                              tmpDestPort));
 602     EXPECT_TRUE(dataHeader != NULL);
 603
 604     EXPECT_EQ(CA_STATUS_OK, CAMakeRemainDataSegment(dataSegment,
 605                                                     remainingLen,
 606                                                     data,
 607                                                     dataLen,
 608                                                     0,
 609                                                     dataHeader,
 610                                                     CA_DEFAULT_BLE_MTU_SIZE));
 611     EXPECT_TRUE(dataSegment != NULL);
 612
 613     free(data);
 614 #endif
 615 }
 616
 617 TEST(CAfragmentationTest, DefragmentTest)
 618 {
 619 #if defined(LE_ADAPTER)
 620     const size_t dataLen = 30;
 621     uint8_t *data = (uint8_t *) malloc(dataLen*sizeof(uint8_t));
 622     memset(data, 'a', dataLen);
 623
 624     uint32_t midPacketCount = 0;
 625     size_t remainingLen = 0;
 626     size_t totalLength = 0;
 627
 628     EXPECT_EQ(CA_STATUS_OK, CAGenerateVariableForFragmentation(dataLen,
 629                                                                &midPacketCount,
 630                                                                &remainingLen,
 631                                                                &totalLength,
 632                                                                CA_SUPPORTED_BLE_MTU_SIZE));
 633
 634     uint8_t dataHeader[CA_BLE_HEADER_SIZE] = {0};
 635     const uint8_t tmpSourcePort = 1;
 636     const uint8_t tmpDestPort = 1;
 637
 638     EXPECT_EQ(CA_STATUS_OK, CAGenerateHeader(dataHeader,
 639                                              CA_BLE_PACKET_START,
 640                                              tmpSourcePort,
 641                                              CA_BLE_PACKET_NON_SECURE,
 642                                              tmpDestPort));
 643     EXPECT_TRUE(dataHeader != NULL);
 644
 645     uint8_t lengthHeader[CA_BLE_LENGTH_HEADER_SIZE] = {0};
 646
 647     EXPECT_EQ(CA_STATUS_OK, CAGenerateHeaderPayloadLength(lengthHeader,
 648                                                           CA_BLE_LENGTH_HEADER_SIZE,
 649                                                           dataLen));
 650     EXPECT_TRUE(lengthHeader != NULL);
 651
 652     uint8_t dataSegment[CA_SUPPORTED_BLE_MTU_SIZE] = {0};
 653
 654     EXPECT_EQ(CA_STATUS_OK, CAMakeFirstDataSegment(dataSegment,
 655                                                    data,
 656                                                    CA_BLE_FIRST_SEGMENT_PAYLOAD_SIZE,
 657                                                    dataHeader,
 658                                                    lengthHeader));
 659     EXPECT_TRUE(dataSegment != NULL);
 660
 661     CABLEPacketStart_t startFlag = CA_BLE_PACKET_NOT_START;
 662     CABLEPacketSecure_t secureFlag = CA_BLE_PACKET_NON_SECURE;
 663     uint16_t sourcePort = 0;
 664     uint16_t destPort = 0;
 665
 666     EXPECT_EQ(CA_STATUS_OK, CAParseHeader(dataSegment,
 667                                           &startFlag,
 668                                           &sourcePort,
 669                                           &secureFlag,
 670                                           &destPort));
 671
 672     uint32_t parseDataLength = 0;
 673
 674     EXPECT_EQ(CA_STATUS_OK, CAParseHeaderPayloadLength(dataSegment,
 675                                                        CA_BLE_LENGTH_HEADER_SIZE,
 676                                                        &parseDataLength));
 677
 678     free(data);
 679 #endif
 680 }
 681
 682 TEST(Ipv6ScopeLevel, getMulticastScope)
 683 {
 684
 685     const char interfaceLocalStart[] = "ff01::";
 686     const char linkLocalStart[]      = "ff02::";
 687     const char realmLocalStart[]     = "ff03::";
 688     const char adminLocalStart[]     = "ff04::";
 689     const char siteLocalStart[]      = "ff05::";
 690     const char orgLocalStart[]       = "ff08::";
 691     const char globalStart[]         = "ff0e::";
 692
 693     const char interfaceLocalMid[] = "ff81:0000:0000:f000:0000:0000:0000:0000";
 694     const char linkLocalMid[]      = "ff82:0000:0000:f000:0000:0000:0000:0000";
 695     const char realmLocalMid[]     = "ff83:0000:0000:f000:0000:0000:0000:0000";
 696     const char adminLocalMid[]     = "ff84:0000:0000:f000:0000:0000:0000:0000";
 697     const char siteLocalMid[]      = "ff85:0000:0000:f000:0000:0000:0000:0000";
 698     const char orgLocalMid[]       = "ff88:0000:0000:f000:0000:0000:0000:0000";
 699     const char globalMid[]         = "ff8e:0000:0000:f000:0000:0000:0000:0000";
 700
 701     const char interfaceLocalEnd[] = "fff1:ffff:ffff:ffff:ffff:ffff:ffff:ffff";
 702     const char linkLocalEnd[]      = "fff2:ffff:ffff:ffff:ffff:ffff:ffff:ffff";
 703     const char realmLocalEnd[]     = "fff3:ffff:ffff:ffff:ffff:ffff:ffff:ffff";
 704     const char adminLocalEnd[]     = "fff4:ffff:ffff:ffff:ffff:ffff:ffff:ffff";
 705     const char siteLocalEnd[]      = "fff5:ffff:ffff:ffff:ffff:ffff:ffff:ffff";
 706     const char orgLocalEnd[]       = "fff8:ffff:ffff:ffff:ffff:ffff:ffff:ffff";
 707     const char globalEnd[]         = "fffe:ffff:ffff:ffff:ffff:ffff:ffff:ffff";
 708
 709     // range start
 710     CATransportFlags_t scopeLevel = CA_DEFAULT_FLAGS;
 711     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(interfaceLocalStart, &scopeLevel));
 712     EXPECT_EQ(CA_SCOPE_INTERFACE, scopeLevel);
 713     scopeLevel = CA_DEFAULT_FLAGS;
 714
 715     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(linkLocalStart, &scopeLevel));
 716     EXPECT_EQ(CA_SCOPE_LINK, scopeLevel);
 717     scopeLevel = CA_DEFAULT_FLAGS;
 718
 719     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(realmLocalStart, &scopeLevel));
 720     EXPECT_EQ(CA_SCOPE_REALM, scopeLevel);
 721     scopeLevel = CA_DEFAULT_FLAGS;
 722
 723     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(adminLocalStart, &scopeLevel));
 724     EXPECT_EQ(CA_SCOPE_ADMIN, scopeLevel);
 725     scopeLevel = CA_DEFAULT_FLAGS;
 726
 727     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(siteLocalStart, &scopeLevel));
 728     EXPECT_EQ(CA_SCOPE_SITE, scopeLevel);
 729     scopeLevel = CA_DEFAULT_FLAGS;
 730
 731     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(orgLocalStart, &scopeLevel));
 732     EXPECT_EQ(CA_SCOPE_ORG, scopeLevel);
 733     scopeLevel = CA_DEFAULT_FLAGS;
 734
 735     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(globalStart, &scopeLevel));
 736     EXPECT_EQ(CA_SCOPE_GLOBAL, scopeLevel);
 737     scopeLevel = CA_DEFAULT_FLAGS;
 738
 739     // range mid
 740     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(interfaceLocalMid, &scopeLevel));
 741     EXPECT_EQ(CA_SCOPE_INTERFACE, scopeLevel);
 742     scopeLevel = CA_DEFAULT_FLAGS;
 743
 744     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(linkLocalMid, &scopeLevel));
 745     EXPECT_EQ(CA_SCOPE_LINK, scopeLevel);
 746     scopeLevel = CA_DEFAULT_FLAGS;
 747
 748     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(realmLocalMid, &scopeLevel));
 749     EXPECT_EQ(CA_SCOPE_REALM, scopeLevel);
 750     scopeLevel = CA_DEFAULT_FLAGS;
 751
 752     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(adminLocalMid, &scopeLevel));
 753     EXPECT_EQ(CA_SCOPE_ADMIN, scopeLevel);
 754     scopeLevel = CA_DEFAULT_FLAGS;
 755
 756     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(siteLocalMid, &scopeLevel));
 757     EXPECT_EQ(CA_SCOPE_SITE, scopeLevel);
 758     scopeLevel = CA_DEFAULT_FLAGS;
 759
 760     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(orgLocalMid, &scopeLevel));
 761     EXPECT_EQ(CA_SCOPE_ORG, scopeLevel);
 762     scopeLevel = CA_DEFAULT_FLAGS;
 763
 764     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(globalMid, &scopeLevel));
 765     EXPECT_EQ(CA_SCOPE_GLOBAL, scopeLevel);
 766     scopeLevel = CA_DEFAULT_FLAGS;
 767
 768     // range end
 769     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(interfaceLocalEnd, &scopeLevel));
 770     EXPECT_EQ(CA_SCOPE_INTERFACE, scopeLevel);
 771     scopeLevel = CA_DEFAULT_FLAGS;
 772
 773     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(linkLocalEnd, &scopeLevel));
 774     EXPECT_EQ(CA_SCOPE_LINK, scopeLevel);
 775     scopeLevel = CA_DEFAULT_FLAGS;
 776
 777     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(realmLocalEnd, &scopeLevel));
 778     EXPECT_EQ(CA_SCOPE_REALM, scopeLevel);
 779     scopeLevel = CA_DEFAULT_FLAGS;
 780
 781     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(adminLocalEnd, &scopeLevel));
 782     EXPECT_EQ(CA_SCOPE_ADMIN, scopeLevel);
 783     scopeLevel = CA_DEFAULT_FLAGS;
 784
 785     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(siteLocalEnd, &scopeLevel));
 786     EXPECT_EQ(CA_SCOPE_SITE, scopeLevel);
 787     scopeLevel = CA_DEFAULT_FLAGS;
 788
 789     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(orgLocalEnd, &scopeLevel));
 790     EXPECT_EQ(CA_SCOPE_ORG, scopeLevel);
 791     scopeLevel = CA_DEFAULT_FLAGS;
 792
 793     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(globalEnd, &scopeLevel));
 794     EXPECT_EQ(CA_SCOPE_GLOBAL, scopeLevel);
 795     scopeLevel = CA_DEFAULT_FLAGS;
 796 }
 797
 798 TEST(Ipv6ScopeLevel, getUnicastScope)
 799 {
 800     const char linkLocalLoopBack[]  = "::1";
 801
 802     const char linkLocalStart[]     = "fe80::";
 803     const char linkLocalMid[]       = "fe80:0000:0000:0000:0f00:0000:0000:0000";
 804     const char linkLocalEnd[]       = "febf:ffff:ffff:ffff:ffff:ffff:ffff:ffff";
 805
 806     const char siteLocalStart[]     = "fec0::";
 807     const char siteLocalMid[]       = "fec0:0000:0000:0000:0f00:0000:0000:0000";
 808     const char siteLocalEnd[]       = "feff:ffff:ffff:ffff:ffff:ffff:ffff:ffff";
 809
 810     const char globalStart[]   = "2000:0000:0000:0000:0000:0000:0000:0000";
 811     const char globalMid[]     = "2000:0000:0000:0f00:0000:0000:0000:0000";
 812     const char globalEnd[]     = "3fff:ffff:ffff:ffff:ffff:ffff:ffff:ffff";
 813
 814     // loopback
 815     CATransportFlags_t scopeLevel = CA_DEFAULT_FLAGS;
 816     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(linkLocalLoopBack, &scopeLevel));
 817     EXPECT_EQ(CA_SCOPE_LINK, scopeLevel);
 818     scopeLevel = CA_DEFAULT_FLAGS;
 819
 820     // linklocal
 821     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(linkLocalStart, &scopeLevel));
 822     EXPECT_EQ(CA_SCOPE_LINK, scopeLevel);
 823     scopeLevel = CA_DEFAULT_FLAGS;
 824
 825     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(linkLocalMid, &scopeLevel));
 826     EXPECT_EQ(CA_SCOPE_LINK, scopeLevel);
 827     scopeLevel = CA_DEFAULT_FLAGS;
 828
 829     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(linkLocalEnd, &scopeLevel));
 830     EXPECT_EQ(CA_SCOPE_LINK, scopeLevel);
 831     scopeLevel = CA_DEFAULT_FLAGS;
 832
 833     // sitelocal
 834     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(siteLocalStart, &scopeLevel));
 835     EXPECT_EQ(CA_SCOPE_SITE, scopeLevel);
 836     scopeLevel = CA_DEFAULT_FLAGS;
 837
 838     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(siteLocalMid, &scopeLevel));
 839     EXPECT_EQ(CA_SCOPE_SITE, scopeLevel);
 840     scopeLevel = CA_DEFAULT_FLAGS;
 841
 842     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(siteLocalEnd, &scopeLevel));
 843     EXPECT_EQ(CA_SCOPE_SITE, scopeLevel);
 844     scopeLevel = CA_DEFAULT_FLAGS;
 845
 846     // global
 847     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(globalStart, &scopeLevel));
 848     EXPECT_EQ(CA_SCOPE_GLOBAL, scopeLevel);
 849     scopeLevel = CA_DEFAULT_FLAGS;
 850
 851     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(globalMid, &scopeLevel));
 852     EXPECT_EQ(CA_SCOPE_GLOBAL, scopeLevel);
 853     scopeLevel = CA_DEFAULT_FLAGS;
 854
 855     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(globalEnd, &scopeLevel));
 856     EXPECT_EQ(CA_SCOPE_GLOBAL, scopeLevel);
 857     scopeLevel = CA_DEFAULT_FLAGS;
 858 }
 859
 860 TEST(Ipv6ScopeLevel, invalidAddressTest)
 861 {
 862     const char invalidAddr1[]    = "qqqq";
 863     const char invalidAddr2[]    = "ffx7:ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff";
 864     const char invalidAddr3[]    = "ffx7::::::::::dsds";
 865     const char invalidAddr4[]    = "ffx7:ffff:ffff:ff@f:ffff:ffff:ffff:ffff";
 866
 867     CATransportFlags_t scopeLevel = CA_DEFAULT_FLAGS;
 868     EXPECT_EQ(CA_STATUS_FAILED, CAGetIpv6AddrScope(invalidAddr1, &scopeLevel));
 869     EXPECT_EQ(CA_STATUS_FAILED, CAGetIpv6AddrScope(invalidAddr2, &scopeLevel));
 870     EXPECT_EQ(CA_STATUS_FAILED, CAGetIpv6AddrScope(invalidAddr3, &scopeLevel));
 871     EXPECT_EQ(CA_STATUS_FAILED, CAGetIpv6AddrScope(invalidAddr4, &scopeLevel));
 872 }