resource/csdk/connectivity/src/caconnectivitymanager.c

   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 <stdio.h>
  22 #include <stdlib.h>
  23 #include <stdint.h>
  24 #include <stdbool.h>
  25
  26 #include "cainterface.h"
  27 #include "caremotehandler.h"
  28 #include "camessagehandler.h"
  29 #include "caprotocolmessage.h"
  30 #include "canetworkconfigurator.h"
  31 #include "cainterfacecontroller.h"
  32 #include "logger.h"
  33 #ifdef __WITH_DTLS__
  34 #include "caadapternetdtls.h"
  35 #endif
  36
  37 #ifdef TCP_ADAPTER
  38 #include "catcpadapter.h"
  39 #endif
  40
  41 CAGlobals_t caglobals = { 0 };
  42
  43 #define TAG "CA_CONN_MGR"
  44
  45 static bool g_isInitialized = false;
  46
  47 #ifdef __WITH_DTLS__
  48 // CAAdapterNetDTLS will register the callback.
  49 // Taking callback all the way through adapters not the right approach, hence calling here.
  50 extern void CADTLSSetCredentialsCallback(CAGetDTLSPskCredentialsHandler credCallback);
  51 #endif
  52
  53 #ifdef __WITH_X509__
  54 // CAAdapterNetDTLS will register the callback.
  55 // Taking callback all the way through adapters not the right approach, hence calling here.
  56 extern void CADTLSSetX509CredentialsCallback(CAGetDTLSX509CredentialsHandler credCallback);
  57 extern void CADTLSSetCrlCallback(CAGetDTLSCrlHandler crlCallback);
  58 #endif
  59
  60 CAResult_t CAInitialize()
  61 {
  62     OIC_LOG(DEBUG, TAG, "CAInitialize");
  63
  64     if (!g_isInitialized)
  65     {
  66         CAResult_t res = CAInitializeMessageHandler();
  67         if (res != CA_STATUS_OK)
  68         {
  69             OIC_LOG(ERROR, TAG, "CAInitialize has failed");
  70             return res;
  71         }
  72         g_isInitialized = true;
  73     }
  74     return CA_STATUS_OK;
  75 }
  76
  77 void CATerminate()
  78 {
  79     OIC_LOG(DEBUG, TAG, "CATerminate");
  80
  81     if (g_isInitialized)
  82     {
  83         CATerminateMessageHandler();
  84         CATerminateNetworkType();
  85
  86         g_isInitialized = false;
  87     }
  88 }
  89
  90 CAResult_t CAStartListeningServer()
  91 {
  92     OIC_LOG(DEBUG, TAG, "CAStartListeningServer");
  93
  94     if(!g_isInitialized)
  95     {
  96         return CA_STATUS_NOT_INITIALIZED;
  97     }
  98
  99     return CAStartListeningServerAdapters();
 100 }
 101
 102 CAResult_t CAStopListeningServer()
 103 {
 104     OIC_LOG(DEBUG, TAG, "CAStopListeningServer");
 105
 106     if(!g_isInitialized)
 107     {
 108         return CA_STATUS_NOT_INITIALIZED;
 109     }
 110
 111     return CAStopListeningServerAdapters();
 112 }
 113
 114 CAResult_t CAStartDiscoveryServer()
 115 {
 116     OIC_LOG(DEBUG, TAG, "CAStartDiscoveryServer");
 117
 118     if(!g_isInitialized)
 119     {
 120         return CA_STATUS_NOT_INITIALIZED;
 121     }
 122
 123     return CAStartDiscoveryServerAdapters();
 124 }
 125
 126 void CARegisterHandler(CARequestCallback ReqHandler, CAResponseCallback RespHandler,
 127                        CAErrorCallback ErrorHandler)
 128 {
 129     OIC_LOG(DEBUG, TAG, "CARegisterHandler");
 130
 131     if(!g_isInitialized)
 132     {
 133         OIC_LOG(DEBUG, TAG, "CA is not initialized");
 134         return;
 135     }
 136
 137     CASetInterfaceCallbacks(ReqHandler, RespHandler, ErrorHandler);
 138 }
 139
 140 #ifdef __WITH_DTLS__
 141 CAResult_t CARegisterDTLSCredentialsHandler(CAGetDTLSPskCredentialsHandler GetDTLSCredentialsHandler)
 142 {
 143     OIC_LOG(DEBUG, TAG, "CARegisterDTLSCredentialsHandler");
 144
 145     if(!g_isInitialized)
 146     {
 147         return CA_STATUS_NOT_INITIALIZED;
 148     }
 149
 150     CADTLSSetCredentialsCallback(GetDTLSCredentialsHandler);
 151     return CA_STATUS_OK;
 152 }
 153 #endif //__WITH_DTLS__
 154
 155 #ifdef __WITH_X509__
 156 CAResult_t CARegisterDTLSX509CredentialsHandler(CAGetDTLSX509CredentialsHandler GetDTLSX509CredentialsHandler)
 157 {
 158     OIC_LOG(DEBUG, TAG, "CARegisterDTLSX509CredentialsHandler");
 159
 160     if(!g_isInitialized)
 161     {
 162         return CA_STATUS_NOT_INITIALIZED;
 163     }
 164
 165     CADTLSSetX509CredentialsCallback(GetDTLSX509CredentialsHandler);
 166     return CA_STATUS_OK;
 167 }
 168
 169 CAResult_t CARegisterDTLSCrlHandler(CAGetDTLSCrlHandler GetDTLSCrlHandler)
 170 {
 171     OIC_LOG(DEBUG, TAG, "CARegisterDTLSCrlHandler");
 172
 173     if(!g_isInitialized)
 174     {
 175         return CA_STATUS_NOT_INITIALIZED;
 176     }
 177
 178     CADTLSSetCrlCallback(GetDTLSCrlHandler);
 179     return CA_STATUS_OK;
 180 }
 181 #endif //__WITH_X509__
 182
 183 CAResult_t CACreateEndpoint(CATransportFlags_t flags,
 184                             CATransportAdapter_t adapter,
 185                             const char *addr,
 186                             uint16_t port,
 187                             CAEndpoint_t **object)
 188 {
 189     if (!object)
 190     {
 191         OIC_LOG(ERROR, TAG, "Invalid Parameter");
 192         return CA_STATUS_INVALID_PARAM;
 193     }
 194
 195     CAEndpoint_t *endpoint = CACreateEndpointObject(flags, adapter, addr, port);
 196     if (!endpoint)
 197     {
 198         return CA_STATUS_FAILED;
 199     }
 200     *object = endpoint;
 201     return CA_STATUS_OK;
 202 }
 203
 204 void CADestroyEndpoint(CAEndpoint_t *rep)
 205 {
 206     OIC_LOG(DEBUG, TAG, "CADestroyEndpoint");
 207
 208     CAFreeEndpoint(rep);
 209 }
 210
 211 CAResult_t CAGenerateToken(CAToken_t *token, uint8_t tokenLength)
 212 {
 213     OIC_LOG(DEBUG, TAG, "CAGenerateToken");
 214
 215     return CAGenerateTokenInternal(token, tokenLength);
 216 }
 217
 218 void CADestroyToken(CAToken_t token)
 219 {
 220     OIC_LOG(DEBUG, TAG, "CADestroyToken");
 221
 222     CADestroyTokenInternal(token);
 223
 224     OIC_LOG(DEBUG, TAG, "OUT");
 225 }
 226
 227 CAResult_t CAGetNetworkInformation(CAEndpoint_t **info, uint32_t *size)
 228 {
 229     OIC_LOG(DEBUG, TAG, "CAGetNetworkInformation");
 230
 231     if(!g_isInitialized)
 232     {
 233         return CA_STATUS_NOT_INITIALIZED;
 234     }
 235
 236     return CAGetNetworkInformationInternal(info, size);
 237 }
 238
 239 CAResult_t CASendRequest(const CAEndpoint_t *object,const CARequestInfo_t *requestInfo)
 240 {
 241     OIC_LOG(DEBUG, TAG, "CASendGetRequest");
 242
 243     if(!g_isInitialized)
 244     {
 245         return CA_STATUS_NOT_INITIALIZED;
 246     }
 247
 248     return CADetachRequestMessage(object, requestInfo);
 249 }
 250
 251 CAResult_t CASendNotification(const CAEndpoint_t *object, const CAResponseInfo_t *responseInfo)
 252 {
 253     OIC_LOG(DEBUG, TAG, "CASendNotification");
 254
 255     if(!g_isInitialized)
 256     {
 257         return CA_STATUS_NOT_INITIALIZED;
 258     }
 259
 260     return CADetachResponseMessage(object, responseInfo);
 261 }
 262
 263 CAResult_t CASendResponse(const CAEndpoint_t *object, const CAResponseInfo_t *responseInfo)
 264 {
 265     OIC_LOG(DEBUG, TAG, "CASendResponse");
 266
 267     if(!g_isInitialized)
 268     {
 269         return CA_STATUS_NOT_INITIALIZED;
 270     }
 271
 272     return CADetachResponseMessage(object, responseInfo);
 273 }
 274
 275 CAResult_t CASelectNetwork(CATransportAdapter_t interestedNetwork)
 276 {
 277     OIC_LOG_V(DEBUG, TAG, "Selected network : %d", interestedNetwork);
 278
 279     if(!g_isInitialized)
 280     {
 281         return CA_STATUS_NOT_INITIALIZED;
 282     }
 283
 284     CAResult_t res = CA_STATUS_OK;
 285
 286     if (interestedNetwork & CA_ADAPTER_IP)
 287     {
 288         res = CAAddNetworkType(CA_ADAPTER_IP);
 289         OIC_LOG_V(DEBUG, TAG, "CAAddNetworkType(CA_IP_ADAPTER) function returns result: %d", res);
 290     }
 291     else if (interestedNetwork & CA_ADAPTER_RFCOMM_BTEDR)
 292     {
 293         res = CAAddNetworkType(CA_ADAPTER_RFCOMM_BTEDR);
 294         OIC_LOG_V(DEBUG, TAG, "CAAddNetworkType(CA_RFCOMM_ADAPTER) function returns result : %d", res);
 295     }
 296     else if (interestedNetwork & CA_ADAPTER_GATT_BTLE)
 297     {
 298         res = CAAddNetworkType(CA_ADAPTER_GATT_BTLE);
 299         OIC_LOG_V(DEBUG, TAG, "CAAddNetworkType(CA_GATT_ADAPTER) function returns result : %d", res);
 300     }
 301
 302 #ifdef RA_ADAPTER
 303     else if (interestedNetwork & CA_ADAPTER_REMOTE_ACCESS)
 304     {
 305         res = CAAddNetworkType(CA_ADAPTER_REMOTE_ACCESS);
 306         OIC_LOG_V(DEBUG, TAG,
 307                   "CAAddNetworkType(CA_ADAPTER_REMOTE_ACCESS) function returns result : %d", res);
 308     }
 309 #endif
 310
 311 #ifdef TCP_ADAPTER
 312     else if (interestedNetwork & CA_ADAPTER_TCP)
 313     {
 314         res = CAAddNetworkType(CA_ADAPTER_TCP);
 315         OIC_LOG_V(DEBUG, TAG,
 316                   "CAAddNetworkType(CA_ADAPTER_TCP) function returns result : %d", res);
 317     }
 318 #endif
 319
 320     else
 321     {
 322         res = CA_NOT_SUPPORTED;
 323     }
 324     return res;
 325 }
 326
 327 CAResult_t CAUnSelectNetwork(CATransportAdapter_t nonInterestedNetwork)
 328 {
 329     OIC_LOG_V(DEBUG, TAG, "unselected network : %d", nonInterestedNetwork);
 330
 331     if(!g_isInitialized)
 332     {
 333         return CA_STATUS_NOT_INITIALIZED;
 334     }
 335
 336     CAResult_t res = CA_STATUS_OK;
 337
 338     if (nonInterestedNetwork & CA_ADAPTER_IP)
 339     {
 340         res = CARemoveNetworkType(CA_ADAPTER_IP);
 341         OIC_LOG_V(DEBUG, TAG, "CARemoveNetworkType(CA_IP_ADAPTER) function returns result : %d", res);
 342     }
 343     else if (nonInterestedNetwork & CA_ADAPTER_RFCOMM_BTEDR)
 344     {
 345         res = CARemoveNetworkType(CA_ADAPTER_RFCOMM_BTEDR);
 346         OIC_LOG_V(DEBUG, TAG, "CARemoveNetworkType(CA_RFCOMM_ADAPTER) function returns result : %d", res);
 347     }
 348     else if (nonInterestedNetwork & CA_ADAPTER_GATT_BTLE)
 349     {
 350         res = CARemoveNetworkType(CA_ADAPTER_GATT_BTLE);
 351         OIC_LOG_V(DEBUG, TAG, "CARemoveNetworkType(CA_GATT_ADAPTER) function returns result : %d", res);
 352     }
 353 #ifdef RA_ADAPTER
 354     else if (nonInterestedNetwork & CA_ADAPTER_REMOTE_ACCESS)
 355     {
 356         res = CARemoveNetworkType(CA_ADAPTER_REMOTE_ACCESS);
 357         OIC_LOG_V(DEBUG, TAG, "CARemoveNetworkType(CA_ADAPTER_REMOTE_ACCESS) function returns result : %d",
 358                   res);
 359     }
 360 #endif
 361
 362
 363 #ifdef TCP_ADAPTER
 364     else if (nonInterestedNetwork & CA_ADAPTER_TCP)
 365     {
 366         res = CARemoveNetworkType(CA_ADAPTER_TCP);
 367         OIC_LOG_V(DEBUG, TAG, "CARemoveNetworkType(CA_ADAPTER_TCP) function returns result : %d",
 368                   res);
 369     }
 370 #endif
 371
 372     else
 373     {
 374         res = CA_STATUS_FAILED;
 375     }
 376     return res;
 377 }
 378
 379 CAResult_t CAHandleRequestResponse()
 380 {
 381     if (!g_isInitialized)
 382     {
 383         OIC_LOG(ERROR, TAG, "not initialized");
 384         return CA_STATUS_NOT_INITIALIZED;
 385     }
 386
 387     CAHandleRequestResponseCallbacks();
 388
 389     return CA_STATUS_OK;
 390 }
 391
 392 #ifdef __WITH_DTLS__
 393
 394 CAResult_t CASelectCipherSuite(const uint16_t cipher)
 395 {
 396     OIC_LOG_V(DEBUG, TAG, "CASelectCipherSuite");
 397
 398     return CADtlsSelectCipherSuite(cipher);
 399 }
 400
 401 CAResult_t CAEnableAnonECDHCipherSuite(const bool enable)
 402 {
 403     OIC_LOG_V(DEBUG, TAG, "CAEnableAnonECDHCipherSuite");
 404
 405     return CADtlsEnableAnonECDHCipherSuite(enable);
 406 }
 407
 408 CAResult_t CAGenerateOwnerPSK(const CAEndpoint_t* endpoint,
 409                     const uint8_t* label, const size_t labelLen,
 410                     const uint8_t* rsrcServerDeviceID, const size_t rsrcServerDeviceIDLen,
 411                     const uint8_t* provServerDeviceID, const size_t provServerDeviceIDLen,
 412                     uint8_t* ownerPSK, const size_t ownerPSKSize)
 413 {
 414     OIC_LOG_V(DEBUG, TAG, "IN : CAGenerateOwnerPSK");
 415
 416     CAResult_t res = CA_STATUS_OK;
 417
 418     //newOwnerLabel and prevOwnerLabe can be NULL
 419     if (!endpoint || !label || 0 == labelLen || !ownerPSK || 0 == ownerPSKSize)
 420     {
 421         return CA_STATUS_INVALID_PARAM;
 422     }
 423
 424     res = CADtlsGenerateOwnerPSK(endpoint, label, labelLen,
 425                                   rsrcServerDeviceID, rsrcServerDeviceIDLen,
 426                                   provServerDeviceID, provServerDeviceIDLen,
 427                                   ownerPSK, ownerPSKSize);
 428     if (CA_STATUS_OK != res)
 429     {
 430         OIC_LOG_V(ERROR, TAG, "Failed to CAGenerateOwnerPSK : %d", res);
 431     }
 432
 433     OIC_LOG_V(DEBUG, TAG, "OUT : CAGenerateOwnerPSK");
 434
 435     return res;
 436 }
 437
 438 CAResult_t CAInitiateHandshake(const CAEndpoint_t *endpoint)
 439 {
 440     OIC_LOG_V(DEBUG, TAG, "IN : CAInitiateHandshake");
 441     CAResult_t res = CA_STATUS_OK;
 442
 443     if (!endpoint)
 444     {
 445         return CA_STATUS_INVALID_PARAM;
 446     }
 447
 448     res = CADtlsInitiateHandshake(endpoint);
 449     if (CA_STATUS_OK != res)
 450     {
 451         OIC_LOG_V(ERROR, TAG, "Failed to CADtlsInitiateHandshake : %d", res);
 452     }
 453
 454     OIC_LOG_V(DEBUG, TAG, "OUT : CAInitiateHandshake");
 455
 456     return res;
 457 }
 458
 459 CAResult_t CACloseDtlsSession(const CAEndpoint_t *endpoint)
 460 {
 461     OIC_LOG_V(DEBUG, TAG, "IN : CACloseDtlsSession");
 462     CAResult_t res = CA_STATUS_OK;
 463
 464     if (!endpoint)
 465     {
 466         return CA_STATUS_INVALID_PARAM;
 467     }
 468
 469     res = CADtlsClose(endpoint);
 470     if (CA_STATUS_OK != res)
 471     {
 472         OIC_LOG_V(ERROR, TAG, "Failed to CADtlsClose : %d", res);
 473     }
 474
 475     OIC_LOG_V(DEBUG, TAG, "OUT : CACloseDtlsSession");
 476
 477     return res;
 478 }
 479
 480 #endif /* __WITH_DTLS__ */