Consolidate DHCP v4 and V6 implementation. No functional change intended

The DHCP proxy and VSS information maintained by VPP is the same for v4 and v6, so we can manage this state using the same code.
Packet handling is cleary different, so this is kept separate.

Change-Id: I10f10cc1f7f19debcd4c4b099c6de64e56bb0c69
Signed-off-by: Neale Ranns <nranns@cisco.com>

13 files changed, 840 insertions, 940 deletions

diff --git a/src/vnet/dhcp/client.c b/src/vnet/dhcp/client.c
index 8a1a43b3fd4..d34c5a645eb 100644
--- a/src/vnet/dhcp/client.c
+++ b/src/vnet/dhcp/client.c
@@ -14,7 +14,7 @@
  */
 #include <vlib/vlib.h>
 #include <vnet/dhcp/client.h>
-#include <vnet/dhcp/proxy.h>
+#include <vnet/dhcp/dhcp_proxy.h>
 #include <vnet/fib/fib_table.h>
 
 dhcp_client_main_t dhcp_client_main;
diff --git a/src/vnet/dhcp/client.h b/src/vnet/dhcp/client.h
index a74368cbe07..1f85d7ce772 100644
--- a/src/vnet/dhcp/client.h
+++ b/src/vnet/dhcp/client.h
@@ -20,7 +20,7 @@
 #define included_dhcp_client_h
 
 #include <vnet/ip/ip.h>
-#include <vnet/dhcp/packet.h>
+#include <vnet/dhcp/dhcp4_packet.h>
 
 #define foreach_dhcp_client_state               \
 _(DHCP_DISCOVER)                                \
diff --git a/src/vnet/dhcp/packet.h b/src/vnet/dhcp/dhcp4_packet.h
index 267a8eafc93..28c4b156e5c 100644
--- a/src/vnet/dhcp/packet.h
+++ b/src/vnet/dhcp/dhcp4_packet.h
@@ -1,5 +1,5 @@
-#ifndef included_vnet_dhcp_packet_h
-#define included_vnet_dhcp_packet_h
+#ifndef included_vnet_dhcp4_packet_h
+#define included_vnet_dhcp4_packet_h
 
 /*
  * DHCP packet format
@@ -58,4 +58,4 @@ typedef enum {
 /* charming antique: 99.130.83.99 is the dhcp magic cookie */
 #define DHCP_MAGIC (clib_host_to_net_u32(0x63825363))
 
-#endif /* included_vnet_dhcp_packet_h */
+#endif /* included_vnet_dhcp4_packet_h */
diff --git a/src/vnet/dhcp/proxy_error.def b/src/vnet/dhcp/dhcp4_proxy_error.def
index 6d790d732d6..adf04808fa3 100644
--- a/src/vnet/dhcp/proxy_error.def
+++ b/src/vnet/dhcp/dhcp4_proxy_error.def
@@ -29,3 +29,4 @@ dhcp_proxy_error (OPTION_82_VSS_NOT_PROCESSED, "DHCP VSS not processed by DHCP s
 dhcp_proxy_error (BAD_YIADDR, "DHCP packets with bad your_ip_address fields")
 dhcp_proxy_error (BAD_SVR_FIB_OR_ADDRESS, "DHCP packets not from DHCP server or server FIB.")
 dhcp_proxy_error (PKT_TOO_BIG, "DHCP packets which are too big.")
+
diff --git a/src/vnet/dhcp/proxy_node.c b/src/vnet/dhcp/dhcp4_proxy_node.c
index ab6819fed54..88a99249684 100644
--- a/src/vnet/dhcp/proxy_node.c
+++ b/src/vnet/dhcp/dhcp4_proxy_node.c
@@ -17,13 +17,13 @@
 
 #include <vlib/vlib.h>
 #include <vnet/pg/pg.h>
-#include <vnet/dhcp/proxy.h>
+#include <vnet/dhcp/dhcp_proxy.h>
 #include <vnet/dhcp/client.h>
 #include <vnet/fib/ip4_fib.h>
 
 static char * dhcp_proxy_error_strings[] = {
 #define dhcp_proxy_error(n,s) s,
-#include "proxy_error.def"
+#include <vnet/dhcp/dhcp4_proxy_error.def>
 #undef dhcp_proxy_error
 };
 
@@ -55,12 +55,11 @@ typedef struct {
                                 VPP_DHCP_OPTION82_SUB5_SIZE + \
                                 VPP_DHCP_OPTION82_VSS_SIZE +3)
 
-vlib_node_registration_t dhcp_proxy_to_server_node;
-vlib_node_registration_t dhcp_proxy_to_client_node;
+static vlib_node_registration_t dhcp_proxy_to_server_node;
+static 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)
+static u8 *
+format_dhcp_proxy_trace (u8 * s, va_list * args)
 {
   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
@@ -82,7 +81,8 @@ u8 * format_dhcp_proxy_trace (u8 * s, va_list * args)
   return s;
 }
 
-u8 * format_dhcp_proxy_header_with_length (u8 * s, va_list * args)
+static u8 *
+format_dhcp_proxy_header_with_length (u8 * s, va_list * args)
 {
   dhcp_header_t * h = va_arg (*args, dhcp_header_t *);
   u32 max_header_bytes = va_arg (*args, u32);
@@ -97,42 +97,6 @@ u8 * format_dhcp_proxy_header_with_length (u8 * s, va_list * args)
   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,
@@ -208,7 +172,7 @@ 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];
-          server = dhcp_get_server(dpm, fib_index);
+          server = dhcp_get_server(dpm, fib_index, FIB_PROTOCOL_IP4);
           
           if (PREDICT_FALSE (NULL == server))
             {
@@ -225,8 +189,8 @@ dhcp_proxy_to_server_input (vlib_main_t * vm,
           u0->checksum = 0;
           sum0 = ip0->checksum;
           old0 = ip0->dst_address.as_u32;
-          new0 = server->dhcp_server.as_u32;
-          ip0->dst_address.as_u32 = server->dhcp_server.as_u32;
+          new0 = server->dhcp_server.ip4.as_u32;
+          ip0->dst_address.as_u32 = server->dhcp_server.ip4.as_u32;
           sum0 = ip_csum_update (sum0, old0, new0, 
                                 ip4_header_t /* structure */, 
                                 dst_address /* changed member */);
@@ -234,7 +198,7 @@ dhcp_proxy_to_server_input (vlib_main_t * vm,
 
           sum0 = ip0->checksum;
           old0 = ip0->src_address.as_u32;
-          new0 = server->dhcp_src_address.as_u32;
+          new0 = server->dhcp_src_address.ip4.as_u32;
           ip0->src_address.as_u32 = new0;
           sum0 = ip_csum_update (sum0, old0, new0, 
                                 ip4_header_t /* structure */, 
@@ -245,7 +209,7 @@ dhcp_proxy_to_server_input (vlib_main_t * vm,
           vnet_buffer(b0)->sw_if_index[VLIB_TX] =
             server->server_fib_index;
 
-          h0->gateway_ip_address.as_u32 = server->dhcp_src_address.as_u32;
+          h0->gateway_ip_address.as_u32 = server->dhcp_src_address.ip4.as_u32;
           pkts_to_server++;
 
           o = (dhcp_option_t *) h0->options;
@@ -272,7 +236,7 @@ dhcp_proxy_to_server_input (vlib_main_t * vm,
               vnet_main_t *vnm = vnet_get_main();   
               u16 old_l0, new_l0;
               ip4_address_t _ia0, * ia0 = &_ia0;
-              vss_info *vss;
+              dhcp_vss_t *vss;
               vnet_sw_interface_t *swif;
               sw_if_index = 0;
               original_sw_if_index = 0;
@@ -315,13 +279,13 @@ dhcp_proxy_to_server_input (vlib_main_t * vm,
               o->data[11] = ia0->as_u8[3];
               o->data[12] = 0xFF;
 
-              vss = dhcp_get_vss_info (dpm, fib_index);
+              vss = dhcp_get_vss_info (dpm, fib_index, FIB_PROTOCOL_IP4);
               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;
+                  opt82_oui =  vss->oui;
+                  opt82_fib_id =  vss->fib_id;
 
                   o->data[12] = 151; /* vss suboption */
                   if (255 == opt82_fib_id) {
@@ -386,7 +350,7 @@ dhcp_proxy_to_server_input (vlib_main_t * vm,
                tr->original_sw_if_index = original_sw_if_index;
                tr->sw_if_index = sw_if_index;
                if (next0 == DHCP_PROXY_TO_SERVER_INPUT_NEXT_LOOKUP)
-                 tr->trace_ip4_address.as_u32 = server->dhcp_server.as_u32;
+                 tr->trace_ip4_address.as_u32 = server->dhcp_server.ip4.as_u32;
             }
 
         do_enqueue:
@@ -416,7 +380,7 @@ dhcp_proxy_to_server_input (vlib_main_t * vm,
   return from_frame->n_vectors;
 }
 
-VLIB_REGISTER_NODE (dhcp_proxy_to_server_node) = {
+VLIB_REGISTER_NODE (dhcp_proxy_to_server_node, static) = {
   .function = dhcp_proxy_to_server_input,
   .name = "dhcp-proxy-to-server",
   /* Takes a vector of packets. */
@@ -583,7 +547,7 @@ dhcp_proxy_to_client_input (vlib_main_t * vm,
         }
 
       fib_index = im->fib_index_by_sw_if_index [sw_if_index];
-      server = dhcp_get_server(dpm, fib_index);
+      server = dhcp_get_server(dpm, fib_index, FIB_PROTOCOL_IP4);
 
       if (PREDICT_FALSE (NULL == server))
         {
@@ -591,7 +555,7 @@ dhcp_proxy_to_client_input (vlib_main_t * vm,
           goto drop_packet;
         }
       
-      if (ip0->src_address.as_u32 != server->dhcp_server.as_u32)
+      if (ip0->src_address.as_u32 != server->dhcp_server.ip4.as_u32)
         {             
           error0 = DHCP_PROXY_ERROR_BAD_SVR_FIB_OR_ADDRESS;
           goto drop_packet;
@@ -681,7 +645,7 @@ dhcp_proxy_to_client_input (vlib_main_t * vm,
   return from_frame->n_vectors;
 }
 
-VLIB_REGISTER_NODE (dhcp_proxy_to_client_node) = {
+VLIB_REGISTER_NODE (dhcp_proxy_to_client_node, static) = {
   .function = dhcp_proxy_to_client_input,
   .name = "dhcp-proxy-to-client",
   /* Takes a vector of packets. */
@@ -696,44 +660,36 @@ VLIB_REGISTER_NODE (dhcp_proxy_to_client_node) = {
 #endif
 };
 
-clib_error_t * dhcp_proxy_init (vlib_main_t * vm)
+static clib_error_t *
+dhcp4_proxy_init (vlib_main_t * vm)
 {
   dhcp_proxy_main_t * dm = &dhcp_proxy_main;
   vlib_node_t * error_drop_node;
-  dhcp_server_t * server;
 
-  dm->vlib_main = vm;
-  dm->vnet_main = vnet_get_main();
   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_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_server, 
                          dhcp_proxy_to_server_node.index, 1 /* is_ip4 */);
 
-  /* Create the default server, don't mark it valid */
-  pool_get (dm->dhcp_servers, server);
-  memset (server, 0, sizeof (*server));
-
   return 0;
 }
 
-VLIB_INIT_FUNCTION (dhcp_proxy_init);
 
-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)
+VLIB_INIT_FUNCTION (dhcp4_proxy_init);
+
+int
+dhcp4_proxy_set_server (ip46_address_t *addr,
+                        ip46_address_t *src_addr,
+                        u32 rx_table_id,
+                        u32 server_table_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;
+  int rc = 0;
 
   const fib_prefix_t all_1s =
   {
@@ -742,98 +698,70 @@ int dhcp_proxy_set_server (ip4_address_t *addr,
       .fp_proto = FIB_PROTOCOL_IP4,
   };
 
-  if (addr->as_u32 == 0)
+  if (ip46_address_is_zero(addr))
     return VNET_API_ERROR_INVALID_DST_ADDRESS;
   
-  if (src_address->as_u32 == 0)
+  if (ip46_address_is_zero(src_addr))
     return VNET_API_ERROR_INVALID_SRC_ADDRESS;
 
   rx_fib_index = fib_table_find_or_create_and_lock(FIB_PROTOCOL_IP4,
-                                                   rx_fib_id);
+                                                   rx_table_id);
 
   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 (server_index == ~0)
-        return VNET_API_ERROR_NO_SUCH_ENTRY;
-
-      /* Use the default server again.  */
-      dpm->dhcp_server_index_by_rx_fib_index[rx_fib_index] = ~0;
-      server = pool_elt_at_index (dpm->dhcp_servers, server_index);
-
-      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;
+      rc = dhcp_proxy_server_del (FIB_PROTOCOL_IP4, rx_fib_index);
+
+      if (0 == rc)
+      {
+          fib_table_entry_special_remove(rx_fib_index,
+                                         &all_1s,
+                                         FIB_SOURCE_DHCP);
+          fib_table_unlock (rx_fib_index, FIB_PROTOCOL_IP4);
+      }
     }
   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] = 
-          server - dpm->dhcp_servers;
+      if (dhcp_proxy_server_add (FIB_PROTOCOL_IP4,
+                                 addr, src_addr,
+                                 rx_fib_index, server_table_id))
+      {
+          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);
+      }
   }
+  fib_table_unlock (rx_fib_index, FIB_PROTOCOL_IP4);
 
-  fib_table_unlock (rx_fib_index,
-                    FIB_PROTOCOL_IP4);
-
-  return 0;
+  return (rc);
 }
 
 static clib_error_t *
-dhcp_proxy_set_command_fn (vlib_main_t * vm,
-                           unformat_input_t * input,
-                           vlib_cli_command_t * cmd)
+dhcp4_proxy_set_command_fn (vlib_main_t * vm,
+                            unformat_input_t * input,
+                            vlib_cli_command_t * cmd)
 {
-  ip4_address_t server_addr, src_addr;
-  u32 server_fib_id = 0, rx_fib_id = 0;
+  ip46_address_t server_addr, src_addr;
+  u32 server_table_id = 0, rx_table_id = 0;
   int is_del = 0;
   int set_src = 0, set_server = 0;
-  
+
+  memset(&server_addr, 0, sizeof(server_addr));
+  memset(&src_addr, 0, sizeof(src_addr));
+
   while (unformat_check_input(input) != UNFORMAT_END_OF_INPUT) 
     {
       if (unformat (input, "server %U", 
-                    unformat_ip4_address, &server_addr)) 
+                    unformat_ip4_address, &server_addr.ip4)) 
         set_server = 1;
-      else if (unformat (input, "server-fib-id %d", &server_fib_id))
+      else if (unformat (input, "server-fib-id %d", &server_table_id))
         ;
-      else if (unformat (input, "rx-fib-id %d", &rx_fib_id))
+      else if (unformat (input, "rx-fib-id %d", &rx_table_id))
         ;
       else if (unformat(input, "src-address %U", 
-			unformat_ip4_address, &src_addr))
+			unformat_ip4_address, &src_addr.ip4))
         set_src = 1;
       else if (unformat (input, "delete") ||
                unformat (input, "del"))
@@ -846,8 +774,8 @@ dhcp_proxy_set_command_fn (vlib_main_t * vm,
     {
       int rv;
 
-      rv = dhcp_proxy_set_server (&server_addr, &src_addr, rx_fib_id, 
-                                  server_fib_id, is_del);
+      rv = dhcp4_proxy_set_server (&server_addr, &src_addr, rx_table_id, 
+                                   server_table_id, is_del);
       switch (rv)
         {
         case 0:
@@ -858,17 +786,10 @@ dhcp_proxy_set_command_fn (vlib_main_t * vm,
           
         case VNET_API_ERROR_INVALID_SRC_ADDRESS:
           return clib_error_return (0, "Invalid src address");
-          
-        case VNET_API_ERROR_NO_SUCH_INNER_FIB:
-          return clib_error_return (0, "No such rx fib id %d", rx_fib_id);
-          
-        case VNET_API_ERROR_NO_SUCH_FIB:
-          return clib_error_return (0, "No such server fib id %d", 
-                                    server_fib_id);
 
         case VNET_API_ERROR_NO_SUCH_ENTRY:
           return clib_error_return 
-            (0, "Fib id %d: no per-fib DHCP server configured", rx_fib_id);
+            (0, "Fib id %d: no per-fib DHCP server configured", rx_table_id);
 
         default:
           return clib_error_return (0, "BUG: rv %d", rv);
@@ -882,18 +803,16 @@ dhcp_proxy_set_command_fn (vlib_main_t * vm,
 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> [server-fib-id <n>] [rx-fib-id <n>]",
-  .function = dhcp_proxy_set_command_fn,
+  .function = dhcp4_proxy_set_command_fn,
 };
 
-u8 * format_dhcp_proxy_server (u8 * s, va_list * args)
+static u8 *
+format_dhcp4_proxy_server (u8 * s, va_list * args)
 {
-  dhcp_proxy_main_t * dm = va_arg (*args, dhcp_proxy_main_t *);
   dhcp_server_t * server = va_arg (*args, dhcp_server_t *);
-  u32 rx_fib_index = va_arg (*args, u32);
   ip4_fib_t * rx_fib, * server_fib;
-  u32 server_fib_id = ~0, rx_fib_id = ~0;
 
-  if (dm == 0)
+  if (server == 0)
     {
       s = format (s, "%=16s%=16s%=14s%=14s", "Server", "Src Address", 
                   "Server FIB", "RX FIB");
@@ -901,155 +820,45 @@ u8 * format_dhcp_proxy_server (u8 * s, va_list * args)
     }
 
   server_fib = ip4_fib_get(server->server_fib_index);
-
-  if (server_fib)
-    server_fib_id = server_fib->table_id;
-
-  rx_fib = ip4_fib_get(rx_fib_index);
-
-  if (rx_fib)
-    rx_fib_id = rx_fib->table_id;
+  rx_fib = ip4_fib_get(server->rx_fib_index);
 
   s = format (s, "%=16U%=16U%=14u%=14u",
-              format_ip4_address, &server->dhcp_server,
-              format_ip4_address, &server->dhcp_src_address,
-              server_fib_id, rx_fib_id);
+              format_ip46_address, &server->dhcp_server, IP46_TYPE_ANY,
+              format_ip46_address, &server->dhcp_src_address, IP46_TYPE_ANY,
+              server_fib->table_id,
+              rx_fib->table_id);
   return s;
 }
 
-static clib_error_t *
-dhcp_proxy_show_command_fn (vlib_main_t * vm,
-                            unformat_input_t * input,
-                            vlib_cli_command_t * cmd)
+static int
+dhcp4_proxy_show_walk (dhcp_server_t *server,
+                       void *ctx)
 {
-  dhcp_proxy_main_t * dpm = &dhcp_proxy_main;
-  dhcp_server_t * server;
-  u32 server_index, i;
+    vlib_main_t * vm = ctx;
 
-  vlib_cli_output (vm, "%U", format_dhcp_proxy_server, 0 /* header line */,
-                   0, 0);
+    vlib_cli_output (vm, "%U", format_dhcp4_proxy_server, server);
 
-  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;
+    return (1);
+}
 
-      server = pool_elt_at_index (dpm->dhcp_servers, server_index);
+static clib_error_t *
+dhcp4_proxy_show_command_fn (vlib_main_t * vm,
+                             unformat_input_t * input,
+                             vlib_cli_command_t * cmd)
+{
+  vlib_cli_output (vm, "%U", format_dhcp4_proxy_server, NULL /* header line */);
 
-      vlib_cli_output (vm, "%U", format_dhcp_proxy_server, dpm, 
-                       server, i);
-    }
+  dhcp_proxy_walk(FIB_PROTOCOL_IP4, dhcp4_proxy_show_walk, vm);
 
-  return 0;
+  return (NULL);
 }
 
 VLIB_CLI_COMMAND (dhcp_proxy_show_command, static) = {
   .path = "show dhcp proxy",
   .short_help = "Display dhcp proxy server info",
-  .function = dhcp_proxy_show_command_fn,
+  .function = dhcp4_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 tbl_id,
-                                u32 oui,
-                                u32 fib_id, 
-                                int is_del)
-{
-  dhcp_proxy_main_t *dm = &dhcp_proxy_main;
-  vss_info *v = NULL;
-  u32  rx_fib_index;
-  int rc = 0;
-  
-  rx_fib_index = ip4_fib_table_find_or_create_and_lock(tbl_id);
-  v = dhcp_get_vss_info(dm, rx_fib_index);
-
-  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_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 (rc);
-}
-
 static clib_error_t *
 dhcp_option_82_vss_fn (vlib_main_t * vm,
                         unformat_input_t * input,
@@ -1057,7 +866,6 @@ dhcp_option_82_vss_fn (vlib_main_t * vm,
 {
   int is_del = 0, got_new_vpn_id=0;
   u32 oui=0, fib_id=0, tbl_id=~0;
- 
 
   while (unformat_check_input(input) != UNFORMAT_END_OF_INPUT) 
     {
@@ -1079,7 +887,7 @@ dhcp_option_82_vss_fn (vlib_main_t * vm,
   if (is_del || got_new_vpn_id)
     {
       int rv;
-      rv = dhcp_proxy_set_option82_vss(tbl_id, oui, fib_id, is_del);
+      rv = dhcp_proxy_set_vss(FIB_PROTOCOL_IP4, tbl_id, oui, fib_id, is_del);
       switch (rv)
         {
         case 0:
@@ -1107,31 +915,15 @@ VLIB_CLI_COMMAND (dhcp_proxy_vss_command,static) = {
   .function = dhcp_option_82_vss_fn,
 };
 
-
 static clib_error_t *
 dhcp_vss_show_command_fn (vlib_main_t * vm,
                           unformat_input_t * input,
                           vlib_cli_command_t * cmd)
   
 {
-  dhcp_proxy_main_t * dm = &dhcp_proxy_main;
-  ip4_fib_t *fib;
-  u32 *fib_index;
-  vss_info *v;
-  
-  vlib_cli_output (vm, "%=9s%=11s%=12s","Table", "OUI", "VPN-ID");
-  pool_foreach (fib_index, dm->vss_index_by_rx_fib_index,
-  ({
-      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;
+  dhcp_vss_walk(FIB_PROTOCOL_IP4, dhcp_vss_show_walk, vm);
+
+  return (NULL);
 }
 
 VLIB_CLI_COMMAND (dhcp_proxy_vss_show_command, static) = {
@@ -1146,17 +938,16 @@ dhcp_option_82_address_show_command_fn (vlib_main_t * vm,
                                 vlib_cli_command_t * cmd)
   
 {
-  dhcp_proxy_main_t *dm = &dhcp_proxy_main;
   vnet_main_t *vnm = vnet_get_main();                                     
   u32 sw_if_index0=0, sw_if_index;
-  ip4_address_t *ia0;
   vnet_sw_interface_t *swif;
+  ip4_address_t *ia0;
   
   while (unformat_check_input(input) != UNFORMAT_END_OF_INPUT) 
     {
       
       if (unformat(input, "%U",
-                   unformat_vnet_sw_interface, dm->vnet_main, &sw_if_index0))
+                   unformat_vnet_sw_interface, vnm, &sw_if_index0))
         {
           swif = vnet_get_sw_interface (vnm, sw_if_index0);
           sw_if_index = (swif->flags & VNET_SW_INTERFACE_FLAG_UNNUMBERED) ?
@@ -1169,14 +960,14 @@ dhcp_option_82_address_show_command_fn (vlib_main_t * vm,
               
               vlib_cli_output (vm, "%=20U%=20U",
                                format_vnet_sw_if_index_name, 
-                               dm->vnet_main, sw_if_index0,
+                               vnm, sw_if_index0,
                                format_ip4_address, ia0);
             }
           else
             vlib_cli_output (vm, "%=34s %=20U", 
                              "No IPv4 address configured on",
                              format_vnet_sw_if_index_name, 
-                             dm->vnet_main, sw_if_index);
+                             vnm, sw_if_index);
         }
       else
         break;
diff --git a/src/vnet/dhcpv6/packet.h b/src/vnet/dhcp/dhcp6_packet.h
index 8634b5d8e9b..ddcde7a0dd9 100644
--- a/src/vnet/dhcpv6/packet.h
+++ b/src/vnet/dhcp/dhcp6_packet.h
@@ -1,5 +1,5 @@
-#ifndef included_vnet_dhcp_packet_h
-#define included_vnet_dhcp_packet_h
+#ifndef included_vnet_dhcp6_packet_h
+#define included_vnet_dhcp6_packet_h
 
 /*
  * DHCP packet format
@@ -180,4 +180,4 @@ typedef CLIB_PACKED (struct {
 }) dhcpv6_client_mac_t;
 
 
-#endif /* included_vnet_dhcp_packet_h */
+#endif /* included_vnet_dhcp6_packet_h */
diff --git a/src/vnet/dhcpv6/proxy_error.def b/src/vnet/dhcp/dhcp6_proxy_error.def
index 55fa731766c..55fa731766c 100644
--- a/src/vnet/dhcpv6/proxy_error.def
+++ b/src/vnet/dhcp/dhcp6_proxy_error.def
diff --git a/src/vnet/dhcpv6/proxy_node.c b/src/vnet/dhcp/dhcp6_proxy_node.c
index f40798e6c5d..ed44977d76b 100644
--- a/src/vnet/dhcpv6/proxy_node.c
+++ b/src/vnet/dhcp/dhcp6_proxy_node.c
@@ -1,5 +1,5 @@
 /*
- * proxy_node.c: dhcpv6 proxy node processing
+ * dhcp6_proxy_node.c: dhcpv6 proxy node processing
  *
  * Copyright (c) 2013 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,15 +17,15 @@
 
 #include <vlib/vlib.h>
 #include <vnet/pg/pg.h>
-#include <vnet/dhcpv6/proxy.h>
-#include <vnet/dhcp/proxy.h>
+#include <vnet/dhcp/dhcp_proxy.h>
+#include <vnet/dhcp/dhcp6_packet.h>
 #include <vnet/fib/ip6_fib.h>
 #include <vnet/mfib/mfib_table.h>
 #include <vnet/mfib/ip6_mfib.h>
 
 static char * dhcpv6_proxy_error_strings[] = {
 #define dhcpv6_proxy_error(n,s) s,
-#include "proxy_error.def"
+#include <vnet/dhcp/dhcp6_proxy_error.def>
 #undef dhcpv6_proxy_error
 };
 
@@ -51,11 +51,15 @@ typedef struct {
   u32 original_sw_if_index;
 } dhcpv6_proxy_trace_t;
 
-vlib_node_registration_t dhcpv6_proxy_to_server_node;
-vlib_node_registration_t dhcpv6_proxy_to_client_node;
+static vlib_node_registration_t dhcpv6_proxy_to_server_node;
+static vlib_node_registration_t dhcpv6_proxy_to_client_node;
 
+/* all DHCP servers address */
+static ip6_address_t all_dhcpv6_server_address;
+static ip6_address_t all_dhcpv6_server_relay_agent_address;
 
-u8 * format_dhcpv6_proxy_trace (u8 * s, va_list * args)
+static u8 *
+format_dhcpv6_proxy_trace (u8 * s, va_list * args)
 {
   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
@@ -76,7 +80,8 @@ u8 * format_dhcpv6_proxy_trace (u8 * s, va_list * args)
   return s;
 }
 
-u8 * format_dhcpv6_proxy_header_with_length (u8 * s, va_list * args)
+static u8 *
+format_dhcpv6_proxy_header_with_length (u8 * s, va_list * args)
 {
   dhcpv6_header_t * h = va_arg (*args, dhcpv6_header_t *);
   u32 max_header_bytes = va_arg (*args, u32);
@@ -111,56 +116,20 @@ ip6_interface_first_global_or_site_address (ip6_main_t * im, u32 sw_if_index)
   return result;
 }
 
-static inline void copy_ip6_address (ip6_address_t *dst, ip6_address_t *src) 
+static inline void copy_ip6_address (ip6_address_t *dst,
+                                     ip6_address_t *src) 
 {
-
   dst->as_u64[0] = src->as_u64[0];
   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,
-                            vlib_frame_t * from_frame)
+                              vlib_node_runtime_t * node,
+                              vlib_frame_t * from_frame)
 {
   u32 n_left_from, next_index, * from, * to_next;
-  dhcpv6_proxy_main_t * dpm = &dhcpv6_proxy_main;
+  dhcp_proxy_main_t * dpm = &dhcp_proxy_main;
   from = vlib_frame_vector_args (from_frame);
   n_left_from = from_frame->n_vectors;
   u32 pkts_to_server=0, pkts_to_client=0, pkts_no_server=0;
@@ -171,7 +140,7 @@ dhcpv6_proxy_to_server_input (vlib_main_t * vm,
   ip6_main_t * im = &ip6_main;
   ip6_address_t * src;
   int bogus_length;
-  dhcpv6_server_t * server;
+  dhcp_server_t * server;
   u32  rx_fib_idx = 0, server_fib_idx = 0;
 
   next_index = node->cached_next_index;
@@ -206,7 +175,7 @@ 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;
-          dhcpv6_vss_info *vss;
+          dhcp_vss_t *vss;
 
 	  bi0 = from[0];
 	  to_next[0] = bi0;
@@ -258,7 +227,7 @@ 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];
-          server = dhcpv6_get_server(dpm, rx_fib_idx);
+          server = dhcp_get_server(dpm, rx_fib_idx, FIB_PROTOCOL_IP6);
 
           if (PREDICT_FALSE (NULL == server))
           {
@@ -268,7 +237,7 @@ dhcpv6_proxy_to_server_input (vlib_main_t * vm,
               goto do_trace;
           }
 
-          server_fib_idx = server->server_fib6_index;
+          server_fib_idx = server->server_fib_index;
           vnet_buffer(b0)->sw_if_index[VLIB_TX] = server_fib_idx;
 
 
@@ -368,8 +337,7 @@ dhcpv6_proxy_to_server_input (vlib_main_t * vm,
                u1->length += sizeof(*cmac);
             }
 
-          //TODO: Revisit if hash makes sense here
-          vss = dhcpv6_get_vss_info(dpm, rx_fib_idx);
+          vss = dhcp_get_vss_info(dpm, rx_fib_idx, FIB_PROTOCOL_IP6);
 
           if (NULL != vss) {
               vss1 = (dhcpv6_vss_t *) (((uword) ip1) + b0->current_length);
@@ -378,13 +346,13 @@ dhcpv6_proxy_to_server_input (vlib_main_t * vm,
 						     sizeof(vss1->opt));
               vss1->opt.option = clib_host_to_net_u16(DHCPV6_OPTION_VSS);
               vss1->data[0] = 1;   // type
-              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;
+              vss1->data[1] = vss->oui >>16 & 0xff;
+              vss1->data[2] = vss->oui >>8  & 0xff;
+              vss1->data[3] = vss->oui & 0xff;
+              vss1->data[4] = vss->fib_id >> 24 & 0xff;
+              vss1->data[5] = vss->fib_id >> 16 & 0xff;
+              vss1->data[6] = vss->fib_id >> 8 & 0xff;
+              vss1->data[7] = vss->fib_id & 0xff;
               u1->length += sizeof(*vss1);
           }
 
@@ -403,16 +371,18 @@ dhcpv6_proxy_to_server_input (vlib_main_t * vm,
           ip1->payload_length =  u1->length;
           ip1->protocol = PROTO_UDP;
           ip1->hop_limit = HOP_COUNT_LIMIT;
-	      src = (server->dhcp6_server.as_u64[0] || server->dhcp6_server.as_u64[1]) ?
-	        &server->dhcp6_server : &dpm->all_dhcpv6_server_address;
+	      src = (server->dhcp_server.ip6.as_u64[0] ||
+                     server->dhcp_server.ip6.as_u64[1]) ?
+	        &server->dhcp_server.ip6 : &all_dhcpv6_server_address;
           copy_ip6_address(&ip1->dst_address, src);
 
 
           ia0 = ip6_interface_first_global_or_site_address
               (&ip6_main, vnet_buffer(b0)->sw_if_index[VLIB_RX]);
 
-	      src = (server->dhcp6_src_address.as_u64[0] || server->dhcp6_src_address.as_u64[1]) ?
-	        &server->dhcp6_src_address : ia0;
+	      src = (server->dhcp_src_address.ip6.as_u64[0] ||
+                     server->dhcp_src_address.ip6.as_u64[1]) ?
+	        &server->dhcp_src_address.ip6 : ia0;
           if (ia0 == 0)
             {
               error0 = DHCPV6_PROXY_ERROR_NO_SRC_ADDRESS;
@@ -440,7 +410,7 @@ dhcpv6_proxy_to_server_input (vlib_main_t * vm,
                tr->original_sw_if_index = rx_sw_if_index;
                tr->sw_if_index = sw_if_index;
                if (DHCPV6_PROXY_TO_SERVER_INPUT_NEXT_LOOKUP == next0)
-                 copy_ip6_address((ip6_address_t *)&tr->packet_data[0], &server->dhcp6_server);
+                 copy_ip6_address((ip6_address_t *)&tr->packet_data[0], &server->dhcp_server.ip6);
             }
 
         do_enqueue:
@@ -473,7 +443,7 @@ dhcpv6_proxy_to_server_input (vlib_main_t * vm,
   return from_frame->n_vectors;
 }
 
-VLIB_REGISTER_NODE (dhcpv6_proxy_to_server_node) = {
+VLIB_REGISTER_NODE (dhcpv6_proxy_to_server_node, static) = {
   .function = dhcpv6_proxy_to_server_input,
   .name = "dhcpv6-proxy-to-server",
   /* Takes a vector of packets. */
@@ -504,8 +474,8 @@ dhcpv6_proxy_to_client_input (vlib_main_t * vm,
 
   u32 n_left_from, * from;
   ethernet_main_t *em = ethernet_get_main (vm);
-  dhcpv6_proxy_main_t * dm = &dhcpv6_proxy_main;
-  dhcpv6_server_t * server;
+  dhcp_proxy_main_t * dm = &dhcp_proxy_main;
+  dhcp_server_t * server;
   vnet_main_t * vnm = vnet_get_main();
   int bogus_length;
 
@@ -618,7 +588,7 @@ 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];
-      server = dhcpv6_get_server(dm, client_fib_idx);
+      server = dhcp_get_server(dm, client_fib_idx, FIB_PROTOCOL_IP6);
 
       if (NULL == server)
       {
@@ -629,9 +599,9 @@ dhcpv6_proxy_to_client_input (vlib_main_t * vm,
       server_fib_idx = im->fib_index_by_sw_if_index
           [vnet_buffer(b0)->sw_if_index[VLIB_RX]];
 
-      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])
+      if (server_fib_idx != server->server_fib_index ||
+          ip0->src_address.as_u64[0] != server->dhcp_server.ip6.as_u64[0] ||
+          ip0->src_address.as_u64[1] != server->dhcp_server.ip6.as_u64[1])
         {
           //drop packet if not from server with configured address or FIB
           error0 = DHCPV6_PROXY_ERROR_BAD_SVR_FIB_OR_ADDRESS;
@@ -731,7 +701,7 @@ dhcpv6_proxy_to_client_input (vlib_main_t * vm,
 
 }
 
-VLIB_REGISTER_NODE (dhcpv6_proxy_to_client_node) = {
+VLIB_REGISTER_NODE (dhcpv6_proxy_to_client_node, static) = {
   .function = dhcpv6_proxy_to_client_input,
   .name = "dhcpv6-proxy-to-client",
   /* Takes a vector of packets. */
@@ -746,26 +716,22 @@ VLIB_REGISTER_NODE (dhcpv6_proxy_to_client_node) = {
 #endif
 };
 
-clib_error_t * dhcpv6_proxy_init (vlib_main_t * vm)
+static clib_error_t *
+dhcp6_proxy_init (vlib_main_t * vm)
 {
-  dhcpv6_proxy_main_t * dm = &dhcpv6_proxy_main;
+  dhcp_proxy_main_t * dm = &dhcp_proxy_main;
   vlib_node_t * error_drop_node;
-  dhcpv6_server_t * server;
 
-  dm->vlib_main = vm;
-  dm->vnet_main = vnet_get_main();
   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_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);
-  dm->all_dhcpv6_server_address.as_u64[1] = clib_host_to_net_u64 (0x00010003);
+  all_dhcpv6_server_address.as_u64[0] = clib_host_to_net_u64 (0xFF05000000000000);
+  all_dhcpv6_server_address.as_u64[1] = clib_host_to_net_u64 (0x00010003);
 
   /* RFC says this is the server and agent address */
-  dm->all_dhcpv6_server_relay_agent_address.as_u64[0] = clib_host_to_net_u64 (0xFF02000000000000);
-  dm->all_dhcpv6_server_relay_agent_address.as_u64[1] = clib_host_to_net_u64 (0x00010002);
+  all_dhcpv6_server_relay_agent_address.as_u64[0] = clib_host_to_net_u64 (0xFF02000000000000);
+  all_dhcpv6_server_relay_agent_address.as_u64[1] = clib_host_to_net_u64 (0x00010002);
 
   udp_register_dst_port (vm, UDP_DST_PORT_dhcpv6_to_client,
                          dhcpv6_proxy_to_client_node.index, 0 /* is_ip6 */);
@@ -773,144 +739,84 @@ clib_error_t * dhcpv6_proxy_init (vlib_main_t * vm)
   udp_register_dst_port (vm, UDP_DST_PORT_dhcpv6_to_server,
                          dhcpv6_proxy_to_server_node.index, 0 /* is_ip6 */);
 
-  /* Create the default server, don't mark it valid */
-  pool_get (dm->dhcp6_servers, server);
-  memset (server, 0, sizeof (*server));
-
   return 0;
 }
 
-VLIB_INIT_FUNCTION (dhcpv6_proxy_init);
+VLIB_INIT_FUNCTION (dhcp6_proxy_init);
 
-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)
+int
+dhcp6_proxy_set_server (ip46_address_t *addr,
+                        ip46_address_t *src_addr,
+                        u32 rx_table_id,
+                        u32 server_table_id, 
+                        int is_del)
 {
-  dhcpv6_proxy_main_t * dm = &dhcpv6_proxy_main;
-  dhcpv6_server_t * server = 0;
   u32 rx_fib_index = 0;
   int rc = 0;
 
-  rx_fib_index = ip6_mfib_table_find_or_create_and_lock(rx_fib_id);
-
   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,
+          .ip6 = all_dhcpv6_server_relay_agent_address,
       }
   };
 
-  if (is_del)
-    {
-      server = dhcpv6_get_server(dm, rx_fib_index);
-
-      if (NULL == server)
-        {
-          rc = VNET_API_ERROR_NO_SUCH_ENTRY;
-          goto out;
-        }
+  if (ip46_address_is_zero(addr))
+    return VNET_API_ERROR_INVALID_DST_ADDRESS;
+  
+  if (ip46_address_is_zero(src_addr))
+    return VNET_API_ERROR_INVALID_SRC_ADDRESS;
 
-      /*
-       * release the locks held on the server fib and rx mfib
-       */
-      mfib_table_entry_delete(rx_fib_index,
-                              &all_dhcp_servers,
-                              MFIB_SOURCE_DHCP);
-      mfib_table_unlock(rx_fib_index, FIB_PROTOCOL_IP6);
-      fib_table_unlock(server->server_fib6_index, FIB_PROTOCOL_IP6);
+  rx_fib_index = mfib_table_find_or_create_and_lock(FIB_PROTOCOL_IP6,
+                                                    rx_table_id);
 
-      dm->dhcp6_server_index_by_rx_fib_index[rx_fib_index] = ~0;
+  if (is_del)
+    {
+      rc = dhcp_proxy_server_del (FIB_PROTOCOL_IP6, rx_fib_index);
 
-      memset (server, 0, sizeof (*server));
-      pool_put (dm->dhcp6_servers, server);
+      if (0 == rc)
+      {
+          mfib_table_entry_delete(rx_fib_index,
+                                  &all_dhcp_servers,
+                                  MFIB_SOURCE_DHCP);
+          mfib_table_unlock(rx_fib_index, FIB_PROTOCOL_IP6);
+      }
     }
   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;
-      }
-
-      server = dhcpv6_get_server(dm, rx_fib_index);
-
-      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);
-  }
+     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,
+      };
+     if (dhcp_proxy_server_add (FIB_PROTOCOL_IP6, addr, src_addr,
+                                rx_fib_index, server_table_id))
+     {
+         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);
+         mfib_table_lock(rx_fib_index, FIB_PROTOCOL_IP6);
+     }
+    }
 
-out:
   mfib_table_unlock(rx_fib_index, FIB_PROTOCOL_IP6);
 
   return (rc);
@@ -921,22 +827,22 @@ dhcpv6_proxy_set_command_fn (vlib_main_t * vm,
                            unformat_input_t * input,
                            vlib_cli_command_t * cmd)
 {
-  ip6_address_t addr, src_addr;
+  ip46_address_t addr, src_addr;
   int set_server = 0, set_src_address = 0;
-  u32 rx_fib_id = 0, server_fib_id = 0;
+  u32 rx_table_id = 0, server_table_id = 0;
   int is_del = 0;
 
   while (unformat_check_input(input) != UNFORMAT_END_OF_INPUT)
     {
       if (unformat (input, "server %U",
-                    unformat_ip6_address, &addr))
+                    unformat_ip6_address, &addr.ip6))
 	 set_server = 1;
       else if (unformat(input, "src-address %U",
-			unformat_ip6_address, &src_addr))
+			unformat_ip6_address, &src_addr.ip6))
 	  set_src_address =1;
-       else if (unformat (input, "server-fib-id %d", &server_fib_id))
+       else if (unformat (input, "server-fib-id %d", &server_table_id))
         ;
-       else if (unformat (input, "rx-fib-id %d", &rx_fib_id))
+       else if (unformat (input, "rx-fib-id %d", &rx_table_id))
          ;
        else if (unformat (input, "delete") ||
                 unformat (input, "del"))
@@ -949,8 +855,8 @@ dhcpv6_proxy_set_command_fn (vlib_main_t * vm,
   {
       int rv;
 
-      rv = dhcpv6_proxy_set_server (&addr, &src_addr, rx_fib_id,
-                                    server_fib_id, is_del);
+      rv = dhcp6_proxy_set_server (&addr, &src_addr, rx_table_id,
+                                   server_table_id, is_del);
 
       //TODO: Complete the errors
       switch (rv)
@@ -958,8 +864,15 @@ dhcpv6_proxy_set_command_fn (vlib_main_t * vm,
         case 0:
           return 0;
 
-        case -1:
-          return clib_error_return (0, "FIB id %d does not exist", server_fib_id);
+        case VNET_API_ERROR_INVALID_DST_ADDRESS:
+          return clib_error_return (0, "Invalid server address");
+
+        case VNET_API_ERROR_INVALID_SRC_ADDRESS:
+          return clib_error_return (0, "Invalid src address");
+
+        case VNET_API_ERROR_NO_SUCH_ENTRY:
+          return clib_error_return
+            (0, "Fib id %d: no per-fib DHCP server configured", rx_table_id);
 
         default:
           return clib_error_return (0, "BUG: rv %d", rv);
@@ -977,62 +890,51 @@ VLIB_CLI_COMMAND (dhcpv6_proxy_set_command, static) = {
   .function = dhcpv6_proxy_set_command_fn,
 };
 
-u8 * format_dhcpv6_proxy_server (u8 * s, va_list * args)
+static u8 *
+format_dhcp6_proxy_server (u8 * s, va_list * args)
 {
-  dhcpv6_proxy_main_t * dm = va_arg (*args, dhcpv6_proxy_main_t *);
-  dhcpv6_server_t * server = va_arg (*args, dhcpv6_server_t *);
-  u32 rx_fib_index = va_arg (*args, u32);
+  dhcp_server_t * server = va_arg (*args, dhcp_server_t *);
   ip6_fib_t * rx_fib, * server_fib;
-  u32 server_fib_id = (u32)~0, rx_fib_id = ~0;
 
-  if (dm == 0)
+  if (NULL == server)
     {
       s = format (s, "%=40s%=40s%=14s%=14s", "Server Address", "Source Address",
                   "Server FIB", "RX FIB");
       return s;
     }
 
-  server_fib = ip6_fib_get(server->server_fib6_index);
-  if (server_fib)
-	  server_fib_id= server_fib->table_id;
-
-  rx_fib= ip6_fib_get(rx_fib_index);
+  server_fib = ip6_fib_get(server->server_fib_index);
+  rx_fib = ip6_fib_get(server->rx_fib_index);
 
-  if (rx_fib)
-	  rx_fib_id = rx_fib->table_id;
 
   s = format (s, "%=40U%=40U%=14u%=14u",
-              format_ip6_address, &server->dhcp6_server,
-              format_ip6_address, &server->dhcp6_src_address,
-			  server_fib_id, rx_fib_id);
+              format_ip46_address, &server->dhcp_server, IP46_TYPE_ANY,
+              format_ip46_address, &server->dhcp_src_address, IP46_TYPE_ANY,
+              server_fib->table_id, rx_fib->table_id);
   return s;
 }
 
+static int
+dhcp6_proxy_show_walk (dhcp_server_t *server,
+                       void *ctx)
+{
+    vlib_main_t * vm = ctx;
+
+    vlib_cli_output (vm, "%U", format_dhcp6_proxy_server, server);
+
+    return (1);
+}
+
 static clib_error_t *
 dhcpv6_proxy_show_command_fn (vlib_main_t * vm,
                             unformat_input_t * input,
                             vlib_cli_command_t * cmd)
 {
-  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);
-  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;
+  vlib_cli_output (vm, "%U", format_dhcp6_proxy_server, NULL /* header line */);
 
-      server = pool_elt_at_index (dpm->dhcp6_servers, server_index);
-
-      vlib_cli_output (vm, "%U", format_dhcpv6_proxy_server, dpm, 
-                       server, i);
-    }
+  dhcp_proxy_walk(FIB_PROTOCOL_IP6, dhcp6_proxy_show_walk, vm);
 
-  return 0;
+  return (NULL);
 }
 
 VLIB_CLI_COMMAND (dhcpv6_proxy_show_command, static) = {
@@ -1041,111 +943,10 @@ VLIB_CLI_COMMAND (dhcpv6_proxy_show_command, static) = {
   .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;
-  dhcpv6_vss_info *v = NULL;
-  u32  rx_fib_index;
-  int rc = 0;
-
-  rx_fib_index = ip6_fib_table_find_or_create_and_lock(tbl_id);
-  v = dhcpv6_get_vss_info(dm, rx_fib_index);
-
-  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)
-          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_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;
-      }
-  }
-
-  /* Release the lock taken during the create_or_lock at the start */
-  fib_table_unlock (rx_fib_index,
-                    FIB_PROTOCOL_IP6);
-
-  return (rc);
-}
-
-
 static clib_error_t *
 dhcpv6_vss_command_fn (vlib_main_t * vm,
-                           unformat_input_t * input,
-                           vlib_cli_command_t * cmd)
+                       unformat_input_t * input,
+                       vlib_cli_command_t * cmd)
 {
   int is_del = 0, got_new_vss=0;
   u32 oui=0;
@@ -1172,7 +973,7 @@ dhcpv6_vss_command_fn (vlib_main_t * vm,
     {
       int rv;
 
-      rv = dhcpv6_proxy_set_vss(tbl_id, oui, fib_id, is_del);
+      rv = dhcp_proxy_set_vss(FIB_PROTOCOL_IP6, tbl_id, oui, fib_id, is_del);
       switch (rv)
         {
         case 0:
@@ -1208,24 +1009,9 @@ dhcpv6_vss_show_command_fn (vlib_main_t * vm,
                             vlib_cli_command_t * cmd)
 
 {
-  dhcpv6_proxy_main_t * dm = &dhcpv6_proxy_main;
-  dhcpv6_vss_info *v;
-  ip6_fib_t *fib;
-  u32 *fib_index;
+  dhcp_vss_walk(FIB_PROTOCOL_IP6, dhcp_vss_show_walk, vm);
 
-  vlib_cli_output (vm, "%=6s%=6s%=12s","Table", "OUI", "VPN ID");
-  pool_foreach (fib_index, dm->vss_index_by_rx_fib_index,
-  ({
-      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 (NULL);
 }
 
 VLIB_CLI_COMMAND (dhcpv6_proxy_vss_show_command, static) = {
@@ -1240,17 +1026,16 @@ dhcpv6_link_address_show_command_fn (vlib_main_t * vm,
                                 vlib_cli_command_t * cmd)
 
 {
-  dhcpv6_proxy_main_t *dm = &dhcpv6_proxy_main;
   vnet_main_t *vnm = vnet_get_main();
   u32 sw_if_index0=0, sw_if_index;
-  ip6_address_t *ia0;
   vnet_sw_interface_t *swif;
+  ip6_address_t *ia0;
 
   while (unformat_check_input(input) != UNFORMAT_END_OF_INPUT)
     {
 
       if (unformat(input, "%U",
-                   unformat_vnet_sw_interface, dm->vnet_main, &sw_if_index0))
+                   unformat_vnet_sw_interface, vnm, &sw_if_index0))
         {
             swif = vnet_get_sw_interface (vnm, sw_if_index0);
             sw_if_index = (swif->flags & VNET_SW_INTERFACE_FLAG_UNNUMBERED) ?
@@ -1261,11 +1046,11 @@ dhcpv6_link_address_show_command_fn (vlib_main_t * vm,
                   vlib_cli_output (vm, "%=20s%=48s", "interface", "link-address");
 
                   vlib_cli_output (vm, "%=20U%=48U",
-                                   format_vnet_sw_if_index_name, dm->vnet_main, sw_if_index0,
+                                   format_vnet_sw_if_index_name, vnm, sw_if_index0,
                                    format_ip6_address, ia0);
               } else
                 vlib_cli_output (vm, "%=34s%=20U", "No IPv6 address configured on",
-                                 format_vnet_sw_if_index_name, dm->vnet_main, sw_if_index);
+                                 format_vnet_sw_if_index_name, vnm, sw_if_index);
         } else
           break;
     }
diff --git a/src/vnet/dhcp/dhcp_api.c b/src/vnet/dhcp/dhcp_api.c
index ce9039b7557..bdf02cae799 100644
--- a/src/vnet/dhcp/dhcp_api.c
+++ b/src/vnet/dhcp/dhcp_api.c
@@ -22,9 +22,8 @@
 
 #include <vnet/interface.h>
 #include <vnet/api_errno.h>
-#include <vnet/dhcp/proxy.h>
+#include <vnet/dhcp/dhcp_proxy.h>
 #include <vnet/dhcp/client.h>
-#include <vnet/dhcpv6/proxy.h>
 
 #include <vnet/vnet_msg_enum.h>
 
@@ -51,52 +50,19 @@ _(DHCP_PROXY_DETAILS,dhcp_proxy_details)          \
 _(DHCP_PROXY_SET_VSS,dhcp_proxy_set_vss)          \
 _(DHCP_CLIENT_CONFIG, dhcp_client_config)
 
-static void
-dhcpv4_proxy_config (vl_api_dhcp_proxy_config_t * mp)
-{
-  vl_api_dhcp_proxy_config_reply_t *rmp;
-  int rv;
-
-  rv = dhcp_proxy_set_server ((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),
-			      (int) (mp->is_add == 0));
-
-  REPLY_MACRO (VL_API_DHCP_PROXY_CONFIG_REPLY);
-}
-
-
-static void
-dhcpv6_proxy_config (vl_api_dhcp_proxy_config_t * mp)
-{
-  vl_api_dhcp_proxy_config_reply_t *rmp;
-  int rv = -1;
-
-  rv = dhcpv6_proxy_set_server ((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->is_add == 0));
-
-  REPLY_MACRO (VL_API_DHCP_PROXY_CONFIG_REPLY);
-}
-
 
 static void
 vl_api_dhcp_proxy_set_vss_t_handler (vl_api_dhcp_proxy_set_vss_t * mp)
 {
   vl_api_dhcp_proxy_set_vss_reply_t *rmp;
   int rv;
-  if (!mp->is_ipv6)
-    rv = dhcp_proxy_set_option82_vss (ntohl (mp->tbl_id),
-				      ntohl (mp->oui),
-				      ntohl (mp->fib_id),
-				      (int) mp->is_add == 0);
-  else
-    rv = dhcpv6_proxy_set_vss (ntohl (mp->tbl_id),
-			       ntohl (mp->oui),
-			       ntohl (mp->fib_id), (int) mp->is_add == 0);
+
+  rv = dhcp_proxy_set_vss ((mp->is_ipv6 ?
+			    FIB_PROTOCOL_IP6 :
+			    FIB_PROTOCOL_IP4),
+			   ntohl (mp->tbl_id),
+			   ntohl (mp->oui),
+			   ntohl (mp->fib_id), (int) mp->is_add == 0);
 
   REPLY_MACRO (VL_API_DHCP_PROXY_SET_VSS_REPLY);
 }
@@ -105,10 +71,38 @@ vl_api_dhcp_proxy_set_vss_t_handler (vl_api_dhcp_proxy_set_vss_t * mp)
 static void vl_api_dhcp_proxy_config_t_handler
   (vl_api_dhcp_proxy_config_t * mp)
 {
-  if (mp->is_ipv6 == 0)
-    dhcpv4_proxy_config (mp);
+  vl_api_dhcp_proxy_set_vss_reply_t *rmp;
+  ip46_address_t src, server;
+  int rv = -1;
+
+  if (mp->is_ipv6)
+    {
+      clib_memcpy (&src.ip6, mp->dhcp_src_address, sizeof (src.ip6));
+      clib_memcpy (&server.ip6, mp->dhcp_server, sizeof (server.ip6));
+
+      rv = dhcp6_proxy_set_server (&server,
+				   &src,
+				   (u32) ntohl (mp->rx_vrf_id),
+				   (u32) ntohl (mp->server_vrf_id),
+				   (int) (mp->is_add == 0));
+    }
   else
-    dhcpv6_proxy_config (mp);
+    {
+      ip46_address_reset (&src);
+      ip46_address_reset (&server);
+
+      clib_memcpy (&src.ip4, mp->dhcp_src_address, sizeof (src.ip4));
+      clib_memcpy (&server.ip4, mp->dhcp_server, sizeof (server.ip4));
+
+      rv = dhcp4_proxy_set_server (&server,
+				   &src,
+				   (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);
 }
 
 static void
@@ -120,14 +114,13 @@ vl_api_dhcp_proxy_dump_t_handler (vl_api_dhcp_proxy_dump_t * mp)
   if (q == 0)
     return;
 
-  if (mp->is_ip6 == 0)
-    dhcp_proxy_dump (q, mp->context);
-  else
-    dhcpv6_proxy_dump (q, mp->context);
+  dhcp_proxy_dump ((mp->is_ip6 == 0 ?
+		    FIB_PROTOCOL_IP6 : FIB_PROTOCOL_IP4), q, mp->context);
 }
 
 void
-dhcp_send_details (void *opaque,
+dhcp_send_details (fib_protocol_t proto,
+		   void *opaque,
 		   u32 context,
 		   const ip46_address_t * server,
 		   const ip46_address_t * src,
@@ -149,7 +142,7 @@ dhcp_send_details (void *opaque,
   mp->vss_oui = htonl (vss_oui);
   mp->vss_fib_id = htonl (vss_fib_id);
 
-  mp->is_ipv6 = !ip46_address_is_ip4 (server);
+  mp->is_ipv6 = (proto == FIB_PROTOCOL_IP6);
 
   if (mp->is_ipv6)
     {
diff --git a/src/vnet/dhcp/dhcp_proxy.c b/src/vnet/dhcp/dhcp_proxy.c
new file mode 100644
index 00000000000..da2deea65f6
--- /dev/null
+++ b/src/vnet/dhcp/dhcp_proxy.c
@@ -0,0 +1,275 @@
+/*
+ * proxy_node.c: common dhcp v4 and v6 proxy node processing
+ *
+ * Copyright (c) 2013 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <vnet/dhcp/dhcp_proxy.h>
+#include <vnet/fib/fib_table.h>
+
+/**
+ * @brief Shard 4/6 instance of DHCP main
+ */
+dhcp_proxy_main_t dhcp_proxy_main;
+
+void
+dhcp_proxy_walk (fib_protocol_t proto,
+                 dhcp_proxy_walk_fn_t fn,
+                 void *ctx)
+{
+  dhcp_proxy_main_t * dpm = &dhcp_proxy_main;
+  dhcp_server_t * server;
+  u32 server_index, i;
+
+  vec_foreach_index (i, dpm->dhcp_server_index_by_rx_fib_index[proto])
+  {
+      server_index = dpm->dhcp_server_index_by_rx_fib_index[proto][i];
+      if (~0 == server_index)
+          continue;
+
+      server = pool_elt_at_index (dpm->dhcp_servers[proto], server_index);
+
+      if (!fn(server, ctx))
+          break;
+    }
+}
+
+void
+dhcp_vss_walk (fib_protocol_t proto,
+               dhcp_vss_walk_fn_t fn,
+               void *ctx)
+{
+  dhcp_proxy_main_t * dpm = &dhcp_proxy_main;
+  dhcp_vss_t * vss;
+  u32 vss_index, i;
+  fib_table_t *fib;
+
+
+  vec_foreach_index (i, dpm->vss_index_by_rx_fib_index[proto])
+  {
+      vss_index = dpm->vss_index_by_rx_fib_index[proto][i];
+      if (~0 == vss_index)
+          continue;
+
+      vss = pool_elt_at_index (dpm->vss[proto], vss_index);
+
+      fib = fib_table_get(i, proto);
+
+      if (!fn(vss, fib->ft_table_id, ctx))
+          break;
+    }
+}
+
+int
+dhcp_proxy_server_del (fib_protocol_t proto,
+                       u32 rx_fib_index)
+{
+  dhcp_proxy_main_t * dpm = &dhcp_proxy_main;
+  dhcp_server_t * server = 0;
+  int rc = 0;
+
+  server = dhcp_get_server(dpm, rx_fib_index, proto);
+
+  if (NULL == server)
+  {
+      rc = VNET_API_ERROR_NO_SUCH_ENTRY;
+  }
+  else
+  {
+      /* Use the default server again.  */
+      dpm->dhcp_server_index_by_rx_fib_index[proto][rx_fib_index] = ~0;
+
+      fib_table_unlock (server->server_fib_index, proto);
+
+      pool_put (dpm->dhcp_servers[proto], server);
+  }
+
+  return (rc);
+}
+
+int
+dhcp_proxy_server_add (fib_protocol_t proto,
+                       ip46_address_t *addr,
+                       ip46_address_t *src_address,
+                       u32 rx_fib_index,
+                       u32 server_table_id)
+{
+  dhcp_proxy_main_t * dpm = &dhcp_proxy_main;
+  dhcp_server_t * server = 0;
+  int new = 0;
+
+  server = dhcp_get_server(dpm, rx_fib_index, proto);
+
+  if (NULL == server)
+  {
+      vec_validate_init_empty(dpm->dhcp_server_index_by_rx_fib_index[proto],
+                              rx_fib_index,
+                              ~0);
+
+      pool_get (dpm->dhcp_servers[proto], server);
+      memset (server, 0, sizeof (*server));
+      new = 1;
+
+      dpm->dhcp_server_index_by_rx_fib_index[proto][rx_fib_index] =
+          server - dpm->dhcp_servers[proto];
+
+      server->rx_fib_index = rx_fib_index;
+      server->server_fib_index = 
+          fib_table_find_or_create_and_lock(proto, server_table_id);
+  }
+  else
+  {
+      /* modify, may need to swap server FIBs */
+      u32 tmp_index;
+
+      tmp_index = fib_table_find(proto, server_table_id);
+
+      if (tmp_index != server->server_fib_index)
+      {
+          tmp_index = server->server_fib_index;
+
+          /* certainly swapping if the fib doesn't exist */
+          server->server_fib_index = 
+              fib_table_find_or_create_and_lock(proto, server_table_id);
+          fib_table_unlock (tmp_index, proto);
+      }
+  }
+
+  server->dhcp_server = *addr;
+  server->dhcp_src_address = *src_address;
+
+  return (new);
+}
+
+typedef struct dhcp4_proxy_dump_walk_ctx_t_
+{
+    fib_protocol_t proto;
+    void *opaque;
+    u32 context;
+} dhcp_proxy_dump_walk_cxt_t;
+
+static int
+dhcp_proxy_dump_walk (dhcp_server_t *server,
+                      void *arg)
+{
+  dhcp_proxy_dump_walk_cxt_t *ctx = arg;
+  fib_table_t *s_fib, *r_fib;
+  dhcp_vss_t *v;
+
+  v = dhcp_get_vss_info(&dhcp_proxy_main,
+                        server->rx_fib_index,
+                        ctx->proto);
+
+  s_fib = fib_table_get(server->server_fib_index, ctx->proto);
+  r_fib = fib_table_get(server->rx_fib_index, ctx->proto);
+
+  dhcp_send_details(ctx->proto,
+                    ctx->opaque,
+                    ctx->context,
+                    &server->dhcp_server,
+                    &server->dhcp_src_address,
+                    s_fib->ft_table_id,
+                    r_fib->ft_table_id,
+                    (v ? v->fib_id : 0),
+                    (v ? v->oui : 0));
+
+  return (1);
+}
+
+void
+dhcp_proxy_dump (fib_protocol_t proto,
+                 void *opaque,
+                 u32 context)
+{
+    dhcp_proxy_dump_walk_cxt_t ctx =  {
+        .proto = proto,
+        .opaque = opaque,
+        .context = context,
+    };
+    dhcp_proxy_walk(proto, dhcp_proxy_dump_walk, &ctx);
+}
+
+int
+dhcp_vss_show_walk (dhcp_vss_t *vss,
+                    u32 rx_table_id,
+                    void *ctx)
+{
+    vlib_main_t * vm = ctx;
+
+    vlib_cli_output (vm, "%=6d%=6d%=12d",
+                     rx_table_id,
+                     vss->oui,
+                     vss->fib_id);
+
+    return (1);
+}
+
+int dhcp_proxy_set_vss (fib_protocol_t proto,
+                        u32 tbl_id,
+                        u32 oui,
+                        u32 fib_id, 
+                        int is_del)
+{
+  dhcp_proxy_main_t *dm = &dhcp_proxy_main;
+  dhcp_vss_t *v = NULL;
+  u32  rx_fib_index;
+  int rc = 0;
+  
+  rx_fib_index = fib_table_find_or_create_and_lock(proto, tbl_id);
+  v = dhcp_get_vss_info(dm, rx_fib_index, proto);
+
+  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, proto);
+
+          pool_put (dm->vss[proto], v);
+          dm->vss_index_by_rx_fib_index[proto][rx_fib_index] = ~0;
+      }
+      else
+      {
+          /* this is a modify */
+          v->fib_id = fib_id;
+          v->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[proto],
+                                  rx_fib_index, ~0);
+
+          /* hold a lock on the table whilst the VSS info exist */
+          fib_table_lock (rx_fib_index, proto);
+
+          pool_get (dm->vss[proto], v);
+          v->fib_id = fib_id;
+          v->oui = oui;
+          dm->vss_index_by_rx_fib_index[proto][rx_fib_index] =
+              v - dm->vss[proto];
+      }
+  }
+
+  /* Release the lock taken during the create_or_lock at the start */
+  fib_table_unlock (rx_fib_index, proto);
+  
+  return (rc);
+}
diff --git a/src/vnet/dhcp/dhcp_proxy.h b/src/vnet/dhcp/dhcp_proxy.h
new file mode 100644
index 00000000000..c0d79c41af6
--- /dev/null
+++ b/src/vnet/dhcp/dhcp_proxy.h
@@ -0,0 +1,248 @@
+/*
+ * dhcp_proxy.h: DHCP v4 & v6 proxy common functions/types
+ *
+ * Copyright (c) 2013 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef included_dhcp_proxy_h
+#define included_dhcp_proxy_h
+
+#include <vnet/vnet.h>
+#include <vnet/dhcp/dhcp4_packet.h>
+#include <vnet/ethernet/ethernet.h>
+#include <vnet/ip/ip.h>
+#include <vnet/ip/ip4.h>
+#include <vnet/ip/ip4_packet.h>
+#include <vnet/pg/pg.h>
+#include <vnet/ip/format.h>
+#include <vnet/ip/udp.h>
+
+typedef enum {
+#define dhcp_proxy_error(n,s) DHCP_PROXY_ERROR_##n,
+#include <vnet/dhcp/dhcp4_proxy_error.def>
+#undef dhcp_proxy_error
+  DHCP_PROXY_N_ERROR,
+} dhcp_proxy_error_t;
+
+typedef enum {
+#define dhcpv6_proxy_error(n,s) DHCPV6_PROXY_ERROR_##n,
+#include <vnet/dhcp/dhcp6_proxy_error.def>
+#undef dhcpv6_proxy_error
+  DHCPV6_PROXY_N_ERROR,
+} dhcpv6_proxy_error_t;
+
+
+/**
+ * @brief The Virtual Sub-net Selection information for a given RX FIB
+ */
+typedef struct dhcp_vss_t_ {
+    /**
+     * @brief ?? RFC doesn't say
+     */
+    u32 oui;
+    /**
+     * @brief VPN-ID
+     */
+    u32 fib_id;
+} dhcp_vss_t;
+
+/**
+ * @brief A DHCP proxy server represenation
+ */
+typedef struct dhcp_server_t_ {
+    /**
+     * @brief The address of the DHCP server to which to relay the client's
+     *        messages
+     */
+    ip46_address_t dhcp_server;
+
+    /**
+     * @brief The source address to use in relayed messaes
+     */
+    ip46_address_t dhcp_src_address;
+
+    /**
+     * @brief The FIB index (not the external Table-ID) in which the server
+     *        is reachable.
+     */
+    u32 server_fib_index;
+
+    /**
+     * @brief The FIB index (not the external Table-ID) in which the client
+     *        is resides.
+     */
+    u32 rx_fib_index;
+} dhcp_server_t;
+
+#define DHCP_N_PROTOS (FIB_PROTOCOL_IP6 + 1)
+
+/**
+ * @brief Collection of global DHCP proxy data
+ */
+typedef struct {
+  /* Pool of DHCP servers */
+  dhcp_server_t *dhcp_servers[DHCP_N_PROTOS];
+
+  /* Pool of selected DHCP server. Zero is the default server */
+  u32 * dhcp_server_index_by_rx_fib_index[DHCP_N_PROTOS];
+
+  /* to drop pkts in server-to-client direction */
+  u32 error_drop_node_index;
+
+  dhcp_vss_t *vss[DHCP_N_PROTOS];
+
+  /* hash lookup specific vrf_id -> option 82 vss suboption  */
+  u32 *vss_index_by_rx_fib_index[DHCP_N_PROTOS];
+
+} dhcp_proxy_main_t;
+
+extern dhcp_proxy_main_t dhcp_proxy_main;
+
+/**
+ * @brief Send the details of a proxy session to the API client during a dump
+ */
+void dhcp_send_details (fib_protocol_t proto,
+                        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);
+
+/**
+ * @brief Show (on CLI) a VSS config during a show walk
+ */
+int dhcp_vss_show_walk (dhcp_vss_t *vss,
+                        u32 rx_table_id,
+                        void *ctx);
+
+/**
+ * @brief Configure/set a new VSS info
+ */
+int dhcp_proxy_set_vss(fib_protocol_t proto,
+                       u32 vrf_id,
+                       u32 oui,
+                       u32 fib_id,
+                       int is_del);
+
+/**
+ * @brief Dump the proxy configs to the API
+ */
+void dhcp_proxy_dump(fib_protocol_t proto,
+                     void *opaque,
+                     u32 context);
+
+/**
+ * @brief Add a new DHCP proxy server configuration.
+ * @return 1 is the config is new,
+ *         0 otherwise (implying a modify of an existing)
+ */
+int dhcp_proxy_server_add(fib_protocol_t proto,
+                          ip46_address_t *addr,
+                          ip46_address_t *src_address,
+                          u32 rx_fib_iindex,
+                          u32 server_table_id);
+
+/**
+ * @brief Delete a DHCP proxy config
+ * @return 0 is deleted, otherwise an error code
+ */
+int dhcp_proxy_server_del(fib_protocol_t proto,
+                          u32 rx_fib_index);
+
+/**
+ * @brief Callback function invoked for each DHCP proxy entry
+ *  return 0 to break the walk, non-zero otherwise.
+ */
+typedef int (*dhcp_proxy_walk_fn_t)(dhcp_server_t *server,
+                                    void *ctx);
+
+/**
+ * @brief Walk/Visit each DHCP proxy server
+ */
+void dhcp_proxy_walk(fib_protocol_t proto,
+                     dhcp_proxy_walk_fn_t fn,
+                     void *ctx);
+
+/**
+ * @brief Callback function invoked for each DHCP VSS entry
+ *  return 0 to break the walk, non-zero otherwise.
+ */
+typedef int (*dhcp_vss_walk_fn_t)(dhcp_vss_t *server,
+                                  u32 rx_table_id,
+                                  void *ctx);
+
+/**
+ * @brief Walk/Visit each DHCP proxy VSS
+ */
+void dhcp_vss_walk(fib_protocol_t proto,
+                   dhcp_vss_walk_fn_t fn,
+                   void *ctx);
+
+/**
+ * @brief Get the VSS data for the FIB index
+ */
+static inline dhcp_vss_t *
+dhcp_get_vss_info (dhcp_proxy_main_t *dm,
+                   u32 rx_fib_index,
+                   fib_protocol_t proto)
+{
+  dhcp_vss_t *v = NULL;
+
+  if (vec_len(dm->vss_index_by_rx_fib_index[proto]) > rx_fib_index &&
+      dm->vss_index_by_rx_fib_index[proto][rx_fib_index] != ~0)
+  {
+      v = pool_elt_at_index (
+              dm->vss[proto],
+              dm->vss_index_by_rx_fib_index[proto][rx_fib_index]);
+  }
+
+  return (v);
+}
+
+/**
+ * @brief Get the DHCP proxy server data for the FIB index
+ */
+static inline dhcp_server_t *
+dhcp_get_server (dhcp_proxy_main_t *dm,
+                 u32 rx_fib_index,
+                 fib_protocol_t proto)
+{
+  dhcp_server_t *s = NULL;
+
+  if (vec_len(dm->dhcp_server_index_by_rx_fib_index[proto]) > rx_fib_index &&
+      dm->dhcp_server_index_by_rx_fib_index[proto][rx_fib_index] != ~0)
+  {
+      s = pool_elt_at_index (
+              dm->dhcp_servers[proto],
+              dm->dhcp_server_index_by_rx_fib_index[proto][rx_fib_index]);
+  }
+
+  return (s);
+}
+
+int dhcp6_proxy_set_server (ip46_address_t *addr,
+                            ip46_address_t *src_addr,
+                            u32 rx_table_id,
+                            u32 server_table_id,
+                            int is_del);
+int dhcp4_proxy_set_server (ip46_address_t *addr,
+                            ip46_address_t *src_addr,
+                            u32 rx_table_id,
+                            u32 server_table_id,
+                            int is_del);
+
+#endif /* included_dhcp_proxy_h */
diff --git a/src/vnet/dhcp/proxy.h b/src/vnet/dhcp/proxy.h
deleted file mode 100644
index 4b115c741ff..00000000000
--- a/src/vnet/dhcp/proxy.h
+++ /dev/null
@@ -1,99 +0,0 @@
-/*
- * proxy.h: dhcp proxy 
- *
- * Copyright (c) 2013 Cisco and/or its affiliates.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at:
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef included_dhcp_proxy_h
-#define included_dhcp_proxy_h
-
-#include <vnet/vnet.h>
-#include <vnet/dhcp/packet.h>
-#include <vnet/ethernet/ethernet.h>
-#include <vnet/ip/ip.h>
-#include <vnet/ip/ip4.h>
-#include <vnet/ip/ip4_packet.h>
-#include <vnet/pg/pg.h>
-#include <vnet/ip/format.h>
-#include <vnet/ip/udp.h>
-
-typedef enum {
-#define dhcp_proxy_error(n,s) DHCP_PROXY_ERROR_##n,
-#include <vnet/dhcp/proxy_error.def>
-#undef dhcp_proxy_error
-  DHCP_PROXY_N_ERROR,
-} dhcp_proxy_error_t;
-
-typedef struct {
-  u32 oui;
-  u32 fib_id;
-} vss_id;
-
-typedef union {
-  u8 as_u8[8];
-  vss_id vpn_id;
-} vss_info;
-
-typedef struct {
-  ip4_address_t dhcp_server;
-  ip4_address_t dhcp_src_address;
-  u32 server_fib_index;
-} dhcp_server_t;
-
-typedef struct {
-  /* Pool of DHCP servers */
-  dhcp_server_t * dhcp_servers;
-
-  /* Pool of selected DHCP server. Zero is the default server */
-  u32 * dhcp_server_index_by_rx_fib_index;
-
-  /* to drop pkts in server-to-client direction */
-  u32 error_drop_node_index;
-
-  vss_info *vss;
-
-  /* hash lookup specific vrf_id -> option 82 vss suboption  */
-  u32 *vss_index_by_rx_fib_index;
-
-  /* convenience */
-  vlib_main_t * vlib_main;
-  vnet_main_t * vnet_main;
-} dhcp_proxy_main_t;
-
-extern dhcp_proxy_main_t dhcp_proxy_main;
-
-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 (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);
-
-void dhcp_proxy_dump(void *opaque,
-                     u32 context);
-
-#endif /* included_dhcp_proxy_h */
diff --git a/src/vnet/dhcpv6/proxy.h b/src/vnet/dhcpv6/proxy.h
deleted file mode 100644
index 77ced3619c4..00000000000
--- a/src/vnet/dhcpv6/proxy.h
+++ /dev/null
@@ -1,94 +0,0 @@
-/*
- * proxy.h: dhcp proxy 
- *
- * Copyright (c) 2013 Cisco and/or its affiliates.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at:
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef included_dhcpv6_proxy_h
-#define included_dhcpv6_proxy_h
-
-#include <vnet/vnet.h>
-#include <vnet/ethernet/ethernet.h>
-#include <vnet/ip/ip.h>
-#include <vnet/ip/ip4.h>
-#include <vnet/ip/ip6_packet.h>
-#include <vnet/pg/pg.h>
-#include <vnet/ip/format.h>
-#include <vnet/ip/udp.h>
-#include <vnet/dhcpv6/packet.h>
-
-typedef enum {
-#define dhcpv6_proxy_error(n,s) DHCPV6_PROXY_ERROR_##n,
-#include <vnet/dhcpv6/proxy_error.def>
-#undef dhcpv6_proxy_error
-  DHCPV6_PROXY_N_ERROR,
-} dhcpv6_proxy_error_t;
-
-typedef struct {
-  u32 oui;
-  u32 fib_id;
-} dhcpv6_vss_id;
-
-typedef union {
-  u8 as_u8[8];
-  dhcpv6_vss_id vpn_id;
-} dhcpv6_vss_info;
-
-typedef struct {
-  ip6_address_t dhcp6_server;
-  ip6_address_t dhcp6_src_address;
-  u32 server_fib6_index;
-} dhcpv6_server_t;
-
-typedef struct {
-  /* Pool of DHCP servers */
-  dhcpv6_server_t * dhcp6_servers;
-
-  /* Pool of selected DHCP server. Zero is the default server */
-   u32 * dhcp6_server_index_by_rx_fib_index;
-
-  /* all DHCP servers address */
-  ip6_address_t all_dhcpv6_server_address;
-  ip6_address_t all_dhcpv6_server_relay_agent_address;
-
-  /* to drop pkts in server-to-client direction */
-  u32 error_drop_node_index;
-
-  dhcpv6_vss_info *vss;
-
-  /* hash lookup specific vrf_id -> VSS vector index*/
-  u32 *vss_index_by_rx_fib_index;
-   
-  /* convenience */
-  vlib_main_t * vlib_main;
-  vnet_main_t * vnet_main;
-} dhcpv6_proxy_main_t;
-
-dhcpv6_proxy_main_t dhcpv6_proxy_main;
-
-int dhcpv6_proxy_set_vss(u32 tbl_id,
-                         u32 oui,
-                         u32 fib_id, 
-                         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 */