resource/csdk/connectivity/util/src/cautilinterface.c

   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 #include "camanagerleinterface.h"
  22 #include "cabtpairinginterface.h"
  23 #include "cautilinterface.h"
  24 #include "cainterfacecontroller.h"
  25 #include "cacommon.h"
  26 #include "logger.h"
  27 #include "caremotehandler.h"
  28 #ifdef TCP_ADAPTER
  29 #include "catcpadapter.h"
  30 #endif
  31 #define TAG "OIC_CA_COMMON_UTILS"
  32
  33 CAResult_t CARegisterNetworkMonitorHandler(CAAdapterStateChangedCB adapterStateCB, CAConnectionStateChangedCB connStateCB)
  34 {
  35         OIC_LOG(DEBUG, TAG, "CARegisterNetworkMonitorHandler");
  36
  37         CASetNetworkMonitorCallbacks(adapterStateCB, connStateCB);
  38         return CA_STATUS_OK;
  39 }
  40
  41 CAResult_t CAUnregisterNetworkMonitorHandler(CAAdapterStateChangedCB adapterStateCB, CAConnectionStateChangedCB connStateCB)
  42 {
  43         OIC_LOG(DEBUG, TAG, "CAUnregisterNetworkMonitorHandler");
  44
  45         return CAUnsetNetworkMonitorCallbacks(adapterStateCB, connStateCB);
  46 }
  47
  48 CAResult_t CASetAutoConnectionDeviceInfo(const char *address)
  49 {
  50         OIC_LOG(DEBUG, TAG, "CASetAutoConnectionDeviceInfo");
  51
  52 #if (defined(__ANDROID__) || defined(__APPLE__)) && defined(LE_ADAPTER)
  53         return CASetLEClientAutoConnectionDeviceInfo(address);
  54 #else
  55         (void)address;
  56         return CA_NOT_SUPPORTED;
  57 #endif
  58 }
  59
  60 CAResult_t CAUnsetAutoConnectionDeviceInfo(const char *address)
  61 {
  62         OIC_LOG(DEBUG, TAG, "CAUnsetAutoConnectionDeviceInfo");
  63
  64 #if (defined(__ANDROID__) || defined(__APPLE__))  && defined(LE_ADAPTER)
  65         return CAUnsetLEClientAutoConnectionDeviceInfo(address);
  66 #else
  67         (void)address;
  68         return CA_NOT_SUPPORTED;
  69 #endif
  70 }
  71
  72 #ifdef __APPLE__
  73
  74 CAResult_t CAUtilClientInitialize()
  75 {
  76         OIC_LOG(DEBUG, TAG, "CAUtilClientInitialize");
  77
  78         CAResult_t res = CA_STATUS_OK;
  79 #ifdef LE_ADAPTER
  80         if (CA_STATUS_OK != CAManagerLEClientInitialize()) {
  81                 OIC_LOG(ERROR, TAG, "CAManagerLEClientInitialize has failed");
  82                 res = CA_STATUS_FAILED;
  83         }
  84 #else
  85         OIC_LOG(DEBUG, TAG, "it is not supported");
  86         res = CA_NOT_SUPPORTED;
  87 #endif
  88
  89         return res;
  90 }
  91
  92 CAResult_t CAUtilClientTerminate()
  93 {
  94         OIC_LOG(DEBUG, TAG, "CAUtilClientTerminate");
  95 #ifdef LE_ADAPTER
  96         return CAManagerLEClientTerminate();
  97 #else
  98         OIC_LOG(DEBUG, TAG, "it is not supported");
  99         return CA_NOT_SUPPORTED;
 100 #endif
 101 }
 102
 103 CAResult_t CAUtilStopLEScan()
 104 {
 105         OIC_LOG(DEBUG, TAG, "CAUtilStopLEScan");
 106 #ifdef LE_ADAPTER
 107         CAManagerLEStopScan();
 108         return CA_STATUS_OK;
 109 #else
 110         OIC_LOG(DEBUG, TAG, "it is not supported");
 111         return CA_NOT_SUPPORTED;
 112 #endif
 113 }
 114
 115 CAResult_t CAUtilStartLEScan()
 116 {
 117         OIC_LOG(DEBUG, TAG, "CAUtilStartLEScan");
 118 #ifdef LE_ADAPTER
 119         CAManagerLEStartScan();
 120         return CA_STATUS_OK;
 121 #else
 122         OIC_LOG(DEBUG, TAG, "it is not supported");
 123         return CA_NOT_SUPPORTED;
 124 #endif
 125 }
 126
 127 CAResult_t CAUtilClientDisconnect()
 128 {
 129         OIC_LOG(DEBUG, TAG, "CAUtilClientDisconnect");
 130 #ifdef LE_ADAPTER
 131         CAManagerLEDisconnect();
 132         return CA_STATUS_OK;
 133 #else
 134         OIC_LOG(DEBUG, TAG, "it is not supported");
 135         return CA_NOT_SUPPORTED;
 136 #endif
 137 }
 138
 139 #endif
 140
 141 CAResult_t CASetPortNumberToAssign(CATransportAdapter_t adapter, CATransportFlags_t flag, uint16_t port)
 142 {
 143         uint16_t *targetPort = 0;
 144
 145         if (CA_ADAPTER_IP & adapter) {
 146                 if (CA_SECURE & flag) {
 147                         if (CA_IPV6 & flag) {
 148                                 targetPort = &caglobals.ports.udp.u6s;
 149                         } else if (CA_IPV4 & flag) {
 150                                 targetPort = &caglobals.ports.udp.u4s;
 151                         }
 152                 } else {
 153                         if (CA_IPV6 & flag) {
 154                                 targetPort = &caglobals.ports.udp.u6;
 155                         } else if (CA_IPV4 & flag) {
 156                                 targetPort = &caglobals.ports.udp.u4;
 157                         }
 158                 }
 159         }
 160 #ifdef TCP_ADAPTER
 161         if (CA_ADAPTER_TCP & adapter) {
 162                 if (CA_IPV6 & flag) {
 163                         targetPort = &caglobals.ports.tcp.u6;
 164                 } else if (CA_IPV4 & flag) {
 165                         targetPort = &caglobals.ports.tcp.u4;
 166                 }
 167         }
 168 #endif
 169
 170         if (targetPort) {
 171                 *targetPort = port;
 172                 return CA_STATUS_OK;
 173         }
 174
 175         return CA_NOT_SUPPORTED;
 176 }
 177
 178 uint16_t CAGetAssignedPortNumber(CATransportAdapter_t adapter, CATransportFlags_t flag)
 179 {
 180         OIC_LOG(DEBUG, TAG, "CAGetAssignedPortNumber");
 181
 182         if (CA_ADAPTER_IP & adapter) {
 183                 if (CA_SECURE & flag) {
 184                         if (CA_IPV6 & flag) {
 185                                 return caglobals.ip.u6s.port;
 186                         } else if (CA_IPV4 & flag) {
 187                                 return caglobals.ip.u4s.port;
 188                         }
 189                 } else {
 190                         if (CA_IPV6 & flag) {
 191                                 return caglobals.ip.u6.port;
 192                         } else if (CA_IPV4 & flag) {
 193                                 return caglobals.ip.u4.port;
 194                         }
 195                 }
 196         }
 197 #ifdef TCP_ADAPTER
 198         if (CA_ADAPTER_TCP & adapter) {
 199                 if (CA_SECURE & flag) {
 200                         if (CA_IPV6 & flag) {
 201                                 return caglobals.tcp.ipv6s.port;
 202                         } else if (CA_IPV4 & flag) {
 203                                 return caglobals.tcp.ipv4s.port;
 204                         }
 205                 } else {
 206                         if (CA_IPV6 & flag) {
 207                                 return caglobals.tcp.ipv6.port;
 208                         } else if (CA_IPV4 & flag) {
 209                                 return caglobals.tcp.ipv4.port;
 210                         }
 211                 }
 212         }
 213 #endif
 214         return 0;
 215 }
 216
 217 #if defined(__TIZEN__) && defined(LE_ADAPTER) && defined(BLE_CUSTOM_ADVERTISE)
 218 CAResult_t CASetAdvertisementData(const char* data, int length)
 219 {
 220         return CAManagerLEServerSetAdvertisementData(data, length);
 221 }
 222 void CASetAdvertisementDataGetter(CAAdvertisementDataGetterCB getter)
 223 {
 224         CAManagerLEServerSetAdvertisementDataGetter(getter);
 225 }
 226 void CASetAutoAdvertisement(bool autoAdvertisement)
 227 {
 228         CAManagerLEServerSetAutoAdvertisement(autoAdvertisement);
 229 }
 230 CAResult_t CASetScanResponseData(const char* data, int length)
 231 {
 232         return CAManagerLEServerSetScanResponseData(data, length);
 233 }
 234 #endif
 235
 236 #ifdef __ANDROID__
 237 /**
 238  * initialize client connection manager
 239  * @param[in]   env                   JNI interface pointer.
 240  * @param[in]   jvm                   invocation inferface for JAVA virtual machine.
 241  * @param[in]   context               application context.
 242  */
 243 CAResult_t CAUtilClientInitialize(JNIEnv *env, JavaVM *jvm, jobject context)
 244 {
 245         OIC_LOG(DEBUG, TAG, "CAUtilClientInitialize");
 246
 247         CAResult_t res = CA_STATUS_OK;
 248 #ifdef LE_ADAPTER
 249         if (CA_STATUS_OK != CAManagerLEClientInitialize(env, jvm, context)) {
 250                 OIC_LOG(ERROR, TAG, "CAManagerLEClientInitialize has failed");
 251                 res = CA_STATUS_FAILED;
 252         }
 253 #endif
 254
 255 #ifdef EDR_ADAPTER
 256         if (CA_STATUS_OK != CABTPairingInitialize(env, jvm, context)) {
 257                 OIC_LOG(ERROR, TAG, "CABTPairingInitialize has failed");
 258                 res = CA_STATUS_FAILED;
 259         }
 260 #endif
 261
 262 #if !defined(LE_ADAPTER) && !defined(EDR_ADAPTER)
 263         (void)env;
 264         (void)jvm;
 265         (void)context;
 266 #endif
 267         return res;
 268 }
 269
 270 /**
 271  * terminate client connection manager
 272  * @param[in]   env                   JNI interface pointer.
 273  */
 274 CAResult_t CAUtilClientTerminate(JNIEnv *env)
 275 {
 276         OIC_LOG(DEBUG, TAG, "CAUtilClientTerminate");
 277 #ifdef LE_ADAPTER
 278         return CAManagerLEClientTerminate(env);
 279 #else
 280         OIC_LOG(DEBUG, TAG, "it is not supported");
 281         (void)env;
 282         return CA_NOT_SUPPORTED;
 283 #endif
 284 }
 285
 286 // BT pairing
 287 CAResult_t CAUtilStartScan(JNIEnv *env)
 288 {
 289 #ifdef EDR_ADAPTER
 290         return CABTPairingStartScan(env);
 291 #else
 292         OIC_LOG(DEBUG, TAG, "it is not supported");
 293         (void)env;
 294         return CA_NOT_SUPPORTED;
 295 #endif
 296 }
 297
 298 CAResult_t CAUtilStopScan(JNIEnv *env)
 299 {
 300 #ifdef EDR_ADAPTER
 301         return CABTPairingStopScan(env);
 302 #else
 303         OIC_LOG(DEBUG, TAG, "it is not supported");
 304         (void)env;
 305         return CA_NOT_SUPPORTED;
 306 #endif
 307 }
 308
 309 CAResult_t CAUtilCreateBond(JNIEnv *env, jobject device)
 310 {
 311 #ifdef EDR_ADAPTER
 312         return CABTPairingCreateBond(env, device);
 313 #else
 314         OIC_LOG(DEBUG, TAG, "it is not supported");
 315         (void)env;
 316         (void)device;
 317         return CA_NOT_SUPPORTED;
 318 #endif
 319 }
 320
 321 void CAUtilSetFoundDeviceListener(jobject listener)
 322 {
 323 #ifdef EDR_ADAPTER
 324         CABTPairingSetFoundDeviceListener(listener);
 325 #else
 326         (void)listener;
 327 #endif
 328 }
 329
 330 CAResult_t CAUtilSetLEScanInterval(jint intervalTime, jint workingCount)
 331 {
 332         OIC_LOG(DEBUG, TAG, "CAUtilSetLEScanInterval");
 333 #ifdef LE_ADAPTER
 334         CAManagerLESetScanInterval(intervalTime, workingCount);
 335         return CA_STATUS_OK;
 336 #else
 337         (void)intervalTime;
 338         (void)workingCount;
 339         OIC_LOG(DEBUG, TAG, "it is not supported");
 340         return CA_NOT_SUPPORTED;
 341 #endif
 342 }
 343
 344 CAResult_t CAUtilStopLEScan()
 345 {
 346         OIC_LOG(DEBUG, TAG, "CAUtilStopLEScan");
 347 #ifdef LE_ADAPTER
 348         CAManagerLEStopScan();
 349         return CA_STATUS_OK;
 350 #else
 351         OIC_LOG(DEBUG, TAG, "it is not supported");
 352         return CA_NOT_SUPPORTED;
 353 #endif
 354 }
 355 #endif // __ANDROID__
 356
 357 CAResult_t CAUtilStartLEAdvertising()
 358 {
 359         OIC_LOG(DEBUG, TAG, "CAUtilStartLEAdvertising");
 360 #if (defined(__ANDROID__) || defined(__TIZEN__)) && defined(LE_ADAPTER)
 361         return CAManagerLEStartAdvertising();
 362 #else
 363         OIC_LOG(DEBUG, TAG, "it is not supported");
 364         return CA_NOT_SUPPORTED;
 365 #endif
 366 }
 367
 368 CAResult_t CAUtilStopLEAdvertising()
 369 {
 370         OIC_LOG(DEBUG, TAG, "CAUtilStopLEAdvertising");
 371 #if (defined(__ANDROID__) || defined(__TIZEN__)) && defined(LE_ADAPTER)
 372         return CAManagerLEStopAdvertising();
 373 #else
 374         OIC_LOG(DEBUG, TAG, "it is not supported");
 375         return CA_NOT_SUPPORTED;
 376 #endif
 377 }
 378
 379 CAResult_t CAUtilSetBTConfigure(CAUtilConfig_t config)
 380 {
 381         OIC_LOG_V(DEBUG, TAG, "CAUtilSetConfigure");
 382 #if (defined(__ANDROID__) && defined(LE_ADAPTER))
 383         OIC_LOG_V(DEBUG, TAG, " - bleFlag [%d]", config.bleFlags);
 384         CAManagerSetConfigure(config);
 385         return CA_STATUS_OK;
 386 #else
 387         (void) config;
 388         OIC_LOG(DEBUG, TAG, "it is not supported");
 389         return CA_NOT_SUPPORTED;
 390 #endif
 391 }
 392
 393 void CAUtilSetLogLevel(CAUtilLogLevel_t level, bool hidePrivateLogEntries)
 394 {
 395         OIC_LOG(DEBUG, TAG, "CAUtilSetLogLevel");
 396         LogLevel logLevel = DEBUG;
 397         switch (level) {
 398         case CA_LOG_LEVEL_ALL:
 399                 logLevel = DEBUG;
 400                 break;
 401         case CA_LOG_LEVEL_INFO:
 402                 logLevel = INFO;
 403                 break;
 404         default:
 405                 logLevel = DEBUG;
 406                 break;
 407         }
 408
 409         OCSetLogLevel(logLevel, hidePrivateLogEntries);
 410 }
 411
 412 CAResult_t CAUtilSetMulticastTTL(size_t ttl)
 413 {
 414         OIC_LOG(DEBUG, TAG, "CAUtilSetMulticastTTL");
 415 #ifdef IP_ADAPTER
 416         if (ttl > 255) {
 417                 OIC_LOG(ERROR, TAG, "TTL value is invalid");
 418                 return CA_STATUS_INVALID_PARAM;
 419         }
 420         if (ttl > 32) {
 421                 OIC_LOG(INFO, TAG, "TTL value is not supported");
 422                 return CA_NOT_SUPPORTED;
 423         }
 424         return CASetMulticastTTL(ttl);
 425 #else
 426         (void) ttl;
 427         OIC_LOG(DEBUG, TAG, "it is not supported");
 428         return CA_NOT_SUPPORTED;
 429 #endif
 430 }
 431
 432 CAResult_t CAUtilGetMulticastTTL(size_t *ttl)
 433 {
 434         OIC_LOG(DEBUG, TAG, "CAUtilGetMulticastTTL");
 435 #ifdef IP_ADAPTER
 436         return CAGetMulticastTTL(ttl);
 437 #else
 438         (void) ttl;
 439         OIC_LOG(DEBUG, TAG, "it is not supported");
 440         return CA_NOT_SUPPORTED;
 441 #endif
 442 }
 443
 444 CAResult_t CAUtilTCPDisconnectSession(const char *address, uint16_t port, CATransportFlags_t flags)
 445 {
 446         OIC_LOG(DEBUG, TAG, "CAUtilTCPDisconnectSession");
 447 #ifdef TCP_ADAPTER
 448         CARequestInfo_t reqInfo = {.info.event = CA_REQ_DISCONNECT};
 449         CAEndpoint_t *endpoint = CACreateEndpointObject(flags, CA_ADAPTER_TCP, address, port);
 450         if (!endpoint) {
 451                 return CA_STATUS_FAILED;
 452         }
 453
 454         CAResult_t caResult = CASendRequest(endpoint, &reqInfo);
 455         if (CA_STATUS_OK != caResult) {
 456                 OIC_LOG(ERROR, TAG, "CASendRequest error");
 457         }
 458         CAFreeEndpoint(endpoint);
 459         return caResult;
 460 #else
 461         (void) address;
 462         (void) port;
 463         (void) flags;
 464         OIC_LOG(DEBUG, TAG, "it is not supported");
 465         return CA_NOT_SUPPORTED;
 466 #endif
 467 }
 468
 469 void CAUtilSkipTCPCloseOnInterfaceDown(bool state)
 470 {
 471 #ifdef TCP_ADAPTER
 472     CATCPSkipCloseOnInterfaceDown(state);
 473 #else
 474     (void) state;
 475     OIC_LOG(DEBUG, TAG, "Not supported!");
 476 #endif
 477 }
 478
 479 CAResult_t CAUtilStartGattServer()
 480 {
 481         OIC_LOG(DEBUG, TAG, "CAUtilStartGattServer");
 482         CAResult_t res = CA_STATUS_OK;
 483 #if (defined(__TIZEN__) && defined(LE_ADAPTER))
 484         CAStartGattServer();
 485 #else
 486         OIC_LOG(DEBUG, TAG, "it is not supported");
 487         res = CA_NOT_SUPPORTED;
 488 #endif
 489         return res;
 490 }
 491
 492 CAResult_t CAUtilStopGattServer()
 493 {
 494         OIC_LOG(DEBUG, TAG, "CAUtilStopGattServer");
 495         CAResult_t res = CA_STATUS_OK;
 496 #if (defined(__TIZEN__) && defined(LE_ADAPTER))
 497         CAStopGattServer();
 498 #else
 499         OIC_LOG(DEBUG, TAG, "it is not supported");
 500         res = CA_NOT_SUPPORTED;
 501 #endif
 502         return res;
 503 }
 504
 505 CAResult_t CAGetTCPIPHeader(CATransportAdapter_t adapter, int flag, TCPHeaderInfo* info)
 506 {
 507     CAResult_t res = CA_STATUS_OK;
 508 #ifdef TCP_ADAPTER
 509     if (CA_ADAPTER_TCP & adapter) {
 510         res = CAGetTCPIPHeaderInfo(flag,info);
 511     }
 512     else
 513         res = CA_NOT_SUPPORTED;
 514 #else
 515     res = CA_NOT_SUPPORTED;
 516     OIC_LOG(DEBUG, TAG, "Not supported!");
 517 #endif
 518     return res;
 519 }