resource/provisioning/src/OCCloudProvisioning.cpp

   1 /* *****************************************************************
   2  *
   3  * Copyright 2016 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 "ocstack.h"
  22 #include "OCCloudProvisioning.hpp"
  23
  24 namespace OC
  25 {
  26     void OCCloudProvisioning::callbackWrapper(void *ctx,
  27             OCStackResult result,
  28             void *data)
  29     {
  30         CloudProvisionContext* context = static_cast<CloudProvisionContext*>(ctx);
  31
  32         std::thread exec(context->callback, result, data);
  33         exec.detach();
  34
  35         delete context;
  36     }
  37
  38     void OCCloudProvisioning::aclIdResponseWrapper(void *ctx,
  39             OCStackResult result,
  40             void *data)
  41     {
  42         std::string aclId = "";
  43         AclIdContext* context = static_cast<AclIdContext*>(ctx);
  44
  45         if ((OC_STACK_OK == result) && data)
  46         {
  47             aclId = (char *)data;
  48         }
  49         std::thread exec(context->callback, result, aclId);
  50         exec.detach();
  51
  52         delete context;
  53     }
  54
  55     OCCloudProvisioning::OCCloudProvisioning(std::string& ipAddr, uint16_t port)
  56     {
  57         memset(&m_devAddr, 0, sizeof(m_devAddr));
  58         memcpy(m_devAddr.addr, ipAddr.c_str(), MAX_ADDR_STR_SIZE);
  59         m_devAddr.port = port;
  60     }
  61
  62     OCCloudProvisioning::~OCCloudProvisioning(void)
  63     {
  64     }
  65
  66     OCStackResult OCCloudProvisioning::requestCertificate(ResponseCallBack callback)
  67     {
  68         if (!callback)
  69         {
  70             oclog() <<"Result callback can't be null";
  71             return OC_STACK_INVALID_CALLBACK;
  72         }
  73
  74         OCStackResult result;
  75         auto cLock = OCPlatform_impl::Instance().csdkLock().lock();
  76
  77         if (cLock)
  78         {
  79             CloudProvisionContext *context = new CloudProvisionContext(callback);
  80
  81             std::lock_guard<std::recursive_mutex> lock(*cLock);
  82             result = OCCloudCertificateIssueRequest(static_cast<void*>(context), &m_devAddr,
  83                     &OCCloudProvisioning::callbackWrapper);
  84         }
  85         else
  86         {
  87             oclog() <<"Mutex not found";
  88             result = OC_STACK_ERROR;
  89         }
  90         return result;
  91     }
  92
  93     OCStackResult OCCloudProvisioning::getIndividualAclInfo(const std::string& aclId,
  94                         ResponseCallBack callback)
  95     {
  96         if (!callback)
  97         {
  98             oclog() <<"Result callback can't be null";
  99             return OC_STACK_INVALID_CALLBACK;
 100         }
 101
 102         OCStackResult result;
 103         auto cLock = OCPlatform_impl::Instance().csdkLock().lock();
 104
 105         if (cLock)
 106         {
 107             CloudProvisionContext *context = new CloudProvisionContext(callback);
 108
 109             std::lock_guard<std::recursive_mutex> lock(*cLock);
 110             result = OCCloudAclIndividualGetInfo(static_cast<void*>(context), aclId.c_str(),
 111                     &m_devAddr,
 112                     &OCCloudProvisioning::callbackWrapper);
 113         }
 114         else
 115         {
 116             oclog() <<"Mutex not found";
 117             result = OC_STACK_ERROR;
 118         }
 119         return result;
 120     }
 121
 122     OCStackResult OCCloudProvisioning::getAclIdByDevice(const std::string& deviceId,
 123                                                         AclIdResponseCallBack callback)
 124     {
 125         if (!callback)
 126         {
 127             oclog() <<"Result callback can't be null";
 128             return OC_STACK_INVALID_CALLBACK;
 129         }
 130
 131         OCStackResult result;
 132         auto cLock = OCPlatform_impl::Instance().csdkLock().lock();
 133
 134         if (cLock)
 135         {
 136             AclIdContext *context = new AclIdContext(callback);
 137
 138             std::lock_guard<std::recursive_mutex> lock(*cLock);
 139             result = OCCloudGetAclIdByDevice(static_cast<void*>(context), deviceId.c_str(),
 140                     &m_devAddr,
 141                     &OCCloudProvisioning::aclIdResponseWrapper);
 142         }
 143         else
 144         {
 145             oclog() <<"Mutex not found";
 146             result = OC_STACK_ERROR;
 147         }
 148         return result;
 149     }
 150
 151     OCStackResult OCCloudProvisioning::getCRL(ResponseCallBack callback)
 152     {
 153         if (!callback)
 154         {
 155             oclog() <<"Result callback can't be null";
 156             return OC_STACK_INVALID_CALLBACK;
 157         }
 158
 159         OCStackResult result;
 160         auto cLock = OCPlatform_impl::Instance().csdkLock().lock();
 161
 162         if (cLock)
 163         {
 164             CloudProvisionContext *context = new CloudProvisionContext(callback);
 165
 166             std::lock_guard<std::recursive_mutex> lock(*cLock);
 167             result = OCCloudGetCRL(static_cast<void*>(context), &m_devAddr,
 168                     &OCCloudProvisioning::callbackWrapper);
 169         }
 170         else
 171         {
 172             oclog() <<"Mutex not found";
 173             result = OC_STACK_ERROR;
 174         }
 175         return result;
 176     }
 177
 178     OCStackResult OCCloudProvisioning::postCRL(const std::string& thisUpdate,
 179                                               const std::string& nextUpdate,
 180                                               const OCByteString *crl,
 181                                               const stringArray_t *serialNumbers,
 182                                               ResponseCallBack callback)
 183     {
 184         if (!callback)
 185         {
 186             oclog() <<"Result callback can't be null";
 187             return OC_STACK_INVALID_CALLBACK;
 188         }
 189
 190         OCStackResult result;
 191         auto cLock = OCPlatform_impl::Instance().csdkLock().lock();
 192
 193         if (cLock)
 194         {
 195             CloudProvisionContext *context = new CloudProvisionContext(callback);
 196
 197             std::lock_guard<std::recursive_mutex> lock(*cLock);
 198             result = OCCloudPostCRL(static_cast<void*>(context), thisUpdate.c_str(),
 199                     nextUpdate.c_str(), crl, serialNumbers, &m_devAddr,
 200                     &OCCloudProvisioning::callbackWrapper);
 201         }
 202         else
 203         {
 204             oclog() <<"Mutex not found";
 205             result = OC_STACK_ERROR;
 206         }
 207         return result;
 208     }
 209
 210 }