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                 uint8_t addr1;
 195                 uint8_t addr2;
 196                 uint8_t addr3;
 197                 uint8_t addr4;
 198                 uint16_t port;
 199
 200                 ostringstream os;
 201
 202                 if(sec== OCSecureType::IPv4)
 203                 {
 204                     os<<"coap://";
 205                 }
 206                 else if(sec == OCSecureType::IPv4Secure)
 207                 {
 208                     os<<"coaps://";
 209                 }
 210                 else
 211                 {
 212                     oclog() << "ConvertOCAddrToString():  invalid SecureType"<<std::flush;
 213                     throw ResourceInitException(false, false, false, false, false, true);
 214                 }
 215
 216                 if(0== OCDevAddrToIPv4Addr(&m_address, &addr1, &addr2, &addr3, &addr4))
 217                 {
 218                     // nothing to do, successful case.
 219                 }
 220                 else
 221                 {
 222                     oclog() << "ConvertOCAddrToString(): Invalid Ip"
 223                         << std::flush;
 224                     throw ResourceInitException(false, false, false, false, false, true);
 225                 }
 226
 227                 os<<static_cast<int>(addr1)<<'.'
 228                     <<static_cast<int>(addr2)<<'.'
 229                     <<static_cast<int>(addr3)<<'.'
 230                     <<static_cast<int>(addr4);
 231
 232                 if(sec == OCSecureType::IPv4Secure && secureport>0 && secureport<=65535)
 233                 {
 234                     port = static_cast<uint16_t>(secureport);
 235                 }
 236                 else if(sec == OCSecureType::IPv4 && 0==OCDevAddrToPort(&m_address, &port))
 237                 {
 238                     // nothing to do, this is a successful case
 239                 }
 240                 else
 241                 {
 242                     oclog() << "ConvertOCAddrToString() : Invalid Port"
 243                             <<std::flush;
 244                     throw ResourceInitException(false, false, false, false, true, false);
 245                 }
 246
 247                 os <<":"<< static_cast<int>(port);
 248
 249                 return os.str();
 250             }
 251
 252             void LoadFromJson(std::stringstream& json)
 253             {
 254                 cereal::JSONInputArchive archive(json);
 255
 256                 std::vector<ListenResourceContainer> resources;
 257                 archive(cereal::make_nvp(OC::Key::OCKEY, resources));
 258
 259                 m_resources.clear();
 260
 261                 for(const auto& res : resources)
 262                 {
 263                     try
 264                     {
 265                         if(res.loaded())
 266                         {
 267                             m_resources.push_back(std::shared_ptr<OCResource>(
 268                                 new OCResource(m_clientWrapper,
 269                                     ConvertOCAddrToString(res.secureType(),res.port()),
 270                                     res.m_uri, res.observable(), res.resourceTypes(),
 271                                     res.interfaces())));
 272                         }
 273
 274                     }
 275                     catch(ResourceInitException& e)
 276                     {
 277                         oclog() << "listenCallback(): failed to create resource: " << e.what()
 278                                 << std::flush;
 279                     }
 280                 }
 281             }
 282             std::vector<std::shared_ptr<OC::OCResource>> m_resources;
 283             std::weak_ptr<IClientWrapper> m_clientWrapper;
 284             OCDevAddr m_address;
 285     };
 286 }