dhcp: multiple additions 49/5449/4
authorNeale Ranns <nranns@cisco.com>
Tue, 14 Feb 2017 15:28:41 +0000 (07:28 -0800)
committerDamjan Marion <dmarion.lists@gmail.com>
Tue, 21 Feb 2017 22:25:48 +0000 (22:25 +0000)
DHCP additions:
1) DHCPv4 will only relay a message back to the client, if the Option82 information is present. So make this the default.
2) It is no longer possible to select via the API to "insert circuit ID" - since this is now default
3) Remove the version 2 API since it's now the same as version 1.
4) Adding the VSS option is now conditional only on the presence of VSS config (not the 'insert' option in the set API)
5) DHCP proxy dump via API

Change-Id: Ia7271ba8c1d4dbf34a02c401d268ccfbb1b74f17
Signed-off-by: Neale Ranns <nranns@cisco.com>
15 files changed:
src/scripts/vnet/dhcp/proxy [new file with mode: 0644]
src/vat/api_format.c
src/vnet/dhcp/client.c
src/vnet/dhcp/client.h
src/vnet/dhcp/dhcp.api
src/vnet/dhcp/dhcp_api.c
src/vnet/dhcp/proxy.h
src/vnet/dhcp/proxy_error.def
src/vnet/dhcp/proxy_node.c
src/vnet/dhcpv6/proxy.h
src/vnet/dhcpv6/proxy_node.c
src/vnet/dpo/receive_dpo.c
src/vpp/api/custom_dump.c
test/test_dhcp.py
test/vpp_papi_provider.py

diff --git a/src/scripts/vnet/dhcp/proxy b/src/scripts/vnet/dhcp/proxy
new file mode 100644 (file)
index 0000000..c709d87
--- /dev/null
@@ -0,0 +1,21 @@
+loop create
+loop create
+
+set int state loop0 up
+set int state loop1 up
+
+set int ip  table loop1 1
+set int ip6 table loop1 1
+
+set int ip addr loop0 10.0.0.1/24
+set int ip addr loop0 10.0.1.1/24
+
+set int ip addr loop0 2001::1/64
+set int ip addr loop0 2001:1::1/64
+
+set dhcp proxy server 10.255.0.1 src-address 10.0.0.1 server-fib-id 0 rx-fib-id 0
+set dhcp proxy server 10.255.0.2 src-address 10.0.1.1 server-fib-id 1 rx-fib-id 1
+
+set dhcpv6 proxy server 3001::1 src-address 2001::1 server-fib-id 0 rx-fib-id 0
+set dhcpv6 proxy server 3002::1 src-address 2001:1::1 server-fib-id 1 rx-fib-id 1
+
index 11e6821..78c5e27 100644 (file)
@@ -3819,7 +3819,6 @@ _(reset_vrf_reply)                                      \
 _(oam_add_del_reply)                                    \
 _(reset_fib_reply)                                      \
 _(dhcp_proxy_config_reply)                              \
 _(oam_add_del_reply)                                    \
 _(reset_fib_reply)                                      \
 _(dhcp_proxy_config_reply)                              \
-_(dhcp_proxy_config_2_reply)                            \
 _(dhcp_proxy_set_vss_reply)                             \
 _(dhcp_client_config_reply)                             \
 _(set_ip_flow_hash_reply)                               \
 _(dhcp_proxy_set_vss_reply)                             \
 _(dhcp_client_config_reply)                             \
 _(set_ip_flow_hash_reply)                               \
@@ -4033,8 +4032,8 @@ _(CREATE_SUBIF_REPLY, create_subif_reply)                                 \
 _(OAM_ADD_DEL_REPLY, oam_add_del_reply)                                 \
 _(RESET_FIB_REPLY, reset_fib_reply)                                     \
 _(DHCP_PROXY_CONFIG_REPLY, dhcp_proxy_config_reply)                     \
 _(OAM_ADD_DEL_REPLY, oam_add_del_reply)                                 \
 _(RESET_FIB_REPLY, reset_fib_reply)                                     \
 _(DHCP_PROXY_CONFIG_REPLY, dhcp_proxy_config_reply)                     \
-_(DHCP_PROXY_CONFIG_2_REPLY, dhcp_proxy_config_2_reply)                 \
 _(DHCP_PROXY_SET_VSS_REPLY, dhcp_proxy_set_vss_reply)                   \
 _(DHCP_PROXY_SET_VSS_REPLY, dhcp_proxy_set_vss_reply)                   \
+_(DHCP_PROXY_DETAILS, dhcp_proxy_details)                               \
 _(DHCP_CLIENT_CONFIG_REPLY, dhcp_client_config_reply)                   \
 _(SET_IP_FLOW_HASH_REPLY, set_ip_flow_hash_reply)                       \
 _(SW_INTERFACE_IP6_ENABLE_DISABLE_REPLY,                                \
 _(DHCP_CLIENT_CONFIG_REPLY, dhcp_client_config_reply)                   \
 _(SET_IP_FLOW_HASH_REPLY, set_ip_flow_hash_reply)                       \
 _(SW_INTERFACE_IP6_ENABLE_DISABLE_REPLY,                                \
@@ -7635,9 +7634,9 @@ api_dhcp_proxy_config (vat_main_t * vam)
 {
   unformat_input_t *i = vam->input;
   vl_api_dhcp_proxy_config_t *mp;
 {
   unformat_input_t *i = vam->input;
   vl_api_dhcp_proxy_config_t *mp;
-  u32 vrf_id = 0;
+  u32 rx_vrf_id = 0;
+  u32 server_vrf_id = 0;
   u8 is_add = 1;
   u8 is_add = 1;
-  u8 insert_cid = 1;
   u8 v4_address_set = 0;
   u8 v6_address_set = 0;
   ip4_address_t v4address;
   u8 v4_address_set = 0;
   u8 v6_address_set = 0;
   ip4_address_t v4address;
@@ -7653,9 +7652,9 @@ api_dhcp_proxy_config (vat_main_t * vam)
     {
       if (unformat (i, "del"))
        is_add = 0;
     {
       if (unformat (i, "del"))
        is_add = 0;
-      else if (unformat (i, "vrf %d", &vrf_id))
+      else if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
        ;
        ;
-      else if (unformat (i, "insert-cid %d", &insert_cid))
+      else if (unformat (i, "server_vrf_id %d", &server_vrf_id))
        ;
       else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
        v4_address_set = 1;
        ;
       else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
        v4_address_set = 1;
@@ -7701,9 +7700,9 @@ api_dhcp_proxy_config (vat_main_t * vam)
   /* Construct the API message */
   M (DHCP_PROXY_CONFIG, mp);
 
   /* Construct the API message */
   M (DHCP_PROXY_CONFIG, mp);
 
-  mp->insert_circuit_id = insert_cid;
   mp->is_add = is_add;
   mp->is_add = is_add;
-  mp->vrf_id = ntohl (vrf_id);
+  mp->rx_vrf_id = ntohl (rx_vrf_id);
+  mp->server_vrf_id = ntohl (server_vrf_id);
   if (v6_address_set)
     {
       mp->is_ipv6 = 1;
   if (v6_address_set)
     {
       mp->is_ipv6 = 1;
@@ -7724,100 +7723,98 @@ api_dhcp_proxy_config (vat_main_t * vam)
   return ret;
 }
 
   return ret;
 }
 
-static int
-api_dhcp_proxy_config_2 (vat_main_t * vam)
+#define vl_api_dhcp_proxy_details_t_endian vl_noop_handler
+#define vl_api_dhcp_proxy_details_t_print vl_noop_handler
+
+static void
+vl_api_dhcp_proxy_details_t_handler (vl_api_dhcp_proxy_details_t * mp)
 {
 {
-  unformat_input_t *i = vam->input;
-  vl_api_dhcp_proxy_config_2_t *mp;
-  u32 rx_vrf_id = 0;
-  u32 server_vrf_id = 0;
-  u8 is_add = 1;
-  u8 insert_cid = 1;
-  u8 v4_address_set = 0;
-  u8 v6_address_set = 0;
-  ip4_address_t v4address;
-  ip6_address_t v6address;
-  u8 v4_src_address_set = 0;
-  u8 v6_src_address_set = 0;
-  ip4_address_t v4srcaddress;
-  ip6_address_t v6srcaddress;
-  int ret;
+  vat_main_t *vam = &vat_main;
 
 
-  /* Parse args required to build the message */
-  while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
-    {
-      if (unformat (i, "del"))
-       is_add = 0;
-      else if (unformat (i, "rx_vrf_id %d", &rx_vrf_id))
-       ;
-      else if (unformat (i, "server_vrf_id %d", &server_vrf_id))
-       ;
-      else if (unformat (i, "insert-cid %d", &insert_cid))
-       ;
-      else if (unformat (i, "svr %U", unformat_ip4_address, &v4address))
-       v4_address_set = 1;
-      else if (unformat (i, "svr %U", unformat_ip6_address, &v6address))
-       v6_address_set = 1;
-      else if (unformat (i, "src %U", unformat_ip4_address, &v4srcaddress))
-       v4_src_address_set = 1;
-      else if (unformat (i, "src %U", unformat_ip6_address, &v6srcaddress))
-       v6_src_address_set = 1;
-      else
-       break;
-    }
+  if (mp->is_ipv6)
+    print (vam->ofp,
+          "RX Table-ID %d, Server Table-ID %d, Server Address %U, Source Address %U, VSS FIB-ID %d, VSS OUI %d",
+          ntohl (mp->rx_vrf_id),
+          ntohl (mp->server_vrf_id),
+          format_ip6_address, mp->dhcp_server,
+          format_ip6_address, mp->dhcp_src_address,
+          ntohl (mp->vss_oui), ntohl (mp->vss_fib_id));
+  else
+    print (vam->ofp,
+          "RX Table-ID %d, Server Table-ID %d, Server Address %U, Source Address %U, VSS FIB-ID %d, VSS OUI %d",
+          ntohl (mp->rx_vrf_id),
+          ntohl (mp->server_vrf_id),
+          format_ip4_address, mp->dhcp_server,
+          format_ip4_address, mp->dhcp_src_address,
+          ntohl (mp->vss_oui), ntohl (mp->vss_fib_id));
+}
 
 
-  if (v4_address_set && v6_address_set)
-    {
-      errmsg ("both v4 and v6 server addresses set");
-      return -99;
-    }
-  if (!v4_address_set && !v6_address_set)
-    {
-      errmsg ("no server addresses set");
-      return -99;
-    }
+static void vl_api_dhcp_proxy_details_t_handler_json
+  (vl_api_dhcp_proxy_details_t * mp)
+{
+  vat_main_t *vam = &vat_main;
+  vat_json_node_t *node = NULL;
+  struct in_addr ip4;
+  struct in6_addr ip6;
 
 
-  if (v4_src_address_set && v6_src_address_set)
+  if (VAT_JSON_ARRAY != vam->json_tree.type)
     {
     {
-      errmsg ("both v4 and v6  src addresses set");
-      return -99;
+      ASSERT (VAT_JSON_NONE == vam->json_tree.type);
+      vat_json_init_array (&vam->json_tree);
     }
     }
-  if (!v4_src_address_set && !v6_src_address_set)
+  node = vat_json_array_add (&vam->json_tree);
+
+  vat_json_init_object (node);
+  vat_json_object_add_uint (node, "rx-table-id", ntohl (mp->rx_vrf_id));
+  vat_json_object_add_uint (node, "server-table-id",
+                           ntohl (mp->server_vrf_id));
+  if (mp->is_ipv6)
     {
     {
-      errmsg ("no src addresses set");
-      return -99;
+      clib_memcpy (&ip6, &mp->dhcp_server, sizeof (ip6));
+      vat_json_object_add_ip6 (node, "server_address", ip6);
+      clib_memcpy (&ip6, &mp->dhcp_src_address, sizeof (ip6));
+      vat_json_object_add_ip6 (node, "src_address", ip6);
     }
     }
-
-  if (!(v4_src_address_set && v4_address_set) &&
-      !(v6_src_address_set && v6_address_set))
+  else
     {
     {
-      errmsg ("no matching server and src addresses set");
-      return -99;
+      clib_memcpy (&ip4, &mp->dhcp_server, sizeof (ip4));
+      vat_json_object_add_ip4 (node, "server_address", ip4);
+      clib_memcpy (&ip4, &mp->dhcp_src_address, sizeof (ip4));
+      vat_json_object_add_ip4 (node, "src_address", ip4);
     }
     }
+  vat_json_object_add_uint (node, "vss-fib-id", ntohl (mp->vss_fib_id));
+  vat_json_object_add_uint (node, "vss-oui", ntohl (mp->vss_oui));
+}
 
 
-  /* Construct the API message */
-  M (DHCP_PROXY_CONFIG_2, mp);
+static int
+api_dhcp_proxy_dump (vat_main_t * vam)
+{
+  unformat_input_t *i = vam->input;
+  vl_api_control_ping_t *mp_ping;
+  vl_api_dhcp_proxy_dump_t *mp;
+  u8 is_ipv6 = 0;
+  int ret;
 
 
-  mp->insert_circuit_id = insert_cid;
-  mp->is_add = is_add;
-  mp->rx_vrf_id = ntohl (rx_vrf_id);
-  mp->server_vrf_id = ntohl (server_vrf_id);
-  if (v6_address_set)
-    {
-      mp->is_ipv6 = 1;
-      clib_memcpy (mp->dhcp_server, &v6address, sizeof (v6address));
-      clib_memcpy (mp->dhcp_src_address, &v6srcaddress, sizeof (v6address));
-    }
-  else
+  while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
     {
     {
-      clib_memcpy (mp->dhcp_server, &v4address, sizeof (v4address));
-      clib_memcpy (mp->dhcp_src_address, &v4srcaddress, sizeof (v4address));
+      if (unformat (i, "ipv6"))
+       is_ipv6 = 1;
+      else
+       {
+         clib_warning ("parse error '%U'", format_unformat_error, i);
+         return -99;
+       }
     }
 
     }
 
-  /* send it... */
+  M (DHCP_PROXY_DUMP, mp);
+
+  mp->is_ip6 = is_ipv6;
   S (mp);
 
   S (mp);
 
-  /* Wait for a reply, return good/bad news  */
+  /* Use a control ping for synchronization */
+  M (CONTROL_PING, mp_ping);
+  S (mp_ping);
+
   W (ret);
   return ret;
 }
   W (ret);
   return ret;
 }
@@ -18187,12 +18184,10 @@ _(oam_add_del, "src <ip4-address> dst <ip4-address> [vrf <n>] [del]")   \
 _(reset_fib, "vrf <n> [ipv6]")                                          \
 _(dhcp_proxy_config,                                                    \
   "svr <v46-address> src <v46-address>\n"                               \
 _(reset_fib, "vrf <n> [ipv6]")                                          \
 _(dhcp_proxy_config,                                                    \
   "svr <v46-address> src <v46-address>\n"                               \
-   "insert-cid <n> [del]")                                              \
-_(dhcp_proxy_config_2,                                                  \
-  "svr <v46-address> src <v46-address>\n"                               \
-   "rx_vrf_id <nn> server_vrf_id <nn> insert-cid <n> [del]")            \
+   "rx_vrf_id <nn> server_vrf_id <nn>  [del]")                          \
 _(dhcp_proxy_set_vss,                                                   \
   "tbl_id <n> fib_id <n> oui <n> [ipv6] [del]")                         \
 _(dhcp_proxy_set_vss,                                                   \
   "tbl_id <n> fib_id <n> oui <n> [ipv6] [del]")                         \
+_(dhcp_proxy_dump, "ip6")                                               \
 _(dhcp_client_config,                                                   \
   "<intfc> | sw_if_index <id> [hostname <name>] [disable_event] [del]") \
 _(set_ip_flow_hash,                                                     \
 _(dhcp_client_config,                                                   \
   "<intfc> | sw_if_index <id> [hostname <name>] [disable_event] [del]") \
 _(set_ip_flow_hash,                                                     \
index c352e31..8a1a43b 100644 (file)
@@ -13,6 +13,7 @@
  * limitations under the License.
  */
 #include <vlib/vlib.h>
  * limitations under the License.
  */
 #include <vlib/vlib.h>
+#include <vnet/dhcp/client.h>
 #include <vnet/dhcp/proxy.h>
 #include <vnet/fib/fib_table.h>
 
 #include <vnet/dhcp/proxy.h>
 #include <vnet/fib/fib_table.h>
 
index d15e686..a74368c 100644 (file)
@@ -19,6 +19,9 @@
 #ifndef included_dhcp_client_h
 #define included_dhcp_client_h
 
 #ifndef included_dhcp_client_h
 #define included_dhcp_client_h
 
+#include <vnet/ip/ip.h>
+#include <vnet/dhcp/packet.h>
+
 #define foreach_dhcp_client_state               \
 _(DHCP_DISCOVER)                                \
 _(DHCP_REQUEST)                                 \
 #define foreach_dhcp_client_state               \
 _(DHCP_DISCOVER)                                \
 _(DHCP_REQUEST)                                 \
index c228cd0..8daadd8 100644 (file)
@@ -16,7 +16,8 @@
 /** \brief DHCP Proxy config add / del request
     @param client_index - opaque cookie to identify the sender
     @param context - sender context, to match reply w/ request
 /** \brief DHCP Proxy config add / del request
     @param client_index - opaque cookie to identify the sender
     @param context - sender context, to match reply w/ request
-    @param vrf_id - vrf id
+    @param rx_vrf_id - Rx/interface vrf id
+    @param server_vrf_id - server vrf id
     @param if_ipv6 - ipv6 if non-zero, else ipv4
     @param is_add - add the config if non-zero, else delete
     @param insert_circuit_id - option82 suboption 1 fib number
     @param if_ipv6 - ipv6 if non-zero, else ipv4
     @param is_add - add the config if non-zero, else delete
     @param insert_circuit_id - option82 suboption 1 fib number
@@ -27,10 +28,10 @@ define dhcp_proxy_config
 {
   u32 client_index;
   u32 context;
 {
   u32 client_index;
   u32 context;
-  u32 vrf_id;
+  u32 rx_vrf_id;
+  u32 server_vrf_id;
   u8 is_ipv6;
   u8 is_add;
   u8 is_ipv6;
   u8 is_add;
-  u8 insert_circuit_id;
   u8 dhcp_server[16];
   u8 dhcp_src_address[16];
 };
   u8 dhcp_server[16];
   u8 dhcp_src_address[16];
 };
@@ -45,40 +46,6 @@ define dhcp_proxy_config_reply
   i32 retval;
 };
 
   i32 retval;
 };
 
-/** \brief DHCP Proxy config 2 add / del request
-    @param client_index - opaque cookie to identify the sender
-    @param context - sender context, to match reply w/ request
-    @param rx_vrf_id - receive vrf id
-    @param server_vrf_id - server vrf id
-    @param if_ipv6 - ipv6 if non-zero, else ipv4
-    @param is_add - add the config if non-zero, else delete
-    @param insert_circuit_id - option82 suboption 1 fib number
-    @param dhcp_server[] - server address
-    @param dhcp_src_address[] - <fix this, need details>
-*/
-define dhcp_proxy_config_2
-{
-  u32 client_index;
-  u32 context;
-  u32 rx_vrf_id;
-  u32 server_vrf_id;
-  u8 is_ipv6;
-  u8 is_add;
-  u8 insert_circuit_id;
-  u8 dhcp_server[16];
-  u8 dhcp_src_address[16];
-};
-
-/** \brief DHCP Proxy config 2 add / del response
-    @param context - sender context, to match reply w/ request
-    @param retval - return code for request
-*/
-define dhcp_proxy_config_2_reply
-{
-  u32 context;
-  i32 retval;
-};
-
 /** \brief DHCP Proxy set / unset vss request
     @param client_index - opaque cookie to identify the sender
     @param context - sender context, to match reply w/ request
 /** \brief DHCP Proxy set / unset vss request
     @param client_index - opaque cookie to identify the sender
     @param context - sender context, to match reply w/ request
@@ -159,6 +126,32 @@ define dhcp_compl_event
   u8 host_mac[6];
 };
 
   u8 host_mac[6];
 };
 
+/** \brief Dump DHCP proxy table
+    @param client_index - opaque cookie to identify the sender
+    @param True for IPv6 proxy table
+*/
+define dhcp_proxy_dump
+{
+  u32 client_index;
+  u32 context;
+  u8  is_ip6;
+};
+
+/** \brief Tell client about a DHCP completion event
+    @param client_index - opaque cookie to identify the sender
+*/
+define dhcp_proxy_details
+{
+  u32 context;
+  u32 rx_vrf_id;
+  u32 server_vrf_id;
+  u32 vss_oui;
+  u32 vss_fib_id;
+  u8 is_ipv6;
+  u8 dhcp_server[16];
+  u8 dhcp_src_address[16];
+};
+
 /*
  * Local Variables:
  * eval: (c-set-style "gnu")
 /*
  * Local Variables:
  * eval: (c-set-style "gnu")
index 88b32b2..ce9039b 100644 (file)
@@ -46,7 +46,8 @@
 
 #define foreach_vpe_api_msg                       \
 _(DHCP_PROXY_CONFIG,dhcp_proxy_config)            \
 
 #define foreach_vpe_api_msg                       \
 _(DHCP_PROXY_CONFIG,dhcp_proxy_config)            \
-_(DHCP_PROXY_CONFIG_2,dhcp_proxy_config_2)        \
+_(DHCP_PROXY_DUMP,dhcp_proxy_dump)                \
+_(DHCP_PROXY_DETAILS,dhcp_proxy_details)          \
 _(DHCP_PROXY_SET_VSS,dhcp_proxy_set_vss)          \
 _(DHCP_CLIENT_CONFIG, dhcp_client_config)
 
 _(DHCP_PROXY_SET_VSS,dhcp_proxy_set_vss)          \
 _(DHCP_CLIENT_CONFIG, dhcp_client_config)
 
@@ -58,8 +59,8 @@ dhcpv4_proxy_config (vl_api_dhcp_proxy_config_t * mp)
 
   rv = dhcp_proxy_set_server ((ip4_address_t *) (&mp->dhcp_server),
                              (ip4_address_t *) (&mp->dhcp_src_address),
 
   rv = dhcp_proxy_set_server ((ip4_address_t *) (&mp->dhcp_server),
                              (ip4_address_t *) (&mp->dhcp_src_address),
-                             (u32) ntohl (mp->vrf_id),
-                             (int) mp->insert_circuit_id,
+                             (u32) ntohl (mp->rx_vrf_id),
+                             (u32) ntohl (mp->server_vrf_id),
                              (int) (mp->is_add == 0));
 
   REPLY_MACRO (VL_API_DHCP_PROXY_CONFIG_REPLY);
                              (int) (mp->is_add == 0));
 
   REPLY_MACRO (VL_API_DHCP_PROXY_CONFIG_REPLY);
@@ -74,44 +75,11 @@ dhcpv6_proxy_config (vl_api_dhcp_proxy_config_t * mp)
 
   rv = dhcpv6_proxy_set_server ((ip6_address_t *) (&mp->dhcp_server),
                                (ip6_address_t *) (&mp->dhcp_src_address),
 
   rv = dhcpv6_proxy_set_server ((ip6_address_t *) (&mp->dhcp_server),
                                (ip6_address_t *) (&mp->dhcp_src_address),
-                               (u32) ntohl (mp->vrf_id),
-                               (int) mp->insert_circuit_id,
-                               (int) (mp->is_add == 0));
-
-  REPLY_MACRO (VL_API_DHCP_PROXY_CONFIG_REPLY);
-}
-
-static void
-dhcpv4_proxy_config_2 (vl_api_dhcp_proxy_config_2_t * mp)
-{
-  vl_api_dhcp_proxy_config_reply_t *rmp;
-  int rv;
-
-  rv = dhcp_proxy_set_server_2 ((ip4_address_t *) (&mp->dhcp_server),
-                               (ip4_address_t *) (&mp->dhcp_src_address),
                                (u32) ntohl (mp->rx_vrf_id),
                                (u32) ntohl (mp->server_vrf_id),
                                (u32) ntohl (mp->rx_vrf_id),
                                (u32) ntohl (mp->server_vrf_id),
-                               (int) mp->insert_circuit_id,
                                (int) (mp->is_add == 0));
 
                                (int) (mp->is_add == 0));
 
-  REPLY_MACRO (VL_API_DHCP_PROXY_CONFIG_2_REPLY);
-}
-
-
-static void
-dhcpv6_proxy_config_2 (vl_api_dhcp_proxy_config_2_t * mp)
-{
-  vl_api_dhcp_proxy_config_reply_t *rmp;
-  int rv = -1;
-
-  rv = dhcpv6_proxy_set_server_2 ((ip6_address_t *) (&mp->dhcp_server),
-                                 (ip6_address_t *) (&mp->dhcp_src_address),
-                                 (u32) ntohl (mp->rx_vrf_id),
-                                 (u32) ntohl (mp->server_vrf_id),
-                                 (int) mp->insert_circuit_id,
-                                 (int) (mp->is_add == 0));
-
-  REPLY_MACRO (VL_API_DHCP_PROXY_CONFIG_2_REPLY);
+  REPLY_MACRO (VL_API_DHCP_PROXY_CONFIG_REPLY);
 }
 
 
 }
 
 
@@ -143,6 +111,67 @@ static void vl_api_dhcp_proxy_config_t_handler
     dhcpv6_proxy_config (mp);
 }
 
     dhcpv6_proxy_config (mp);
 }
 
+static void
+vl_api_dhcp_proxy_dump_t_handler (vl_api_dhcp_proxy_dump_t * mp)
+{
+  unix_shared_memory_queue_t *q;
+
+  q = vl_api_client_index_to_input_queue (mp->client_index);
+  if (q == 0)
+    return;
+
+  if (mp->is_ip6 == 0)
+    dhcp_proxy_dump (q, mp->context);
+  else
+    dhcpv6_proxy_dump (q, mp->context);
+}
+
+void
+dhcp_send_details (void *opaque,
+                  u32 context,
+                  const ip46_address_t * server,
+                  const ip46_address_t * src,
+                  u32 server_fib_id,
+                  u32 rx_fib_id, u32 vss_fib_id, u32 vss_oui)
+{
+  vl_api_dhcp_proxy_details_t *mp;
+  unix_shared_memory_queue_t *q = opaque;
+
+  mp = vl_msg_api_alloc (sizeof (*mp));
+  if (!mp)
+    return;
+  memset (mp, 0, sizeof (*mp));
+  mp->_vl_msg_id = ntohs (VL_API_DHCP_PROXY_DETAILS);
+  mp->context = context;
+
+  mp->rx_vrf_id = htonl (rx_fib_id);
+  mp->server_vrf_id = htonl (server_fib_id);
+  mp->vss_oui = htonl (vss_oui);
+  mp->vss_fib_id = htonl (vss_fib_id);
+
+  mp->is_ipv6 = !ip46_address_is_ip4 (server);
+
+  if (mp->is_ipv6)
+    {
+      memcpy (mp->dhcp_server, server, 16);
+      memcpy (mp->dhcp_src_address, src, 16);
+    }
+  else
+    {
+      /* put the address in the first bytes */
+      memcpy (mp->dhcp_server, &server->ip4, 4);
+      memcpy (mp->dhcp_src_address, &src->ip4, 4);
+    }
+  vl_msg_api_send_shmem (q, (u8 *) & mp);
+}
+
+
+static void
+vl_api_dhcp_proxy_details_t_handler (vl_api_dhcp_proxy_details_t * mp)
+{
+  clib_warning ("BUG");
+}
+
 void
 dhcp_compl_event_callback (u32 client_index, u32 pid, u8 * hostname,
                           u8 is_ipv6, u8 * host_address, u8 * router_address,
 void
 dhcp_compl_event_callback (u32 client_index, u32 pid, u8 * hostname,
                           u8 is_ipv6, u8 * host_address, u8 * router_address,
@@ -172,15 +201,6 @@ dhcp_compl_event_callback (u32 client_index, u32 pid, u8 * hostname,
   vl_msg_api_send_shmem (q, (u8 *) & mp);
 }
 
   vl_msg_api_send_shmem (q, (u8 *) & mp);
 }
 
-static void vl_api_dhcp_proxy_config_2_t_handler
-  (vl_api_dhcp_proxy_config_2_t * mp)
-{
-  if (mp->is_ipv6 == 0)
-    dhcpv4_proxy_config_2 (mp);
-  else
-    dhcpv6_proxy_config_2 (mp);
-}
-
 static void vl_api_dhcp_client_config_t_handler
   (vl_api_dhcp_client_config_t * mp)
 {
 static void vl_api_dhcp_client_config_t_handler
   (vl_api_dhcp_client_config_t * mp)
 {
index e12c0d0..4b115c7 100644 (file)
@@ -27,7 +27,6 @@
 #include <vnet/pg/pg.h>
 #include <vnet/ip/format.h>
 #include <vnet/ip/udp.h>
 #include <vnet/pg/pg.h>
 #include <vnet/ip/format.h>
 #include <vnet/ip/udp.h>
-#include <vnet/dhcp/client.h>
 
 typedef enum {
 #define dhcp_proxy_error(n,s) DHCP_PROXY_ERROR_##n,
 
 typedef enum {
 #define dhcp_proxy_error(n,s) DHCP_PROXY_ERROR_##n,
@@ -49,9 +48,7 @@ typedef union {
 typedef struct {
   ip4_address_t dhcp_server;
   ip4_address_t dhcp_src_address;
 typedef struct {
   ip4_address_t dhcp_server;
   ip4_address_t dhcp_src_address;
-  u32 insert_option_82;
   u32 server_fib_index;
   u32 server_fib_index;
-  u32 valid;
 } dhcp_server_t;
 
 typedef struct {
 } dhcp_server_t;
 
 typedef struct {
@@ -64,29 +61,39 @@ typedef struct {
   /* to drop pkts in server-to-client direction */
   u32 error_drop_node_index;
 
   /* to drop pkts in server-to-client direction */
   u32 error_drop_node_index;
 
-  vss_info *opt82vss;
+  vss_info *vss;
 
   /* hash lookup specific vrf_id -> option 82 vss suboption  */
 
   /* hash lookup specific vrf_id -> option 82 vss suboption  */
-  uword * opt82vss_index_by_vrf_id;
+  u32 *vss_index_by_rx_fib_index;
 
   /* convenience */
 
   /* convenience */
-  dhcp_client_main_t * dhcp_client_main;
   vlib_main_t * vlib_main;
   vnet_main_t * vnet_main;
 } dhcp_proxy_main_t;
 
   vlib_main_t * vlib_main;
   vnet_main_t * vnet_main;
 } dhcp_proxy_main_t;
 
-dhcp_proxy_main_t dhcp_proxy_main;
+extern dhcp_proxy_main_t dhcp_proxy_main;
 
 
-int dhcp_proxy_set_server (ip4_address_t *addr, ip4_address_t *src_address,
-                           u32 fib_id, int insert_option_82, int is_del);
+void dhcp_send_details (void *opaque,
+                        u32 context,
+                        const ip46_address_t *server,
+                        const ip46_address_t *src,
+                        u32 server_fib_id,
+                        u32 rx_fib_id,
+                        u32 vss_fib_id,
+                        u32 vss_oui);
 
 
-int dhcp_proxy_set_server_2 (ip4_address_t *addr, ip4_address_t *src_address,
-                             u32 rx_fib_id,
-                             u32 server_fib_id, 
-                             int insert_option_82, int is_del);
+int dhcp_proxy_set_server (ip4_address_t *addr,
+                           ip4_address_t *src_address,
+                           u32 fib_id,
+                           u32 server_fib_id, 
+                           int is_del);
 
 int dhcp_proxy_set_option82_vss(u32 vrf_id,
                                 u32 oui,
                                 u32 fib_id, 
                                 int is_del);
 
 int dhcp_proxy_set_option82_vss(u32 vrf_id,
                                 u32 oui,
                                 u32 fib_id, 
                                 int is_del);
+
+void dhcp_proxy_dump(void *opaque,
+                     u32 context);
+
 #endif /* included_dhcp_proxy_h */
 #endif /* included_dhcp_proxy_h */
index 6aa06eb..6d790d7 100644 (file)
@@ -21,7 +21,8 @@ dhcp_proxy_error (RELAY_TO_SERVER, "DHCP packets relayed to the server")
 dhcp_proxy_error (RELAY_TO_CLIENT, "DHCP packets relayed to clients")
 dhcp_proxy_error (OPTION_82_ERROR, "DHCP failed to insert option 82")
 dhcp_proxy_error (NO_OPTION_82, "DHCP option 82 missing")
 dhcp_proxy_error (RELAY_TO_CLIENT, "DHCP packets relayed to clients")
 dhcp_proxy_error (OPTION_82_ERROR, "DHCP failed to insert option 82")
 dhcp_proxy_error (NO_OPTION_82, "DHCP option 82 missing")
-dhcp_proxy_error (BAD_OPTION_82, "Bad DHCP option 82 value")
+dhcp_proxy_error (BAD_OPTION_82_ITF, "Bad DHCP option 82 interface value")
+dhcp_proxy_error (BAD_OPTION_82_ADDR, "Bad DHCP option 82 address value")
 dhcp_proxy_error (BAD_FIB_ID, "DHCP option 82 fib-id to fib-index map failure")
 dhcp_proxy_error (NO_INTERFACE_ADDRESS, "DHCP no interface address")
 dhcp_proxy_error (OPTION_82_VSS_NOT_PROCESSED, "DHCP VSS not processed by DHCP server")
 dhcp_proxy_error (BAD_FIB_ID, "DHCP option 82 fib-id to fib-index map failure")
 dhcp_proxy_error (NO_INTERFACE_ADDRESS, "DHCP no interface address")
 dhcp_proxy_error (OPTION_82_VSS_NOT_PROCESSED, "DHCP VSS not processed by DHCP server")
index 6a58fcd..ab6819f 100644 (file)
@@ -18,6 +18,7 @@
 #include <vlib/vlib.h>
 #include <vnet/pg/pg.h>
 #include <vnet/dhcp/proxy.h>
 #include <vlib/vlib.h>
 #include <vnet/pg/pg.h>
 #include <vnet/dhcp/proxy.h>
+#include <vnet/dhcp/client.h>
 #include <vnet/fib/ip4_fib.h>
 
 static char * dhcp_proxy_error_strings[] = {
 #include <vnet/fib/ip4_fib.h>
 
 static char * dhcp_proxy_error_strings[] = {
@@ -57,6 +58,8 @@ typedef struct {
 vlib_node_registration_t dhcp_proxy_to_server_node;
 vlib_node_registration_t dhcp_proxy_to_client_node;
 
 vlib_node_registration_t dhcp_proxy_to_server_node;
 vlib_node_registration_t dhcp_proxy_to_client_node;
 
+dhcp_proxy_main_t dhcp_proxy_main;
+
 u8 * format_dhcp_proxy_trace (u8 * s, va_list * args)
 {
   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
 u8 * format_dhcp_proxy_trace (u8 * s, va_list * args)
 {
   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
@@ -94,6 +97,42 @@ u8 * format_dhcp_proxy_header_with_length (u8 * s, va_list * args)
   return s;
 }
 
   return s;
 }
 
+static inline vss_info *
+dhcp_get_vss_info (dhcp_proxy_main_t *dm,
+                   u32 rx_fib_index)
+{
+  vss_info *v;
+
+  if (vec_len(dm->vss_index_by_rx_fib_index) <= rx_fib_index ||
+      dm->vss_index_by_rx_fib_index[rx_fib_index] == ~0)
+  {
+      v = NULL;
+  }
+  else
+  {
+      v = pool_elt_at_index (dm->vss,
+                             dm->vss_index_by_rx_fib_index[rx_fib_index]);
+  }
+
+  return (v);
+}
+
+static inline dhcp_server_t *
+dhcp_get_server (dhcp_proxy_main_t *dm,
+                 u32 rx_fib_index)
+{
+  dhcp_server_t *s = NULL;
+
+  if (vec_len(dm->dhcp_server_index_by_rx_fib_index) > rx_fib_index &&
+      dm->dhcp_server_index_by_rx_fib_index[rx_fib_index] != ~0)
+  {
+      s = pool_elt_at_index (dm->dhcp_servers,
+                             dm->dhcp_server_index_by_rx_fib_index[rx_fib_index]);
+  }
+
+  return (s);
+}
+
 static uword
 dhcp_proxy_to_server_input (vlib_main_t * vm,
                             vlib_node_runtime_t * node,
 static uword
 dhcp_proxy_to_server_input (vlib_main_t * vm,
                             vlib_node_runtime_t * node,
@@ -131,9 +170,12 @@ dhcp_proxy_to_server_input (vlib_main_t * vm,
           u32 sw_if_index = 0;
           u32 original_sw_if_index = 0;
           u8  *end = NULL;
           u32 sw_if_index = 0;
           u32 original_sw_if_index = 0;
           u8  *end = NULL;
-          u32 fib_index, server_index;
+          u32 fib_index;
           dhcp_server_t * server;
           u32 rx_sw_if_index;
           dhcp_server_t * server;
           u32 rx_sw_if_index;
+          dhcp_option_t *o;
+          u32 len = 0;
+          vlib_buffer_free_list_t *fl;
 
          bi0 = from[0];
          to_next[0] = bi0;
 
          bi0 = from[0];
          to_next[0] = bi0;
@@ -166,26 +208,16 @@ dhcp_proxy_to_server_input (vlib_main_t * vm,
           rx_sw_if_index = vnet_buffer(b0)->sw_if_index[VLIB_RX];
 
           fib_index = im->fib_index_by_sw_if_index [rx_sw_if_index];
           rx_sw_if_index = vnet_buffer(b0)->sw_if_index[VLIB_RX];
 
           fib_index = im->fib_index_by_sw_if_index [rx_sw_if_index];
-
-          if (fib_index < vec_len(dpm->dhcp_server_index_by_rx_fib_index))
-            server_index = dpm->dhcp_server_index_by_rx_fib_index[fib_index];
-          else
-            server_index = 0;
+          server = dhcp_get_server(dpm, fib_index);
           
           
-          if (PREDICT_FALSE (pool_is_free_index (dpm->dhcp_servers, 
-                                                 server_index)))
+          if (PREDICT_FALSE (NULL == server))
             {
             {
-            no_server:
               error0 = DHCP_PROXY_ERROR_NO_SERVER;
               next0 = DHCP_PROXY_TO_SERVER_INPUT_NEXT_DROP;
               pkts_no_server++;
               goto do_trace;
             }
           
               error0 = DHCP_PROXY_ERROR_NO_SERVER;
               next0 = DHCP_PROXY_TO_SERVER_INPUT_NEXT_DROP;
               pkts_no_server++;
               goto do_trace;
             }
           
-          server = pool_elt_at_index (dpm->dhcp_servers, server_index);
-          if (server->valid == 0)
-            goto no_server;
-
           vlib_buffer_advance (b0, -(sizeof(*ip0)));
           ip0 = vlib_buffer_get_current (b0);
 
           vlib_buffer_advance (b0, -(sizeof(*ip0)));
           ip0 = vlib_buffer_get_current (b0);
 
@@ -216,142 +248,131 @@ dhcp_proxy_to_server_input (vlib_main_t * vm,
           h0->gateway_ip_address.as_u32 = server->dhcp_src_address.as_u32;
           pkts_to_server++;
 
           h0->gateway_ip_address.as_u32 = server->dhcp_src_address.as_u32;
           pkts_to_server++;
 
-          if (server->insert_option_82) 
-            {
-              u32 fib_index, fib_id, opt82_fib_id=0, opt82_oui=0;
-             ip4_fib_t * fib;
-              dhcp_option_t *o = (dhcp_option_t *) h0->options;
-              u32 len = 0;
-              vlib_buffer_free_list_t *fl;
+          o = (dhcp_option_t *) h0->options;
               
               
-              fib_index = im->fib_index_by_sw_if_index 
-                [vnet_buffer(b0)->sw_if_index[VLIB_RX]];
-             fib = ip4_fib_get (fib_index);
-             fib_id = fib->table_id;
-
-              end = b0->data + b0->current_data + b0->current_length;
-              /* TLVs are not performance-friendly... */
-              while  (o->option != 0xFF /* end of options */ && (u8 *)o < end) 
-                  o = (dhcp_option_t *) (((uword) o) + (o->length + 2));
-
-              fl = vlib_buffer_get_free_list (vm, b0->free_list_index);
-              // start write at (option*)o, some packets have padding
-              if (((u8 *)o - (u8 *)b0->data + VPP_DHCP_OPTION82_SIZE) > fl->n_data_bytes)
-                {
-                  next0 = DHCP_PROXY_TO_SERVER_INPUT_NEXT_DROP;
-                  pkts_too_big++;
-                  goto do_trace;
-                }
+          fib_index = im->fib_index_by_sw_if_index 
+              [vnet_buffer(b0)->sw_if_index[VLIB_RX]];
+
+          end = b0->data + b0->current_data + b0->current_length;
+          /* TLVs are not performance-friendly... */
+          while  (o->option != 0xFF /* end of options */ && (u8 *)o < end) 
+              o = (dhcp_option_t *) (((uword) o) + (o->length + 2));
 
 
-              if ((o->option == 0xFF)  && ((u8 *)o <= end))
-                {  
-                  vnet_main_t *vnm = vnet_get_main();   
-                  u16 old_l0, new_l0;
-                  ip4_address_t _ia0, * ia0 = &_ia0;
-                  uword  *p_vss;
-                  vss_info *vss;
-                  vnet_sw_interface_t *swif;
-                  sw_if_index = 0;
-                  original_sw_if_index = 0;
+          fl = vlib_buffer_get_free_list (vm, b0->free_list_index);
+          // start write at (option*)o, some packets have padding
+          if (((u8 *)o - (u8 *)b0->data + VPP_DHCP_OPTION82_SIZE) > fl->n_data_bytes)
+          {
+              next0 = DHCP_PROXY_TO_SERVER_INPUT_NEXT_DROP;
+              pkts_too_big++;
+              goto do_trace;
+          }
+
+          if ((o->option == 0xFF)  && ((u8 *)o <= end))
+          {  
+              vnet_main_t *vnm = vnet_get_main();   
+              u16 old_l0, new_l0;
+              ip4_address_t _ia0, * ia0 = &_ia0;
+              vss_info *vss;
+              vnet_sw_interface_t *swif;
+              sw_if_index = 0;
+              original_sw_if_index = 0;
                   
                   
-                  original_sw_if_index = sw_if_index = 
-                      vnet_buffer(b0)->sw_if_index[VLIB_RX];
-                  swif = vnet_get_sw_interface (vnm, sw_if_index);
-                  if (swif->flags & VNET_SW_INTERFACE_FLAG_UNNUMBERED)
-                      sw_if_index = swif->unnumbered_sw_if_index;
+              original_sw_if_index = sw_if_index = 
+                  vnet_buffer(b0)->sw_if_index[VLIB_RX];
+              swif = vnet_get_sw_interface (vnm, sw_if_index);
+              if (swif->flags & VNET_SW_INTERFACE_FLAG_UNNUMBERED)
+                  sw_if_index = swif->unnumbered_sw_if_index;
                   
                   
-                  p_vss = hash_get (dpm->opt82vss_index_by_vrf_id,
-                                    fib_id);
-                  if (p_vss) 
-                    {
-                      vss = pool_elt_at_index (dpm->opt82vss, p_vss[0]);
-                      opt82_oui =  vss->vpn_id.oui;
-                      opt82_fib_id =  vss->vpn_id.fib_id;
-                    }
-                  /* 
-                   * Get the first ip4 address on the [client-side] 
-                   * RX interface, if not unnumbered. otherwise use
-                   * the loopback interface's ip address.
-                   */
-                  ia0 = ip4_interface_first_address(&ip4_main, sw_if_index, 0);
+              /* 
+               * Get the first ip4 address on the [client-side] 
+               * RX interface, if not unnumbered. otherwise use
+               * the loopback interface's ip address.
+               */
+              ia0 = ip4_interface_first_address(&ip4_main, sw_if_index, 0);
                   
                   
-                  if (ia0 == 0)
-                    {
-                      error0 = DHCP_PROXY_ERROR_NO_INTERFACE_ADDRESS;
-                      next0 = DHCP_PROXY_TO_SERVER_INPUT_NEXT_DROP;
-                      pkts_no_interface_address++;
-                      goto do_trace;
-                    }
-
-                  /* Add option 82 */
-                  o->option = 82;   /* option 82 */
-                  o->length = 12;   /* 12 octets to follow */
-                  o->data[0] = 1;   /* suboption 1, circuit ID (=FIB id) */
-                  o->data[1] = 4;   /* length of suboption */
-                  o->data[2] = (original_sw_if_index >> 24) & 0xFF;
-                  o->data[3] = (original_sw_if_index >> 16) & 0xFF;
-                  o->data[4] = (original_sw_if_index >> 8)  & 0xFF;
-                  o->data[5] = (original_sw_if_index >> 0)  & 0xFF;
-                 o->data[6] = 5; /* suboption 5 (client RX intfc address) */
-                 o->data[7] = 4; /* length 4 */
-                 o->data[8] = ia0->as_u8[0];
-                 o->data[9] = ia0->as_u8[1];
-                 o->data[10] = ia0->as_u8[2];
-                 o->data[11] = ia0->as_u8[3];
-                  o->data[12] = 0xFF;
-                  if (opt82_oui !=0 || opt82_fib_id != 0)
-                    {
-                      o->data[12] = 151; /* vss suboption */
-                      if (255 == opt82_fib_id) {
-                          o->data[13] = 1;   /* length */
-                          o->data[14] = 255;   /* vss option type */
-                          o->data[15] = 152; /* vss control suboption */
-                          o->data[16] = 0;   /* length */
-                          /* and a new "end-of-options" option (0xff) */
-                          o->data[17] = 0xFF;
-                          o->length += 5;
-                      } else {
-                          o->data[13] = 8;   /* length */
-                          o->data[14] = 1;   /* vss option type */
-                          o->data[15] = (opt82_oui >> 16) & 0xff;
-                          o->data[16] = (opt82_oui >> 8) & 0xff;
-                          o->data[17] = (opt82_oui ) & 0xff;
-                          o->data[18] = (opt82_fib_id >> 24) & 0xff;
-                          o->data[19] = (opt82_fib_id >> 16) & 0xff;
-                          o->data[20] = (opt82_fib_id >> 8) & 0xff;
-                          o->data[21] = (opt82_fib_id) & 0xff;
-                          o->data[22] = 152; /* vss control suboption */
-                          o->data[23] = 0;   /* length */
+              if (ia0 == 0)
+              {
+                  error0 = DHCP_PROXY_ERROR_NO_INTERFACE_ADDRESS;
+                  next0 = DHCP_PROXY_TO_SERVER_INPUT_NEXT_DROP;
+                  pkts_no_interface_address++;
+                  goto do_trace;
+              }
+
+              /* Add option 82 */
+              o->option = 82;   /* option 82 */
+              o->length = 12;   /* 12 octets to follow */
+              o->data[0] = 1;   /* suboption 1, circuit ID (=FIB id) */
+              o->data[1] = 4;   /* length of suboption */
+              o->data[2] = (original_sw_if_index >> 24) & 0xFF;
+              o->data[3] = (original_sw_if_index >> 16) & 0xFF;
+              o->data[4] = (original_sw_if_index >> 8)  & 0xFF;
+              o->data[5] = (original_sw_if_index >> 0)  & 0xFF;
+              o->data[6] = 5; /* suboption 5 (client RX intfc address) */
+              o->data[7] = 4; /* length 4 */
+              o->data[8] = ia0->as_u8[0];
+              o->data[9] = ia0->as_u8[1];
+              o->data[10] = ia0->as_u8[2];
+              o->data[11] = ia0->as_u8[3];
+              o->data[12] = 0xFF;
+
+              vss = dhcp_get_vss_info (dpm, fib_index);
+              if (NULL != vss)
+              {
+                  u32 opt82_fib_id=0, opt82_oui=0;
+
+                  opt82_oui =  vss->vpn_id.oui;
+                  opt82_fib_id =  vss->vpn_id.fib_id;
+
+                  o->data[12] = 151; /* vss suboption */
+                  if (255 == opt82_fib_id) {
+                      o->data[13] = 1;   /* length */
+                      o->data[14] = 255;   /* vss option type */
+                      o->data[15] = 152; /* vss control suboption */
+                      o->data[16] = 0;   /* length */
+                      /* and a new "end-of-options" option (0xff) */
+                      o->data[17] = 0xFF;
+                      o->length += 5;
+                  } else {
+                      o->data[13] = 8;   /* length */
+                      o->data[14] = 1;   /* vss option type */
+                      o->data[15] = (opt82_oui >> 16) & 0xff;
+                      o->data[16] = (opt82_oui >> 8) & 0xff;
+                      o->data[17] = (opt82_oui ) & 0xff;
+                      o->data[18] = (opt82_fib_id >> 24) & 0xff;
+                      o->data[19] = (opt82_fib_id >> 16) & 0xff;
+                      o->data[20] = (opt82_fib_id >> 8) & 0xff;
+                      o->data[21] = (opt82_fib_id) & 0xff;
+                      o->data[22] = 152; /* vss control suboption */
+                      o->data[23] = 0;   /* length */
                           
                           
-                          /* and a new "end-of-options" option (0xff) */
-                          o->data[24] = 0xFF;
-                          o->length += 12;
-                      }
+                      /* and a new "end-of-options" option (0xff) */
+                      o->data[24] = 0xFF;
+                      o->length += 12;
                   }
                   }
-
-                  len = o->length + 3;
-                  b0->current_length += len;
-                  /* Fix IP header length and checksum */
-                  old_l0 = ip0->length;
-                  new_l0 = clib_net_to_host_u16 (old_l0);
-                  new_l0 += len;
-                  new_l0 = clib_host_to_net_u16 (new_l0);
-                  ip0->length = new_l0;
-                  sum0 = ip0->checksum;
-                  sum0 = ip_csum_update (sum0, old_l0, new_l0, ip4_header_t,
-                                         length /* changed member */);
-                  ip0->checksum = ip_csum_fold (sum0);
-
-                  /* Fix UDP length */
-                  new_l0 = clib_net_to_host_u16 (u0->length);
-                  new_l0 += len;
-                  u0->length = clib_host_to_net_u16 (new_l0);
-                } else {
-                  vlib_node_increment_counter 
-                      (vm, dhcp_proxy_to_server_node.index,
-                       DHCP_PROXY_ERROR_OPTION_82_ERROR, 1);
-                }
-            }
+              }
+
+              len = o->length + 3;
+              b0->current_length += len;
+              /* Fix IP header length and checksum */
+              old_l0 = ip0->length;
+              new_l0 = clib_net_to_host_u16 (old_l0);
+              new_l0 += len;
+              new_l0 = clib_host_to_net_u16 (new_l0);
+              ip0->length = new_l0;
+              sum0 = ip0->checksum;
+              sum0 = ip_csum_update (sum0, old_l0, new_l0, ip4_header_t,
+                                     length /* changed member */);
+              ip0->checksum = ip_csum_fold (sum0);
+
+              /* Fix UDP length */
+              new_l0 = clib_net_to_host_u16 (u0->length);
+              new_l0 += len;
+              u0->length = clib_host_to_net_u16 (new_l0);
+          } else {
+              vlib_node_increment_counter 
+                  (vm, dhcp_proxy_to_server_node.index,
+                   DHCP_PROXY_ERROR_OPTION_82_ERROR, 1);
+          }
           
           next0 = DHCP_PROXY_TO_SERVER_INPUT_NEXT_LOOKUP;
 
           
           next0 = DHCP_PROXY_TO_SERVER_INPUT_NEXT_LOOKUP;
 
@@ -451,11 +472,13 @@ dhcp_proxy_to_client_input (vlib_main_t * vm,
       vnet_sw_interface_t *si0;
       u32 error0 = (u32)~0;
       vnet_sw_interface_t *swif;
       vnet_sw_interface_t *si0;
       u32 error0 = (u32)~0;
       vnet_sw_interface_t *swif;
-      u32 server_index;
       u32 fib_index;
       dhcp_server_t * server;
       u32 original_sw_if_index = (u32) ~0;
       u32 fib_index;
       dhcp_server_t * server;
       u32 original_sw_if_index = (u32) ~0;
-          
+      ip4_address_t relay_addr = {
+          .as_u32 = 0,
+      };
+
       bi0 = from[0];
       from += 1;
       n_left_from -= 1;
       bi0 = from[0];
       from += 1;
       n_left_from -= 1;
@@ -501,13 +524,21 @@ dhcp_proxy_to_client_input (vlib_main_t * vm,
                            and the sw_if_index */
                         if (sub->option == 1 && sub->length == 4)
                           {
                            and the sw_if_index */
                         if (sub->option == 1 && sub->length == 4)
                           {
-                            sw_if_index = (o->data[2] << 24)
-                                | (o->data[3] << 16)
-                                | (o->data[4] << 8)
-                                | (o->data[5]);
-                          } else if (sub->option == 151 &&
-                                     sub->length == 7 &&
-                                     sub->data[0] == 1)
+                            sw_if_index = ((sub->data[0] << 24) |
+                                           (sub->data[1] << 16) |
+                                           (sub->data[2] << 8)  |
+                                           (sub->data[3]));
+                          }
+                        else if (sub->option == 5 && sub->length == 4)
+                          {
+                              relay_addr.as_u8[0] = sub->data[0];
+                              relay_addr.as_u8[1] = sub->data[1];
+                              relay_addr.as_u8[2] = sub->data[2];
+                              relay_addr.as_u8[3] = sub->data[3];
+                          }
+                        else if (sub->option == 151 &&
+                                 sub->length == 7 &&
+                                 sub->data[0] == 1)
                             vss_exist = 1;
                         else if (sub->option == 152 && sub->length == 0)
                             vss_ctrl = 1;
                             vss_exist = 1;
                         else if (sub->option == 152 && sub->length == 0)
                             vss_ctrl = 1;
@@ -539,34 +570,27 @@ dhcp_proxy_to_client_input (vlib_main_t * vm,
           goto do_trace;
         }
       
           goto do_trace;
         }
       
+      if (relay_addr.as_u32 == 0)
+        {
+          error0 = DHCP_PROXY_ERROR_BAD_OPTION_82_ADDR;
+          goto drop_packet;
+        }
 
       if (sw_if_index >= vec_len (im->fib_index_by_sw_if_index))
         {
 
       if (sw_if_index >= vec_len (im->fib_index_by_sw_if_index))
         {
-          error0 = DHCP_PROXY_ERROR_BAD_OPTION_82;
+          error0 = DHCP_PROXY_ERROR_BAD_OPTION_82_ITF;
           goto drop_packet;
         }
 
       fib_index = im->fib_index_by_sw_if_index [sw_if_index];
           goto drop_packet;
         }
 
       fib_index = im->fib_index_by_sw_if_index [sw_if_index];
+      server = dhcp_get_server(dpm, fib_index);
 
 
-      if (fib_index < vec_len(dpm->dhcp_server_index_by_rx_fib_index))
-        server_index = dpm->dhcp_server_index_by_rx_fib_index[fib_index];
-      else
-        server_index = 0;
-
-      if (PREDICT_FALSE (pool_is_free_index (dpm->dhcp_servers, 
-                                             server_index)))
-        {
-          error0 = DHCP_PROXY_ERROR_BAD_OPTION_82;
-          goto drop_packet;
-        }
-      
-      server = pool_elt_at_index (dpm->dhcp_servers, server_index);
-      if (server->valid == 0)
+      if (PREDICT_FALSE (NULL == server))
         {
           error0 = DHCP_PROXY_ERROR_NO_SERVER;
           goto drop_packet;
         }
         {
           error0 = DHCP_PROXY_ERROR_NO_SERVER;
           goto drop_packet;
         }
-
+      
       if (ip0->src_address.as_u32 != server->dhcp_server.as_u32)
         {             
           error0 = DHCP_PROXY_ERROR_BAD_SVR_FIB_OR_ADDRESS;
       if (ip0->src_address.as_u32 != server->dhcp_server.as_u32)
         {             
           error0 = DHCP_PROXY_ERROR_BAD_SVR_FIB_OR_ADDRESS;
@@ -587,6 +611,12 @@ dhcp_proxy_to_client_input (vlib_main_t * vm,
           goto drop_packet;
         }
 
           goto drop_packet;
         }
 
+      if (relay_addr.as_u32 != ia0->as_u32)
+        {             
+          error0 = DHCP_PROXY_ERROR_BAD_YIADDR;
+          goto drop_packet;
+        }
+
       u0->checksum = 0;
       u0->dst_port = clib_net_to_host_u16 (UDP_DST_PORT_dhcp_to_client);
       sum0 = ip0->checksum;
       u0->checksum = 0;
       u0->dst_port = clib_net_to_host_u16 (UDP_DST_PORT_dhcp_to_client);
       sum0 = ip0->checksum;
@@ -677,7 +707,7 @@ clib_error_t * dhcp_proxy_init (vlib_main_t * vm)
   error_drop_node = vlib_get_node_by_name (vm, (u8 *) "error-drop");
   dm->error_drop_node_index = error_drop_node->index;
 
   error_drop_node = vlib_get_node_by_name (vm, (u8 *) "error-drop");
   dm->error_drop_node_index = error_drop_node->index;
 
-  dm->opt82vss_index_by_vrf_id = hash_create (0, sizeof (uword));
+  dm->vss_index_by_rx_fib_index = NULL;
 
   udp_register_dst_port (vm, UDP_DST_PORT_dhcp_to_client, 
                          dhcp_proxy_to_client_node.index, 1 /* is_ip4 */);
 
   udp_register_dst_port (vm, UDP_DST_PORT_dhcp_to_client, 
                          dhcp_proxy_to_client_node.index, 1 /* is_ip4 */);
@@ -694,15 +724,17 @@ clib_error_t * dhcp_proxy_init (vlib_main_t * vm)
 
 VLIB_INIT_FUNCTION (dhcp_proxy_init);
 
 
 VLIB_INIT_FUNCTION (dhcp_proxy_init);
 
-int dhcp_proxy_set_server_2 (ip4_address_t *addr, ip4_address_t *src_address,
-                             u32 rx_fib_id,
-                             u32 server_fib_id, 
-                             int insert_option_82, int is_del)
+int dhcp_proxy_set_server (ip4_address_t *addr,
+                           ip4_address_t *src_address,
+                           u32 rx_fib_id,
+                           u32 server_fib_id, 
+                           int is_del)
 {
   dhcp_proxy_main_t * dpm = &dhcp_proxy_main;
   dhcp_server_t * server = 0;
   u32 server_index = 0;
   u32 rx_fib_index = 0;
 {
   dhcp_proxy_main_t * dpm = &dhcp_proxy_main;
   dhcp_server_t * server = 0;
   u32 server_index = 0;
   u32 rx_fib_index = 0;
+
   const fib_prefix_t all_1s =
   {
       .fp_len = 32,
   const fib_prefix_t all_1s =
   {
       .fp_len = 32,
@@ -719,97 +751,68 @@ int dhcp_proxy_set_server_2 (ip4_address_t *addr, ip4_address_t *src_address,
   rx_fib_index = fib_table_find_or_create_and_lock(FIB_PROTOCOL_IP4,
                                                    rx_fib_id);
 
   rx_fib_index = fib_table_find_or_create_and_lock(FIB_PROTOCOL_IP4,
                                                    rx_fib_id);
 
-  if (rx_fib_id == 0)
-    {
-      server = pool_elt_at_index (dpm->dhcp_servers, 0);
-      
-      if (is_del)
-        {
-          memset (server, 0, sizeof (*server));
-          fib_table_entry_special_remove(rx_fib_index,
-                                         &all_1s,
-                                         FIB_SOURCE_DHCP);
-         return 0;
-        }
-      if (!server->valid)
-          fib_table_entry_special_add(rx_fib_index,
-                                      &all_1s,
-                                      FIB_SOURCE_DHCP,
-                                      FIB_ENTRY_FLAG_LOCAL,
-                                      ADJ_INDEX_INVALID);
-
-      goto initialize_it;
-    }
-
   if (is_del)
     {
       if (rx_fib_index >= vec_len(dpm->dhcp_server_index_by_rx_fib_index))
         return VNET_API_ERROR_NO_SUCH_ENTRY;
       
       server_index = dpm->dhcp_server_index_by_rx_fib_index[rx_fib_index];
   if (is_del)
     {
       if (rx_fib_index >= vec_len(dpm->dhcp_server_index_by_rx_fib_index))
         return VNET_API_ERROR_NO_SUCH_ENTRY;
       
       server_index = dpm->dhcp_server_index_by_rx_fib_index[rx_fib_index];
-      ASSERT(server_index > 0);
+
+      if (server_index == ~0)
+        return VNET_API_ERROR_NO_SUCH_ENTRY;
 
       /* Use the default server again.  */
 
       /* Use the default server again.  */
-      dpm->dhcp_server_index_by_rx_fib_index[rx_fib_index] = 0;
+      dpm->dhcp_server_index_by_rx_fib_index[rx_fib_index] = ~0;
       server = pool_elt_at_index (dpm->dhcp_servers, server_index);
       server = pool_elt_at_index (dpm->dhcp_servers, server_index);
-      memset (server, 0, sizeof (*server));
-      pool_put (dpm->dhcp_servers, server);
 
       fib_table_entry_special_remove(rx_fib_index,
                                      &all_1s,
                                      FIB_SOURCE_DHCP);
 
       fib_table_entry_special_remove(rx_fib_index,
                                      &all_1s,
                                      FIB_SOURCE_DHCP);
+      fib_table_unlock (rx_fib_index,
+                        FIB_PROTOCOL_IP4);
+      fib_table_unlock (server->server_fib_index,
+                        FIB_PROTOCOL_IP4);
 
 
+      memset (server, 0, sizeof (*server));
+      pool_put (dpm->dhcp_servers, server);
       return 0;
     }
       return 0;
     }
-
-  if (rx_fib_index < vec_len(dpm->dhcp_server_index_by_rx_fib_index))
-    {
-      server_index = dpm->dhcp_server_index_by_rx_fib_index[rx_fib_index];
-      if (server_index != 0)
-        {
-          server = pool_elt_at_index (dpm->dhcp_servers, server_index);
-          goto initialize_it;
-        }
-    }
-
-  pool_get (dpm->dhcp_servers, server);
-
-  fib_table_entry_special_add(rx_fib_index,
-                              &all_1s,
-                              FIB_SOURCE_DHCP,
-                              FIB_ENTRY_FLAG_LOCAL,
-                              ADJ_INDEX_INVALID);
-  
- initialize_it:
-
-
-  server->dhcp_server.as_u32 = addr->as_u32;
-  server->server_fib_index = 
-      fib_table_find_or_create_and_lock(FIB_PROTOCOL_IP4,
-                                       server_fib_id);
-  server->dhcp_src_address.as_u32 = src_address->as_u32;
-  server->insert_option_82 = insert_option_82;
-  server->valid = 1;
-  if (rx_fib_index)
-    {
-      vec_validate (dpm->dhcp_server_index_by_rx_fib_index, rx_fib_index);
+  else
+  {
+      vec_validate_init_empty(dpm->dhcp_server_index_by_rx_fib_index,
+                              rx_fib_index,
+                              ~0);
+
+      pool_get (dpm->dhcp_servers, server);
+
+      server->dhcp_server.as_u32 = addr->as_u32;
+      server->dhcp_src_address.as_u32 = src_address->as_u32;
+
+      fib_table_entry_special_add(rx_fib_index,
+                                  &all_1s,
+                                  FIB_SOURCE_DHCP,
+                                  FIB_ENTRY_FLAG_LOCAL,
+                                  ADJ_INDEX_INVALID);
+      fib_table_lock (rx_fib_index,
+                      FIB_PROTOCOL_IP4);
+
+      server->server_fib_index = 
+          fib_table_find_or_create_and_lock(FIB_PROTOCOL_IP4,
+                                            server_fib_id);
+
+      vec_validate_init_empty (dpm->dhcp_server_index_by_rx_fib_index,
+                               rx_fib_index,
+                               ~0);
       dpm->dhcp_server_index_by_rx_fib_index[rx_fib_index] = 
       dpm->dhcp_server_index_by_rx_fib_index[rx_fib_index] = 
-        server - dpm->dhcp_servers;
-    }
+          server - dpm->dhcp_servers;
+  }
 
 
-  return 0;
-}
+  fib_table_unlock (rx_fib_index,
+                    FIB_PROTOCOL_IP4);
 
 
-/* Old API, manipulates the default server (only) */
-int dhcp_proxy_set_server (ip4_address_t *addr, ip4_address_t *src_address,
-                           u32 fib_id, int insert_option_82, int is_del)
-{
-  return dhcp_proxy_set_server_2 (addr, src_address, 0 /* rx_fib_id */,
-                                  fib_id /* server_fib_id */, 
-                                  insert_option_82, is_del);
+  return 0;
 }
 
 }
 
-
 static clib_error_t *
 dhcp_proxy_set_command_fn (vlib_main_t * vm,
                            unformat_input_t * input,
 static clib_error_t *
 dhcp_proxy_set_command_fn (vlib_main_t * vm,
                            unformat_input_t * input,
@@ -818,7 +821,6 @@ dhcp_proxy_set_command_fn (vlib_main_t * vm,
   ip4_address_t server_addr, src_addr;
   u32 server_fib_id = 0, rx_fib_id = 0;
   int is_del = 0;
   ip4_address_t server_addr, src_addr;
   u32 server_fib_id = 0, rx_fib_id = 0;
   int is_del = 0;
-  int add_option_82 = 0;
   int set_src = 0, set_server = 0;
   
   while (unformat_check_input(input) != UNFORMAT_END_OF_INPUT) 
   int set_src = 0, set_server = 0;
   
   while (unformat_check_input(input) != UNFORMAT_END_OF_INPUT) 
@@ -833,9 +835,6 @@ dhcp_proxy_set_command_fn (vlib_main_t * vm,
       else if (unformat(input, "src-address %U", 
                        unformat_ip4_address, &src_addr))
         set_src = 1;
       else if (unformat(input, "src-address %U", 
                        unformat_ip4_address, &src_addr))
         set_src = 1;
-      else if (unformat (input, "add-option-82")
-               || unformat (input, "insert-option-82"))
-        add_option_82 = 1;
       else if (unformat (input, "delete") ||
                unformat (input, "del"))
         is_del = 1;
       else if (unformat (input, "delete") ||
                unformat (input, "del"))
         is_del = 1;
@@ -847,8 +846,8 @@ dhcp_proxy_set_command_fn (vlib_main_t * vm,
     {
       int rv;
 
     {
       int rv;
 
-      rv = dhcp_proxy_set_server_2 (&server_addr, &src_addr, rx_fib_id, 
-                                    server_fib_id, add_option_82, is_del);
+      rv = dhcp_proxy_set_server (&server_addr, &src_addr, rx_fib_id, 
+                                  server_fib_id, is_del);
       switch (rv)
         {
         case 0:
       switch (rv)
         {
         case 0:
@@ -882,7 +881,7 @@ dhcp_proxy_set_command_fn (vlib_main_t * vm,
 
 VLIB_CLI_COMMAND (dhcp_proxy_set_command, static) = {
   .path = "set dhcp proxy",
 
 VLIB_CLI_COMMAND (dhcp_proxy_set_command, static) = {
   .path = "set dhcp proxy",
-  .short_help = "set dhcp proxy [del] server <ip-addr> src-address <ip-addr> [add-option-82] [server-fib-id <n>] [rx-fib-id <n>]",
+  .short_help = "set dhcp proxy [del] server <ip-addr> src-address <ip-addr> [server-fib-id <n>] [rx-fib-id <n>]",
   .function = dhcp_proxy_set_command_fn,
 };
 
   .function = dhcp_proxy_set_command_fn,
 };
 
@@ -896,8 +895,8 @@ u8 * format_dhcp_proxy_server (u8 * s, va_list * args)
 
   if (dm == 0)
     {
 
   if (dm == 0)
     {
-      s = format (s, "%=16s%=16s%=14s%=14s%=20s", "Server", "Src Address", 
-                  "Server FIB", "RX FIB", "Insert Option 82");
+      s = format (s, "%=16s%=16s%=14s%=14s", "Server", "Src Address", 
+                  "Server FIB", "RX FIB");
       return s;
     }
 
       return s;
     }
 
@@ -911,11 +910,10 @@ u8 * format_dhcp_proxy_server (u8 * s, va_list * args)
   if (rx_fib)
     rx_fib_id = rx_fib->table_id;
 
   if (rx_fib)
     rx_fib_id = rx_fib->table_id;
 
-  s = format (s, "%=16U%=16U%=14u%=14u%=20s",
+  s = format (s, "%=16U%=16U%=14u%=14u",
               format_ip4_address, &server->dhcp_server,
               format_ip4_address, &server->dhcp_src_address,
               format_ip4_address, &server->dhcp_server,
               format_ip4_address, &server->dhcp_src_address,
-              server_fib_id, rx_fib_id,
-              server->insert_option_82 ? "yes" : "no");
+              server_fib_id, rx_fib_id);
   return s;
 }
 
   return s;
 }
 
@@ -925,24 +923,22 @@ dhcp_proxy_show_command_fn (vlib_main_t * vm,
                             vlib_cli_command_t * cmd)
 {
   dhcp_proxy_main_t * dpm = &dhcp_proxy_main;
                             vlib_cli_command_t * cmd)
 {
   dhcp_proxy_main_t * dpm = &dhcp_proxy_main;
-  ip4_main_t * im = &ip4_main;
   dhcp_server_t * server;
   dhcp_server_t * server;
-  u32 server_index;
-  int i;
+  u32 server_index, i;
 
   vlib_cli_output (vm, "%U", format_dhcp_proxy_server, 0 /* header line */,
                    0, 0);
 
 
   vlib_cli_output (vm, "%U", format_dhcp_proxy_server, 0 /* header line */,
                    0, 0);
 
-  for (i = 0; i < vec_len (im->fibs); i++)
-    {
-      if (i < vec_len(dpm->dhcp_server_index_by_rx_fib_index))
-        server_index = dpm->dhcp_server_index_by_rx_fib_index[i];
-      else
-        server_index = 0;
+  vec_foreach_index (i, dpm->dhcp_server_index_by_rx_fib_index)
+  {
+      server_index = dpm->dhcp_server_index_by_rx_fib_index[i];
+      if (~0 == server_index)
+          continue;
+
       server = pool_elt_at_index (dpm->dhcp_servers, server_index);
       server = pool_elt_at_index (dpm->dhcp_servers, server_index);
-      if (server->valid)
-        vlib_cli_output (vm, "%U", format_dhcp_proxy_server, dpm, 
-                         server, i);
+
+      vlib_cli_output (vm, "%U", format_dhcp_proxy_server, dpm, 
+                       server, i);
     }
 
   return 0;
     }
 
   return 0;
@@ -954,50 +950,104 @@ VLIB_CLI_COMMAND (dhcp_proxy_show_command, static) = {
   .function = dhcp_proxy_show_command_fn,
 };
 
   .function = dhcp_proxy_show_command_fn,
 };
 
+void
+dhcp_proxy_dump (void *opaque,
+                 u32 context)
+{
+  dhcp_proxy_main_t * dpm = &dhcp_proxy_main;
+  ip4_fib_t *s_fib, *r_fib;
+  dhcp_server_t * server;
+  u32 server_index, i;
+  vss_info *v;
+
+  vec_foreach_index (i, dpm->dhcp_server_index_by_rx_fib_index)
+  {
+      server_index = dpm->dhcp_server_index_by_rx_fib_index[i];
+      if (~0 == server_index)
+          continue;
+
+      server = pool_elt_at_index (dpm->dhcp_servers, server_index);
+      v = dhcp_get_vss_info(dpm, i);
+
+      ip46_address_t src_addr = {
+          .ip4 = server->dhcp_src_address,
+      };
+      ip46_address_t server_addr = {
+          .ip4 = server->dhcp_server,
+      };
+
+      s_fib = ip4_fib_get(server->server_fib_index);
+      r_fib = ip4_fib_get(i);
+
+      dhcp_send_details(opaque,
+                        context,
+                        &server_addr,
+                        &src_addr,
+                        s_fib->table_id,
+                        r_fib->table_id,
+                        (v ? v->vpn_id.fib_id : 0),
+                        (v ? v->vpn_id.oui : 0));
+  }
+}
 
 
-int dhcp_proxy_set_option82_vss(  u32 vrf_id,
-                                  u32 oui,
-                                  u32 fib_id, 
-                                  int is_del)
+int dhcp_proxy_set_option82_vss(u32 tbl_id,
+                                u32 oui,
+                                u32 fib_id, 
+                                int is_del)
 {
   dhcp_proxy_main_t *dm = &dhcp_proxy_main;
 {
   dhcp_proxy_main_t *dm = &dhcp_proxy_main;
-  uword *p;
-  vss_info *a;
-  u32 old_oui=0, old_fib_id=0;
+  vss_info *v = NULL;
+  u32  rx_fib_index;
+  int rc = 0;
   
   
-  p = hash_get (dm->opt82vss_index_by_vrf_id, vrf_id);
+  rx_fib_index = ip4_fib_table_find_or_create_and_lock(tbl_id);
+  v = dhcp_get_vss_info(dm, rx_fib_index);
 
 
-  if (p) 
-    {
-      a = pool_elt_at_index (dm->opt82vss, p[0]);
-      if (!a) 
-        return VNET_API_ERROR_NO_SUCH_FIB;
-      old_oui = a->vpn_id.oui;
-      old_fib_id = a->vpn_id.fib_id;
-          
+  if (NULL != v)
+  {
       if (is_del)
       if (is_del)
-        {
-          if (old_oui == oui &&
-              old_fib_id == fib_id)
-            {
-              pool_put(dm->opt82vss, a);
-              hash_unset (dm->opt82vss_index_by_vrf_id, vrf_id);
-              return 0;
-            }
-          else
-            return VNET_API_ERROR_NO_SUCH_ENTRY;
-        }
-      pool_put(dm->opt82vss, a);
-      hash_unset (dm->opt82vss_index_by_vrf_id, vrf_id);
-  } else if (is_del)
-    return VNET_API_ERROR_NO_SUCH_ENTRY;
-  pool_get (dm->opt82vss, a);
-  memset (a, ~0, sizeof (a[0]));
-  a->vpn_id.oui = oui;
-  a->vpn_id.fib_id = fib_id;
-  hash_set (dm->opt82vss_index_by_vrf_id, vrf_id, a - dm->opt82vss);
+      {
+          /* release the lock held on the table when the VSS
+           * info was created */
+          fib_table_unlock (rx_fib_index,
+                            FIB_PROTOCOL_IP4);
+
+          pool_put (dm->vss, v);
+          dm->vss_index_by_rx_fib_index[rx_fib_index] = ~0;
+      }
+      else
+      {
+          /* this is a modify */
+          v->vpn_id.fib_id = fib_id;
+          v->vpn_id.oui = oui;
+      }
+  }
+  else
+  {
+      if (is_del)
+          rc = VNET_API_ERROR_NO_SUCH_ENTRY;
+      else
+      {
+          /* create a new entry */
+          vec_validate_init_empty(dm->vss_index_by_rx_fib_index,
+                                  rx_fib_index, ~0);
+
+          /* hold a lock on the table whilst the VSS info exist */
+          fib_table_lock (rx_fib_index,
+                          FIB_PROTOCOL_IP4);
+
+          pool_get (dm->vss, v);
+          v->vpn_id.fib_id = fib_id;
+          v->vpn_id.oui = oui;
+          dm->vss_index_by_rx_fib_index[rx_fib_index] = v - dm->vss;
+      }
+  }
+
+  /* Release the lock taken during the create_or_lock at the start */
+  fib_table_unlock (rx_fib_index,
+                    FIB_PROTOCOL_IP4);
   
   
-  return 0;
+  return (rc);
 }
 
 static clib_error_t *
 }
 
 static clib_error_t *
@@ -1065,20 +1115,20 @@ dhcp_vss_show_command_fn (vlib_main_t * vm,
   
 {
   dhcp_proxy_main_t * dm = &dhcp_proxy_main;
   
 {
   dhcp_proxy_main_t * dm = &dhcp_proxy_main;
+  ip4_fib_t *fib;
+  u32 *fib_index;
   vss_info *v;
   vss_info *v;
-  u32 oui;
-  u32 fib_id;
-  u32 tbl_id;
-  uword index;
   
   vlib_cli_output (vm, "%=9s%=11s%=12s","Table", "OUI", "VPN-ID");
   
   vlib_cli_output (vm, "%=9s%=11s%=12s","Table", "OUI", "VPN-ID");
-  hash_foreach (tbl_id, index, dm->opt82vss_index_by_vrf_id,
+  pool_foreach (fib_index, dm->vss_index_by_rx_fib_index,
   ({
   ({
-     v = pool_elt_at_index (dm->opt82vss, index);
-     oui = v->vpn_id.oui;
-     fib_id = v->vpn_id.fib_id;
-     vlib_cli_output (vm, "%=9d 0x%08x%=12d",
-                      tbl_id, oui, fib_id);
+      fib = ip4_fib_get (*fib_index);
+      v = pool_elt_at_index (dm->vss, *fib_index);
+
+      vlib_cli_output (vm, "%=6d%=6d%=12d",
+                       fib->table_id,
+                       v->vpn_id.oui,
+                       v->vpn_id.fib_id);
   }));
   
   return 0;
   }));
   
   return 0;
index 9e18913..77ced36 100644 (file)
@@ -48,9 +48,7 @@ typedef union {
 typedef struct {
   ip6_address_t dhcp6_server;
   ip6_address_t dhcp6_src_address;
 typedef struct {
   ip6_address_t dhcp6_server;
   ip6_address_t dhcp6_src_address;
-  u32 insert_vss;
   u32 server_fib6_index;
   u32 server_fib6_index;
-  u32 valid;
 } dhcpv6_server_t;
 
 typedef struct {
 } dhcpv6_server_t;
 
 typedef struct {
@@ -70,7 +68,7 @@ typedef struct {
   dhcpv6_vss_info *vss;
 
   /* hash lookup specific vrf_id -> VSS vector index*/
   dhcpv6_vss_info *vss;
 
   /* hash lookup specific vrf_id -> VSS vector index*/
-  uword  *vss_index_by_vrf_id;
+  u32 *vss_index_by_rx_fib_index;
    
   /* convenience */
   vlib_main_t * vlib_main;
    
   /* convenience */
   vlib_main_t * vlib_main;
@@ -79,17 +77,18 @@ typedef struct {
 
 dhcpv6_proxy_main_t dhcpv6_proxy_main;
 
 
 dhcpv6_proxy_main_t dhcpv6_proxy_main;
 
-int dhcpv6_proxy_set_server (ip6_address_t *addr, ip6_address_t *src_address,
-                             u32 fib_id, int insert_vss, int is_del);
-
 int dhcpv6_proxy_set_vss(u32 tbl_id,
                          u32 oui,
                          u32 fib_id, 
                          int is_del);
 
 int dhcpv6_proxy_set_vss(u32 tbl_id,
                          u32 oui,
                          u32 fib_id, 
                          int is_del);
 
-int dhcpv6_proxy_set_server_2 (ip6_address_t *addr, ip6_address_t *src_address,
-                             u32 rx_fib_id,
-                             u32 server_fib_id,
-                             int insert_vss, int is_del);
+int dhcpv6_proxy_set_server(ip6_address_t *addr,
+                            ip6_address_t *src_address,
+                            u32 rx_fib_id,
+                            u32 server_fib_id,
+                            int is_del);
+
+void dhcpv6_proxy_dump(void *opaque,
+                       u32 context);
 
 #endif /* included_dhcpv6_proxy_h */
 
 #endif /* included_dhcpv6_proxy_h */
index 4137624..f40798e 100644 (file)
@@ -18,6 +18,7 @@
 #include <vlib/vlib.h>
 #include <vnet/pg/pg.h>
 #include <vnet/dhcpv6/proxy.h>
 #include <vlib/vlib.h>
 #include <vnet/pg/pg.h>
 #include <vnet/dhcpv6/proxy.h>
+#include <vnet/dhcp/proxy.h>
 #include <vnet/fib/ip6_fib.h>
 #include <vnet/mfib/mfib_table.h>
 #include <vnet/mfib/ip6_mfib.h>
 #include <vnet/fib/ip6_fib.h>
 #include <vnet/mfib/mfib_table.h>
 #include <vnet/mfib/ip6_mfib.h>
@@ -117,6 +118,42 @@ static inline void copy_ip6_address (ip6_address_t *dst, ip6_address_t *src)
   dst->as_u64[1] = src->as_u64[1];
 } 
 
   dst->as_u64[1] = src->as_u64[1];
 } 
 
+static inline dhcpv6_vss_info *
+dhcpv6_get_vss_info (dhcpv6_proxy_main_t *dm,
+                     u32 rx_fib_index)
+{
+  dhcpv6_vss_info *v;
+
+  if (vec_len(dm->vss_index_by_rx_fib_index) <= rx_fib_index ||
+      dm->vss_index_by_rx_fib_index[rx_fib_index] == ~0)
+  {
+      v = NULL;
+  }
+  else
+  {
+      v = pool_elt_at_index (dm->vss,
+                             dm->vss_index_by_rx_fib_index[rx_fib_index]);
+  }
+
+  return (v);
+}
+
+static inline dhcpv6_server_t *
+dhcpv6_get_server (dhcpv6_proxy_main_t *dm,
+                   u32 rx_fib_index)
+{
+  dhcpv6_server_t *s = NULL;
+
+  if (vec_len(dm->dhcp6_server_index_by_rx_fib_index) > rx_fib_index &&
+      dm->dhcp6_server_index_by_rx_fib_index[rx_fib_index] != ~0)
+  {
+      s = pool_elt_at_index (dm->dhcp6_servers,
+                             dm->dhcp6_server_index_by_rx_fib_index[rx_fib_index]);
+  }
+
+  return (s);
+}
+
 static uword
 dhcpv6_proxy_to_server_input (vlib_main_t * vm,
                             vlib_node_runtime_t * node,
 static uword
 dhcpv6_proxy_to_server_input (vlib_main_t * vm,
                             vlib_node_runtime_t * node,
@@ -132,13 +169,10 @@ dhcpv6_proxy_to_server_input (vlib_main_t * vm,
   u32 pkts_wrong_msg_type=0;
   u32 pkts_too_big=0;
   ip6_main_t * im = &ip6_main;
   u32 pkts_wrong_msg_type=0;
   u32 pkts_too_big=0;
   ip6_main_t * im = &ip6_main;
-  ip6_fib_t * fib;
   ip6_address_t * src;
   int bogus_length;
   dhcpv6_server_t * server;
   u32  rx_fib_idx = 0, server_fib_idx = 0;
   ip6_address_t * src;
   int bogus_length;
   dhcpv6_server_t * server;
   u32  rx_fib_idx = 0, server_fib_idx = 0;
-  u32 server_idx;
-  u32 fib_id1 = 0;
 
   next_index = node->cached_next_index;
 
 
   next_index = node->cached_next_index;
 
@@ -172,12 +206,8 @@ dhcpv6_proxy_to_server_input (vlib_main_t * vm,
           ethernet_header_t * e_h0;
           u8 client_src_mac[6];
           vlib_buffer_free_list_t *fl;
           ethernet_header_t * e_h0;
           u8 client_src_mac[6];
           vlib_buffer_free_list_t *fl;
-
-          uword *p_vss;
-          u32  oui1=0;
           dhcpv6_vss_info *vss;
 
           dhcpv6_vss_info *vss;
 
-
          bi0 = from[0];
          to_next[0] = bi0;
          from += 1;
          bi0 = from[0];
          to_next[0] = bi0;
          from += 1;
@@ -228,25 +258,15 @@ dhcpv6_proxy_to_server_input (vlib_main_t * vm,
           /* Send to DHCPV6 server via the configured FIB */
           rx_sw_if_index = sw_if_index =  vnet_buffer(b0)->sw_if_index[VLIB_RX];
           rx_fib_idx = im->fib_index_by_sw_if_index [rx_sw_if_index];
           /* Send to DHCPV6 server via the configured FIB */
           rx_sw_if_index = sw_if_index =  vnet_buffer(b0)->sw_if_index[VLIB_RX];
           rx_fib_idx = im->fib_index_by_sw_if_index [rx_sw_if_index];
+          server = dhcpv6_get_server(dpm, rx_fib_idx);
 
 
-         if (vec_len(dpm->dhcp6_server_index_by_rx_fib_index) <= rx_fib_idx)
-           goto no_server;
-
-         server_idx = dpm->dhcp6_server_index_by_rx_fib_index[rx_fib_idx];
-
-          if (PREDICT_FALSE (pool_is_free_index (dpm->dhcp6_servers,
-                                                          server_idx)))
-                     {
-                     no_server:
-                       error0 = DHCPV6_PROXY_ERROR_NO_SERVER;
-                       next0 = DHCPV6_PROXY_TO_SERVER_INPUT_NEXT_DROP;
-                       pkts_no_server++;
-                       goto do_trace;
-                     }
-
-          server = pool_elt_at_index(dpm->dhcp6_servers, server_idx);
-          if (server->valid == 0)
-            goto no_server;
+          if (PREDICT_FALSE (NULL == server))
+          {
+              error0 = DHCPV6_PROXY_ERROR_NO_SERVER;
+              next0 = DHCPV6_PROXY_TO_SERVER_INPUT_NEXT_DROP;
+              pkts_no_server++;
+              goto do_trace;
+          }
 
           server_fib_idx = server->server_fib6_index;
           vnet_buffer(b0)->sw_if_index[VLIB_TX] = server_fib_idx;
 
           server_fib_idx = server->server_fib6_index;
           vnet_buffer(b0)->sw_if_index[VLIB_TX] = server_fib_idx;
@@ -331,19 +351,6 @@ dhcpv6_proxy_to_server_input (vlib_main_t * vm,
           id1 = (dhcpv6_int_id_t *) (((uword) ip1) + b0->current_length);
           b0->current_length += (sizeof (*id1));
 
           id1 = (dhcpv6_int_id_t *) (((uword) ip1) + b0->current_length);
           b0->current_length += (sizeof (*id1));
 
-
-          fib = ip6_fib_get (rx_fib_idx);
-
-          //TODO: Revisit if hash makes sense here
-          p_vss = hash_get (dpm->vss_index_by_vrf_id,
-                            fib->table_id);
-          if (p_vss)
-            {
-              vss = pool_elt_at_index (dpm->vss, p_vss[0]);
-              oui1 =  vss->vpn_id.oui;
-              fib_id1 =  vss->vpn_id.fib_id;
-            }
-
           id1->opt.option = clib_host_to_net_u16(DHCPV6_OPTION_INTERFACE_ID);
           id1->opt.length = clib_host_to_net_u16(sizeof(rx_sw_if_index));
           id1->int_idx = clib_host_to_net_u32(rx_sw_if_index);
           id1->opt.option = clib_host_to_net_u16(DHCPV6_OPTION_INTERFACE_ID);
           id1->opt.length = clib_host_to_net_u16(sizeof(rx_sw_if_index));
           id1->int_idx = clib_host_to_net_u32(rx_sw_if_index);
@@ -360,20 +367,24 @@ dhcpv6_proxy_to_server_input (vlib_main_t * vm,
                clib_memcpy(cmac->data, client_src_mac, 6);
                u1->length += sizeof(*cmac);
             }
                clib_memcpy(cmac->data, client_src_mac, 6);
                u1->length += sizeof(*cmac);
             }
-          if (server->insert_vss !=0 ) {
+
+          //TODO: Revisit if hash makes sense here
+          vss = dhcpv6_get_vss_info(dpm, rx_fib_idx);
+
+          if (NULL != vss) {
               vss1 = (dhcpv6_vss_t *) (((uword) ip1) + b0->current_length);
               b0->current_length += (sizeof (*vss1));
               vss1->opt.length =clib_host_to_net_u16(sizeof(*vss1) -
                                                     sizeof(vss1->opt));
               vss1->opt.option = clib_host_to_net_u16(DHCPV6_OPTION_VSS);
               vss1->data[0] = 1;   // type
               vss1 = (dhcpv6_vss_t *) (((uword) ip1) + b0->current_length);
               b0->current_length += (sizeof (*vss1));
               vss1->opt.length =clib_host_to_net_u16(sizeof(*vss1) -
                                                     sizeof(vss1->opt));
               vss1->opt.option = clib_host_to_net_u16(DHCPV6_OPTION_VSS);
               vss1->data[0] = 1;   // type
-              vss1->data[1] = oui1>>16 & 0xff;
-              vss1->data[2] = oui1>>8  & 0xff;
-              vss1->data[3] = oui1 & 0xff;
-              vss1->data[4] = fib_id1>>24 & 0xff;
-              vss1->data[5] = fib_id1>>16 & 0xff;
-              vss1->data[6] = fib_id1>>8 & 0xff;
-              vss1->data[7] = fib_id1 & 0xff;
+              vss1->data[1] = vss->vpn_id.oui >>16 & 0xff;
+              vss1->data[2] = vss->vpn_id.oui >>8  & 0xff;
+              vss1->data[3] = vss->vpn_id.oui & 0xff;
+              vss1->data[4] = vss->vpn_id.fib_id >> 24 & 0xff;
+              vss1->data[5] = vss->vpn_id.fib_id >> 16 & 0xff;
+              vss1->data[6] = vss->vpn_id.fib_id >> 8 & 0xff;
+              vss1->data[7] = vss->vpn_id.fib_id & 0xff;
               u1->length += sizeof(*vss1);
           }
 
               u1->length += sizeof(*vss1);
           }
 
@@ -524,9 +535,8 @@ dhcpv6_proxy_to_client_input (vlib_main_t * vm,
       u16 len = 0;
       u8 interface_opt_flag = 0;
       u8 relay_msg_opt_flag = 0;
       u16 len = 0;
       u8 interface_opt_flag = 0;
       u8 relay_msg_opt_flag = 0;
-      ip6_fib_t * svr_fib;
       ip6_main_t * im = &ip6_main;
       ip6_main_t * im = &ip6_main;
-      u32 server_fib_idx, svr_fib_id, client_fib_idx, server_idx;
+      u32 server_fib_idx, client_fib_idx;
 
       bi0 = from[0];
       from += 1;
 
       bi0 = from[0];
       from += 1;
@@ -608,31 +618,18 @@ dhcpv6_proxy_to_client_input (vlib_main_t * vm,
       vlib_buffer_advance (b0, sizeof(*r0));
 
       client_fib_idx = im->fib_index_by_sw_if_index[sw_if_index];
       vlib_buffer_advance (b0, sizeof(*r0));
 
       client_fib_idx = im->fib_index_by_sw_if_index[sw_if_index];
-      if (client_fib_idx < vec_len(dm->dhcp6_server_index_by_rx_fib_index))
-         server_idx = dm->dhcp6_server_index_by_rx_fib_index[client_fib_idx];
-      else
-         server_idx = 0;
-
-      if (PREDICT_FALSE (pool_is_free_index (dm->dhcp6_servers, server_idx)))
-        {
-          error0 = DHCPV6_PROXY_ERROR_WRONG_INTERFACE_ID_OPTION;
-          goto drop_packet;
-        }
+      server = dhcpv6_get_server(dm, client_fib_idx);
 
 
-      server = pool_elt_at_index (dm->dhcp6_servers, server_idx);
-      if (server->valid == 0)
+      if (NULL == server)
       {
          error0 = DHCPV6_PROXY_ERROR_NO_SERVER;
           goto drop_packet;
       }
 
       {
          error0 = DHCPV6_PROXY_ERROR_NO_SERVER;
           goto drop_packet;
       }
 
-
       server_fib_idx = im->fib_index_by_sw_if_index
           [vnet_buffer(b0)->sw_if_index[VLIB_RX]];
       server_fib_idx = im->fib_index_by_sw_if_index
           [vnet_buffer(b0)->sw_if_index[VLIB_RX]];
-      svr_fib = ip6_fib_get (server_fib_idx);
-      svr_fib_id = svr_fib->table_id;
 
 
-      if (svr_fib_id != server->server_fib6_index ||
+      if (server_fib_idx != server->server_fib6_index ||
           ip0->src_address.as_u64[0] != server->dhcp6_server.as_u64[0] ||
           ip0->src_address.as_u64[1] != server->dhcp6_server.as_u64[1])
         {
           ip0->src_address.as_u64[0] != server->dhcp6_server.as_u64[0] ||
           ip0->src_address.as_u64[1] != server->dhcp6_server.as_u64[1])
         {
@@ -760,7 +757,7 @@ clib_error_t * dhcpv6_proxy_init (vlib_main_t * vm)
   error_drop_node = vlib_get_node_by_name (vm, (u8 *) "error-drop");
   dm->error_drop_node_index = error_drop_node->index;
 
   error_drop_node = vlib_get_node_by_name (vm, (u8 *) "error-drop");
   dm->error_drop_node_index = error_drop_node->index;
 
-  dm->vss_index_by_vrf_id = hash_create (0, sizeof (uword));
+  dm->vss_index_by_rx_fib_index = NULL;
 
   /* RFC says this is the dhcpv6 server address  */
   dm->all_dhcpv6_server_address.as_u64[0] = clib_host_to_net_u64 (0xFF05000000000000);
 
   /* RFC says this is the dhcpv6 server address  */
   dm->all_dhcpv6_server_address.as_u64[0] = clib_host_to_net_u64 (0xFF05000000000000);
@@ -785,121 +782,138 @@ clib_error_t * dhcpv6_proxy_init (vlib_main_t * vm)
 
 VLIB_INIT_FUNCTION (dhcpv6_proxy_init);
 
 
 VLIB_INIT_FUNCTION (dhcpv6_proxy_init);
 
-/* Old API, manipulates a single server (only) shared by all Rx VRFs */
-int dhcpv6_proxy_set_server (ip6_address_t *addr, ip6_address_t *src_address,
-                             u32 fib_id, int insert_vss, int is_del)
-{
-       return dhcpv6_proxy_set_server_2 (addr, src_address,
-                       0, fib_id,
-                       insert_vss, is_del);
-}
-
-int dhcpv6_proxy_set_server_2 (ip6_address_t *addr, ip6_address_t *src_address,
-                               u32 rx_fib_id, u32 server_fib_id,
-                               int insert_vss, int is_del)
+int dhcpv6_proxy_set_server (ip6_address_t *addr,
+                             ip6_address_t *src_address,
+                             u32 rx_fib_id,
+                             u32 server_fib_id,
+                             int is_del)
 {
   dhcpv6_proxy_main_t * dm = &dhcpv6_proxy_main;
   dhcpv6_server_t * server = 0;
 {
   dhcpv6_proxy_main_t * dm = &dhcpv6_proxy_main;
   dhcpv6_server_t * server = 0;
-  u32 server_fib_index = 0;
   u32 rx_fib_index = 0;
   u32 rx_fib_index = 0;
+  int rc = 0;
 
   rx_fib_index = ip6_mfib_table_find_or_create_and_lock(rx_fib_id);
 
   rx_fib_index = ip6_mfib_table_find_or_create_and_lock(rx_fib_id);
-  server_fib_index = ip6_fib_table_find_or_create_and_lock(server_fib_id);
-
-  if (is_del)
-      {
-
-         if (rx_fib_index >= vec_len(dm->dhcp6_server_index_by_rx_fib_index))
-                 return VNET_API_ERROR_NO_SUCH_ENTRY;
 
 
-         server_fib_index = dm->dhcp6_server_index_by_rx_fib_index[rx_fib_index];
-
-         dm->dhcp6_server_index_by_rx_fib_index[rx_fib_index] = 0;
-         server = pool_elt_at_index (dm->dhcp6_servers, server_fib_index);
-         memset (server, 0, sizeof (*server));
-         pool_put (dm->dhcp6_servers, server);
-         return 0;
+  const mfib_prefix_t all_dhcp_servers = {
+      .fp_len = 128,
+      .fp_proto = FIB_PROTOCOL_IP6,
+      .fp_grp_addr = {
+          .ip6 = dm->all_dhcpv6_server_relay_agent_address,
       }
       }
+  };
 
 
-  if (addr->as_u64[0] == 0 &&
-        addr->as_u64[1] == 0 )
-      return VNET_API_ERROR_INVALID_DST_ADDRESS;
-
-    if (src_address->as_u64[0] == 0 &&
-        src_address->as_u64[1] == 0)
-      return VNET_API_ERROR_INVALID_SRC_ADDRESS;
-
-  if (rx_fib_id == 0)
+  if (is_del)
     {
     {
-      server = pool_elt_at_index (dm->dhcp6_servers, 0);
-      if (server->valid)
-          goto reconfigure_it;
-      else
-          goto initialize_it;
-    }
+      server = dhcpv6_get_server(dm, rx_fib_index);
 
 
-  if (rx_fib_index < vec_len(dm->dhcp6_server_index_by_rx_fib_index))
-    {
-      server_fib_index = dm->dhcp6_server_index_by_rx_fib_index[rx_fib_index];
-      if (server_fib_index != 0)
+      if (NULL == server)
         {
         {
-          server = pool_elt_at_index (dm->dhcp6_servers, server_fib_index);
-          goto initialize_it;
+          rc = VNET_API_ERROR_NO_SUCH_ENTRY;
+          goto out;
         }
         }
-    }
 
 
-  /*Allocate a new server*/
-  pool_get (dm->dhcp6_servers, server);
-
-  initialize_it:
-  {
-      const mfib_prefix_t all_dhcp_servers = {
-          .fp_len = 128,
-          .fp_proto = FIB_PROTOCOL_IP6,
-          .fp_grp_addr = {
-              .ip6 = dm->all_dhcpv6_server_relay_agent_address,
-          }
-      };
-      const fib_route_path_t path_for_us = {
-          .frp_proto = FIB_PROTOCOL_IP6,
-          .frp_addr = zero_addr,
-          .frp_sw_if_index = 0xffffffff,
-          .frp_fib_index = ~0,
-          .frp_weight = 0,
-          .frp_flags = FIB_ROUTE_PATH_LOCAL,
-      };
-      mfib_table_entry_path_update(rx_fib_index,
-                                   &all_dhcp_servers,
-                                   MFIB_SOURCE_DHCP,
-                                   &path_for_us,
-                                   MFIB_ITF_FLAG_FORWARD);
       /*
       /*
-       * Each interface that is enabled in this table, needs to be added
-       * as an accepting interface, but this is not easily doable in VPP.
-       * So we cheat. Add a flag to the entry that indicates accept form
-       * any interface.
-       * We will still only accept on v6 enabled interfaces, since the input
-       * feature ensures this.
+       * release the locks held on the server fib and rx mfib
        */
        */
-      mfib_table_entry_update(rx_fib_index,
+      mfib_table_entry_delete(rx_fib_index,
                               &all_dhcp_servers,
                               &all_dhcp_servers,
-                              MFIB_SOURCE_DHCP,
-                              MFIB_ENTRY_FLAG_ACCEPT_ALL_ITF);
-  }
+                              MFIB_SOURCE_DHCP);
+      mfib_table_unlock(rx_fib_index, FIB_PROTOCOL_IP6);
+      fib_table_unlock(server->server_fib6_index, FIB_PROTOCOL_IP6);
 
 
-reconfigure_it:
+      dm->dhcp6_server_index_by_rx_fib_index[rx_fib_index] = ~0;
 
 
-  copy_ip6_address(&server->dhcp6_server, addr);
-  copy_ip6_address(&server->dhcp6_src_address, src_address);
-  server->server_fib6_index = server_fib_index;
-  server->valid = 1;
-  server->insert_vss = insert_vss;
+      memset (server, 0, sizeof (*server));
+      pool_put (dm->dhcp6_servers, server);
+    }
+  else
+    {
+      if (addr->as_u64[0] == 0 &&
+          addr->as_u64[1] == 0 )
+      {
+          rc = VNET_API_ERROR_INVALID_DST_ADDRESS;
+          goto out;
+      }
+      if (src_address->as_u64[0] == 0 &&
+          src_address->as_u64[1] == 0)
+      {
+          rc = VNET_API_ERROR_INVALID_SRC_ADDRESS;
+          goto out;
+      }
 
 
-  vec_validate (dm->dhcp6_server_index_by_rx_fib_index, rx_fib_index);
-  dm->dhcp6_server_index_by_rx_fib_index[rx_fib_index] =
-                 server - dm->dhcp6_servers;
+      server = dhcpv6_get_server(dm, rx_fib_index);
 
 
-  return 0;
+      if (NULL != server)
+        {
+          /* modify of an existing entry */
+          ip6_fib_t *fib;
+
+          fib = ip6_fib_get(server->server_fib6_index);
+
+          if (fib->table_id != server_fib_id)
+            {
+              /* swap tables */
+              fib_table_unlock(server->server_fib6_index, FIB_PROTOCOL_IP6);
+              server->server_fib6_index =
+                  ip6_fib_table_find_or_create_and_lock(server_fib_id);
+            }
+        }
+      else
+        {
+          /* Allocate a new server */
+          pool_get (dm->dhcp6_servers, server);
+
+          vec_validate_init_empty (dm->dhcp6_server_index_by_rx_fib_index,
+                                   rx_fib_index, ~0);
+          dm->dhcp6_server_index_by_rx_fib_index[rx_fib_index] =
+              server - dm->dhcp6_servers;
+
+          server->server_fib6_index =
+              ip6_fib_table_find_or_create_and_lock(server_fib_id);
+          mfib_table_lock(rx_fib_index, FIB_PROTOCOL_IP6);
+
+          const mfib_prefix_t all_dhcp_servers = {
+              .fp_len = 128,
+              .fp_proto = FIB_PROTOCOL_IP6,
+              .fp_grp_addr = {
+                  .ip6 = dm->all_dhcpv6_server_relay_agent_address,
+              }
+            };
+          const fib_route_path_t path_for_us = {
+              .frp_proto = FIB_PROTOCOL_IP6,
+              .frp_addr = zero_addr,
+              .frp_sw_if_index = 0xffffffff,
+              .frp_fib_index = ~0,
+              .frp_weight = 0,
+              .frp_flags = FIB_ROUTE_PATH_LOCAL,
+          };
+          mfib_table_entry_path_update(rx_fib_index,
+                                       &all_dhcp_servers,
+                                       MFIB_SOURCE_DHCP,
+                                       &path_for_us,
+                                       MFIB_ITF_FLAG_FORWARD);
+          /*
+           * Each interface that is enabled in this table, needs to be added
+           * as an accepting interface, but this is not easily doable in VPP.
+           * So we cheat. Add a flag to the entry that indicates accept form
+           * any interface.
+           * We will still only accept on v6 enabled interfaces, since the
+           * input feature ensures this.
+           */
+          mfib_table_entry_update(rx_fib_index,
+                                  &all_dhcp_servers,
+                                  MFIB_SOURCE_DHCP,
+                                  MFIB_ENTRY_FLAG_ACCEPT_ALL_ITF);
+        }
+      copy_ip6_address(&server->dhcp6_server, addr);
+      copy_ip6_address(&server->dhcp6_src_address, src_address);
+  }
+
+out:
+  mfib_table_unlock(rx_fib_index, FIB_PROTOCOL_IP6);
+
+  return (rc);
 }
 
 static clib_error_t *
 }
 
 static clib_error_t *
@@ -910,7 +924,7 @@ dhcpv6_proxy_set_command_fn (vlib_main_t * vm,
   ip6_address_t addr, src_addr;
   int set_server = 0, set_src_address = 0;
   u32 rx_fib_id = 0, server_fib_id = 0;
   ip6_address_t addr, src_addr;
   int set_server = 0, set_src_address = 0;
   u32 rx_fib_id = 0, server_fib_id = 0;
-  int is_del = 0, add_vss = 0;
+  int is_del = 0;
 
   while (unformat_check_input(input) != UNFORMAT_END_OF_INPUT)
     {
 
   while (unformat_check_input(input) != UNFORMAT_END_OF_INPUT)
     {
@@ -924,9 +938,6 @@ dhcpv6_proxy_set_command_fn (vlib_main_t * vm,
         ;
        else if (unformat (input, "rx-fib-id %d", &rx_fib_id))
          ;
         ;
        else if (unformat (input, "rx-fib-id %d", &rx_fib_id))
          ;
-       else if (unformat (input, "add-vss-option")
-               || unformat (input, "insert-option"))
-          add_vss = 1;
        else if (unformat (input, "delete") ||
                 unformat (input, "del"))
            is_del = 1;
        else if (unformat (input, "delete") ||
                 unformat (input, "del"))
            is_del = 1;
@@ -938,8 +949,8 @@ dhcpv6_proxy_set_command_fn (vlib_main_t * vm,
   {
       int rv;
 
   {
       int rv;
 
-      rv = dhcpv6_proxy_set_server_2 (&addr, &src_addr, rx_fib_id,
-                 server_fib_id, add_vss, is_del);
+      rv = dhcpv6_proxy_set_server (&addr, &src_addr, rx_fib_id,
+                                    server_fib_id, is_del);
 
       //TODO: Complete the errors
       switch (rv)
 
       //TODO: Complete the errors
       switch (rv)
@@ -962,7 +973,7 @@ dhcpv6_proxy_set_command_fn (vlib_main_t * vm,
 VLIB_CLI_COMMAND (dhcpv6_proxy_set_command, static) = {
   .path = "set dhcpv6 proxy",
   .short_help = "set dhcpv6 proxy [del] server <ipv6-addr> src-address <ipv6-addr> "
 VLIB_CLI_COMMAND (dhcpv6_proxy_set_command, static) = {
   .path = "set dhcpv6 proxy",
   .short_help = "set dhcpv6 proxy [del] server <ipv6-addr> src-address <ipv6-addr> "
-                 "[add-vss-option] [server-fib-id <fib-id>] [rx-fib-id <fib-id>] ",
+                 "[server-fib-id <fib-id>] [rx-fib-id <fib-id>] ",
   .function = dhcpv6_proxy_set_command_fn,
 };
 
   .function = dhcpv6_proxy_set_command_fn,
 };
 
@@ -976,8 +987,8 @@ u8 * format_dhcpv6_proxy_server (u8 * s, va_list * args)
 
   if (dm == 0)
     {
 
   if (dm == 0)
     {
-      s = format (s, "%=40s%=40s%=14s%=14s%=20s", "Server Address", "Source Address",
-                  "Server FIB", "RX FIB", "Insert VSS Option");
+      s = format (s, "%=40s%=40s%=14s%=14s", "Server Address", "Source Address",
+                  "Server FIB", "RX FIB");
       return s;
     }
 
       return s;
     }
 
@@ -990,11 +1001,10 @@ u8 * format_dhcpv6_proxy_server (u8 * s, va_list * args)
   if (rx_fib)
          rx_fib_id = rx_fib->table_id;
 
   if (rx_fib)
          rx_fib_id = rx_fib->table_id;
 
-  s = format (s, "%=40U%=40U%=14u%=14u%=20s",
+  s = format (s, "%=40U%=40U%=14u%=14u",
               format_ip6_address, &server->dhcp6_server,
               format_ip6_address, &server->dhcp6_src_address,
               format_ip6_address, &server->dhcp6_server,
               format_ip6_address, &server->dhcp6_src_address,
-                         server_fib_id, rx_fib_id,
-                                       server->insert_vss ? "yes" : "no");
+                         server_fib_id, rx_fib_id);
   return s;
 }
 
   return s;
 }
 
@@ -1003,25 +1013,25 @@ dhcpv6_proxy_show_command_fn (vlib_main_t * vm,
                             unformat_input_t * input,
                             vlib_cli_command_t * cmd)
 {
                             unformat_input_t * input,
                             vlib_cli_command_t * cmd)
 {
-  dhcpv6_proxy_main_t * dm = &dhcpv6_proxy_main;
-  ip6_main_t * im = &ip6_main;
+  dhcpv6_proxy_main_t * dpm = &dhcpv6_proxy_main;
   int i;
   u32 server_index;
   dhcpv6_server_t * server;
 
   vlib_cli_output (vm, "%U", format_dhcpv6_proxy_server, 0 /* header line */,
                  0, 0);
   int i;
   u32 server_index;
   dhcpv6_server_t * server;
 
   vlib_cli_output (vm, "%U", format_dhcpv6_proxy_server, 0 /* header line */,
                  0, 0);
-  for (i = 0; i < vec_len (im->fibs); i++)
-      {
-        if (i < vec_len(dm->dhcp6_server_index_by_rx_fib_index))
-          server_index = dm->dhcp6_server_index_by_rx_fib_index[i];
-        else
-          server_index = 0;
-        server = pool_elt_at_index (dm->dhcp6_servers, server_index);
-        if (server->valid)
-          vlib_cli_output (vm, "%U", format_dhcpv6_proxy_server, dm,
-                 server, i);
-      }
+  vec_foreach_index (i, dpm->dhcp6_server_index_by_rx_fib_index)
+  {
+      server_index = dpm->dhcp6_server_index_by_rx_fib_index[i];
+      if (~0 == server_index)
+          continue;
+
+      server = pool_elt_at_index (dpm->dhcp6_servers, server_index);
+
+      vlib_cli_output (vm, "%U", format_dhcpv6_proxy_server, dpm, 
+                       server, i);
+    }
+
   return 0;
 }
 
   return 0;
 }
 
@@ -1031,51 +1041,104 @@ VLIB_CLI_COMMAND (dhcpv6_proxy_show_command, static) = {
   .function = dhcpv6_proxy_show_command_fn,
 };
 
   .function = dhcpv6_proxy_show_command_fn,
 };
 
+void
+dhcpv6_proxy_dump (void *opaque,
+                   u32 context)
+{
+  dhcpv6_proxy_main_t * dpm = &dhcpv6_proxy_main;
+  ip6_fib_t *s_fib, *r_fib;
+  dhcpv6_server_t * server;
+  u32 server_index, i;
+  dhcpv6_vss_info *v;
+
+  vec_foreach_index (i, dpm->dhcp6_server_index_by_rx_fib_index)
+  {
+      server_index = dpm->dhcp6_server_index_by_rx_fib_index[i];
+      if (~0 == server_index)
+          continue;
+
+      server = pool_elt_at_index (dpm->dhcp6_servers, server_index);
+      v = dhcpv6_get_vss_info(dpm, i);
+
+      ip46_address_t src_addr = {
+          .ip6 = server->dhcp6_src_address,
+      };
+      ip46_address_t server_addr = {
+          .ip6 = server->dhcp6_server,
+      };
+
+      s_fib = ip6_fib_get(server->server_fib6_index);
+      r_fib = ip6_fib_get(i);
+
+      dhcp_send_details(opaque,
+                        context,
+                        &server_addr,
+                        &src_addr,
+                        s_fib->table_id,
+                        r_fib->table_id,
+                        (v ? v->vpn_id.fib_id : 0),
+                        (v ? v->vpn_id.oui : 0));
+  }
+}
+
 int dhcpv6_proxy_set_vss(u32 tbl_id,
                          u32 oui,
                          u32 fib_id,
                          int is_del)
 {
   dhcpv6_proxy_main_t *dm = &dhcpv6_proxy_main;
 int dhcpv6_proxy_set_vss(u32 tbl_id,
                          u32 oui,
                          u32 fib_id,
                          int is_del)
 {
   dhcpv6_proxy_main_t *dm = &dhcpv6_proxy_main;
-  u32 old_oui, old_fib_id;
-  uword *p;
-  dhcpv6_vss_info *v;
+  dhcpv6_vss_info *v = NULL;
+  u32  rx_fib_index;
+  int rc = 0;
 
 
-  p = hash_get (dm->vss_index_by_vrf_id, tbl_id);
+  rx_fib_index = ip6_fib_table_find_or_create_and_lock(tbl_id);
+  v = dhcpv6_get_vss_info(dm, rx_fib_index);
 
 
-  if (p) {
-      v = pool_elt_at_index (dm->vss, p[0]);
-      if (!v)
-        return VNET_API_ERROR_NO_SUCH_FIB;
-
-      old_oui = v->vpn_id.oui;
-      old_fib_id = v->vpn_id.fib_id;
+  if (NULL != v)
+  {
+      if (is_del)
+      {
+          /* release the lock held on the table when the VSS
+           * info was created */
+          fib_table_unlock (rx_fib_index,
+                            FIB_PROTOCOL_IP6);
 
 
+          pool_put (dm->vss, v);
+          dm->vss_index_by_rx_fib_index[rx_fib_index] = ~0;
+      }
+      else
+      {
+          /* this is a modify */
+          v->vpn_id.fib_id = fib_id;
+          v->vpn_id.oui = oui;
+      }
+  }
+  else
+  {
       if (is_del)
       if (is_del)
+          rc = VNET_API_ERROR_NO_SUCH_ENTRY;
+      else
       {
       {
-          if (old_oui == oui &&
-              old_fib_id == fib_id )
-          {
-              pool_put(dm->vss, v);
-              hash_unset (dm->vss_index_by_vrf_id, tbl_id);
-              return 0;
-          }
-          else
-            return VNET_API_ERROR_NO_SUCH_ENTRY;
+          /* create a new entry */
+          vec_validate_init_empty(dm->vss_index_by_rx_fib_index,
+                                  rx_fib_index, ~0);
+
+          /* hold a lock on the table whilst the VSS info exist */
+          fib_table_lock (rx_fib_index,
+                          FIB_PROTOCOL_IP6);
+
+          pool_get (dm->vss, v);
+          v->vpn_id.fib_id = fib_id;
+          v->vpn_id.oui = oui;
+          dm->vss_index_by_rx_fib_index[rx_fib_index] = v - dm->vss;
       }
       }
+  }
 
 
-      pool_put(dm->vss, v);
-      hash_unset (dm->vss_index_by_vrf_id, tbl_id);
-  } else if (is_del)
-    return VNET_API_ERROR_NO_SUCH_ENTRY;
-
-  pool_get (dm->vss, v);
-  memset (v, ~0, sizeof (*v));
-  v->vpn_id.fib_id = fib_id;
-  v->vpn_id.oui = oui;
-  hash_set (dm->vss_index_by_vrf_id, tbl_id, v - dm->vss);
+  /* Release the lock taken during the create_or_lock at the start */
+  fib_table_unlock (rx_fib_index,
+                    FIB_PROTOCOL_IP6);
 
 
-  return 0;
+  return (rc);
 }
 
 
 }
 
 
@@ -1147,19 +1210,19 @@ dhcpv6_vss_show_command_fn (vlib_main_t * vm,
 {
   dhcpv6_proxy_main_t * dm = &dhcpv6_proxy_main;
   dhcpv6_vss_info *v;
 {
   dhcpv6_proxy_main_t * dm = &dhcpv6_proxy_main;
   dhcpv6_vss_info *v;
-  u32 oui;
-  u32 fib_id;
-  u32 tbl_id;
-  uword index;
+  ip6_fib_t *fib;
+  u32 *fib_index;
 
   vlib_cli_output (vm, "%=6s%=6s%=12s","Table", "OUI", "VPN ID");
 
   vlib_cli_output (vm, "%=6s%=6s%=12s","Table", "OUI", "VPN ID");
-  hash_foreach (tbl_id, index, dm->vss_index_by_vrf_id,
+  pool_foreach (fib_index, dm->vss_index_by_rx_fib_index,
   ({
   ({
-     v = pool_elt_at_index (dm->vss, index);
-     oui = v->vpn_id.oui;
-     fib_id = v->vpn_id.fib_id;
-     vlib_cli_output (vm, "%=6d%=6d%=12d",
-                      tbl_id, oui, fib_id);
+      fib = ip6_fib_get (*fib_index);
+      v = pool_elt_at_index (dm->vss, *fib_index);
+
+      vlib_cli_output (vm, "%=6d%=6d%=12d",
+                       fib->table_id,
+                       v->vpn_id.oui,
+                       v->vpn_id.fib_id);
   }));
 
   return 0;
   }));
 
   return 0;
index 2b2571c..83e33ed 100644 (file)
@@ -102,6 +102,11 @@ format_receive_dpo (u8 *s, va_list *ap)
     vnet_main_t * vnm = vnet_get_main();
     receive_dpo_t *rd;
 
     vnet_main_t * vnm = vnet_get_main();
     receive_dpo_t *rd;
 
+    if (pool_is_free_index(receive_dpo_pool, index))
+    {
+        return (format(s, "dpo-receive DELETED"));
+    }
+
     rd = receive_dpo_get(index);
 
     if (~0 != rd->rd_sw_if_index)
     rd = receive_dpo_get(index);
 
     if (~0 != rd->rd_sw_if_index)
index a7dca98..70b4e4c 100644 (file)
@@ -772,37 +772,6 @@ static void *vl_api_dhcp_proxy_config_t_print
 {
   u8 *s;
 
 {
   u8 *s;
 
-  s = format (0, "SCRIPT: dhcp_proxy_config ");
-
-  s = format (s, "vrf_id %d ", ntohl (mp->vrf_id));
-
-  if (mp->is_ipv6)
-    {
-      s = format (s, "svr %U ", format_ip6_address,
-                 (ip6_address_t *) mp->dhcp_server);
-      s = format (s, "src %U ", format_ip6_address,
-                 (ip6_address_t *) mp->dhcp_src_address);
-    }
-  else
-    {
-      s = format (s, "svr %U ", format_ip4_address,
-                 (ip4_address_t *) mp->dhcp_server);
-      s = format (s, "src %U ", format_ip4_address,
-                 (ip4_address_t *) mp->dhcp_src_address);
-    }
-  if (mp->is_add == 0)
-    s = format (s, "del ");
-
-  s = format (s, "insert-cid %d ", mp->insert_circuit_id);
-
-  FINISH;
-}
-
-static void *vl_api_dhcp_proxy_config_2_t_print
-  (vl_api_dhcp_proxy_config_2_t * mp, void *handle)
-{
-  u8 *s;
-
   s = format (0, "SCRIPT: dhcp_proxy_config_2 ");
 
   s = format (s, "rx_vrf_id %d ", ntohl (mp->rx_vrf_id));
   s = format (0, "SCRIPT: dhcp_proxy_config_2 ");
 
   s = format (s, "rx_vrf_id %d ", ntohl (mp->rx_vrf_id));
@@ -825,8 +794,6 @@ static void *vl_api_dhcp_proxy_config_2_t_print
   if (mp->is_add == 0)
     s = format (s, "del ");
 
   if (mp->is_add == 0)
     s = format (s, "del ");
 
-  s = format (s, "insert-cid %d ", mp->insert_circuit_id);
-
   FINISH;
 }
 
   FINISH;
 }
 
@@ -2954,7 +2921,6 @@ _(BRIDGE_DOMAIN_DUMP, bridge_domain_dump)                               \
 _(CLASSIFY_SET_INTERFACE_IP_TABLE, classify_set_interface_ip_table)    \
 _(CLASSIFY_SET_INTERFACE_L2_TABLES, classify_set_interface_l2_tables)  \
 _(ADD_NODE_NEXT, add_node_next)                                                \
 _(CLASSIFY_SET_INTERFACE_IP_TABLE, classify_set_interface_ip_table)    \
 _(CLASSIFY_SET_INTERFACE_L2_TABLES, classify_set_interface_l2_tables)  \
 _(ADD_NODE_NEXT, add_node_next)                                                \
-_(DHCP_PROXY_CONFIG_2, dhcp_proxy_config_2)                            \
 _(DHCP_CLIENT_CONFIG, dhcp_client_config)                              \
 _(L2TPV3_CREATE_TUNNEL, l2tpv3_create_tunnel)                           \
 _(L2TPV3_SET_TUNNEL_COOKIES, l2tpv3_set_tunnel_cookies)                 \
 _(DHCP_CLIENT_CONFIG, dhcp_client_config)                              \
 _(L2TPV3_CREATE_TUNNEL, l2tpv3_create_tunnel)                           \
 _(L2TPV3_SET_TUNNEL_COOKIES, l2tpv3_set_tunnel_cookies)                 \
index 04ab2e1..fbfb8a0 100644 (file)
@@ -65,7 +65,7 @@ class TestDHCP(VppTestCase):
         for i in self.pg_interfaces:
             i.assert_nothing_captured(remark=remark)
 
         for i in self.pg_interfaces:
             i.assert_nothing_captured(remark=remark)
 
-    def validate_option_82(self, pkt, intf, ip_addr):
+    def validate_relay_options(self, pkt, intf, ip_addr, fib_id, oui):
         dhcp = pkt[DHCP]
         found = 0
         data = []
         dhcp = pkt[DHCP]
         found = 0
         data = []
@@ -77,7 +77,10 @@ class TestDHCP(VppTestCase):
                     # There are two sb-options present - each of length 6.
                     #
                     data = i[1]
                     # There are two sb-options present - each of length 6.
                     #
                     data = i[1]
-                    self.assertEqual(len(data), 12)
+                    if oui != 0:
+                        self.assertEqual(len(data), 24)
+                    else:
+                        self.assertEqual(len(data), 12)
 
                     #
                     # First sub-option is ID 1, len 4, then encoded
 
                     #
                     # First sub-option is ID 1, len 4, then encoded
@@ -107,12 +110,30 @@ class TestDHCP(VppTestCase):
                     self.assertEqual(data[10], claddr[2])
                     self.assertEqual(data[11], claddr[3])
 
                     self.assertEqual(data[10], claddr[2])
                     self.assertEqual(data[11], claddr[3])
 
+                    if oui != 0:
+                        # sub-option 151 encodes the 3 byte oui
+                        # and the 4 byte fib_id
+                        self.assertEqual(ord(data[12]), 151)
+                        self.assertEqual(ord(data[13]), 8)
+                        self.assertEqual(ord(data[14]), 1)
+                        self.assertEqual(ord(data[15]), 0)
+                        self.assertEqual(ord(data[16]), 0)
+                        self.assertEqual(ord(data[17]), oui)
+                        self.assertEqual(ord(data[18]), 0)
+                        self.assertEqual(ord(data[19]), 0)
+                        self.assertEqual(ord(data[20]), 0)
+                        self.assertEqual(ord(data[21]), fib_id)
+
+                        # VSS control sub-option
+                        self.assertEqual(ord(data[22]), 152)
+                        self.assertEqual(ord(data[23]), 0)
+
                     found = 1
         self.assertTrue(found)
 
         return data
 
                     found = 1
         self.assertTrue(found)
 
         return data
 
-    def verify_dhcp_offer(self, pkt, intf, check_option_82=True):
+    def verify_dhcp_offer(self, pkt, intf):
         ether = pkt[Ether]
         self.assertEqual(ether.dst, "ff:ff:ff:ff:ff:ff")
         self.assertEqual(ether.src, intf.local_mac)
         ether = pkt[Ether]
         self.assertEqual(ether.dst, "ff:ff:ff:ff:ff:ff")
         self.assertEqual(ether.src, intf.local_mac)
@@ -134,11 +155,9 @@ class TestDHCP(VppTestCase):
                     is_offer = True
         self.assertTrue(is_offer)
 
                     is_offer = True
         self.assertTrue(is_offer)
 
-        if check_option_82:
-            data = self.validate_option_82(pkt, intf, intf.local_ip4)
+        data = self.validate_relay_options(pkt, intf, intf.local_ip4, 0, 0)
 
 
-    def verify_dhcp_discover(self, pkt, intf, src_intf=None,
-                             option_82_present=True):
+    def verify_dhcp_discover(self, pkt, intf, src_intf=None, fib_id=0, oui=0):
         ether = pkt[Ether]
         self.assertEqual(ether.dst, intf.remote_mac)
         self.assertEqual(ether.src, intf.local_mac)
         ether = pkt[Ether]
         self.assertEqual(ether.dst, intf.remote_mac)
         self.assertEqual(ether.src, intf.local_mac)
@@ -161,13 +180,10 @@ class TestDHCP(VppTestCase):
                     is_discover = True
         self.assertTrue(is_discover)
 
                     is_discover = True
         self.assertTrue(is_discover)
 
-        if option_82_present:
-            data = self.validate_option_82(pkt, src_intf, src_intf.local_ip4)
-            return data
-        else:
-            for i in dhcp.options:
-                if type(i) is tuple:
-                    self.assertNotEqual(i[0], "relay_agent_Information")
+        data = self.validate_relay_options(pkt, src_intf,
+                                           src_intf.local_ip4,
+                                           fib_id, oui)
+        return data
 
     def verify_dhcp6_solicit(self, pkt, intf,
                              peer_ip, peer_mac,
 
     def verify_dhcp6_solicit(self, pkt, intf,
                              peer_ip, peer_mac,
@@ -193,18 +209,19 @@ class TestDHCP(VppTestCase):
         self.assertEqual(cll.lltype, 1)
         self.assertEqual(cll.clladdr, peer_mac)
 
         self.assertEqual(cll.lltype, 1)
         self.assertEqual(cll.clladdr, peer_mac)
 
-        vss = pkt[DHCP6OptVSS]
-        self.assertEqual(vss.optlen, 8)
-        self.assertEqual(vss.type, 1)
-        # the OUI and FIB-id are really 3 and 4 bytes resp.
-        # but the tested range is small
-        self.assertEqual(ord(vss.data[0]), 0)
-        self.assertEqual(ord(vss.data[1]), 0)
-        self.assertEqual(ord(vss.data[2]), oui)
-        self.assertEqual(ord(vss.data[3]), 0)
-        self.assertEqual(ord(vss.data[4]), 0)
-        self.assertEqual(ord(vss.data[5]), 0)
-        self.assertEqual(ord(vss.data[6]), fib_id)
+        if fib_id != 0:
+            vss = pkt[DHCP6OptVSS]
+            self.assertEqual(vss.optlen, 8)
+            self.assertEqual(vss.type, 1)
+            # the OUI and FIB-id are really 3 and 4 bytes resp.
+            # but the tested range is small
+            self.assertEqual(ord(vss.data[0]), 0)
+            self.assertEqual(ord(vss.data[1]), 0)
+            self.assertEqual(ord(vss.data[2]), oui)
+            self.assertEqual(ord(vss.data[3]), 0)
+            self.assertEqual(ord(vss.data[4]), 0)
+            self.assertEqual(ord(vss.data[5]), 0)
+            self.assertEqual(ord(vss.data[6]), fib_id)
 
         # the relay message should be an encoded Solicit
         msg = pkt[DHCP6OptRelayMsg]
 
         # the relay message should be an encoded Solicit
         msg = pkt[DHCP6OptRelayMsg]
@@ -267,29 +284,16 @@ class TestDHCP(VppTestCase):
                                     rx_table_id=0)
 
         #
                                     rx_table_id=0)
 
         #
-        # Now a DHCP request on pg2, which is in the same VRF
-        # as the DHCP config, will result in a relayed DHCP
-        # message to the [fake] server
-        #
-        self.pg2.add_stream(pkts_disc_vrf0)
-        self.pg_enable_capture(self.pg_interfaces)
-        self.pg_start()
-
-        rx = self.pg0.get_capture(1)
-        rx = rx[0]
-
-        #
-        # Rx'd packet should be to the server address and from the configured
-        # source address
-        # UDP source ports are unchanged
-        # we've no option 82 config so that should be absent
+        # Discover packets from the client are dropped because there is no
+        # IP address configured on the client facing interface
         #
         #
-        self.verify_dhcp_discover(rx, self.pg0, option_82_present=False)
+        self.send_and_assert_no_replies(self.pg2, pkts_disc_vrf0,
+                                        "Discover DHCP no relay address")
 
         #
         # Inject a response from the server
 
         #
         # Inject a response from the server
-        #  VPP will only relay the offer if option 82 is present.
-        #  so this one is dropped
+        #  dropped, because there is no IP addrees on the
+        #  clinet interfce to fill in the option.
         #
         p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
              IP(src=self.pg0.remote_ip4, dst=self.pg0.local_ip4) /
         #
         p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
              IP(src=self.pg0.remote_ip4, dst=self.pg0.local_ip4) /
@@ -298,24 +302,8 @@ class TestDHCP(VppTestCase):
              DHCP(options=[('message-type', 'offer'), ('end')]))
         pkts = [p]
 
              DHCP(options=[('message-type', 'offer'), ('end')]))
         pkts = [p]
 
-        self.send_and_assert_no_replies(self.pg0, pkts,
-                                        "DHCP offer no option 82")
-
-        #
-        # Configure sending option 82 in relayed messages
-        #
-        self.vapi.dhcp_proxy_config(server_addr,
-                                    src_addr,
-                                    rx_table_id=0,
-                                    insert_circuit_id=1)
-
-        #
-        # Send a request:
-        #  again dropped, but ths time because there is no IP addrees on the
-        #  clinet interfce to fill in the option.
-        #
-        self.send_and_assert_no_replies(self.pg2, pkts_disc_vrf0,
-                                        "DHCP no relay address")
+        self.send_and_assert_no_replies(self.pg2, pkts,
+                                        "Offer DHCP no relay address")
 
         #
         # configure an IP address on the client facing interface
 
         #
         # configure an IP address on the client facing interface
@@ -376,15 +364,8 @@ class TestDHCP(VppTestCase):
                            ('relay_agent_Information', bad_ip),
                            ('end')]))
         pkts = [p]
                            ('relay_agent_Information', bad_ip),
                            ('end')]))
         pkts = [p]
-
-        self.pg0.add_stream(pkts)
-        self.pg_enable_capture(self.pg_interfaces)
-        self.pg_start()
-        rx = self.pg2.get_capture(1)
-        rx = rx[0]
-
-        self.verify_dhcp_offer(rx, self.pg2, check_option_82=False)
-        self.pg0.assert_nothing_captured(remark="")
+        self.send_and_assert_no_replies(self.pg0, pkts,
+                                        "DHCP offer option 82 bad address")
 
         # 2. Not a sw_if_index VPP knows
         bad_if_index = option_82[0:2] + chr(33) + option_82[3:]
 
         # 2. Not a sw_if_index VPP knows
         bad_if_index = option_82[0:2] + chr(33) + option_82[3:]
@@ -413,8 +394,7 @@ class TestDHCP(VppTestCase):
         self.vapi.dhcp_proxy_config(server_addr,
                                     src_addr,
                                     rx_table_id=0,
         self.vapi.dhcp_proxy_config(server_addr,
                                     src_addr,
                                     rx_table_id=0,
-                                    is_add=0,
-                                    insert_circuit_id=1)
+                                    is_add=0)
 
         self.send_and_assert_no_replies(self.pg2, pkts_disc_vrf0,
                                         "DHCP config removed VRF 0")
 
         self.send_and_assert_no_replies(self.pg2, pkts_disc_vrf0,
                                         "DHCP config removed VRF 0")
@@ -429,8 +409,7 @@ class TestDHCP(VppTestCase):
         self.vapi.dhcp_proxy_config(server_addr,
                                     src_addr,
                                     rx_table_id=1,
         self.vapi.dhcp_proxy_config(server_addr,
                                     src_addr,
                                     rx_table_id=1,
-                                    server_table_id=1,
-                                    insert_circuit_id=1)
+                                    server_table_id=1)
 
         #
         # Confim DHCP requests ok in VRF 1.
 
         #
         # Confim DHCP requests ok in VRF 1.
@@ -452,14 +431,41 @@ class TestDHCP(VppTestCase):
         rx = rx[0]
         self.verify_dhcp_discover(rx, self.pg1, src_intf=self.pg3)
 
         rx = rx[0]
         self.verify_dhcp_discover(rx, self.pg1, src_intf=self.pg3)
 
+        #
+        # Add VSS config
+        #  table=1, fib=id=1, oui=4
+        self.vapi.dhcp_proxy_set_vss(1, 1, 4)
+
+        self.pg3.add_stream(pkts_disc_vrf1)
+        self.pg_enable_capture(self.pg_interfaces)
+        self.pg_start()
+
+        rx = self.pg1.get_capture(1)
+        rx = rx[0]
+        self.verify_dhcp_discover(rx, self.pg1, src_intf=self.pg3,
+                                  fib_id=1, oui=4)
+
+        #
+        # Remove the VSS config
+        #  relayed DHCP has default vlaues in the option.
+        #
+        self.vapi.dhcp_proxy_set_vss(1, 1, 4, is_add=0)
+
+        self.pg3.add_stream(pkts_disc_vrf1)
+        self.pg_enable_capture(self.pg_interfaces)
+        self.pg_start()
+
+        rx = self.pg1.get_capture(1)
+        rx = rx[0]
+        self.verify_dhcp_discover(rx, self.pg1, src_intf=self.pg3)
+
         #
         # remove DHCP config to cleanup
         #
         self.vapi.dhcp_proxy_config(server_addr,
                                     src_addr,
                                     rx_table_id=1,
         #
         # remove DHCP config to cleanup
         #
         self.vapi.dhcp_proxy_config(server_addr,
                                     src_addr,
                                     rx_table_id=1,
-                                    server_table_id=1,
-                                    insert_circuit_id=1,
+                                    server_table_id=11,
                                     is_add=0)
 
         self.send_and_assert_no_replies(self.pg2, pkts_disc_vrf0,
                                     is_add=0)
 
         self.send_and_assert_no_replies(self.pg2, pkts_disc_vrf0,
@@ -510,7 +516,6 @@ class TestDHCP(VppTestCase):
                                     src_addr_vrf0,
                                     rx_table_id=0,
                                     server_table_id=0,
                                     src_addr_vrf0,
                                     rx_table_id=0,
                                     server_table_id=0,
-                                    insert_circuit_id=1,
                                     is_ipv6=1)
 
         self.send_and_assert_no_replies(self.pg2, pkts_solicit_vrf0,
                                     is_ipv6=1)
 
         self.send_and_assert_no_replies(self.pg2, pkts_solicit_vrf0,
@@ -630,7 +635,6 @@ class TestDHCP(VppTestCase):
                                     src_addr_vrf1,
                                     rx_table_id=1,
                                     server_table_id=1,
                                     src_addr_vrf1,
                                     rx_table_id=1,
                                     server_table_id=1,
-                                    insert_circuit_id=1,
                                     is_ipv6=1)
         self.pg3.config_ip6()
 
                                     is_ipv6=1)
         self.pg3.config_ip6()
 
@@ -708,14 +712,12 @@ class TestDHCP(VppTestCase):
                                     src_addr_vrf1,
                                     rx_table_id=1,
                                     server_table_id=1,
                                     src_addr_vrf1,
                                     rx_table_id=1,
                                     server_table_id=1,
-                                    insert_circuit_id=1,
                                     is_ipv6=1,
                                     is_add=0)
         self.vapi.dhcp_proxy_config(server_addr_vrf1,
                                     src_addr_vrf1,
                                     rx_table_id=0,
                                     server_table_id=0,
                                     is_ipv6=1,
                                     is_add=0)
         self.vapi.dhcp_proxy_config(server_addr_vrf1,
                                     src_addr_vrf1,
                                     rx_table_id=0,
                                     server_table_id=0,
-                                    insert_circuit_id=1,
                                     is_ipv6=1,
                                     is_add=0)
 
                                     is_ipv6=1,
                                     is_add=0)
 
index 3268042..59e58ad 100644 (file)
@@ -1240,16 +1240,14 @@ class VppPapiProvider(object):
                           rx_table_id=0,
                           server_table_id=0,
                           is_add=1,
                           rx_table_id=0,
                           server_table_id=0,
                           is_add=1,
-                          is_ipv6=0,
-                          insert_circuit_id=0):
+                          is_ipv6=0):
         return self.api(
         return self.api(
-            self.papi.dhcp_proxy_config_2,
+            self.papi.dhcp_proxy_config,
             {
                 'rx_vrf_id': rx_table_id,
                 'server_vrf_id': server_table_id,
                 'is_ipv6': is_ipv6,
                 'is_add': is_add,
             {
                 'rx_vrf_id': rx_table_id,
                 'server_vrf_id': server_table_id,
                 'is_ipv6': is_ipv6,
                 'is_add': is_add,
-                'insert_circuit_id': insert_circuit_id,
                 'dhcp_server': dhcp_server,
                 'dhcp_src_address': dhcp_src_address,
             })
                 'dhcp_server': dhcp_server,
                 'dhcp_src_address': dhcp_src_address,
             })