resource/csdk/connectivity/src/adapter_util/caadapterutils.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 "caadapterutils.h"
  22
  23 #include <string.h>
  24 #ifndef __ARDUINO__
  25 #include "oic_malloc.h"
  26 #endif //#ifndef __ARDUINO__
  27 #define CA_ADAPTER_UTILS_TAG "CA_ADAPTER_UTILS"
  28
  29 CALocalConnectivity_t *CAAdapterCreateLocalEndpoint(CAConnectivityType_t type, const char *address,
  30         const char *interfaceName)
  31 {
  32     CALocalConnectivity_t *info = (CALocalConnectivity_t *) OICMalloc(
  33             sizeof(CALocalConnectivity_t));
  34     if (NULL == info)
  35     {
  36         OIC_LOG_V(ERROR, CA_ADAPTER_UTILS_TAG, "Memory allocation failed !");
  37         return NULL;
  38     }
  39     memset(info, 0, sizeof(CALocalConnectivity_t));
  40
  41     info->type = type;
  42     if (address && strlen(address))
  43     {
  44         if (CA_EDR == type)
  45         {
  46             strncpy(info->addressInfo.BT.btMacAddress, address, CA_MACADDR_SIZE - 1);
  47             info->addressInfo.BT.btMacAddress[CA_MACADDR_SIZE - 1] = '\0';
  48         }
  49         else if (CA_LE == type)
  50         {
  51             strncpy(info->addressInfo.LE.leMacAddress, address, CA_MACADDR_SIZE - 1);
  52             info->addressInfo.LE.leMacAddress[CA_MACADDR_SIZE - 1] = '\0';
  53         }
  54         else if (CA_WIFI == type || CA_ETHERNET == type)
  55         {
  56             strncpy(info->addressInfo.IP.ipAddress, address, CA_IPADDR_SIZE - 1);
  57             info->addressInfo.IP.ipAddress[CA_IPADDR_SIZE - 1] = '\0';
  58         }
  59     }
  60
  61     return info;
  62 }
  63
  64 CALocalConnectivity_t *CAAdapterCopyLocalEndpoint(CALocalConnectivity_t *connectivity)
  65 {
  66     VERIFY_NON_NULL_RET(connectivity, CA_ADAPTER_UTILS_TAG, "connectivity is NULL", NULL);
  67
  68     CALocalConnectivity_t *info = (CALocalConnectivity_t *) OICMalloc(
  69             sizeof(CALocalConnectivity_t));
  70     if (NULL == info)
  71     {
  72         OIC_LOG_V(ERROR, CA_ADAPTER_UTILS_TAG, "Memory allocation failed !");
  73         return NULL;
  74     }
  75     memset(info, 0, sizeof(CALocalConnectivity_t));
  76
  77     info->type = connectivity->type;
  78     if (CA_EDR == info->type && strlen(connectivity->addressInfo.BT.btMacAddress))
  79     {
  80         strncpy(info->addressInfo.BT.btMacAddress, connectivity->addressInfo.BT.btMacAddress,
  81                 CA_MACADDR_SIZE - 1);
  82         info->addressInfo.BT.btMacAddress[CA_MACADDR_SIZE - 1] = '\0';
  83     }
  84     else if (CA_LE == info->type && strlen(connectivity->addressInfo.LE.leMacAddress))
  85     {
  86         strncpy(info->addressInfo.LE.leMacAddress, connectivity->addressInfo.LE.leMacAddress,
  87                 CA_MACADDR_SIZE - 1);
  88         info->addressInfo.LE.leMacAddress[CA_MACADDR_SIZE - 1] = '\0';
  89     }
  90     else if ((CA_WIFI == info->type || CA_ETHERNET == info->type)
  91             && strlen(connectivity->addressInfo.IP.ipAddress))
  92     {
  93         strncpy(info->addressInfo.IP.ipAddress, connectivity->addressInfo.IP.ipAddress,
  94                 CA_IPADDR_SIZE - 1);
  95         info->addressInfo.IP.ipAddress[CA_IPADDR_SIZE - 1] = '\0';
  96     }
  97
  98     return info;
  99 }
 100
 101 void CAAdapterFreeLocalEndpoint(CALocalConnectivity_t *localEndpoint)
 102 {
 103     if (localEndpoint)
 104     {
 105         OICFree(localEndpoint);
 106     }
 107 }
 108
 109 CARemoteEndpoint_t *CAAdapterCreateRemoteEndpoint(CAConnectivityType_t type, const char *address,
 110         const char *resourceUri)
 111 {
 112     CARemoteEndpoint_t *info = (CARemoteEndpoint_t *) OICMalloc(sizeof(CARemoteEndpoint_t));
 113     if (NULL == info)
 114     {
 115         OIC_LOG_V(ERROR, CA_ADAPTER_UTILS_TAG, "Memory allocation failed !");
 116         return NULL;
 117     }
 118     memset(info, 0, sizeof(CARemoteEndpoint_t));
 119
 120     info->connectivityType = type;
 121     if (address && strlen(address))
 122     {
 123         if (CA_EDR == type)
 124         {
 125             strncpy(info->addressInfo.BT.btMacAddress, address, CA_MACADDR_SIZE - 1);
 126             info->addressInfo.BT.btMacAddress[CA_MACADDR_SIZE - 1] = '\0';
 127         }
 128         else if (CA_LE == info->connectivityType)
 129         {
 130             strncpy(info->addressInfo.LE.leMacAddress, address, CA_MACADDR_SIZE - 1);
 131             info->addressInfo.LE.leMacAddress[CA_MACADDR_SIZE - 1] = '\0';
 132         }
 133         else if (CA_WIFI == type || CA_ETHERNET == type)
 134         {
 135             strncpy(info->addressInfo.IP.ipAddress, address, CA_IPADDR_SIZE - 1);
 136             info->addressInfo.IP.ipAddress[CA_IPADDR_SIZE - 1] = '\0';
 137         }
 138     }
 139
 140     if (resourceUri && strlen(resourceUri))
 141     {
 142         info->resourceUri = OICStrdup(resourceUri);
 143     }
 144
 145     return info;
 146 }
 147
 148 CARemoteEndpoint_t *CAAdapterCopyRemoteEndpoint(const CARemoteEndpoint_t *remoteEndpoint)
 149 {
 150     VERIFY_NON_NULL_RET(remoteEndpoint, CA_ADAPTER_UTILS_TAG, "Remote endpoint is NULL", NULL);
 151
 152     CARemoteEndpoint_t *info = (CARemoteEndpoint_t *) OICMalloc(sizeof(CARemoteEndpoint_t));
 153     if (NULL == info)
 154     {
 155         OIC_LOG_V(ERROR, CA_ADAPTER_UTILS_TAG, "Memory allocation failed !");
 156         return NULL;
 157     }
 158     memset(info, 0, sizeof(CARemoteEndpoint_t));
 159
 160     info->connectivityType = remoteEndpoint->connectivityType;
 161     if (CA_EDR == info->connectivityType && strlen(remoteEndpoint->addressInfo.BT.btMacAddress))
 162     {
 163         strncpy(info->addressInfo.BT.btMacAddress, remoteEndpoint->addressInfo.BT.btMacAddress,
 164                 CA_MACADDR_SIZE - 1);
 165         info->addressInfo.BT.btMacAddress[CA_MACADDR_SIZE - 1] = '\0';
 166     }
 167     else if (CA_LE == info->connectivityType && strlen(remoteEndpoint->addressInfo.LE.leMacAddress))
 168     {
 169         strncpy(info->addressInfo.LE.leMacAddress, remoteEndpoint->addressInfo.LE.leMacAddress,
 170                 CA_MACADDR_SIZE - 1);
 171         info->addressInfo.LE.leMacAddress[CA_MACADDR_SIZE - 1] = '\0';
 172     }
 173     else if ((CA_WIFI == info->connectivityType || CA_ETHERNET == info->connectivityType)
 174             && strlen(remoteEndpoint->addressInfo.IP.ipAddress))
 175     {
 176         strncpy(info->addressInfo.IP.ipAddress, remoteEndpoint->addressInfo.IP.ipAddress,
 177                 CA_IPADDR_SIZE - 1);
 178         info->addressInfo.IP.ipAddress[CA_IPADDR_SIZE - 1] = '\0';
 179         info->addressInfo.IP.port = remoteEndpoint->addressInfo.IP.port;
 180     }
 181
 182     if (remoteEndpoint->resourceUri && strlen(remoteEndpoint->resourceUri))
 183     {
 184         info->resourceUri = OICStrdup(remoteEndpoint->resourceUri);
 185     }
 186
 187     return info;
 188 }
 189
 190 void CAAdapterFreeRemoteEndpoint(CARemoteEndpoint_t *remoteEndpoint)
 191 {
 192     if (remoteEndpoint)
 193     {
 194         if (remoteEndpoint->resourceUri)
 195         {
 196             OICFree(remoteEndpoint->resourceUri);
 197         }
 198
 199         OICFree(remoteEndpoint);
 200     }
 201 }
 202