src/plugins/map/map_api.c

   1 /*
   2  *------------------------------------------------------------------
   3  * map_api.c - vnet map api
   4  *
   5  * Copyright (c) 2016 Cisco and/or its affiliates.
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at:
   9  *
  10  *     http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *------------------------------------------------------------------
  18  */
  19
  20 #include <map/map.h>
  21 #include <map/map_msg_enum.h>
  22 #include <vnet/ip/ip.h>
  23 #include <vnet/fib/fib_table.h>
  24 #include <vlibmemory/api.h>
  25
  26 #define vl_typedefs             /* define message structures */
  27 #include <map/map_all_api_h.h>
  28 #undef vl_typedefs
  29
  30 #define vl_endianfun            /* define message structures */
  31 #include <map/map_all_api_h.h>
  32 #undef vl_endianfun
  33
  34 /* instantiate all the print functions we know about */
  35 #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
  36 #define vl_printfun
  37 #include <map/map_all_api_h.h>
  38 #undef vl_printfun
  39
  40 /* Get the API version number */
  41 #define vl_api_version(n,v) static u32 api_version=(v);
  42 #include <map/map_all_api_h.h>
  43 #undef vl_api_version
  44
  45 #define REPLY_MSG_ID_BASE mm->msg_id_base
  46 #include <vlibapi/api_helper_macros.h>
  47
  48 static void
  49 vl_api_map_add_domain_t_handler (vl_api_map_add_domain_t * mp)
  50 {
  51   map_main_t *mm = &map_main;
  52   vl_api_map_add_domain_reply_t *rmp;
  53   int rv = 0;
  54   u32 index;
  55   u8 flags = 0;
  56   char *tag = 0;
  57   u32 len;
  58
  59   len = ntohl (mp->tag.length);
  60   if (len > 0)
  61     {
  62       tag = clib_mem_alloc (len + 1);
  63       clib_memcpy (tag, (char *) mp->tag.buf, len);
  64       tag[len] = 0;
  65     }
  66
  67   rv =
  68     map_create_domain ((ip4_address_t *) & mp->ip4_prefix.prefix,
  69                        mp->ip4_prefix.len,
  70                        (ip6_address_t *) & mp->ip6_prefix.prefix,
  71                        mp->ip6_prefix.len,
  72                        (ip6_address_t *) & mp->ip6_src.prefix,
  73                        mp->ip6_src.len, mp->ea_bits_len, mp->psid_offset,
  74                        mp->psid_length, &index, ntohs (mp->mtu), flags, tag);
  75
  76   if (tag)
  77     clib_mem_free (tag);
  78
  79   /* *INDENT-OFF* */
  80   REPLY_MACRO2(VL_API_MAP_ADD_DOMAIN_REPLY,
  81   ({
  82     rmp->index = ntohl(index);
  83   }));
  84   /* *INDENT-ON* */
  85 }
  86
  87 static void
  88 vl_api_map_del_domain_t_handler (vl_api_map_del_domain_t * mp)
  89 {
  90   map_main_t *mm = &map_main;
  91   vl_api_map_del_domain_reply_t *rmp;
  92   int rv = 0;
  93
  94   rv = map_delete_domain (ntohl (mp->index));
  95
  96   REPLY_MACRO (VL_API_MAP_DEL_DOMAIN_REPLY);
  97 }
  98
  99 static void
 100 vl_api_map_add_del_rule_t_handler (vl_api_map_add_del_rule_t * mp)
 101 {
 102   map_main_t *mm = &map_main;
 103   vl_api_map_del_domain_reply_t *rmp;
 104   int rv = 0;
 105
 106   rv =
 107     map_add_del_psid (ntohl (mp->index), ntohs (mp->psid),
 108                       (ip6_address_t *) & mp->ip6_dst, mp->is_add);
 109
 110   REPLY_MACRO (VL_API_MAP_ADD_DEL_RULE_REPLY);
 111 }
 112
 113 static void
 114 vl_api_map_domain_dump_t_handler (vl_api_map_domain_dump_t * mp)
 115 {
 116   vl_api_map_domain_details_t *rmp;
 117   map_main_t *mm = &map_main;
 118   map_domain_t *d;
 119   map_domain_extra_t *de;
 120   vl_api_registration_t *reg;
 121   u32 map_domain_index;
 122
 123   if (pool_elts (mm->domains) == 0)
 124     return;
 125
 126   reg = vl_api_client_index_to_registration (mp->client_index);
 127   if (!reg)
 128     return;
 129
 130   /* *INDENT-OFF* */
 131   pool_foreach(d, mm->domains,
 132   ({
 133     u32 len;
 134
 135     map_domain_index = d - mm->domains;
 136     de = vec_elt_at_index(mm->domain_extras, map_domain_index);
 137
 138     len = 0;
 139     if (de->tag)
 140       len = strlen(de->tag);
 141
 142     /* Make sure every field is initiated (or don't skip the clib_memset()) */
 143     rmp = vl_msg_api_alloc (sizeof (*rmp) + sizeof(rmp->tag.length) + len);
 144
 145     rmp->_vl_msg_id = htons(VL_API_MAP_DOMAIN_DETAILS + mm->msg_id_base);
 146     rmp->context = mp->context;
 147     rmp->domain_index = htonl(map_domain_index);
 148     clib_memcpy(&rmp->ip6_prefix.prefix, &d->ip6_prefix, sizeof(rmp->ip6_prefix.prefix));
 149     clib_memcpy(&rmp->ip4_prefix.prefix, &d->ip4_prefix, sizeof(rmp->ip4_prefix.prefix));
 150     clib_memcpy(&rmp->ip6_src.prefix, &d->ip6_src, sizeof(rmp->ip6_src.prefix));
 151     rmp->ip6_prefix.len = d->ip6_prefix_len;
 152     rmp->ip4_prefix.len = d->ip4_prefix_len;
 153     rmp->ip6_src.len = d->ip6_src_len;
 154     rmp->ea_bits_len = d->ea_bits_len;
 155     rmp->psid_offset = d->psid_offset;
 156     rmp->psid_length = d->psid_length;
 157     rmp->flags = d->flags;
 158     rmp->mtu = htons(d->mtu);
 159
 160     if (de->tag)
 161       {
 162         rmp->tag.length = htonl (len);
 163         clib_memcpy ((char *)rmp->tag.buf, de->tag, len);
 164       }
 165
 166     vl_api_send_msg (reg, (u8 *) rmp);
 167   }));
 168   /* *INDENT-ON* */
 169 }
 170
 171 static void
 172 vl_api_map_rule_dump_t_handler (vl_api_map_rule_dump_t * mp)
 173 {
 174   vl_api_registration_t *reg;
 175   u16 i;
 176   ip6_address_t dst;
 177   vl_api_map_rule_details_t *rmp;
 178   map_main_t *mm = &map_main;
 179   u32 domain_index = ntohl (mp->domain_index);
 180   map_domain_t *d;
 181
 182   if (pool_elts (mm->domains) == 0)
 183     return;
 184
 185   d = pool_elt_at_index (mm->domains, domain_index);
 186   if (!d || !d->rules)
 187     {
 188       return;
 189     }
 190
 191   reg = vl_api_client_index_to_registration (mp->client_index);
 192   if (!reg)
 193     return;
 194
 195   for (i = 0; i < (0x1 << d->psid_length); i++)
 196     {
 197       dst = d->rules[i];
 198       if (dst.as_u64[0] == 0 && dst.as_u64[1] == 0)
 199         {
 200           continue;
 201         }
 202       rmp = vl_msg_api_alloc (sizeof (*rmp));
 203       clib_memset (rmp, 0, sizeof (*rmp));
 204       rmp->_vl_msg_id = ntohs (VL_API_MAP_RULE_DETAILS + mm->msg_id_base);
 205       rmp->psid = htons (i);
 206       clib_memcpy (&rmp->ip6_dst, &dst, sizeof (rmp->ip6_dst));
 207       rmp->context = mp->context;
 208       vl_api_send_msg (reg, (u8 *) rmp);
 209     }
 210 }
 211
 212 static void
 213 vl_api_map_summary_stats_t_handler (vl_api_map_summary_stats_t * mp)
 214 {
 215   vl_api_map_summary_stats_reply_t *rmp;
 216   vlib_combined_counter_main_t *cm;
 217   vlib_counter_t v;
 218   int i, which;
 219   u64 total_pkts[VLIB_N_RX_TX];
 220   u64 total_bytes[VLIB_N_RX_TX];
 221   map_main_t *mm = &map_main;
 222   vl_api_registration_t *reg;
 223
 224   reg = vl_api_client_index_to_registration (mp->client_index);
 225   if (!reg)
 226     return;
 227
 228   rmp = vl_msg_api_alloc (sizeof (*rmp));
 229   rmp->_vl_msg_id = htons (VL_API_MAP_SUMMARY_STATS_REPLY + mm->msg_id_base);
 230   rmp->context = mp->context;
 231   rmp->retval = 0;
 232
 233   if (pool_elts (mm->domains) == 0)
 234     {
 235       rmp->retval = -1;
 236       goto out;
 237     }
 238
 239   clib_memset (total_pkts, 0, sizeof (total_pkts));
 240   clib_memset (total_bytes, 0, sizeof (total_bytes));
 241
 242   map_domain_counter_lock (mm);
 243   vec_foreach (cm, mm->domain_counters)
 244   {
 245     which = cm - mm->domain_counters;
 246
 247     for (i = 0; i < vlib_combined_counter_n_counters (cm); i++)
 248       {
 249         vlib_get_combined_counter (cm, i, &v);
 250         total_pkts[which] += v.packets;
 251         total_bytes[which] += v.bytes;
 252       }
 253   }
 254
 255   map_domain_counter_unlock (mm);
 256
 257   /* Note: in network byte order! */
 258   rmp->total_pkts[MAP_DOMAIN_COUNTER_RX] =
 259     clib_host_to_net_u64 (total_pkts[MAP_DOMAIN_COUNTER_RX]);
 260   rmp->total_bytes[MAP_DOMAIN_COUNTER_RX] =
 261     clib_host_to_net_u64 (total_bytes[MAP_DOMAIN_COUNTER_RX]);
 262   rmp->total_pkts[MAP_DOMAIN_COUNTER_TX] =
 263     clib_host_to_net_u64 (total_pkts[MAP_DOMAIN_COUNTER_TX]);
 264   rmp->total_bytes[MAP_DOMAIN_COUNTER_TX] =
 265     clib_host_to_net_u64 (total_bytes[MAP_DOMAIN_COUNTER_TX]);
 266   rmp->total_bindings = clib_host_to_net_u64 (pool_elts (mm->domains));
 267   rmp->total_ip4_fragments = 0; // Not yet implemented. Should be a simple counter.
 268   rmp->total_security_check[MAP_DOMAIN_COUNTER_TX] =
 269     clib_host_to_net_u64 (map_error_counter_get
 270                           (ip4_map_node.index, MAP_ERROR_ENCAP_SEC_CHECK));
 271   rmp->total_security_check[MAP_DOMAIN_COUNTER_RX] =
 272     clib_host_to_net_u64 (map_error_counter_get
 273                           (ip4_map_node.index, MAP_ERROR_DECAP_SEC_CHECK));
 274
 275 out:
 276   vl_api_send_msg (reg, (u8 *) rmp);
 277 }
 278
 279
 280 int
 281 map_param_set_fragmentation (bool inner, bool ignore_df)
 282 {
 283   map_main_t *mm = &map_main;
 284
 285   mm->frag_inner = ! !inner;
 286   mm->frag_ignore_df = ! !ignore_df;
 287
 288   return 0;
 289 }
 290
 291 static void
 292   vl_api_map_param_set_fragmentation_t_handler
 293   (vl_api_map_param_set_fragmentation_t * mp)
 294 {
 295   map_main_t *mm = &map_main;
 296   vl_api_map_param_set_fragmentation_reply_t *rmp;
 297   int rv = 0;
 298
 299   rv = map_param_set_fragmentation (mp->inner, mp->ignore_df);
 300
 301   REPLY_MACRO (VL_API_MAP_PARAM_SET_FRAGMENTATION_REPLY);
 302 }
 303
 304
 305 int
 306 map_param_set_icmp (ip4_address_t * icmp_src_address)
 307 {
 308   map_main_t *mm = &map_main;
 309
 310   if (icmp_src_address == 0)
 311     return -1;
 312
 313   mm->icmp4_src_address = *icmp_src_address;
 314
 315   return 0;
 316 }
 317
 318
 319 static void
 320 vl_api_map_param_set_icmp_t_handler (vl_api_map_param_set_icmp_t * mp)
 321 {
 322   map_main_t *mm = &map_main;
 323   vl_api_map_param_set_icmp_reply_t *rmp;
 324   int rv;
 325
 326   rv = map_param_set_icmp ((ip4_address_t *) & mp->ip4_err_relay_src);
 327
 328   REPLY_MACRO (VL_API_MAP_PARAM_SET_ICMP_REPLY);
 329 }
 330
 331
 332 int
 333 map_param_set_icmp6 (u8 enable_unreachable)
 334 {
 335   map_main_t *mm = &map_main;
 336
 337   mm->icmp6_enabled = ! !enable_unreachable;
 338
 339   return 0;
 340 }
 341
 342 static void
 343 vl_api_map_param_set_icmp6_t_handler (vl_api_map_param_set_icmp6_t * mp)
 344 {
 345   map_main_t *mm = &map_main;
 346   vl_api_map_param_set_icmp6_reply_t *rmp;
 347   int rv;
 348
 349   rv = map_param_set_icmp6 (mp->enable_unreachable);
 350
 351   REPLY_MACRO (VL_API_MAP_PARAM_SET_ICMP6_REPLY);
 352 }
 353
 354
 355 static void
 356   vl_api_map_param_add_del_pre_resolve_t_handler
 357   (vl_api_map_param_add_del_pre_resolve_t * mp)
 358 {
 359   map_main_t *mm = &map_main;
 360   vl_api_map_param_add_del_pre_resolve_reply_t *rmp;
 361   int rv = 0;
 362
 363   map_pre_resolve ((ip4_address_t *) & mp->ip4_nh_address,
 364                    (ip6_address_t *) & mp->ip6_nh_address, !mp->is_add);
 365
 366   REPLY_MACRO (VL_API_MAP_PARAM_ADD_DEL_PRE_RESOLVE_REPLY);
 367 }
 368
 369
 370 int
 371 map_param_set_reassembly (bool is_ipv6,
 372                           u16 lifetime_ms,
 373                           u16 pool_size,
 374                           u32 buffers,
 375                           f64 ht_ratio, u32 * reass, u32 * packets)
 376 {
 377   u32 ps_reass = 0, ps_packets = 0;
 378   u32 ht_reass = 0, ht_packets = 0;
 379
 380   if (is_ipv6)
 381     {
 382       if (pool_size != (u16) ~ 0)
 383         {
 384           if (pool_size > MAP_IP6_REASS_CONF_POOL_SIZE_MAX)
 385             return MAP_ERR_BAD_POOL_SIZE;
 386           if (map_ip6_reass_conf_pool_size
 387               (pool_size, &ps_reass, &ps_packets))
 388             return MAP_ERR_BAD_POOL_SIZE;
 389         }
 390
 391       if (ht_ratio != (MAP_IP6_REASS_CONF_HT_RATIO_MAX + 1))
 392         {
 393           if (ht_ratio > MAP_IP6_REASS_CONF_HT_RATIO_MAX)
 394             return MAP_ERR_BAD_HT_RATIO;
 395           if (map_ip6_reass_conf_ht_ratio (ht_ratio, &ht_reass, &ht_packets))
 396             return MAP_ERR_BAD_HT_RATIO;
 397         }
 398
 399       if (lifetime_ms != (u16) ~ 0)
 400         {
 401           if (lifetime_ms > MAP_IP6_REASS_CONF_LIFETIME_MAX)
 402             return MAP_ERR_BAD_LIFETIME;
 403           if (map_ip6_reass_conf_lifetime (lifetime_ms))
 404             return MAP_ERR_BAD_LIFETIME;
 405         }
 406
 407       if (buffers != ~0)
 408         {
 409           if (buffers > MAP_IP6_REASS_CONF_BUFFERS_MAX)
 410             return MAP_ERR_BAD_BUFFERS;
 411           if (map_ip6_reass_conf_buffers (buffers))
 412             return MAP_ERR_BAD_BUFFERS;
 413         }
 414
 415       if (map_main.ip6_reass_conf_buffers >
 416           map_main.ip6_reass_conf_pool_size *
 417           MAP_IP6_REASS_MAX_FRAGMENTS_PER_REASSEMBLY)
 418         {
 419           return MAP_ERR_BAD_BUFFERS_TOO_LARGE;
 420         }
 421     }
 422   else
 423     {
 424       if (pool_size != (u16) ~ 0)
 425         {
 426           if (pool_size > MAP_IP4_REASS_CONF_POOL_SIZE_MAX)
 427             return MAP_ERR_BAD_POOL_SIZE;
 428           if (map_ip4_reass_conf_pool_size
 429               (pool_size, &ps_reass, &ps_packets))
 430             return MAP_ERR_BAD_POOL_SIZE;
 431         }
 432
 433       if (ht_ratio != (MAP_IP4_REASS_CONF_HT_RATIO_MAX + 1))
 434         {
 435           if (ht_ratio > MAP_IP4_REASS_CONF_HT_RATIO_MAX)
 436             return MAP_ERR_BAD_HT_RATIO;
 437           if (map_ip4_reass_conf_ht_ratio (ht_ratio, &ht_reass, &ht_packets))
 438             return MAP_ERR_BAD_HT_RATIO;
 439         }
 440
 441       if (lifetime_ms != (u16) ~ 0)
 442         {
 443           if (lifetime_ms > MAP_IP4_REASS_CONF_LIFETIME_MAX)
 444             return MAP_ERR_BAD_LIFETIME;
 445           if (map_ip4_reass_conf_lifetime (lifetime_ms))
 446             return MAP_ERR_BAD_LIFETIME;
 447         }
 448
 449       if (buffers != ~0)
 450         {
 451           if (buffers > MAP_IP4_REASS_CONF_BUFFERS_MAX)
 452             return MAP_ERR_BAD_BUFFERS;
 453           if (map_ip4_reass_conf_buffers (buffers))
 454             return MAP_ERR_BAD_BUFFERS;
 455         }
 456
 457       if (map_main.ip4_reass_conf_buffers >
 458           map_main.ip4_reass_conf_pool_size *
 459           MAP_IP4_REASS_MAX_FRAGMENTS_PER_REASSEMBLY)
 460         {
 461           return MAP_ERR_BAD_BUFFERS_TOO_LARGE;
 462         }
 463     }
 464
 465   if (reass)
 466     *reass = ps_reass + ht_reass;
 467
 468   if (packets)
 469     *packets = ps_packets + ht_packets;
 470
 471   return 0;
 472 }
 473
 474
 475 static void
 476   vl_api_map_param_set_reassembly_t_handler
 477   (vl_api_map_param_set_reassembly_t * mp)
 478 {
 479   map_main_t *mm = &map_main;
 480   vl_api_map_param_set_reassembly_reply_t *rmp;
 481   u32 reass = 0, packets = 0;
 482   int rv;
 483   f64 ht_ratio;
 484
 485   ht_ratio = (f64) clib_net_to_host_u64 (mp->ht_ratio);
 486   if (ht_ratio == ~0)
 487     ht_ratio = MAP_IP6_REASS_CONF_HT_RATIO_MAX + 1;
 488
 489   rv = map_param_set_reassembly (mp->is_ip6,
 490                                  clib_net_to_host_u16 (mp->lifetime_ms),
 491                                  clib_net_to_host_u16 (mp->pool_size),
 492                                  clib_net_to_host_u32 (mp->buffers),
 493                                  ht_ratio, &reass, &packets);
 494
 495   /*
 496    * FIXME: Should the lost reass and packet counts be returned in the API?
 497    */
 498
 499   REPLY_MACRO (VL_API_MAP_PARAM_SET_REASSEMBLY_REPLY);
 500 }
 501
 502
 503 int
 504 map_param_set_security_check (bool enable, bool fragments)
 505 {
 506   map_main_t *mm = &map_main;
 507
 508   mm->sec_check = ! !enable;
 509   mm->sec_check_frag = ! !fragments;
 510
 511   return 0;
 512 }
 513
 514 static void
 515   vl_api_map_param_set_security_check_t_handler
 516   (vl_api_map_param_set_security_check_t * mp)
 517 {
 518   map_main_t *mm = &map_main;
 519   vl_api_map_param_set_security_check_reply_t *rmp;
 520   int rv;
 521
 522   rv = map_param_set_security_check (mp->enable, mp->fragments);
 523
 524   REPLY_MACRO (VL_API_MAP_PARAM_SET_SECURITY_CHECK_REPLY);
 525 }
 526
 527
 528 int
 529 map_param_set_traffic_class (bool copy, u8 tc)
 530 {
 531   map_main_t *mm = &map_main;
 532
 533   mm->tc_copy = ! !copy;
 534   mm->tc = tc;
 535
 536   return 0;
 537 }
 538
 539 static void
 540   vl_api_map_param_set_traffic_class_t_handler
 541   (vl_api_map_param_set_traffic_class_t * mp)
 542 {
 543   map_main_t *mm = &map_main;
 544   vl_api_map_param_set_traffic_class_reply_t *rmp;
 545   int rv;
 546
 547   rv = map_param_set_traffic_class (mp->copy, mp->class);
 548
 549   REPLY_MACRO (VL_API_MAP_PARAM_SET_TRAFFIC_CLASS_REPLY);
 550 }
 551
 552
 553 int
 554 map_param_set_tcp (u16 tcp_mss)
 555 {
 556   map_main_t *mm = &map_main;
 557
 558   mm->tcp_mss = tcp_mss;
 559
 560   return 0;
 561 }
 562
 563
 564 static void
 565 vl_api_map_param_set_tcp_t_handler (vl_api_map_param_set_tcp_t * mp)
 566 {
 567   map_main_t *mm = &map_main;
 568   vl_api_map_param_set_tcp_reply_t *rmp;
 569   int rv = 0;
 570
 571   map_param_set_tcp (ntohs (mp->tcp_mss));
 572   REPLY_MACRO (VL_API_MAP_PARAM_SET_TCP_REPLY);
 573 }
 574
 575
 576 static void
 577 vl_api_map_param_get_t_handler (vl_api_map_param_get_t * mp)
 578 {
 579   map_main_t *mm = &map_main;
 580   vl_api_map_param_get_reply_t *rmp;
 581   vl_api_registration_t *reg;
 582
 583   reg = vl_api_client_index_to_registration (mp->client_index);
 584   if (!reg)
 585     return;
 586
 587   rmp = vl_msg_api_alloc (sizeof (*rmp));
 588   rmp->_vl_msg_id = htons (VL_API_MAP_PARAM_GET_REPLY + mm->msg_id_base);
 589   rmp->context = mp->context;
 590   rmp->retval = 0;
 591
 592   rmp->frag_inner = mm->frag_inner;
 593   rmp->frag_ignore_df = mm->frag_ignore_df;
 594
 595   clib_memcpy (&rmp->icmp_ip4_err_relay_src,
 596                &mm->icmp4_src_address, sizeof (rmp->icmp_ip4_err_relay_src));
 597
 598   rmp->icmp6_enable_unreachable = mm->icmp6_enabled;
 599
 600   /*
 601    * FIXME: How are these addresses re-extracted from the FIB?
 602    * Or should a local map_main copy be kept?
 603    */
 604   clib_memset (&rmp->ip4_nh_address, 0, sizeof (rmp->ip4_nh_address));
 605   clib_memset (&rmp->ip6_nh_address, 0, sizeof (rmp->ip6_nh_address));
 606
 607   rmp->ip4_lifetime_ms =
 608     clib_net_to_host_u16 (mm->ip4_reass_conf_lifetime_ms);
 609   rmp->ip4_pool_size = clib_net_to_host_u16 (mm->ip4_reass_conf_pool_size);
 610   rmp->ip4_buffers = clib_net_to_host_u32 (mm->ip4_reass_conf_buffers);
 611   rmp->ip4_ht_ratio =
 612     clib_net_to_host_u64 ((u64) mm->ip4_reass_conf_ht_ratio);
 613
 614   rmp->ip6_lifetime_ms =
 615     clib_net_to_host_u16 (mm->ip6_reass_conf_lifetime_ms);
 616   rmp->ip6_pool_size = clib_net_to_host_u16 (mm->ip6_reass_conf_pool_size);
 617   rmp->ip6_buffers = clib_net_to_host_u32 (mm->ip6_reass_conf_buffers);
 618   rmp->ip6_ht_ratio =
 619     clib_net_to_host_u64 ((u64) mm->ip6_reass_conf_ht_ratio);
 620
 621   rmp->sec_check_enable = mm->sec_check;
 622   rmp->sec_check_fragments = mm->sec_check_frag;
 623
 624   rmp->tc_copy = mm->tc_copy;
 625   rmp->tc_class = mm->tc;
 626
 627   vl_api_send_msg (reg, (u8 *) rmp);
 628 }
 629
 630
 631 int
 632 map_if_enable_disable (bool is_enable, u32 sw_if_index, bool is_translation)
 633 {
 634   map_main_t *mm = &map_main;
 635
 636   if (pool_is_free_index (mm->vnet_main->interface_main.sw_interfaces,
 637                           sw_if_index))
 638     return VNET_API_ERROR_INVALID_SW_IF_INDEX;
 639
 640   is_enable = ! !is_enable;
 641
 642   if (is_translation)
 643     {
 644       if (clib_bitmap_get (mm->bm_trans_enabled_by_sw_if, sw_if_index)
 645           == is_enable)
 646         return 0;
 647     }
 648   else
 649     {
 650       if (clib_bitmap_get (mm->bm_encap_enabled_by_sw_if, sw_if_index)
 651           == is_enable)
 652         return 0;
 653     }
 654
 655   if (is_translation == false)
 656     {
 657       vnet_feature_enable_disable ("ip4-unicast", "ip4-map", sw_if_index,
 658                                    is_enable ? 1 : 0, 0, 0);
 659       vnet_feature_enable_disable ("ip6-unicast", "ip6-map", sw_if_index,
 660                                    is_enable ? 1 : 0, 0, 0);
 661       mm->bm_encap_enabled_by_sw_if =
 662         clib_bitmap_set (mm->bm_encap_enabled_by_sw_if, sw_if_index,
 663                          is_enable);
 664     }
 665   else
 666     {
 667       vnet_feature_enable_disable ("ip4-unicast", "ip4-map-t", sw_if_index,
 668                                    is_enable ? 1 : 0, 0, 0);
 669       vnet_feature_enable_disable ("ip6-unicast", "ip6-map-t", sw_if_index,
 670                                    is_enable ? 1 : 0, 0, 0);
 671       mm->bm_trans_enabled_by_sw_if =
 672         clib_bitmap_set (mm->bm_trans_enabled_by_sw_if, sw_if_index,
 673                          is_enable);
 674     }
 675
 676   return 0;
 677 }
 678
 679
 680 static void
 681 vl_api_map_if_enable_disable_t_handler (vl_api_map_if_enable_disable_t * mp)
 682 {
 683   map_main_t *mm = &map_main;
 684   vl_api_map_if_enable_disable_reply_t *rmp;
 685   int rv = 0;
 686
 687   VALIDATE_SW_IF_INDEX (mp);
 688
 689   rv =
 690     map_if_enable_disable (mp->is_enable, htonl (mp->sw_if_index),
 691                            mp->is_translation);
 692
 693   BAD_SW_IF_INDEX_LABEL;
 694   REPLY_MACRO (VL_API_MAP_IF_ENABLE_DISABLE_REPLY);
 695 }
 696
 697
 698 #define foreach_map_plugin_api_msg              \
 699 _(MAP_ADD_DOMAIN, map_add_domain)               \
 700 _(MAP_DEL_DOMAIN, map_del_domain)               \
 701 _(MAP_ADD_DEL_RULE, map_add_del_rule)           \
 702 _(MAP_DOMAIN_DUMP, map_domain_dump)             \
 703 _(MAP_RULE_DUMP, map_rule_dump)                 \
 704 _(MAP_IF_ENABLE_DISABLE, map_if_enable_disable) \
 705 _(MAP_SUMMARY_STATS, map_summary_stats)         \
 706 _(MAP_PARAM_SET_FRAGMENTATION, map_param_set_fragmentation)     \
 707 _(MAP_PARAM_SET_ICMP, map_param_set_icmp)       \
 708 _(MAP_PARAM_SET_ICMP6, map_param_set_icmp6)     \
 709 _(MAP_PARAM_ADD_DEL_PRE_RESOLVE, map_param_add_del_pre_resolve) \
 710 _(MAP_PARAM_SET_REASSEMBLY, map_param_set_reassembly)           \
 711 _(MAP_PARAM_SET_SECURITY_CHECK, map_param_set_security_check)   \
 712 _(MAP_PARAM_SET_TRAFFIC_CLASS, map_param_set_traffic_class)     \
 713 _(MAP_PARAM_SET_TCP, map_param_set_tcp) \
 714 _(MAP_PARAM_GET, map_param_get)
 715
 716 #define vl_msg_name_crc_list
 717 #include <map/map_all_api_h.h>
 718 #undef vl_msg_name_crc_list
 719
 720 static void
 721 setup_message_id_table (map_main_t * mm, api_main_t * am)
 722 {
 723 #define _(id,n,crc)                                                     \
 724   vl_msg_api_add_msg_name_crc (am, #n "_" #crc, id + mm->msg_id_base);
 725   foreach_vl_msg_name_crc_map;
 726 #undef _
 727 }
 728
 729 /* Set up the API message handling tables */
 730 clib_error_t *
 731 map_plugin_api_hookup (vlib_main_t * vm)
 732 {
 733   map_main_t *mm = &map_main;
 734   u8 *name = format (0, "map_%08x%c", api_version, 0);
 735
 736   /* Ask for a correctly-sized block of API message decode slots */
 737   mm->msg_id_base =
 738     vl_msg_api_get_msg_ids ((char *) name, VL_MSG_FIRST_AVAILABLE);
 739 #define _(N,n)                                                  \
 740     vl_msg_api_set_handlers((VL_API_##N + mm->msg_id_base),     \
 741                            #n,                                  \
 742                            vl_api_##n##_t_handler,              \
 743                            vl_noop_handler,                     \
 744                            vl_api_##n##_t_endian,               \
 745                            vl_api_##n##_t_print,                \
 746                            sizeof(vl_api_##n##_t), 1);
 747   foreach_map_plugin_api_msg;
 748 #undef _
 749
 750   /*
 751    * Set up the (msg_name, crc, message-id) table
 752    */
 753   setup_message_id_table (mm, &api_main);
 754
 755   vec_free (name);
 756   return 0;
 757 }
 758
 759 /*
 760  * fd.io coding-style-patch-verification: ON
 761  *
 762  * Local Variables:
 763  * eval: (c-set-style "gnu")
 764  * End:
 765  */