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 CAGlobals_t caglobals;
  38
  39 #define TAG PCF("CA")
  40
  41 static bool g_isInitialized = false;
  42
  43 #ifdef __WITH_DTLS__
  44 // CAAdapterNetDTLS will register the callback.
  45 // Taking callback all the way through adapters not the right approach, hence calling here.
  46 extern void CADTLSSetCredentialsCallback(CAGetDTLSCredentialsHandler credCallback);
  47 #endif
  48
  49 CAResult_t CAInitialize()
  50 {
  51     OIC_LOG(DEBUG, TAG, "CAInitialize");
  52
  53     if (!g_isInitialized)
  54     {
  55         CAResult_t res = CAInitializeMessageHandler();
  56         if (res != CA_STATUS_OK)
  57         {
  58             OIC_LOG(ERROR, TAG, "CAInitialize has failed");
  59             return res;
  60         }
  61         g_isInitialized = true;
  62     }
  63     return CA_STATUS_OK;
  64 }
  65
  66 void CATerminate()
  67 {
  68     OIC_LOG(DEBUG, TAG, "CATerminate");
  69
  70     if (g_isInitialized)
  71     {
  72         CATerminateMessageHandler();
  73         CATerminateNetworkType();
  74
  75         g_isInitialized = false;
  76     }
  77 }
  78
  79 CAResult_t CAStartListeningServer()
  80 {
  81     OIC_LOG(DEBUG, TAG, "CAStartListeningServer");
  82
  83     if(!g_isInitialized)
  84     {
  85         return CA_STATUS_NOT_INITIALIZED;
  86     }
  87
  88     return CAStartListeningServerAdapters();
  89 }
  90
  91 CAResult_t CAStartDiscoveryServer()
  92 {
  93     OIC_LOG(DEBUG, TAG, "CAStartDiscoveryServer");
  94
  95     if(!g_isInitialized)
  96     {
  97         return CA_STATUS_NOT_INITIALIZED;
  98     }
  99
 100     return CAStartDiscoveryServerAdapters();
 101 }
 102
 103 void CARegisterHandler(CARequestCallback ReqHandler, CAResponseCallback RespHandler,
 104                        CAErrorCallback ErrorHandler)
 105 {
 106     OIC_LOG(DEBUG, TAG, "CARegisterHandler");
 107
 108     if(!g_isInitialized)
 109     {
 110         OIC_LOG(DEBUG, TAG, "CA is not initialized");
 111         return;
 112     }
 113
 114     CASetInterfaceCallbacks(ReqHandler, RespHandler, ErrorHandler);
 115 }
 116
 117 #ifdef __WITH_DTLS__
 118 CAResult_t CARegisterDTLSCredentialsHandler(CAGetDTLSCredentialsHandler GetDTLSCredentialsHandler)
 119 {
 120     OIC_LOG(DEBUG, TAG, "CARegisterDTLSCredentialsHandler");
 121
 122     if(!g_isInitialized)
 123     {
 124         return CA_STATUS_NOT_INITIALIZED;
 125     }
 126
 127     CADTLSSetCredentialsCallback(GetDTLSCredentialsHandler);
 128     return CA_STATUS_OK;
 129 }
 130 #endif //__WITH_DTLS__
 131
 132 void CADestroyEndpoint(CAEndpoint_t *rep)
 133 {
 134     OIC_LOG(DEBUG, TAG, "CADestroyEndpoint");
 135
 136     CADestroyEndpointInternal(rep);
 137 }
 138
 139 CAResult_t CAGenerateToken(CAToken_t *token, uint8_t tokenLength)
 140 {
 141     OIC_LOG(DEBUG, TAG, "CAGenerateToken");
 142
 143     if(!g_isInitialized)
 144     {
 145         return CA_STATUS_NOT_INITIALIZED;
 146     }
 147     return CAGenerateTokenInternal(token, tokenLength);
 148 }
 149
 150 void CADestroyToken(CAToken_t token)
 151 {
 152     OIC_LOG(DEBUG, TAG, "CADestroyToken");
 153     CADestroyTokenInternal(token);
 154 }
 155
 156 CAResult_t CAGetNetworkInformation(CAEndpoint_t **info, uint32_t *size)
 157 {
 158     OIC_LOG(DEBUG, TAG, "CAGetNetworkInformation");
 159
 160     if(!g_isInitialized)
 161     {
 162         return CA_STATUS_NOT_INITIALIZED;
 163     }
 164
 165     return CAGetNetworkInformationInternal(info, size);
 166 }
 167
 168 CAResult_t CASendRequest(const CAEndpoint_t *object,const CARequestInfo_t *requestInfo)
 169 {
 170     OIC_LOG(DEBUG, TAG, "CASendGetRequest");
 171
 172     if(!g_isInitialized)
 173     {
 174         return CA_STATUS_NOT_INITIALIZED;
 175     }
 176
 177     return CADetachRequestMessage(object, requestInfo);
 178 }
 179
 180 CAResult_t CASendNotification(const CAEndpoint_t *object, const CAResponseInfo_t *responseInfo)
 181 {
 182     OIC_LOG(DEBUG, TAG, "CASendNotification");
 183
 184     if(!g_isInitialized)
 185     {
 186         return CA_STATUS_NOT_INITIALIZED;
 187     }
 188
 189     return CADetachResponseMessage(object, responseInfo);
 190
 191 }
 192
 193 CAResult_t CASendResponse(const CAEndpoint_t *object, const CAResponseInfo_t *responseInfo)
 194 {
 195     OIC_LOG(DEBUG, TAG, "CASendResponse");
 196
 197     if(!g_isInitialized)
 198     {
 199         return CA_STATUS_NOT_INITIALIZED;
 200     }
 201
 202     return CADetachResponseMessage(object, responseInfo);
 203
 204 }
 205
 206 CAResult_t CASelectNetwork(const uint32_t interestedNetwork)
 207 {
 208     OIC_LOG_V(DEBUG, TAG, "Selected network : %d", interestedNetwork);
 209
 210     if(!g_isInitialized)
 211     {
 212         return CA_STATUS_NOT_INITIALIZED;
 213     }
 214
 215     CAResult_t res = CA_STATUS_OK;
 216
 217     if (interestedNetwork & CA_ADAPTER_IP)
 218     {
 219         res = CAAddNetworkType(CA_ADAPTER_IP);
 220         OIC_LOG_V(ERROR, TAG, "CAAddNetworkType(CA_IP_ADAPTER) function returns error : %d", res);
 221     }
 222     else if (interestedNetwork & CA_ADAPTER_RFCOMM_BTEDR)
 223     {
 224         res = CAAddNetworkType(CA_ADAPTER_RFCOMM_BTEDR);
 225         OIC_LOG_V(ERROR, TAG, "CAAddNetworkType(CA_RFCOMM_ADAPTER) function returns error : %d", res);
 226     }
 227     else if (interestedNetwork & CA_ADAPTER_GATT_BTLE)
 228     {
 229         res = CAAddNetworkType(CA_ADAPTER_GATT_BTLE);
 230         OIC_LOG_V(ERROR, TAG, "CAAddNetworkType(CA_GATT_ADAPTER) function returns error : %d", res);
 231     }
 232     else
 233     {
 234         res = CA_NOT_SUPPORTED;
 235     }
 236
 237     return res;
 238 }
 239
 240 CAResult_t CAUnSelectNetwork(const uint32_t nonInterestedNetwork)
 241 {
 242     OIC_LOG_V(DEBUG, TAG, "unselected network : %d", nonInterestedNetwork);
 243
 244     if(!g_isInitialized)
 245     {
 246         return CA_STATUS_NOT_INITIALIZED;
 247     }
 248
 249     CAResult_t res = CA_STATUS_OK;
 250
 251     if (nonInterestedNetwork & CA_ADAPTER_IP)
 252     {
 253         res = CARemoveNetworkType(CA_ADAPTER_IP);
 254         OIC_LOG_V(ERROR, TAG, "CARemoveNetworkType(CA_IP_ADAPTER) function returns error : %d", res);
 255     }
 256     else if (nonInterestedNetwork & CA_ADAPTER_RFCOMM_BTEDR)
 257     {
 258         res = CARemoveNetworkType(CA_ADAPTER_RFCOMM_BTEDR);
 259         OIC_LOG_V(ERROR, TAG, "CARemoveNetworkType(CA_RFCOMM_ADAPTER) function returns error : %d", res);
 260     }
 261     else if (nonInterestedNetwork & CA_ADAPTER_GATT_BTLE)
 262     {
 263         res = CARemoveNetworkType(CA_ADAPTER_GATT_BTLE);
 264         OIC_LOG_V(ERROR, TAG, "CARemoveNetworkType(CA_GATT_ADAPTER) function returns error : %d", res);
 265     }
 266     else
 267     {
 268         res = CA_STATUS_FAILED;
 269     }
 270
 271     return res;
 272 }
 273
 274 CAResult_t CAHandleRequestResponse()
 275 {
 276     OIC_LOG(DEBUG, TAG, "CAHandleRequestResponse");
 277
 278     if (!g_isInitialized)
 279     {
 280         OIC_LOG(ERROR, TAG, "not initialized");
 281         return CA_STATUS_NOT_INITIALIZED;
 282     }
 283
 284     CAHandleRequestResponseCallbacks();
 285
 286     return CA_STATUS_OK;
 287 }
 288
 289 #ifdef __WITH_DTLS__
 290
 291 CAResult_t CASelectCipherSuite(const uint16_t cipher)
 292 {
 293     OIC_LOG_V(DEBUG, TAG, "CASelectCipherSuite");
 294
 295     return CADtlsSelectCipherSuite(cipher);
 296 }
 297
 298 CAResult_t CAEnableAnonECDHCipherSuite(const bool enable)
 299 {
 300     OIC_LOG_V(DEBUG, TAG, "CAEnableAnonECDHCipherSuite");
 301
 302     return CADtlsEnableAnonECDHCipherSuite(enable);
 303 }
 304
 305 CAResult_t CAGenerateOwnerPSK(const CAEndpoint_t* endpoint,
 306                     const uint8_t* label, const size_t labelLen,
 307                     const uint8_t* rsrcServerDeviceID, const size_t rsrcServerDeviceIDLen,
 308                     const uint8_t* provServerDeviceID, const size_t provServerDeviceIDLen,
 309                     uint8_t* ownerPSK, const size_t ownerPSKSize)
 310 {
 311     OIC_LOG_V(DEBUG, TAG, "IN : CAGenerateOwnerPSK");
 312
 313     CAResult_t res = CA_STATUS_OK;
 314
 315     //newOwnerLabel and prevOwnerLabe can be NULL
 316     if (!endpoint || !label || 0 == labelLen || !ownerPSK || 0 == ownerPSKSize)
 317     {
 318         return CA_STATUS_INVALID_PARAM;
 319     }
 320
 321     res = CADtlsGenerateOwnerPSK(endpoint, label, labelLen,
 322                                   rsrcServerDeviceID, rsrcServerDeviceIDLen,
 323                                   provServerDeviceID, provServerDeviceIDLen,
 324                                   ownerPSK, ownerPSKSize);
 325     if (CA_STATUS_OK != res)
 326     {
 327         OIC_LOG_V(ERROR, TAG, "Failed to CAGenerateOwnerPSK : %d", res);
 328     }
 329
 330     OIC_LOG_V(DEBUG, TAG, "OUT : CAGenerateOwnerPSK");
 331
 332     return res;
 333 }
 334
 335 CAResult_t CAInitiateHandshake(const CAEndpoint_t *endpoint)
 336 {
 337     OIC_LOG_V(DEBUG, TAG, "IN : CAInitiateHandshake");
 338     CAResult_t res = CA_STATUS_OK;
 339
 340     if (!endpoint)
 341     {
 342         return CA_STATUS_INVALID_PARAM;
 343     }
 344
 345     res = CADtlsInitiateHandshake(endpoint);
 346     if (CA_STATUS_OK != res)
 347     {
 348         OIC_LOG_V(ERROR, TAG, "Failed to CADtlsInitiateHandshake : %d", res);
 349     }
 350
 351     OIC_LOG_V(DEBUG, TAG, "OUT : CAInitiateHandshake");
 352
 353     return res;
 354 }
 355
 356 CAResult_t CACloseDtlsSession(const CAEndpoint_t *endpoint)
 357 {
 358     OIC_LOG_V(DEBUG, TAG, "IN : CACloseDtlsSession");
 359     CAResult_t res = CA_STATUS_OK;
 360
 361     if (!endpoint)
 362     {
 363         return CA_STATUS_INVALID_PARAM;
 364     }
 365
 366     res = CADtlsClose(endpoint);
 367     if (CA_STATUS_OK != res)
 368     {
 369         OIC_LOG_V(ERROR, TAG, "Failed to CADtlsClose : %d", res);
 370     }
 371
 372     OIC_LOG_V(DEBUG, TAG, "OUT : CACloseDtlsSession");
 373
 374     return res;
 375 }
 376
 377 #endif /* __WITH_DTLS__ */