src/vnet/ip/ip_types_api.c

   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 <vlibapi/api_types.h>
  17 #include <vnet/ip/ip_types_api.h>
  18
  19 #define vl_typedefs             /* define message structures */
  20 #include <vnet/vnet_all_api_h.h>
  21 #undef vl_typedefs
  22
  23 #define vl_endianfun            /* define message structures */
  24 #include <vnet/vnet_all_api_h.h>
  25 #undef vl_endianfun
  26
  27 /* instantiate all the print functions we know about */
  28 #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
  29 #define vl_printfun
  30 #include <vnet/vnet_all_api_h.h>
  31 #undef vl_printfun
  32
  33 int
  34 ip_address_family_decode (int _af, ip_address_family_t * out)
  35 {
  36   vl_api_address_family_t af = clib_host_to_net_u32 (_af);
  37
  38   switch (af)
  39     {
  40     case ADDRESS_IP4:
  41       *out = AF_IP4;
  42       return (0);
  43     case ADDRESS_IP6:
  44       *out = AF_IP6;
  45       return (0);
  46     }
  47   return (-1);
  48 }
  49
  50 int
  51 ip_address_family_encode (ip_address_family_t af)
  52 {
  53   switch (af)
  54     {
  55     case AF_IP4:
  56       return (clib_host_to_net_u32 (ADDRESS_IP4));
  57     case AF_IP6:
  58       return (clib_host_to_net_u32 (ADDRESS_IP6));
  59     }
  60
  61   ASSERT (0);
  62   return (clib_host_to_net_u32 (ADDRESS_IP4));
  63 }
  64
  65 int
  66 ip_proto_decode (int _ipp, ip_protocol_t * out)
  67 {
  68   ip_protocol_t ipp = clib_host_to_net_u32 (_ipp);
  69
  70   switch (ipp)
  71     {
  72 #define ip_protocol(n,s)                       \
  73       case IP_PROTOCOL_##s:                    \
  74         *out = IP_PROTOCOL_##s;                \
  75         return (0);
  76 #include "protocols.def"
  77 #undef ip_protocol
  78     }
  79   return (-1);
  80 }
  81
  82 int
  83 ip_proto_encode (ip_protocol_t ipp)
  84 {
  85   switch (ipp)
  86     {
  87 #define ip_protocol(n,s)                                \
  88       case IP_PROTOCOL_##s:                             \
  89         return (clib_host_to_net_u32 (IP_PROTOCOL_##s));
  90 #include "protocols.def"
  91 #undef ip_protocol
  92     }
  93
  94   ASSERT (0);
  95   return (clib_host_to_net_u32 (IP_API_PROTO_TCP));
  96 }
  97
  98 void
  99 ip6_address_encode (const ip6_address_t * in, vl_api_ip6_address_t out)
 100 {
 101   clib_memcpy (out, in, sizeof (*in));
 102 }
 103
 104 void
 105 ip6_address_decode (const vl_api_ip6_address_t in, ip6_address_t * out)
 106 {
 107   clib_memcpy (out, in, sizeof (*out));
 108 }
 109
 110 void
 111 ip4_address_encode (const ip4_address_t * in, vl_api_ip4_address_t out)
 112 {
 113   clib_memcpy (out, in, sizeof (*in));
 114 }
 115
 116 void
 117 ip4_address_decode (const vl_api_ip4_address_t in, ip4_address_t * out)
 118 {
 119   clib_memcpy (out, in, sizeof (*out));
 120 }
 121
 122 static ip46_type_t
 123 ip_address_union_decode (const vl_api_address_union_t * in,
 124                          vl_api_address_family_t af, ip46_address_t * out)
 125 {
 126   ip46_type_t type;
 127
 128   switch (clib_net_to_host_u32 (af))
 129     {
 130     case ADDRESS_IP4:
 131       clib_memset (out, 0, sizeof (*out));
 132       clib_memcpy (&out->ip4, &in->ip4, sizeof (out->ip4));
 133       type = IP46_TYPE_IP4;
 134       break;
 135     case ADDRESS_IP6:
 136       clib_memcpy (&out->ip6, &in->ip6, sizeof (out->ip6));
 137       type = IP46_TYPE_IP6;
 138       break;
 139     default:
 140       ASSERT (!"Unkown address family in API address type");
 141       type = IP46_TYPE_ANY;
 142       break;
 143     }
 144
 145   return type;
 146 }
 147
 148 ip46_type_t
 149 ip_address_decode (const vl_api_address_t * in, ip46_address_t * out)
 150 {
 151   return (ip_address_union_decode (&in->un, in->af, out));
 152 }
 153
 154 static void
 155 ip_address_union_encode (const ip46_address_t * in,
 156                          vl_api_address_family_t af,
 157                          vl_api_address_union_t * out)
 158 {
 159   if (ADDRESS_IP6 == clib_net_to_host_u32 (af))
 160     ip6_address_encode (&in->ip6, out->ip6);
 161   else
 162     ip4_address_encode (&in->ip4, out->ip4);
 163 }
 164
 165 void
 166 ip_address_encode (const ip46_address_t * in,
 167                    ip46_type_t type, vl_api_address_t * out)
 168 {
 169   switch (type)
 170     {
 171     case IP46_TYPE_IP4:
 172       out->af = clib_net_to_host_u32 (ADDRESS_IP4);
 173       break;
 174     case IP46_TYPE_IP6:
 175       out->af = clib_net_to_host_u32 (ADDRESS_IP6);
 176       break;
 177     case IP46_TYPE_ANY:
 178       if (ip46_address_is_ip4 (in))
 179         out->af = clib_net_to_host_u32 (ADDRESS_IP4);
 180       else
 181         out->af = clib_net_to_host_u32 (ADDRESS_IP6);
 182       break;
 183     }
 184   ip_address_union_encode (in, out->af, &out->un);
 185 }
 186
 187 void
 188 ip_prefix_decode (const vl_api_prefix_t * in, fib_prefix_t * out)
 189 {
 190   switch (clib_net_to_host_u32 (in->address.af))
 191     {
 192     case ADDRESS_IP4:
 193       out->fp_proto = FIB_PROTOCOL_IP4;
 194       break;
 195     case ADDRESS_IP6:
 196       out->fp_proto = FIB_PROTOCOL_IP6;
 197       break;
 198     }
 199   out->fp_len = in->address_length;
 200   out->___fp___pad = 0;
 201   ip_address_decode (&in->address, &out->fp_addr);
 202 }
 203
 204 void
 205 ip_prefix_encode (const fib_prefix_t * in, vl_api_prefix_t * out)
 206 {
 207   out->address_length = in->fp_len;
 208   ip_address_encode (&in->fp_addr,
 209                      fib_proto_to_ip46 (in->fp_proto), &out->address);
 210 }
 211
 212 void
 213 ip_mprefix_encode (const mfib_prefix_t * in, vl_api_mprefix_t * out)
 214 {
 215   out->af = (FIB_PROTOCOL_IP6 == in->fp_proto ? ADDRESS_IP6 : ADDRESS_IP4);
 216   out->af = clib_host_to_net_u32 (out->af);
 217   out->grp_address_length = clib_host_to_net_u16 (in->fp_len);
 218
 219   ip_address_union_encode (&in->fp_grp_addr, out->af, &out->grp_address);
 220   ip_address_union_encode (&in->fp_src_addr, out->af, &out->src_address);
 221 }
 222
 223 void
 224 ip_mprefix_decode (const vl_api_mprefix_t * in, mfib_prefix_t * out)
 225 {
 226   out->fp_proto = (ADDRESS_IP6 == clib_net_to_host_u32 (in->af) ?
 227                    FIB_PROTOCOL_IP6 : FIB_PROTOCOL_IP4);
 228   out->fp_len = clib_net_to_host_u16 (in->grp_address_length);
 229
 230   ip_address_union_decode (&in->grp_address, in->af, &out->fp_grp_addr);
 231   ip_address_union_decode (&in->src_address, in->af, &out->fp_src_addr);
 232
 233   if (!ip46_address_is_zero (&out->fp_src_addr))
 234     out->fp_len = (out->fp_proto == FIB_PROTOCOL_IP6 ? 256 : 64);
 235 }
 236
 237 /*
 238  * fd.io coding-style-patch-verification: ON
 239  *
 240  * Local Variables:
 241  * eval: (c-set-style "gnu")
 242  * End:
 243  */