resource/include/OCSerialization.h

   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 #include <cereal/cereal.hpp>
  22 #include <cereal/types/memory.hpp>
  23 #include <cereal/types/vector.hpp>
  24 #include <cereal/archives/json.hpp>
  25
  26 #include <StringConstants.h>
  27
  28 namespace OC
  29 {
  30     class ListenOCContainer
  31     {
  32         private:
  33         enum class OCSecureType
  34         {
  35             IPv4Secure,
  36             IPv4
  37         };
  38
  39         class ListenResourceContainer
  40         {
  41             class ListenResourcePropertiesContainer
  42             {
  43                 friend class cereal::access;
  44                 friend class ListenResourceContainer;
  45
  46                 template<class Archive>
  47                 void serialize(Archive& ar)
  48                 {
  49                     try
  50                     {
  51                         m_observable=false;
  52                         int obsTemp;
  53                         ar(cereal::make_nvp(OC::Key::OBSERVABLEKEY, obsTemp));
  54                         m_observable = obsTemp != 0;
  55                     }
  56                     catch(cereal::Exception&)
  57                     {
  58                         // we swallow this exception, since it means the key
  59                         // doesn't exist, allowing these to be optional
  60                         ar.setNextName(nullptr);
  61                     }
  62
  63                     try
  64                     {
  65                         m_secure = false;
  66                         int secureTemp;
  67                         ar(cereal::make_nvp(OC::Key::SECUREKEY, secureTemp));
  68                         m_secure = secureTemp != 0;
  69
  70                         m_port = -1;
  71                         ar(cereal::make_nvp(OC::Key::PORTKEY, m_port));
  72                     }
  73                     catch(cereal::Exception&)
  74                     {
  75                         ar.setNextName(nullptr);
  76                     }
  77
  78                     try
  79                     {
  80                         ar(cereal::make_nvp(OC::Key::RESOURCETYPESKEY,m_resourceTypes));
  81                     }
  82                     catch(cereal::Exception&)
  83                     {
  84                         ar.setNextName(nullptr);
  85                     }
  86                     try
  87                     {
  88                         ar(cereal::make_nvp(OC::Key::INTERFACESKEY, m_interfaces));
  89                     }
  90                     catch(cereal::Exception&)
  91                     {
  92                         ar.setNextName(nullptr);
  93                     }
  94                 }
  95
  96                 bool m_observable;
  97                 std::vector<std::string> m_resourceTypes;
  98                 std::vector<std::string> m_interfaces;
  99                 bool m_secure;
 100                 int m_port;
 101             };
 102
 103             public:
 104             ListenResourceContainer() : m_loaded(false)
 105             {}
 106
 107             private:
 108             friend class cereal::access;
 109             friend class ListenOCContainer;
 110
 111             template <class Archive>
 112             void serialize(Archive& ar)
 113             {
 114                 try
 115                 {
 116                     ar(cereal::make_nvp(OC::Key::URIKEY, m_uri));
 117                     m_loaded=true;
 118                 }
 119                 catch(cereal::Exception&)
 120                 {
 121                     ar.setNextName(nullptr);
 122                 }
 123                 try
 124                 {
 125                     ar(cereal::make_nvp(OC::Key::PROPERTYKEY, m_props));
 126                     m_loaded=true;
 127                 }
 128                 catch(cereal::Exception&)
 129                 {
 130                     ar.setNextName(nullptr);
 131                 }
 132             }
 133
 134
 135             std::string m_uri;
 136             bool m_loaded;
 137             ListenResourcePropertiesContainer m_props;
 138
 139             bool loaded() const
 140             {
 141                 return m_loaded;
 142             }
 143
 144             bool observable() const
 145             {
 146                 return m_props.m_observable;
 147             }
 148
 149             OCSecureType secureType() const
 150             {
 151                 return m_props.m_secure?OCSecureType::IPv4Secure :OCSecureType::IPv4;
 152             }
 153
 154             int port() const
 155             {
 156                 return m_props.m_port;
 157             }
 158
 159             std::vector<std::string> resourceTypes() const
 160             {
 161                 return m_props.m_resourceTypes;
 162             }
 163
 164             std::vector<std::string> interfaces() const
 165             {
 166                 return m_props.m_interfaces;
 167             }
 168         };
 169
 170         private:
 171             friend class cereal::access;
 172             template <class Archive>
 173             void serialize(Archive& ar)
 174             {
 175                 std::vector<ListenResourceContainer> resources;
 176                 ar(resources);
 177             }
 178         public:
 179             ListenOCContainer(std::weak_ptr<IClientWrapper> cw, const OCDevAddr& address,
 180                     std::stringstream& json):
 181                 m_clientWrapper(cw), m_address(address)
 182             {
 183                 LoadFromJson(json);
 184             }
 185
 186             const std::vector<std::shared_ptr<OCResource>>& Resources() const
 187             {
 188                 return m_resources;
 189             }
 190
 191         private:
 192             std::string ConvertOCAddrToString(OCSecureType sec, int secureport)
 193             {
 194                 char stringAddress[DEV_ADDR_SIZE_MAX];
 195                 uint16_t port;
 196
 197                 ostringstream os;
 198
 199                 if(sec== OCSecureType::IPv4)
 200                 {
 201                     os<<"coap://";
 202                 }
 203                 else if(sec == OCSecureType::IPv4Secure)
 204                 {
 205                     os<<"coaps://";
 206                 }
 207                 else
 208                 {
 209                     oclog() << "ConvertOCAddrToString():  invalid SecureType"<<std::flush;
 210                     throw ResourceInitException(false, false, false, false, false, true);
 211                 }
 212
 213                 if(0== OCDevAddrToString(&m_address, stringAddress))
 214                 {
 215                     // nothing to do, successful case.
 216                 }
 217                 else
 218                 {
 219                     oclog() << "ConvertOCAddrToString(): Invalid Ip"
 220                         << std::flush;
 221                     throw ResourceInitException(false, false, false, false, false, true);
 222                 }
 223
 224                 os<<stringAddress;
 225
 226                 if(sec == OCSecureType::IPv4Secure && secureport>0 && secureport<=65535)
 227                 {
 228                     port = static_cast<uint16_t>(secureport);
 229                 }
 230                 else if(sec == OCSecureType::IPv4 && 0==OCDevAddrToPort(&m_address, &port))
 231                 {
 232                     // nothing to do, this is a successful case
 233                 }
 234                 else
 235                 {
 236                     oclog() << "ConvertOCAddrToString() : Invalid Port"
 237                         <<std::flush;
 238                     throw ResourceInitException(false, false, false, false, true, false);
 239                 }
 240
 241                 os <<":"<< static_cast<int>(port);
 242
 243                 return os.str();
 244             }
 245
 246             void LoadFromJson(std::stringstream& json)
 247             {
 248                 cereal::JSONInputArchive archive(json);
 249
 250                 std::vector<ListenResourceContainer> resources;
 251                 archive(cereal::make_nvp(OC::Key::OCKEY, resources));
 252
 253                 m_resources.clear();
 254
 255                 for(const auto& res : resources)
 256                 {
 257                     try
 258                     {
 259                         if(res.loaded())
 260                         {
 261                             m_resources.push_back(std::shared_ptr<OCResource>(
 262                                 new OCResource(m_clientWrapper,
 263                                     ConvertOCAddrToString(res.secureType(),res.port()),
 264                                     res.m_uri, res.observable(), res.resourceTypes(),
 265                                     res.interfaces())));
 266                         }
 267
 268                     }
 269                     catch(ResourceInitException& e)
 270                     {
 271                         oclog() << "listenCallback(): failed to create resource: " << e.what()
 272                                 << std::flush;
 273                     }
 274                 }
 275             }
 276             std::vector<std::shared_ptr<OC::OCResource>> m_resources;
 277             std::weak_ptr<IClientWrapper> m_clientWrapper;
 278             OCDevAddr m_address;
 279     };
 280 }