resource/csdk/stack/src/occlientcb.c

   1 //******************************************************************
   2 //
   3 // Copyright 2014 Intel Mobile Communications GmbH 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
  22 #include "occlientcb.h"
  23 #include "utlist.h"
  24 #include "logger.h"
  25 #include "ocmalloc.h"
  26 #include <string.h>
  27
  28 #include "cacommon.h"
  29 #include "cainterface.h"
  30
  31 /// Module Name
  32 #define TAG PCF("occlientcb")
  33
  34 struct ClientCB *cbList = NULL;
  35 static OCMulticastNode * mcPresenceNodes = NULL;
  36
  37 OCStackResult
  38 AddClientCB (ClientCB** clientCB, OCCallbackData* cbData,
  39              CAToken_t * token, OCDoHandle *handle, OCMethod method,
  40              char * requestUri, char * resourceTypeName)
  41 {
  42     if(!clientCB || !cbData || !token || !handle || !requestUri)
  43     {
  44         return OC_STACK_INVALID_PARAM;
  45     }
  46
  47     ClientCB *cbNode = NULL;
  48
  49     #ifdef WITH_PRESENCE
  50     if(method == OC_REST_PRESENCE)
  51     {   // Retrieve the presence callback structure for this specific requestUri.
  52         cbNode = GetClientCB(NULL, NULL, requestUri);
  53     }
  54     #endif // WITH_PRESENCE
  55
  56     if(!cbNode)// If it does not already exist, create new node.
  57     {
  58         cbNode = (ClientCB*) OCMalloc(sizeof(ClientCB));
  59         if(!cbNode)
  60         {
  61             *clientCB = NULL;
  62             goto exit;
  63         }
  64         else
  65         {
  66             cbNode->callBack = cbData->cb;
  67             cbNode->context = cbData->context;
  68             cbNode->deleteCallback = cbData->cd;
  69             //Note: token memory is allocated in the caller OCDoResource
  70             //but freed in DeleteClientCB
  71             cbNode->token = *token;
  72             cbNode->handle = *handle;
  73             cbNode->method = method;
  74             cbNode->sequenceNumber = 0;
  75             #ifdef WITH_PRESENCE
  76             cbNode->presence = NULL;
  77             cbNode->filterResourceType = NULL;
  78             #endif // WITH_PRESENCE
  79             cbNode->requestUri = requestUri;
  80             LL_APPEND(cbList, cbNode);
  81             *clientCB = cbNode;
  82         }
  83     }
  84     else
  85     {
  86         // Ensure that the handle the SDK hands back up to the application layer for the
  87         // OCDoResource call matches the found ClientCB Node.
  88         *clientCB = cbNode;
  89         cbData->cd(cbData->context);
  90         OCFree(*token);
  91         OCFree(*handle);
  92         OCFree(requestUri);
  93         *handle = cbNode->handle;
  94     }
  95
  96     #ifdef WITH_PRESENCE
  97     if(method == OC_REST_PRESENCE && resourceTypeName)
  98     {
  99         // Amend the found or created node by adding a new resourceType to it.
 100         return InsertResourceTypeFilter(cbNode, resourceTypeName);
 101     }
 102     else
 103     {
 104         OCFree(resourceTypeName);
 105     }
 106     #else
 107     OCFree(resourceTypeName);
 108     #endif
 109
 110     return OC_STACK_OK;
 111
 112     exit:
 113         return OC_STACK_NO_MEMORY;
 114 }
 115
 116 void DeleteClientCB(ClientCB * cbNode)
 117 {
 118     if(cbNode) {
 119         LL_DELETE(cbList, cbNode);
 120         OC_LOG(INFO, TAG, PCF("deleting tokens"));
 121         CADestroyToken (cbNode->token);
 122         OC_LOG_BUFFER(INFO, TAG, (const uint8_t *)cbNode->token, CA_MAX_TOKEN_LEN);
 123         OCFree(cbNode->handle);
 124         OCFree(cbNode->requestUri);
 125         if(cbNode->deleteCallback)
 126         {
 127             cbNode->deleteCallback(cbNode->context);
 128         }
 129
 130         #ifdef WITH_PRESENCE
 131         if(cbNode->presence) {
 132             OCFree(cbNode->presence->timeOut);
 133             OCFree(cbNode->presence);
 134         }
 135         if(cbNode->method == OC_REST_PRESENCE)
 136         {
 137             OCResourceType * pointer = cbNode->filterResourceType;
 138             OCResourceType * next = NULL;
 139             while(pointer)
 140             {
 141                 next = pointer->next;
 142                 OCFree(pointer->resourcetypename);
 143                 OCFree(pointer);
 144                 pointer = next;
 145             }
 146         }
 147         #endif // WITH_PRESENCE
 148         OCFree(cbNode);
 149         cbNode = NULL;
 150     }
 151 }
 152
 153 ClientCB* GetClientCB(const CAToken_t * token, OCDoHandle handle, const char * requestUri)
 154 {
 155     ClientCB* out = NULL;
 156     if(token) {
 157         LL_FOREACH(cbList, out) {
 158             OC_LOG(INFO, TAG, PCF("comparing tokens"));
 159             OC_LOG_BUFFER(INFO, TAG, (const uint8_t *)*token, CA_MAX_TOKEN_LEN);
 160             OC_LOG_BUFFER(INFO, TAG, (const uint8_t *)out->token, CA_MAX_TOKEN_LEN);
 161             if(memcmp(out->token, *token, CA_MAX_TOKEN_LEN) == 0)
 162             {
 163                 return out;
 164             }
 165         }
 166     }
 167     else if(handle) {
 168         LL_FOREACH(cbList, out) {
 169             if(out->handle == handle) {
 170                 return out;
 171             }
 172         }
 173     }
 174     else if(requestUri) {
 175         LL_FOREACH(cbList, out) {
 176             if(out->requestUri && strcmp(out->requestUri, requestUri ) == 0)
 177             {
 178                 return out;
 179             }
 180         }
 181     }
 182     OC_LOG(INFO, TAG, PCF("Callback Not found !!"));
 183     return NULL;
 184 }
 185
 186 #ifdef WITH_PRESENCE
 187 OCStackResult InsertResourceTypeFilter(ClientCB * cbNode, char * resourceTypeName)
 188 {
 189     OCResourceType * newResourceType = NULL;
 190     if(cbNode && resourceTypeName)
 191     {
 192         // Form a new resourceType member.
 193         newResourceType = (OCResourceType *) OCMalloc(sizeof(OCResourceType));
 194         if(!newResourceType)
 195         {
 196             return OC_STACK_NO_MEMORY;
 197         }
 198
 199         newResourceType->next = NULL;
 200         newResourceType->resourcetypename = resourceTypeName;
 201
 202         LL_APPEND(cbNode->filterResourceType, newResourceType);
 203         return OC_STACK_OK;
 204     }
 205     return OC_STACK_ERROR;
 206 }
 207 #endif // WITH_PRESENCE
 208
 209 void DeleteClientCBList() {
 210     ClientCB* out;
 211     ClientCB* tmp;
 212     LL_FOREACH_SAFE(cbList, out, tmp) {
 213         DeleteClientCB(out);
 214     }
 215     cbList = NULL;
 216 }
 217
 218 void FindAndDeleteClientCB(ClientCB * cbNode) {
 219     ClientCB* tmp;
 220     if(cbNode)
 221     {
 222         LL_FOREACH(cbList, tmp)
 223         {
 224             if (cbNode == tmp)
 225             {
 226                 DeleteClientCB(tmp);
 227                 break;
 228             }
 229         }
 230     }
 231 }
 232
 233 OCStackResult AddMCPresenceNode(OCMulticastNode** outnode, char* uri, uint32_t nonce)
 234 {
 235     if(!outnode)
 236     {
 237         return OC_STACK_INVALID_PARAM;
 238     }
 239
 240     OCMulticastNode *node;
 241
 242     node = (OCMulticastNode*) OCMalloc(sizeof(OCMulticastNode));
 243
 244     if (node) {
 245         node->nonce = nonce;
 246         node->uri = uri;
 247         LL_APPEND(mcPresenceNodes, node);
 248         *outnode = node;
 249         return OC_STACK_OK;
 250     }
 251     *outnode = NULL;
 252     return OC_STACK_NO_MEMORY;
 253 }
 254
 255 OCMulticastNode* GetMCPresenceNode(const char * uri) {
 256     OCMulticastNode* out = NULL;
 257
 258     if(uri) {
 259         LL_FOREACH(mcPresenceNodes, out) {
 260             if(out->uri && strcmp(out->uri, uri) == 0) {
 261                 return out;
 262             }
 263         }
 264     }
 265     OC_LOG(INFO, TAG, PCF("MulticastNode Not found !!"));
 266     return NULL;
 267 }
 268