resource/csdk/connectivity/common/src/caremotehandler.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 <string.h>
  22
  23 #include "oic_malloc.h"
  24 #include "oic_string.h"
  25 #include "caremotehandler.h"
  26 #include "logger.h"
  27
  28 #define TAG "CA"
  29
  30 CAEndpoint_t *CACloneEndpoint(const CAEndpoint_t *rep)
  31 {
  32     if (NULL == rep)
  33     {
  34         OIC_LOG(ERROR, TAG, "parameter is null");
  35         return NULL;
  36     }
  37
  38     // allocate the remote end point structure.
  39     CAEndpoint_t *clone = (CAEndpoint_t *)OICMalloc(sizeof (CAEndpoint_t));
  40     if (NULL == clone)
  41     {
  42         OIC_LOG(ERROR, TAG, "CACloneRemoteEndpoint Out of memory");
  43         return NULL;
  44     }
  45     *clone = *rep;
  46
  47     return clone;
  48 }
  49
  50 CARequestInfo_t *CACloneRequestInfo(const CARequestInfo_t *rep)
  51 {
  52     if (NULL == rep)
  53     {
  54         OIC_LOG(ERROR, TAG, "parameter is null");
  55         return NULL;
  56     }
  57
  58     // allocate the request info structure.
  59     CARequestInfo_t *clone = (CARequestInfo_t *) OICMalloc(sizeof(CARequestInfo_t));
  60     if (!clone)
  61     {
  62         OIC_LOG(ERROR, TAG, "CACloneRequestInfo Out of memory");
  63         return NULL;
  64     }
  65
  66     CAResult_t result = CACloneInfo(&rep->info, &clone->info);
  67     if(CA_STATUS_OK != result)
  68     {
  69         OIC_LOG(ERROR, TAG, "CACloneRequestInfo error in CACloneInfo");
  70         CADestroyRequestInfoInternal(clone);
  71         return NULL;
  72     }
  73
  74     clone->method = rep->method;
  75     clone->isMulticast = rep->isMulticast;
  76
  77     return clone;
  78 }
  79
  80 CAResponseInfo_t *CACloneResponseInfo(const CAResponseInfo_t *rep)
  81 {
  82     if (NULL == rep)
  83     {
  84         OIC_LOG(ERROR, TAG, "Response pointer is NULL");
  85         return NULL;
  86     }
  87
  88     // check the result value of response info.
  89     // Keep this check in sync with CAResponseResult_t
  90     switch (rep->result)
  91     {
  92         case CA_EMPTY:
  93         case CA_SUCCESS:
  94         case CA_CREATED:
  95         case CA_DELETED:
  96         case CA_VALID:
  97         case CA_CONTENT:
  98         case CA_CHANGED:
  99         case CA_CONTINUE:
 100         case CA_BAD_REQ:
 101         case CA_UNAUTHORIZED_REQ:
 102         case CA_BAD_OPT:
 103         case CA_FORBIDDEN_REQ:
 104         case CA_NOT_FOUND:
 105         case CA_REQUEST_ENTITY_INCOMPLETE:
 106         case CA_REQUEST_ENTITY_TOO_LARGE:
 107         case CA_INTERNAL_SERVER_ERROR:
 108         case CA_RETRANSMIT_TIMEOUT:
 109             break;
 110
 111         default:
 112             OIC_LOG_V(ERROR, TAG, "Response code  %u is invalid", rep->result);
 113             return NULL;
 114     }
 115
 116     // allocate the response info structure.
 117     CAResponseInfo_t *clone = (CAResponseInfo_t *) OICCalloc(1, sizeof(CAResponseInfo_t));
 118     if (NULL == clone)
 119     {
 120         OIC_LOG(ERROR, TAG, "CACloneResponseInfo Out of memory");
 121         return NULL;
 122     }
 123
 124     CAResult_t result = CACloneInfo(&rep->info, &clone->info);
 125     if(CA_STATUS_OK != result)
 126     {
 127         OIC_LOG(ERROR, TAG, "CACloneResponseInfo error in CACloneInfo");
 128         CADestroyResponseInfoInternal(clone);
 129         return NULL;
 130     }
 131
 132     clone->isMulticast = rep->isMulticast;
 133     clone->result = rep->result;
 134     return clone;
 135 }
 136
 137 CAEndpoint_t *CACreateEndpointObject(CATransportFlags_t flags,
 138                                      CATransportAdapter_t adapter,
 139                                      const char *address,
 140                                      uint16_t port)
 141 {
 142     CAEndpoint_t *info = (CAEndpoint_t *)OICCalloc(1, sizeof(CAEndpoint_t));
 143     if (NULL == info)
 144     {
 145         OIC_LOG(ERROR, TAG, "Memory allocation failed !");
 146         return NULL;
 147     }
 148
 149     if (address)
 150     {
 151         OICStrcpy(info->addr, sizeof(info->addr), address);
 152         info->addr[MAX_ADDR_STR_SIZE_CA - 1] = '\0';
 153     }
 154     info->flags = flags;
 155     info->adapter = adapter;
 156     info->port = port;
 157
 158     return info;
 159 }
 160
 161 void CAFreeEndpoint(CAEndpoint_t *rep)
 162 {
 163     OICFree(rep);
 164 }
 165
 166 static void CADestroyInfoInternal(CAInfo_t *info)
 167 {
 168     // free token field
 169     OICFree(info->token);
 170     info->token = NULL;
 171     info->tokenLength = 0;
 172
 173     // free options field
 174     OICFree(info->options);
 175     info->options = NULL;
 176     info->numOptions = 0;
 177
 178     // free payload field
 179     OICFree((char *) info->payload);
 180     info->payload = NULL;
 181     info->payloadSize = 0;
 182
 183     // free uri
 184     OICFree(info->resourceUri);
 185     info->resourceUri = NULL;
 186 }
 187
 188 void CADestroyRequestInfoInternal(CARequestInfo_t *rep)
 189 {
 190     if (NULL == rep)
 191     {
 192         OIC_LOG(ERROR, TAG, "parameter is null");
 193         return;
 194     }
 195
 196     CADestroyInfoInternal(&rep->info);
 197     OICFree(rep);
 198 }
 199
 200 void CADestroyResponseInfoInternal(CAResponseInfo_t *rep)
 201 {
 202     if (NULL == rep)
 203     {
 204         OIC_LOG(ERROR, TAG, "parameter is null");
 205         return;
 206     }
 207
 208     CADestroyInfoInternal(&rep->info);
 209     OICFree(rep);
 210 }
 211
 212 void CADestroyErrorInfoInternal(CAErrorInfo_t *errorInfo)
 213 {
 214     if (NULL == errorInfo)
 215     {
 216         OIC_LOG(ERROR, TAG, "parameter is null");
 217         return;
 218     }
 219
 220     CADestroyInfoInternal(&errorInfo->info);
 221     OICFree(errorInfo);
 222 }
 223
 224 CAResult_t CACloneInfo(const CAInfo_t *info, CAInfo_t *clone)
 225 {
 226     if (!info || !clone)
 227     {
 228         OIC_LOG(ERROR, TAG, "input parameter invalid");
 229         return CA_STATUS_INVALID_PARAM;
 230     }
 231
 232     memset(clone, 0 , sizeof(CAInfo_t));
 233
 234     //Do not free clone. we cannot declare it const, as the content is modified
 235     if ((info->token) && (0 < info->tokenLength))
 236     {
 237         char *temp = NULL;
 238
 239         // allocate token field
 240         uint8_t len = info->tokenLength;
 241
 242         temp = (char *) OICMalloc(len * sizeof(char));
 243         if (!temp)
 244         {
 245             OIC_LOG(ERROR, TAG, "CACloneInfo Out of memory");
 246             return CA_MEMORY_ALLOC_FAILED;
 247         }
 248
 249         memcpy(temp, info->token, len);
 250         // save the token
 251         clone->token = temp;
 252         clone->tokenLength = len;
 253     }
 254
 255     if (info->options && (0 < info->numOptions))
 256     {
 257         // save the options
 258         clone->options =
 259             (CAHeaderOption_t *) OICMalloc(sizeof(CAHeaderOption_t) * info->numOptions);
 260
 261         if (!clone->options)
 262         {
 263             OIC_LOG(ERROR, TAG, "CACloneInfo Out of memory");
 264             CADestroyInfoInternal(clone);
 265             return CA_MEMORY_ALLOC_FAILED;
 266         }
 267         memcpy(clone->options, info->options, sizeof(CAHeaderOption_t) * info->numOptions);
 268         clone->numOptions = info->numOptions;
 269     }
 270
 271     if ((info->payload) && (0 < info->payloadSize))
 272     {
 273         // allocate payload field
 274         uint8_t *temp = OICMalloc(info->payloadSize);
 275         if (!temp)
 276         {
 277             OIC_LOG(ERROR, TAG, "CACloneInfo Out of memory");
 278             CADestroyInfoInternal(clone);
 279             return CA_MEMORY_ALLOC_FAILED;
 280         }
 281         memcpy(temp, info->payload, info->payloadSize);
 282
 283         // save the payload
 284         clone->payload = temp;
 285         clone->payloadSize = info->payloadSize;
 286     }
 287
 288     if (info->resourceUri)
 289     {
 290         // allocate payload field
 291         char *temp = OICStrdup(info->resourceUri);
 292         if (!temp)
 293         {
 294             OIC_LOG(ERROR, TAG, "CACloneInfo Out of memory");
 295             CADestroyInfoInternal(clone);
 296             return CA_MEMORY_ALLOC_FAILED;
 297         }
 298
 299         // save the resourceUri
 300         clone->resourceUri = temp;
 301     }
 302
 303     clone->messageId = info->messageId;
 304     clone->type = info->type;
 305
 306     return CA_STATUS_OK;
 307
 308 }