f72b1573ec83b22ca53eee6cb57a668a54e19106
[iotivity.git] / 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 "experimental/logger.h"
27
28 #define TAG "OIC_CA_REMOTE_HANDLER"
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     // check the method type of request info.
59     // Keep this check in sync with CAMethod_t
60     switch (rep->method)
61     {
62         case CA_GET:
63         case CA_POST:
64         case CA_PUT:
65         case CA_DELETE:
66             break;
67         default:
68             OIC_LOG_V(ERROR, TAG, "Method %u is invalid", rep->method);
69             return NULL;
70     }
71
72     // allocate the request info structure.
73     CARequestInfo_t *clone = (CARequestInfo_t *) OICMalloc(sizeof(CARequestInfo_t));
74     if (!clone)
75     {
76         OIC_LOG(ERROR, TAG, "CACloneRequestInfo Out of memory");
77         return NULL;
78     }
79
80     CAResult_t result = CACloneInfo(&rep->info, &clone->info);
81     if(CA_STATUS_OK != result)
82     {
83         OIC_LOG(ERROR, TAG, "CACloneRequestInfo error in CACloneInfo");
84         CADestroyRequestInfoInternal(clone);
85         return NULL;
86     }
87
88     clone->method = rep->method;
89     clone->isMulticast = rep->isMulticast;
90
91     return clone;
92 }
93
94 CAResponseInfo_t *CACloneResponseInfo(const CAResponseInfo_t *rep)
95 {
96     if (NULL == rep)
97     {
98         OIC_LOG(ERROR, TAG, "Response pointer is NULL");
99         return NULL;
100     }
101
102     // check the result value of response info.
103     // Keep this check in sync with CAResponseResult_t
104     switch (rep->result)
105     {
106         case CA_EMPTY:
107         case CA_CREATED:
108         case CA_DELETED:
109         case CA_VALID:
110         case CA_CHANGED:
111         case CA_CONTENT:
112         case CA_CONTINUE:
113         case CA_BAD_REQ:
114         case CA_UNAUTHORIZED_REQ:
115         case CA_BAD_OPT:
116         case CA_FORBIDDEN_REQ:
117         case CA_NOT_FOUND:
118         case CA_METHOD_NOT_ALLOWED:
119         case CA_NOT_ACCEPTABLE:
120         case CA_REQUEST_ENTITY_INCOMPLETE:
121         case CA_REQUEST_ENTITY_TOO_LARGE:
122         case CA_INTERNAL_SERVER_ERROR:
123         case CA_BAD_GATEWAY:
124         case CA_SERVICE_UNAVAILABLE:
125         case CA_RETRANSMIT_TIMEOUT:
126         case CA_PROXY_NOT_SUPPORTED:
127             break;
128         default:
129             OIC_LOG_V(ERROR, TAG, "Response code  %u is invalid", rep->result);
130             return NULL;
131     }
132
133     // allocate the response info structure.
134     CAResponseInfo_t *clone = (CAResponseInfo_t *) OICCalloc(1, sizeof(CAResponseInfo_t));
135     if (NULL == clone)
136     {
137         OIC_LOG(ERROR, TAG, "CACloneResponseInfo Out of memory");
138         return NULL;
139     }
140
141     CAResult_t result = CACloneInfo(&rep->info, &clone->info);
142     if(CA_STATUS_OK != result)
143     {
144         OIC_LOG(ERROR, TAG, "CACloneResponseInfo error in CACloneInfo");
145         CADestroyResponseInfoInternal(clone);
146         return NULL;
147     }
148
149     clone->isMulticast = rep->isMulticast;
150     clone->result = rep->result;
151     return clone;
152 }
153
154 CAEndpoint_t *CACreateEndpointObject(CATransportFlags_t flags,
155                                      CATransportAdapter_t adapter,
156                                      const char *address,
157                                      uint16_t port)
158 {
159     CAEndpoint_t *info = (CAEndpoint_t *)OICCalloc(1, sizeof(CAEndpoint_t));
160     if (NULL == info)
161     {
162         OIC_LOG(ERROR, TAG, "Memory allocation failed !");
163         return NULL;
164     }
165
166     if (address)
167     {
168         OICStrcpy(info->addr, sizeof(info->addr), address);
169         info->addr[MAX_ADDR_STR_SIZE_CA - 1] = '\0';
170     }
171     info->flags = flags;
172     info->adapter = adapter;
173     info->port = port;
174
175     return info;
176 }
177
178 void CAFreeEndpoint(CAEndpoint_t *rep)
179 {
180     OICFree(rep);
181 }
182
183 static void CADestroyInfoInternal(CAInfo_t *info)
184 {
185     // free token field
186     OICFree(info->token);
187     info->token = NULL;
188     info->tokenLength = 0;
189
190     // free options field
191     OICFree(info->options);
192     info->options = NULL;
193     info->numOptions = 0;
194
195     // free payload field
196     OICFree((char *) info->payload);
197     info->payload = NULL;
198     info->payloadSize = 0;
199
200     // free uri
201     OICFree(info->resourceUri);
202     info->resourceUri = NULL;
203 }
204
205 void CADestroyRequestInfoInternal(CARequestInfo_t *rep)
206 {
207     if (NULL == rep)
208     {
209         OIC_LOG(ERROR, TAG, "parameter is null");
210         return;
211     }
212
213     CADestroyInfoInternal(&rep->info);
214     OICFree(rep);
215 }
216
217 void CADestroyResponseInfoInternal(CAResponseInfo_t *rep)
218 {
219     if (NULL == rep)
220     {
221         OIC_LOG(ERROR, TAG, "parameter is null");
222         return;
223     }
224
225     CADestroyInfoInternal(&rep->info);
226     OICFree(rep);
227 }
228
229 void CADestroyErrorInfoInternal(CAErrorInfo_t *errorInfo)
230 {
231     if (NULL == errorInfo)
232     {
233         OIC_LOG(ERROR, TAG, "parameter is null");
234         return;
235     }
236
237     CADestroyInfoInternal(&errorInfo->info);
238     OICFree(errorInfo);
239 }
240
241 CAResult_t CACloneInfo(const CAInfo_t *info, CAInfo_t *clone)
242 {
243     if (!info || !clone)
244     {
245         OIC_LOG(ERROR, TAG, "input parameter invalid");
246         return CA_STATUS_INVALID_PARAM;
247     }
248
249     memset(clone, 0 , sizeof(CAInfo_t));
250
251     //Do not free clone. we cannot declare it const, as the content is modified
252     if ((info->token) && (0 < info->tokenLength))
253     {
254         // allocate token field
255         uint8_t len = info->tokenLength;
256
257         char *temp = (char *) OICMalloc(len * sizeof(char));
258         if (!temp)
259         {
260             OIC_LOG(ERROR, TAG, "CACloneInfo Out of memory");
261             goto exit;
262         }
263
264         memcpy(temp, info->token, len);
265         // save the token
266         clone->token = temp;
267         clone->tokenLength = len;
268     }
269
270     if (info->options && (0 < info->numOptions))
271     {
272         // save the options
273         clone->options =
274             (CAHeaderOption_t *) OICMalloc(sizeof(CAHeaderOption_t) * info->numOptions);
275
276         if (!clone->options)
277         {
278             OIC_LOG(ERROR, TAG, "CACloneInfo Out of memory");
279             goto exit;
280         }
281         memcpy(clone->options, info->options, sizeof(CAHeaderOption_t) * info->numOptions);
282         clone->numOptions = info->numOptions;
283     }
284
285     memcpy(&(clone->identity), &(info->identity), sizeof(info->identity));
286
287     if ((info->payload) && (0 < info->payloadSize))
288     {
289         // allocate payload field
290         uint8_t *temp = OICMalloc(info->payloadSize);
291         if (!temp)
292         {
293             OIC_LOG(ERROR, TAG, "CACloneInfo Out of memory");
294             goto exit;
295         }
296         memcpy(temp, info->payload, info->payloadSize);
297
298         // save the payload
299         clone->payload = temp;
300         clone->payloadSize = info->payloadSize;
301     }
302     clone->payloadFormat = info->payloadFormat;
303     clone->acceptFormat = info->acceptFormat;
304     clone->payloadVersion = info->payloadVersion;
305     clone->acceptVersion = info->acceptVersion;
306
307     if (info->resourceUri)
308     {
309         // allocate payload field
310         char *temp = OICStrdup(info->resourceUri);
311         if (!temp)
312         {
313             OIC_LOG(ERROR, TAG, "CACloneInfo Out of memory");
314             goto exit;
315         }
316
317         // save the resourceUri
318         clone->resourceUri = temp;
319     }
320
321 #ifdef ROUTING_GATEWAY
322     clone->skipRetransmission = info->skipRetransmission;
323 #endif
324
325     clone->messageId = info->messageId;
326     clone->type = info->type;
327
328     return CA_STATUS_OK;
329
330 exit:
331     CADestroyInfoInternal(clone);
332     return CA_MEMORY_ALLOC_FAILED;
333 }