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     g_adapterHandler = adapterHandler;
 104     g_connectionHandler = connectionHandler;
 105
 106     CAResult_t ret = CARegisterNetworkMonitorHandler(DefaultAdapterStateChangedHandler,
 107                                                      DefaultConnectionStateChangedHandler);
 108
 109     return convertCAResultToOCResult(ret);
 110 }
 111
 112 OCStackResult CAManager::setPortNumberToAssign(OCTransportAdapter adapter,
 113                                                OCTransportFlags flag, uint16_t port)
 114 {
 115     OIC_LOG(INFO, TAG, "setPortNumberToAssign");
 116     CAResult_t ret = CASetPortNumberToAssign((CATransportAdapter_t) adapter,
 117                                              (CATransportFlags_t) flag, port);
 118
 119     return convertCAResultToOCResult(ret);
 120 }
 121
 122 uint16_t CAManager::getAssignedPortNumber(OCTransportAdapter adapter, OCTransportFlags flag)
 123 {
 124     OIC_LOG(INFO, TAG, "getAssignedPortNumber");
 125     return CAGetAssignedPortNumber((CATransportAdapter_t) adapter, (CATransportFlags_t) flag);
 126 }
 127
 128 OCStackResult CAManager::setMulticastTTL(size_t ttl)
 129 {
 130     OIC_LOG(INFO, TAG, "setMulticastTTL");
 131     CAResult_t ret = CAUtilSetMulticastTTL(ttl);
 132     return convertCAResultToOCResult(ret);
 133 }
 134
 135 OCStackResult CAManager::getMulticastTTL(size_t *ttl)
 136 {
 137     OIC_LOG(INFO, TAG, "getMulticastTTL");
 138     CAResult_t ret = CAUtilGetMulticastTTL(ttl);
 139     return convertCAResultToOCResult(ret);
 140 }
 141
 142 OCStackResult CAManager::setBTConfigure(const CAUtilConfig& config)
 143 {
 144     OIC_LOG(INFO, TAG, "setBTConfigure");
 145     CAUtilConfig_t configs = {(CATransportBTFlags_t)config.bleFlag, { {0}, .adapter = CA_DEFAULT_ADAPTER, .level = HIGH_SPEED }};
 146     CAResult_t ret = CAUtilSetBTConfigure(configs);
 147     return convertCAResultToOCResult(ret);
 148 }
 149
 150 void CAManager::setLogLevel(OCLogLevel level, bool hidePrivateLogEntries)
 151 {
 152     OIC_LOG(INFO, TAG, "setLogLevel");
 153     CAUtilSetLogLevel((CAUtilLogLevel_t) level, hidePrivateLogEntries);
 154 }
 155
 156 #if defined(__WITH_DTLS__) || defined(__WITH_TLS__)
 157 OCStackResult CAManager::setCipherSuite(const uint16_t cipher, OCTransportAdapter adapter)
 158 {
 159     CAResult_t ret = CASelectCipherSuite(cipher, (CATransportAdapter_t) adapter);
 160     return convertCAResultToOCResult(ret);
 161 }
 162 #endif // defined(__WITH_DTLS__) || defined(__WITH_TLS__)
 163
 164 #if defined(__TIZEN__) && defined(LE_ADAPTER) && defined(BLE_CUSTOM_ADVERTISE)
 165 OCStackResult CAManager::setAdvertisementData(const char* data, int length)
 166 {
 167     CAResult_t ret = CASetAdvertisementData(data, length);
 168
 169     return convertCAResultToOCResult(ret);
 170 }
 171
 172 OCStackResult CAManager::setScanResponseData(const char* data, int length)
 173 {
 174     CAResult_t ret = CASetScanResponseData(data, length);
 175
 176     return convertCAResultToOCResult(ret);
 177 }
 178 #endif
 179
 180 OCStackResult CAManager::startLEAdvertising()
 181 {
 182     OIC_LOG(INFO, TAG, "startLEAdvertising");
 183     CAResult_t ret = CAUtilStartLEAdvertising();
 184
 185     return convertCAResultToOCResult(ret);
 186 }
 187
 188 OCStackResult CAManager::stopLEAdvertising()
 189 {
 190     OIC_LOG(INFO, TAG, "stopLEAdvertising");
 191     CAResult_t ret = CAUtilStopLEAdvertising();
 192
 193     return convertCAResultToOCResult(ret);
 194 }
 195
 196 OCStackResult CAManager::disconnectTCPSession(const char *address,
 197                                               uint16_t port,
 198                                               OCTransportFlags flags)
 199 {
 200     if (!address)
 201     {
 202         OIC_LOG(ERROR, TAG, "address is invalid");
 203         return OCStackResult::OC_STACK_INVALID_PARAM;
 204     }
 205
 206     OIC_LOG_V(INFO, TAG, "disconnectTCPSession [addr:%s][port:%d][flags:%d]",
 207               address, port, flags);
 208     CAResult_t ret = CAUtilTCPDisconnectSession(address, port, (CATransportFlags_t)flags);
 209
 210     return convertCAResultToOCResult(ret);
 211 }
 212
 213 OCStackResult CAManager::startCAGattServer()
 214 {
 215     OIC_LOG(INFO, TAG, "startCAGattServer]");
 216     CAResult_t ret = CAUtilStartGattServer();
 217
 218     return convertCAResultToOCResult(ret);
 219 }
 220
 221 OCStackResult CAManager::stopCAGattServer()
 222 {
 223         OIC_LOG(INFO, TAG, "stopCAGattServer]");
 224     CAResult_t ret = CAUtilStopGattServer();
 225
 226     return convertCAResultToOCResult(ret);
 227 }