resource/src/CAManager.cpp

   1 /* ****************************************************************
   2  *
   3  * Copyright 2016 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 /**
  22  * @file
  23  *
  24  * This file contains the implementation of classes and its members related
  25  * to CAManager. Network changes status will be passed from CA to application.
  26  */
  27
  28 #include "OCApi.h"
  29 #include "CAManager.h"
  30 #include "cautilinterface.h"
  31 #include "casecurityinterface.h"
  32 #include "logger.h"
  33
  34 #define TAG "OIC_CAMANAGER"
  35
  36 using namespace OC;
  37 namespace
  38 {
  39         CAManager::AdapterChangedCallback g_adapterHandler = nullptr;
  40         CAManager::ConnectionChangedCallback g_connectionHandler = nullptr;
  41 }
  42
  43 OCStackResult convertCAResultToOCResult(CAResult_t caResult)
  44 {
  45     switch (caResult)
  46     {
  47         case CA_STATUS_OK:
  48             return OC_STACK_OK;
  49         case CA_STATUS_INVALID_PARAM:
  50             return OC_STACK_INVALID_PARAM;
  51         case CA_STATUS_FAILED:
  52             return OC_STACK_ERROR;
  53         case CA_NOT_SUPPORTED:
  54             return OC_STACK_NOTIMPL;
  55         default:
  56             return OC_STACK_ERROR;
  57     }
  58 }
  59
  60 void DefaultAdapterStateChangedHandler(CATransportAdapter_t adapter, bool enabled)
  61 {
  62     if (g_adapterHandler)
  63     {
  64         OIC_LOG(INFO, TAG, "Before calling into application address space for adapterStateChanged");
  65         g_adapterHandler((OCTransportAdapter) adapter, enabled);
  66         OIC_LOG(INFO, TAG, "After calling into application address space for adapterStateChanged");
  67     }
  68 }
  69
  70 void DefaultConnectionStateChangedHandler(const CAEndpoint_t *info, bool isConnected)
  71 {
  72     if (g_connectionHandler)
  73     {
  74         std::ostringstream ss;
  75
  76         if (info->flags & CA_IPV6)
  77         {
  78             ss << '[' << info->addr << ']';
  79         }
  80         else
  81         {
  82             ss << info->addr;
  83         }
  84         if (info->port)
  85         {
  86             ss << ':' << info->port;
  87         }
  88
  89         OCTransportAdapter adapter = (OCTransportAdapter)info->adapter;
  90         OCTransportFlags flags = (OCTransportFlags)info->flags;
  91         OCConnectivityType connType = (OCConnectivityType)
  92                 ((adapter << CT_ADAPTER_SHIFT) | (flags & CT_MASK_FLAGS));
  93
  94         OIC_LOG(INFO, TAG, "Before calling into application address space for connectionStateChanged");
  95         g_connectionHandler(ss.str(), connType, isConnected);
  96         OIC_LOG(INFO, TAG, "After calling into application address space for connectionStateChanged");
  97     }
  98 }
  99
 100 OCStackResult CAManager::setNetworkMonitorHandler(AdapterChangedCallback adapterHandler,
 101                                                   ConnectionChangedCallback connectionHandler)
 102 {
 103     if (!adapterHandler || !connectionHandler)
 104     {
 105         return OC_STACK_INVALID_PARAM;
 106     }
 107     g_adapterHandler = adapterHandler;
 108     g_connectionHandler = connectionHandler;
 109
 110     CAResult_t ret = CARegisterNetworkMonitorHandler(DefaultAdapterStateChangedHandler,
 111                                                      DefaultConnectionStateChangedHandler);
 112
 113     return convertCAResultToOCResult(ret);
 114 }
 115
 116 OCStackResult CAManager::setPortNumberToAssign(OCTransportAdapter adapter,
 117                                                OCTransportFlags flag, uint16_t port)
 118 {
 119     OIC_LOG(INFO, TAG, "setPortNumberToAssign");
 120     CAResult_t ret = CASetPortNumberToAssign((CATransportAdapter_t) adapter,
 121                                              (CATransportFlags_t) flag, port);
 122
 123     return convertCAResultToOCResult(ret);
 124 }
 125
 126 uint16_t CAManager::getAssignedPortNumber(OCTransportAdapter adapter, OCTransportFlags flag)
 127 {
 128     OIC_LOG(INFO, TAG, "getAssignedPortNumber");
 129     return CAGetAssignedPortNumber((CATransportAdapter_t) adapter, (CATransportFlags_t) flag);
 130 }
 131
 132 OCStackResult CAManager::setMulticastTTL(size_t ttl)
 133 {
 134     OIC_LOG(INFO, TAG, "setMulticastTTL");
 135     CAResult_t ret = CAUtilSetMulticastTTL(ttl);
 136     return convertCAResultToOCResult(ret);
 137 }
 138
 139 OCStackResult CAManager::getMulticastTTL(size_t *ttl)
 140 {
 141     OIC_LOG(INFO, TAG, "getMulticastTTL");
 142     CAResult_t ret = CAUtilGetMulticastTTL(ttl);
 143     return convertCAResultToOCResult(ret);
 144 }
 145
 146 OCStackResult CAManager::setBTConfigure(const CAUtilConfig& config)
 147 {
 148     OIC_LOG(INFO, TAG, "setBTConfigure");
 149     CAUtilConfig_t configs = {(CATransportBTFlags_t)config.bleFlag, { {0}, .adapter = CA_DEFAULT_ADAPTER, .level = HIGH_SPEED }};
 150     CAResult_t ret = CAUtilSetBTConfigure(configs);
 151     return convertCAResultToOCResult(ret);
 152 }
 153
 154 void CAManager::setLogLevel(OCLogLevel level, bool hidePrivateLogEntries)
 155 {
 156     OIC_LOG(INFO, TAG, "setLogLevel");
 157     CAUtilSetLogLevel((CAUtilLogLevel_t) level, hidePrivateLogEntries);
 158 }
 159
 160 #if defined(__WITH_DTLS__) || defined(__WITH_TLS__)
 161 OCStackResult CAManager::setCipherSuite(const uint16_t cipher, OCTransportAdapter adapter)
 162 {
 163     CAResult_t ret = CASelectCipherSuite(cipher, (CATransportAdapter_t) adapter);
 164     return convertCAResultToOCResult(ret);
 165 }
 166 #endif // defined(__WITH_DTLS__) || defined(__WITH_TLS__)
 167
 168 #if defined(__TIZEN__) && defined(LE_ADAPTER) && defined(BLE_CUSTOM_ADVERTISE)
 169 OCStackResult CAManager::setAdvertisementData(const char* data, int length)
 170 {
 171     CAResult_t ret = CASetAdvertisementData(data, length);
 172
 173     return convertCAResultToOCResult(ret);
 174 }
 175 void CAManager::setAdvertisementDataGetter(CAAdvertisementDataGetterCB getter)
 176 {
 177     CASetAdvertisementDataGetter(getter);
 178 }
 179 void CAManager::setAutoAdvertisement(bool autoAdvertisement)
 180 {
 181     CASetAutoAdvertisement(autoAdvertisement);
 182 }
 183 OCStackResult CAManager::setScanResponseData(const char* data, int length)
 184 {
 185     CAResult_t ret = CASetScanResponseData(data, length);
 186
 187     return convertCAResultToOCResult(ret);
 188 }
 189 #endif
 190
 191 OCStackResult CAManager::startLEAdvertising()
 192 {
 193     OIC_LOG(INFO, TAG, "startLEAdvertising");
 194     CAResult_t ret = CAUtilStartLEAdvertising();
 195
 196     return convertCAResultToOCResult(ret);
 197 }
 198
 199 OCStackResult CAManager::stopLEAdvertising()
 200 {
 201     OIC_LOG(INFO, TAG, "stopLEAdvertising");
 202     CAResult_t ret = CAUtilStopLEAdvertising();
 203
 204     return convertCAResultToOCResult(ret);
 205 }
 206
 207 OCStackResult CAManager::disconnectTCPSession(const char *address,
 208                                               uint16_t port,
 209                                               OCTransportFlags flags)
 210 {
 211     if (!address)
 212     {
 213         OIC_LOG(ERROR, TAG, "address is invalid");
 214         return OCStackResult::OC_STACK_INVALID_PARAM;
 215     }
 216
 217     OIC_LOG_V(INFO, TAG, "disconnectTCPSession [addr:%s][port:%d][flags:%d]",
 218               address, port, flags);
 219     CAResult_t ret = CAUtilTCPDisconnectSession(address, port, (CATransportFlags_t)flags);
 220
 221     return convertCAResultToOCResult(ret);
 222 }
 223
 224 OCStackResult CAManager::startCAGattServer()
 225 {
 226     OIC_LOG(INFO, TAG, "startCAGattServer]");
 227     CAResult_t ret = CAUtilStartGattServer();
 228
 229     return convertCAResultToOCResult(ret);
 230 }
 231
 232 OCStackResult CAManager::stopCAGattServer()
 233 {
 234         OIC_LOG(INFO, TAG, "stopCAGattServer]");
 235     CAResult_t ret = CAUtilStopGattServer();
 236
 237     return convertCAResultToOCResult(ret);
 238 }