extras/vom/vom/api_types.cpp

   1 /*
   2  * Copyright (c) 2018 Cisco and/or its affiliates.
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15
  16 #include <vom/api_types.hpp>
  17
  18 namespace VOM {
  19
  20 vapi_enum_ip_neighbor_flags
  21 to_api(const neighbour::flags_t& f)
  22 {
  23   vapi_enum_ip_neighbor_flags out = IP_API_NEIGHBOR_FLAG_NONE;
  24
  25   if (f & neighbour::flags_t::STATIC)
  26     out = static_cast<vapi_enum_ip_neighbor_flags>(out |
  27                                                    IP_API_NEIGHBOR_FLAG_STATIC);
  28   if (f & neighbour::flags_t::NO_FIB_ENTRY)
  29     out = static_cast<vapi_enum_ip_neighbor_flags>(
  30       out | IP_API_NEIGHBOR_FLAG_NO_FIB_ENTRY);
  31
  32   return (out);
  33 }
  34
  35 const neighbour::flags_t
  36 from_api(vapi_enum_ip_neighbor_flags f)
  37 {
  38   neighbour::flags_t out = neighbour::flags_t::NONE;
  39
  40   if (f & IP_API_NEIGHBOR_FLAG_STATIC)
  41     out |= neighbour::flags_t::STATIC;
  42   if (f & IP_API_NEIGHBOR_FLAG_NO_FIB_ENTRY)
  43     out |= neighbour::flags_t::NO_FIB_ENTRY;
  44
  45   return out;
  46 }
  47
  48 invalid_decode::invalid_decode(const std::string reason)
  49   : reason(reason)
  50 {
  51 }
  52
  53 void
  54 to_api(const boost::asio::ip::address_v4& a, vapi_type_ip4_address& v)
  55 {
  56   std::copy_n(std::begin(a.to_bytes()), a.to_bytes().size(), v);
  57 }
  58 void
  59 to_api(const boost::asio::ip::address_v6& a, vapi_type_ip6_address& v)
  60 {
  61   std::copy_n(std::begin(a.to_bytes()), a.to_bytes().size(), v);
  62 }
  63
  64 void
  65 to_api(const ip_address_t& a, vapi_type_address& v)
  66 {
  67   if (a.is_v4()) {
  68     v.af = ADDRESS_IP4;
  69     memcpy(v.un.ip4, a.to_v4().to_bytes().data(), 4);
  70   } else {
  71     v.af = ADDRESS_IP6;
  72     memcpy(v.un.ip6, a.to_v6().to_bytes().data(), 16);
  73   }
  74 }
  75
  76 void
  77 to_api(const ip_address_t& a,
  78        vapi_union_address_union& u,
  79        vapi_enum_address_family& af)
  80 {
  81   if (a.is_v4()) {
  82     af = ADDRESS_IP4;
  83     memcpy(u.ip4, a.to_v4().to_bytes().data(), 4);
  84   } else {
  85     af = ADDRESS_IP6;
  86     memcpy(u.ip6, a.to_v6().to_bytes().data(), 16);
  87   }
  88 }
  89
  90 void
  91 to_api(const ip_address_t& a, vapi_union_address_union& u)
  92 {
  93   if (a.is_v4()) {
  94     memcpy(u.ip4, a.to_v4().to_bytes().data(), 4);
  95   } else {
  96     memcpy(u.ip6, a.to_v6().to_bytes().data(), 16);
  97   }
  98 }
  99
 100 boost::asio::ip::address_v6
 101 from_api(const vapi_type_ip6_address& v)
 102 {
 103   std::array<uint8_t, 16> a;
 104   std::copy(v, v + 16, std::begin(a));
 105   boost::asio::ip::address_v6 v6(a);
 106
 107   return v6;
 108 }
 109
 110 boost::asio::ip::address_v4
 111 from_api(const vapi_type_ip4_address& v)
 112 {
 113   std::array<uint8_t, 4> a;
 114   std::copy(v, v + 4, std::begin(a));
 115   boost::asio::ip::address_v4 v4(a);
 116
 117   return v4;
 118 }
 119
 120 ip_address_t
 121 from_api(const vapi_type_address& v)
 122 {
 123   boost::asio::ip::address addr;
 124
 125   if (ADDRESS_IP6 == v.af) {
 126     std::array<uint8_t, 16> a;
 127     std::copy(v.un.ip6, v.un.ip6 + 16, std::begin(a));
 128     boost::asio::ip::address_v6 v6(a);
 129     addr = v6;
 130   } else {
 131     std::array<uint8_t, 4> a;
 132     std::copy(v.un.ip6, v.un.ip6 + 4, std::begin(a));
 133     boost::asio::ip::address_v4 v4(a);
 134     addr = v4;
 135   }
 136
 137   return addr;
 138 }
 139
 140 ip_address_t
 141 from_api(const vapi_union_address_union& u, vapi_enum_fib_path_nh_proto proto)
 142 {
 143   boost::asio::ip::address addr;
 144
 145   if (FIB_API_PATH_NH_PROTO_IP6 == proto) {
 146     std::array<uint8_t, 16> a;
 147     std::copy(u.ip6, u.ip6 + 16, std::begin(a));
 148     boost::asio::ip::address_v6 v6(a);
 149     addr = v6;
 150   } else if (FIB_API_PATH_NH_PROTO_IP4 == proto) {
 151     std::array<uint8_t, 4> a;
 152     std::copy(u.ip6, u.ip6 + 4, std::begin(a));
 153     boost::asio::ip::address_v4 v4(a);
 154     addr = v4;
 155   }
 156
 157   return addr;
 158 }
 159
 160 ip_address_t
 161 from_api(const vapi_union_address_union& u, vapi_enum_address_family af)
 162 {
 163   boost::asio::ip::address addr;
 164
 165   if (ADDRESS_IP6 == af) {
 166     std::array<uint8_t, 16> a;
 167     std::copy(u.ip6, u.ip6 + 16, std::begin(a));
 168     boost::asio::ip::address_v6 v6(a);
 169     addr = v6;
 170   } else {
 171     std::array<uint8_t, 4> a;
 172     std::copy(u.ip6, u.ip6 + 4, std::begin(a));
 173     boost::asio::ip::address_v4 v4(a);
 174     addr = v4;
 175   }
 176
 177   return addr;
 178 }
 179
 180 void
 181 to_api(const mac_address_t& a, vapi_type_mac_address& v)
 182 {
 183   std::copy(std::begin(a.bytes), std::end(a.bytes), v);
 184 }
 185
 186 mac_address_t
 187 from_api(const vapi_type_mac_address& v)
 188 {
 189   return mac_address_t(v);
 190 }
 191
 192 route::prefix_t
 193 from_api(const vapi_type_prefix& v)
 194 {
 195   return route::prefix_t(from_api(v.address), v.address_length);
 196 }
 197
 198 vapi_type_prefix
 199 to_api(const route::prefix_t& p)
 200 {
 201   vapi_type_prefix v;
 202   to_api(p.address(), v.address);
 203   v.address_length = p.mask_width();
 204   return v;
 205 }
 206
 207 route::mprefix_t
 208 from_api(const vapi_type_mprefix& v)
 209 {
 210   return route::mprefix_t(from_api(v.src_address, v.af),
 211                           from_api(v.grp_address, v.af), v.grp_address_length);
 212 }
 213
 214 vapi_type_mprefix
 215 to_api(const route::mprefix_t& p)
 216 {
 217   vapi_enum_address_family af;
 218   vapi_type_mprefix v;
 219   to_api(p.grp_address(), v.grp_address, af);
 220   to_api(p.src_address(), v.src_address, af);
 221   v.grp_address_length = p.mask_width();
 222   v.af = af;
 223   return v;
 224 }
 225
 226 vapi_enum_fib_path_nh_proto
 227 to_api(const nh_proto_t& p)
 228 {
 229   if (p == nh_proto_t::IPV4) {
 230     return FIB_API_PATH_NH_PROTO_IP4;
 231   } else if (p == nh_proto_t::IPV6) {
 232     return FIB_API_PATH_NH_PROTO_IP6;
 233   } else if (p == nh_proto_t::ETHERNET) {
 234     return FIB_API_PATH_NH_PROTO_ETHERNET;
 235   } else if (p == nh_proto_t::MPLS) {
 236     return FIB_API_PATH_NH_PROTO_MPLS;
 237   }
 238
 239   return FIB_API_PATH_NH_PROTO_IP4;
 240 }
 241 const nh_proto_t&
 242 from_api(vapi_enum_fib_path_nh_proto p)
 243 {
 244   switch (p) {
 245     case FIB_API_PATH_NH_PROTO_IP4:
 246       return nh_proto_t::IPV4;
 247     case FIB_API_PATH_NH_PROTO_IP6:
 248       return nh_proto_t::IPV6;
 249     case FIB_API_PATH_NH_PROTO_ETHERNET:
 250       return nh_proto_t::ETHERNET;
 251     case FIB_API_PATH_NH_PROTO_MPLS:
 252       return nh_proto_t::MPLS;
 253     case FIB_API_PATH_NH_PROTO_BIER:
 254       break;
 255   }
 256
 257   return nh_proto_t::IPV4;
 258 }
 259
 260 }; // VOM
 261
 262 /*
 263  * fd.io coding-style-patch-verification: ON
 264  *
 265  * Local Variables:
 266  * eval: (c-set-style "mozilla")
 267  * End:
 268  */