aboutsummaryrefslogtreecommitdiffstats
path: root/src/vnet/dhcp
diff options
context:
space:
mode:
Diffstat (limited to 'src/vnet/dhcp')
-rw-r--r--src/vnet/dhcp/client.c2
-rw-r--r--src/vnet/dhcp/client.h2
-rw-r--r--src/vnet/dhcp/dhcp4_packet.h (renamed from src/vnet/dhcp/packet.h)6
-rw-r--r--src/vnet/dhcp/dhcp4_proxy_error.def (renamed from src/vnet/dhcp/proxy_error.def)1
-rw-r--r--src/vnet/dhcp/dhcp4_proxy_node.c (renamed from src/vnet/dhcp/proxy_node.c)423
-rw-r--r--src/vnet/dhcp/dhcp6_packet.h183
-rw-r--r--src/vnet/dhcp/dhcp6_proxy_error.def29
-rw-r--r--src/vnet/dhcp/dhcp6_proxy_node.c1065
-rw-r--r--src/vnet/dhcp/dhcp_api.c95
-rw-r--r--src/vnet/dhcp/dhcp_proxy.c275
-rw-r--r--src/vnet/dhcp/dhcp_proxy.h248
-rw-r--r--src/vnet/dhcp/proxy.h99
12 files changed, 1957 insertions, 471 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/dhcp/dhcp6_packet.h b/src/vnet/dhcp/dhcp6_packet.h
new file mode 100644
index 00000000000..ddcde7a0dd9
--- /dev/null
+++ b/src/vnet/dhcp/dhcp6_packet.h
@@ -0,0 +1,183 @@
+#ifndef included_vnet_dhcp6_packet_h
+#define included_vnet_dhcp6_packet_h
+
+/*
+ * DHCP packet format
+ *
+ * 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/ip/ip6_packet.h>
+
+// #define DHCP_VRF_NAME_MAX_LEN L3VM_MAX_NAME_STR_LEN
+// #define DHCPV6_MAX_VRF_NAME_LEN L3VM_MAX_NAME_STR_LEN
+#define DHCP_MAX_RELAY_ADDR 16
+#define PROTO_UDP 17
+#define DHCPV6_CLIENT_PORT 546
+#define DHCPV6_SERVER_PORT 547
+#define HOP_COUNT_LIMIT 32
+#define DHCPV6_CISCO_ENT_NUM 9
+
+/*
+ * DHCPv6 message types
+ */
+typedef enum dhcpv6_msg_type_{
+ DHCPV6_MSG_SOLICIT = 1,
+ DHCPV6_MSG_ADVERTISE = 2,
+ DHCPV6_MSG_REQUEST = 3,
+ DHCPV6_MSG_CONFIRM = 4,
+ DHCPV6_MSG_RENEW = 5,
+ DHCPV6_MSG_REBIND = 6,
+ DHCPV6_MSG_REPLY = 7,
+ DHCPV6_MSG_RELEASE = 8,
+ DHCPV6_MSG_DECLINE = 9,
+ DHCPV6_MSG_RECONFIGURE = 10,
+ DHCPV6_MSG_INFORMATION_REQUEST = 11,
+ DHCPV6_MSG_RELAY_FORW = 12,
+ DHCPV6_MSG_RELAY_REPL = 13,
+} dhcpv6_msg_type_t;
+
+/*
+ * DHCPv6 options types
+ */
+enum {
+ DHCPV6_OPTION_CLIENTID = 1,
+ DHCPV6_OPTION_SERVERID = 2,
+ DHCPV6_OPTION_IA_NA = 3,
+ DHCPV6_OPTION_IA_TA = 4,
+ DHCPV6_OPTION_IAADDR = 5,
+ DHCPV6_OPTION_ORO = 6,
+ DHCPV6_OPTION_PREFERENCE = 7,
+ DHCPV6_OPTION_ELAPSED_TIME = 8,
+ DHCPV6_OPTION_RELAY_MSG = 9,
+ DHCPV6_OPTION_AUTH = 11,
+ DHCPV6_OPTION_UNICAST = 12,
+ DHCPV6_OPTION_STATUS_CODE = 13,
+ DHCPV6_OPTION_RAPID_COMMIT = 14,
+ DHCPV6_OPTION_USER_CLASS = 15,
+ DHCPV6_OPTION_VENDOR_CLASS = 16,
+ DHCPV6_OPTION_VENDOR_OPTS = 17,
+ DHCPV6_OPTION_INTERFACE_ID = 18, // relay agent fills this
+ DHCPV6_OPTION_RECONF_MSG = 19,
+ DHCPV6_OPTION_RECONF_ACCEPT = 20,
+ DHCPV6_OPTION_REMOTEID = 37, // relay agent fills this
+ DHCPV6_OPTION_VSS = 68, // relay agent fills this
+ DHCPV6_OPTION_CLIENT_LINK_LAYER_ADDRESS = 79,
+ DHCPV6_OPTION_MAX
+};
+
+/*
+* DHCPv6 status codes
+ */
+enum {
+ DHCPV6_STATUS_SUCCESS = 0,
+ DHCPV6_STATUS_UNSPEC_FAIL = 1,
+ DHCPV6_STATUS_NOADDRS_AVAIL = 2,
+ DHCPV6_STATUS_NO_BINDING = 3,
+ DHCPV6_STATUS_NOT_ONLINK = 4,
+ DHCPV6_STATUS_USE_MULTICAST = 5,
+};
+
+/*
+ * DHCPv6 DUID types
+ */
+enum {
+ DHCPV6_DUID_LLT = 1, /* DUID Based on Link-layer Address Plus Time */
+ DHCPV6_DUID_EN = 2, /* DUID Based on Enterprise Number */
+ DHCPV6_DUID_LL = 3, /* DUID Based on Link-layer Address */
+};
+
+//Structure for DHCPv6 payload from client
+typedef struct dhcpv6_hdr_ {
+ union {
+ u8 msg_type; //DHCP msg type
+ u32 xid; // transaction id
+ }u;
+ u8 data[0];
+} dhcpv6_header_t;
+
+
+
+typedef CLIB_PACKED (struct dhcpv6_relay_ctx_ {
+ dhcpv6_header_t *pkt;
+ u32 pkt_len;
+ u32 dhcpv6_len; //DHCPv6 payload load
+// if_ordinal iod;
+ u32 if_index;
+ u32 ctx_id;
+ char ctx_name[32+1];
+ u8 dhcp_msg_type;
+}) dhcpv6_relay_ctx_t;
+
+//Structure for DHCPv6 RELAY-FORWARD and DHCPv6 RELAY-REPLY pkts
+typedef CLIB_PACKED (struct dhcpv6_relay_hdr_ {
+ u8 msg_type;
+ u8 hop_count;
+ ip6_address_t link_addr;
+ ip6_address_t peer_addr;
+ u8 data[0];
+}) dhcpv6_relay_hdr_t;
+
+typedef enum dhcp_stats_action_type_ {
+ DHCP_STATS_ACTION_FORWARDED=1,
+ DHCP_STATS_ACTION_RECEIVED,
+ DHCP_STATS_ACTION_DROPPED
+} dhcp_stats_action_type_t;
+//Generic counters for a packet
+typedef struct dhcp_stats_counters_ {
+ u64 rx_pkts; //counter for received pkts
+ u64 tx_pkts; //counter for forwarded pkts
+ u64 drops; //counter for dropped pkts
+} dhcp_stats_counters_t;
+
+
+typedef enum dhcpv6_stats_drop_reason_ {
+ DHCPV6_RELAY_PKT_DROP_RELAYDISABLE = 1,
+ DHCPV6_RELAY_PKT_DROP_MAX_HOPS,
+ DHCPV6_RELAY_PKT_DROP_VALIDATION_FAIL,
+ DHCPV6_RELAY_PKT_DROP_UNKNOWN_OP_INTF,
+ DHCPV6_RELAY_PKT_DROP_BAD_CONTEXT,
+ DHCPV6_RELAY_PKT_DROP_OPT_INSERT_FAIL,
+ DHCPV6_RELAY_PKT_DROP_REPLY_FROM_CLIENT,
+} dhcpv6_stats_drop_reason_t;
+
+typedef CLIB_PACKED (struct {
+ u16 option;
+ u16 length;
+ u8 data[0];
+}) dhcpv6_option_t;
+
+typedef CLIB_PACKED (struct {
+ dhcpv6_option_t opt;
+ u32 int_idx;
+}) dhcpv6_int_id_t;
+
+typedef CLIB_PACKED (struct {
+ dhcpv6_option_t opt;
+ u8 data[8]; // data[0]:type, data[1..7]: VPN ID
+}) dhcpv6_vss_t;
+
+typedef CLIB_PACKED (struct {
+ dhcpv6_option_t opt;
+ u32 ent_num;
+ u32 rmt_id;
+}) dhcpv6_rmt_id_t;
+
+typedef CLIB_PACKED (struct {
+ dhcpv6_option_t opt;
+ u16 link_type;
+ u8 data[6]; // data[0]:data[5]: MAC address
+}) dhcpv6_client_mac_t;
+
+
+#endif /* included_vnet_dhcp6_packet_h */
diff --git a/src/vnet/dhcp/dhcp6_proxy_error.def b/src/vnet/dhcp/dhcp6_proxy_error.def
new file mode 100644
index 00000000000..55fa731766c
--- /dev/null
+++ b/src/vnet/dhcp/dhcp6_proxy_error.def
@@ -0,0 +1,29 @@
+/*
+ * dhcp_proxy_error.def: dhcp proxy errors
+ *
+ * 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.
+ */
+
+dhcpv6_proxy_error (NONE, "no error")
+dhcpv6_proxy_error (NO_SERVER, "no dhcpv6 server configured")
+dhcpv6_proxy_error (RELAY_TO_SERVER, "DHCPV6 packets relayed to the server")
+dhcpv6_proxy_error (RELAY_TO_CLIENT, "DHCPV6 packets relayed to clients")
+dhcpv6_proxy_error (NO_INTERFACE_ADDRESS, "DHCPV6 no interface address")
+dhcpv6_proxy_error (WRONG_MESSAGE_TYPE, "DHCPV6 wrong message type.")
+dhcpv6_proxy_error (NO_SRC_ADDRESS, "DHCPV6 no srouce IPv6 address configured.")
+dhcpv6_proxy_error (NO_CIRCUIT_ID_OPTION, "DHCPv6 reply packets without circuit ID option")
+dhcpv6_proxy_error (NO_RELAY_MESSAGE_OPTION, "DHCPv6 reply packets without relay message option")
+dhcpv6_proxy_error (BAD_SVR_FIB_OR_ADDRESS, "DHCPv6 packets not from DHCPv6 server or server FIB.")
+dhcpv6_proxy_error (PKT_TOO_BIG, "DHCPv6 packets which are too big.")
+dhcpv6_proxy_error (WRONG_INTERFACE_ID_OPTION, "DHCPv6 reply to invalid interface.")
diff --git a/src/vnet/dhcp/dhcp6_proxy_node.c b/src/vnet/dhcp/dhcp6_proxy_node.c
new file mode 100644
index 00000000000..ed44977d76b
--- /dev/null
+++ b/src/vnet/dhcp/dhcp6_proxy_node.c
@@ -0,0 +1,1065 @@
+/*
+ * 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");
+ * 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 <vlib/vlib.h>
+#include <vnet/pg/pg.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 <vnet/dhcp/dhcp6_proxy_error.def>
+#undef dhcpv6_proxy_error
+};
+
+#define foreach_dhcpv6_proxy_to_server_input_next \
+ _ (DROP, "error-drop") \
+ _ (LOOKUP, "ip6-lookup") \
+ _ (SEND_TO_CLIENT, "dhcpv6-proxy-to-client")
+
+
+typedef enum {
+#define _(s,n) DHCPV6_PROXY_TO_SERVER_INPUT_NEXT_##s,
+ foreach_dhcpv6_proxy_to_server_input_next
+#undef _
+ DHCPV6_PROXY_TO_SERVER_INPUT_N_NEXT,
+} dhcpv6_proxy_to_server_input_next_t;
+
+typedef struct {
+ /* 0 => to server, 1 => to client */
+ int which;
+ u8 packet_data[64];
+ u32 error;
+ u32 sw_if_index;
+ u32 original_sw_if_index;
+} dhcpv6_proxy_trace_t;
+
+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;
+
+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 *);
+ dhcpv6_proxy_trace_t * t = va_arg (*args, dhcpv6_proxy_trace_t *);
+
+ if (t->which == 0)
+ s = format (s, "DHCPV6 proxy: sent to server %U",
+ format_ip6_address, &t->packet_data, sizeof (ip6_address_t));
+ else
+ s = format (s, "DHCPV6 proxy: sent to client from %U",
+ format_ip6_address, &t->packet_data, sizeof (ip6_address_t));
+ if (t->error != (u32)~0)
+ s = format (s, " error: %s\n", dhcpv6_proxy_error_strings[t->error]);
+
+ s = format (s, " original_sw_if_index: %d, sw_if_index: %d\n",
+ t->original_sw_if_index, t->sw_if_index);
+
+ return s;
+}
+
+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);
+ u32 header_bytes;
+
+ header_bytes = sizeof (h[0]);
+ if (max_header_bytes != 0 && header_bytes > max_header_bytes)
+ return format (s, "dhcpv6 header truncated");
+
+ s = format (s, "DHCPV6 Proxy");
+
+ return s;
+}
+/* get first interface address */
+static ip6_address_t *
+ip6_interface_first_global_or_site_address (ip6_main_t * im, u32 sw_if_index)
+{
+ ip_lookup_main_t * lm = &im->lookup_main;
+ ip_interface_address_t * ia = 0;
+ ip6_address_t * result = 0;
+
+ foreach_ip_interface_address (lm, ia, sw_if_index,
+ 1 /* honor unnumbered */,
+ ({
+ ip6_address_t * a = ip_interface_address_get_address (lm, ia);
+ if ((a->as_u8[0] & 0xe0) == 0x20 ||
+ (a->as_u8[0] & 0xfe) == 0xfc) {
+ result = a;
+ break;
+ }
+ }));
+ return result;
+}
+
+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 uword
+dhcpv6_proxy_to_server_input (vlib_main_t * vm,
+ vlib_node_runtime_t * node,
+ vlib_frame_t * from_frame)
+{
+ u32 n_left_from, next_index, * from, * to_next;
+ 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;
+ u32 pkts_no_interface_address=0, pkts_no_exceeding_max_hop=0;
+ u32 pkts_no_src_address=0;
+ u32 pkts_wrong_msg_type=0;
+ u32 pkts_too_big=0;
+ ip6_main_t * im = &ip6_main;
+ ip6_address_t * src;
+ int bogus_length;
+ dhcp_server_t * server;
+ u32 rx_fib_idx = 0, server_fib_idx = 0;
+
+ next_index = node->cached_next_index;
+
+ while (n_left_from > 0)
+ {
+ u32 n_left_to_next;
+
+ vlib_get_next_frame (vm, node, next_index,
+ to_next, n_left_to_next);
+
+ while (n_left_from > 0 && n_left_to_next > 0)
+ {
+ vnet_main_t *vnm = vnet_get_main();
+ u32 sw_if_index = 0;
+ u32 rx_sw_if_index = 0;
+ vnet_sw_interface_t *swif;
+ u32 bi0;
+ vlib_buffer_t * b0;
+ udp_header_t * u0, *u1;
+ dhcpv6_header_t * h0; // client msg hdr
+ ip6_header_t * ip0, *ip1;
+ ip6_address_t _ia0, *ia0=&_ia0;
+ u32 next0;
+ u32 error0 = (u32) ~0;
+ dhcpv6_option_t *fwd_opt;
+ dhcpv6_relay_hdr_t *r1;
+ u16 len;
+ dhcpv6_int_id_t *id1;
+ dhcpv6_vss_t *vss1;
+ dhcpv6_client_mac_t *cmac; // client mac
+ ethernet_header_t * e_h0;
+ u8 client_src_mac[6];
+ vlib_buffer_free_list_t *fl;
+ dhcp_vss_t *vss;
+
+ bi0 = from[0];
+ to_next[0] = bi0;
+ from += 1;
+ to_next += 1;
+ n_left_from -= 1;
+ n_left_to_next -= 1;
+
+ b0 = vlib_get_buffer (vm, bi0);
+
+ h0 = vlib_buffer_get_current (b0);
+
+ /*
+ * udp_local hands us the DHCPV6 header.
+ */
+ u0 = (void *)h0 -(sizeof(*u0));
+ ip0 = (void *)u0 -(sizeof(*ip0));
+ e_h0 = (void *)ip0 - ethernet_buffer_header_size(b0);
+
+ clib_memcpy(client_src_mac, e_h0->src_address, 6);
+
+ switch (h0->u.msg_type) {
+ case DHCPV6_MSG_SOLICIT:
+ case DHCPV6_MSG_REQUEST:
+ case DHCPV6_MSG_CONFIRM:
+ case DHCPV6_MSG_RENEW:
+ case DHCPV6_MSG_REBIND:
+ case DHCPV6_MSG_RELEASE:
+ case DHCPV6_MSG_DECLINE:
+ case DHCPV6_MSG_INFORMATION_REQUEST:
+ case DHCPV6_MSG_RELAY_FORW:
+ /* send to server */
+ break;
+ case DHCPV6_MSG_RELAY_REPL:
+ /* send to client */
+ next0 = DHCPV6_PROXY_TO_SERVER_INPUT_NEXT_SEND_TO_CLIENT;
+ error0 = 0;
+ pkts_to_client++;
+ goto do_enqueue;
+ default:
+ /* drop the packet */
+ pkts_wrong_msg_type++;
+ error0 = DHCPV6_PROXY_ERROR_WRONG_MESSAGE_TYPE;
+ next0 = DHCPV6_PROXY_TO_SERVER_INPUT_NEXT_DROP;
+ goto do_trace;
+
+ }
+
+ /* 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 = dhcp_get_server(dpm, rx_fib_idx, FIB_PROTOCOL_IP6);
+
+ 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_fib_index;
+ vnet_buffer(b0)->sw_if_index[VLIB_TX] = server_fib_idx;
+
+
+ /* relay-option header pointer */
+ vlib_buffer_advance(b0, -(sizeof(*fwd_opt)));
+ fwd_opt = vlib_buffer_get_current(b0);
+ /* relay message header pointer */
+ vlib_buffer_advance(b0, -(sizeof(*r1)));
+ r1 = vlib_buffer_get_current(b0);
+
+ vlib_buffer_advance(b0, -(sizeof(*u1)));
+ u1 = vlib_buffer_get_current(b0);
+
+ vlib_buffer_advance(b0, -(sizeof(*ip1)));
+ ip1 = vlib_buffer_get_current(b0);
+
+ /* fill in all that rubbish... */
+ len = clib_net_to_host_u16(u0->length) - sizeof(udp_header_t);
+ copy_ip6_address(&r1->peer_addr, &ip0->src_address);
+
+ r1->msg_type = DHCPV6_MSG_RELAY_FORW;
+ fwd_opt->length = clib_host_to_net_u16(len);
+ fwd_opt->option = clib_host_to_net_u16(DHCPV6_OPTION_RELAY_MSG);
+
+ r1->hop_count++;
+ r1->hop_count = (h0->u.msg_type != DHCPV6_MSG_RELAY_FORW) ? 0 : r1->hop_count;
+
+ if (PREDICT_FALSE(r1->hop_count >= HOP_COUNT_LIMIT))
+ {
+ error0 = DHCPV6_RELAY_PKT_DROP_MAX_HOPS;
+ next0 = DHCPV6_PROXY_TO_SERVER_INPUT_NEXT_DROP;
+ pkts_no_exceeding_max_hop++;
+ goto do_trace;
+ }
+
+
+ /* If relay-fwd and src address is site or global unicast address */
+ if (h0->u.msg_type == DHCPV6_MSG_RELAY_FORW &&
+ ((ip0->src_address.as_u8[0] & 0xe0) == 0x20 ||
+ (ip0->src_address.as_u8[0] & 0xfe) == 0xfc))
+ {
+ /* Set link address to zero */
+ r1->link_addr.as_u64[0] = 0;
+ r1->link_addr.as_u64[1] = 0;
+ goto link_address_set;
+ }
+
+ /* if receiving interface is unnumbered, use receiving interface
+ * IP address as link address, otherwise use the loopback interface
+ * IP address as link address.
+ */
+
+ swif = vnet_get_sw_interface (vnm, rx_sw_if_index);
+ if (swif->flags & VNET_SW_INTERFACE_FLAG_UNNUMBERED)
+ sw_if_index = swif->unnumbered_sw_if_index;
+
+ ia0 = ip6_interface_first_global_or_site_address(&ip6_main, sw_if_index);
+ if (ia0 == 0)
+ {
+ error0 = DHCPV6_PROXY_ERROR_NO_INTERFACE_ADDRESS;
+ next0 = DHCPV6_PROXY_TO_SERVER_INPUT_NEXT_DROP;
+ pkts_no_interface_address++;
+ goto do_trace;
+ }
+
+ copy_ip6_address(&r1->link_addr, ia0);
+
+ link_address_set:
+ fl = vlib_buffer_get_free_list (vm, b0->free_list_index);
+
+ if ((b0->current_length+sizeof(*id1)+sizeof(*vss1)+sizeof(*cmac))
+ > fl->n_data_bytes)
+ {
+ error0 = DHCPV6_PROXY_ERROR_PKT_TOO_BIG;
+ next0 = DHCPV6_PROXY_TO_SERVER_INPUT_NEXT_DROP;
+ pkts_too_big++;
+ goto do_trace;
+ }
+
+ id1 = (dhcpv6_int_id_t *) (((uword) ip1) + b0->current_length);
+ b0->current_length += (sizeof (*id1));
+
+ 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);
+
+ u1->length =0;
+ if (h0->u.msg_type != DHCPV6_MSG_RELAY_FORW)
+ {
+ cmac = (dhcpv6_client_mac_t *) (((uword) ip1) + b0->current_length);
+ b0->current_length += (sizeof (*cmac));
+ cmac->opt.length =clib_host_to_net_u16(sizeof(*cmac) -
+ sizeof(cmac->opt));
+ cmac->opt.option = clib_host_to_net_u16(DHCPV6_OPTION_CLIENT_LINK_LAYER_ADDRESS);
+ cmac->link_type = clib_host_to_net_u16(1); // ethernet
+ clib_memcpy(cmac->data, client_src_mac, 6);
+ u1->length += sizeof(*cmac);
+ }
+
+ vss = dhcp_get_vss_info(dpm, rx_fib_idx, FIB_PROTOCOL_IP6);
+
+ 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->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);
+ }
+
+ pkts_to_server++;
+ u1->checksum = 0;
+ u1->src_port = clib_host_to_net_u16(UDP_DST_PORT_dhcpv6_to_client);
+ u1->dst_port = clib_host_to_net_u16(UDP_DST_PORT_dhcpv6_to_server);
+
+ u1->length =
+ clib_host_to_net_u16( clib_net_to_host_u16(fwd_opt->length) +
+ sizeof(*r1) + sizeof(*fwd_opt) +
+ sizeof(*u1) + sizeof(*id1) + u1->length);
+
+ memset(ip1, 0, sizeof(*ip1));
+ ip1->ip_version_traffic_class_and_flow_label = 0x60;
+ ip1->payload_length = u1->length;
+ ip1->protocol = PROTO_UDP;
+ ip1->hop_limit = HOP_COUNT_LIMIT;
+ 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->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;
+ next0 = DHCPV6_PROXY_TO_SERVER_INPUT_NEXT_DROP;
+ pkts_no_src_address++;
+ goto do_trace;
+ }
+
+ copy_ip6_address (&ip1->src_address, src);
+
+
+ u1->checksum = ip6_tcp_udp_icmp_compute_checksum(vm, b0, ip1,
+ &bogus_length);
+ ASSERT(bogus_length == 0);
+
+ next0 = DHCPV6_PROXY_TO_SERVER_INPUT_NEXT_LOOKUP;
+
+ do_trace:
+ if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED))
+ {
+ dhcpv6_proxy_trace_t *tr = vlib_add_trace (vm, node,
+ b0, sizeof (*tr));
+ tr->which = 0; /* to server */
+ tr->error = error0;
+ 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->dhcp_server.ip6);
+ }
+
+ do_enqueue:
+ vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
+ to_next, n_left_to_next,
+ bi0, next0);
+ }
+
+ vlib_put_next_frame (vm, node, next_index, n_left_to_next);
+ }
+
+ vlib_node_increment_counter (vm, dhcpv6_proxy_to_server_node.index,
+ DHCPV6_PROXY_ERROR_RELAY_TO_CLIENT,
+ pkts_to_client);
+ vlib_node_increment_counter (vm, dhcpv6_proxy_to_server_node.index,
+ DHCPV6_PROXY_ERROR_RELAY_TO_SERVER,
+ pkts_to_server);
+ vlib_node_increment_counter (vm, dhcpv6_proxy_to_server_node.index,
+ DHCPV6_PROXY_ERROR_NO_INTERFACE_ADDRESS,
+ pkts_no_interface_address);
+ vlib_node_increment_counter (vm, dhcpv6_proxy_to_server_node.index,
+ DHCPV6_PROXY_ERROR_WRONG_MESSAGE_TYPE,
+ pkts_wrong_msg_type);
+ vlib_node_increment_counter (vm, dhcpv6_proxy_to_server_node.index,
+ DHCPV6_PROXY_ERROR_NO_SRC_ADDRESS,
+ pkts_no_src_address);
+ vlib_node_increment_counter (vm, dhcpv6_proxy_to_server_node.index,
+ DHCPV6_PROXY_ERROR_PKT_TOO_BIG,
+ pkts_too_big);
+ return from_frame->n_vectors;
+}
+
+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. */
+ .vector_size = sizeof (u32),
+
+ .n_errors = DHCPV6_PROXY_N_ERROR,
+ .error_strings = dhcpv6_proxy_error_strings,
+
+ .n_next_nodes = DHCPV6_PROXY_TO_SERVER_INPUT_N_NEXT,
+ .next_nodes = {
+#define _(s,n) [DHCPV6_PROXY_TO_SERVER_INPUT_NEXT_##s] = n,
+ foreach_dhcpv6_proxy_to_server_input_next
+#undef _
+ },
+
+ .format_buffer = format_dhcpv6_proxy_header_with_length,
+ .format_trace = format_dhcpv6_proxy_trace,
+#if 0
+ .unformat_buffer = unformat_dhcpv6_proxy_header,
+#endif
+};
+
+static uword
+dhcpv6_proxy_to_client_input (vlib_main_t * vm,
+ vlib_node_runtime_t * node,
+ vlib_frame_t * from_frame)
+{
+
+ u32 n_left_from, * from;
+ ethernet_main_t *em = ethernet_get_main (vm);
+ dhcp_proxy_main_t * dm = &dhcp_proxy_main;
+ dhcp_server_t * server;
+ vnet_main_t * vnm = vnet_get_main();
+ int bogus_length;
+
+ from = vlib_frame_vector_args (from_frame);
+ n_left_from = from_frame->n_vectors;
+
+ while (n_left_from > 0)
+ {
+ u32 bi0;
+ vlib_buffer_t * b0;
+ udp_header_t * u0, *u1=0;
+ dhcpv6_relay_hdr_t * h0;
+ ip6_header_t * ip1 = 0, *ip0;
+ ip6_address_t _ia0, * ia0 = &_ia0;
+ ip6_address_t client_address;
+ ethernet_interface_t *ei0;
+ ethernet_header_t *mac0;
+ vnet_hw_interface_t *hi0;
+ vlib_frame_t *f0;
+ u32 * to_next0;
+ u32 sw_if_index = ~0;
+ u32 original_sw_if_index = ~0;
+ vnet_sw_interface_t *si0;
+ u32 error0 = (u32)~0;
+ vnet_sw_interface_t *swif;
+ dhcpv6_option_t *r0 = 0, *o;
+ u16 len = 0;
+ u8 interface_opt_flag = 0;
+ u8 relay_msg_opt_flag = 0;
+ ip6_main_t * im = &ip6_main;
+ u32 server_fib_idx, client_fib_idx;
+
+ bi0 = from[0];
+ from += 1;
+ n_left_from -= 1;
+
+ b0 = vlib_get_buffer (vm, bi0);
+ h0 = vlib_buffer_get_current (b0);
+
+ if (DHCPV6_MSG_RELAY_REPL != h0->msg_type)
+ {
+ error0 = DHCPV6_PROXY_ERROR_WRONG_MESSAGE_TYPE;
+
+ drop_packet:
+ vlib_node_increment_counter (vm, dhcpv6_proxy_to_client_node.index,
+ error0, 1);
+
+ f0 = vlib_get_frame_to_node (vm, dm->error_drop_node_index);
+ to_next0 = vlib_frame_vector_args (f0);
+ to_next0[0] = bi0;
+ f0->n_vectors = 1;
+ vlib_put_frame_to_node (vm, dm->error_drop_node_index, f0);
+ goto do_trace;
+ }
+ /* hop count seems not need to be checked */
+ if (HOP_COUNT_LIMIT < h0->hop_count)
+ {
+ error0 = DHCPV6_RELAY_PKT_DROP_MAX_HOPS;
+ goto drop_packet;
+ }
+ u0 = (void *)h0 -(sizeof(*u0));
+ ip0 = (void *)u0 -(sizeof(*ip0));
+
+ vlib_buffer_advance (b0, sizeof(*h0));
+ o = vlib_buffer_get_current (b0);
+
+ /* Parse through TLVs looking for option 18 (DHCPV6_OPTION_INTERFACE_ID)
+ _and_ option 9 (DHCPV6_OPTION_RELAY_MSG) option which must be there.
+ Currently assuming no other options need to be processed
+ The interface-ID is the FIB number we need
+ to track down the client-facing interface */
+
+ while ((u8 *) o < (b0->data + b0->current_data + b0->current_length))
+ {
+ if (DHCPV6_OPTION_INTERFACE_ID == clib_net_to_host_u16(o->option))
+ {
+ interface_opt_flag = 1;
+ if (clib_net_to_host_u16(o->length) == sizeof(sw_if_index))
+ sw_if_index = clib_net_to_host_u32(((dhcpv6_int_id_t*)o)->int_idx);
+ if (sw_if_index >= vec_len (im->fib_index_by_sw_if_index))
+ {
+ error0 = DHCPV6_PROXY_ERROR_WRONG_INTERFACE_ID_OPTION;
+ goto drop_packet;
+ }
+ }
+ if (DHCPV6_OPTION_RELAY_MSG == clib_net_to_host_u16(o->option))
+ {
+ relay_msg_opt_flag = 1;
+ r0 = vlib_buffer_get_current (b0);
+ }
+ if ((relay_msg_opt_flag == 1) && (interface_opt_flag == 1))
+ break;
+ vlib_buffer_advance (b0, sizeof(*o) + clib_net_to_host_u16(o->length));
+ o = (dhcpv6_option_t *) (((uword) o) + clib_net_to_host_u16(o->length) + sizeof(*o));
+ }
+
+ if ((relay_msg_opt_flag == 0) || (r0 == 0))
+ {
+ error0 = DHCPV6_PROXY_ERROR_NO_RELAY_MESSAGE_OPTION;
+ goto drop_packet;
+ }
+
+ if ((u32)~0 == sw_if_index)
+ {
+ error0 = DHCPV6_PROXY_ERROR_NO_CIRCUIT_ID_OPTION;
+ goto drop_packet;
+ }
+
+ //Advance buffer to start of encapsulated DHCPv6 message
+ vlib_buffer_advance (b0, sizeof(*r0));
+
+ client_fib_idx = im->fib_index_by_sw_if_index[sw_if_index];
+ server = dhcp_get_server(dm, client_fib_idx, FIB_PROTOCOL_IP6);
+
+ if (NULL == server)
+ {
+ 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]];
+
+ 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;
+ goto drop_packet;
+ }
+
+ vnet_buffer (b0)->sw_if_index[VLIB_TX] = original_sw_if_index
+ = sw_if_index;
+
+ swif = vnet_get_sw_interface (vnm, original_sw_if_index);
+ if (swif->flags & VNET_SW_INTERFACE_FLAG_UNNUMBERED)
+ sw_if_index = swif->unnumbered_sw_if_index;
+
+
+ /*
+ * udp_local hands us the DHCPV6 header, need udp hdr,
+ * ip hdr to relay to client
+ */
+ vlib_buffer_advance (b0, -(sizeof(*u1)));
+ u1 = vlib_buffer_get_current (b0);
+
+ vlib_buffer_advance (b0, -(sizeof(*ip1)));
+ ip1 = vlib_buffer_get_current (b0);
+
+ copy_ip6_address(&client_address, &h0->peer_addr);
+
+ ia0 = ip6_interface_first_address (&ip6_main, sw_if_index);
+ if (ia0 == 0)
+ {
+ error0 = DHCPV6_PROXY_ERROR_NO_INTERFACE_ADDRESS;
+ goto drop_packet;
+ }
+
+ len = clib_net_to_host_u16(r0->length);
+ memset(ip1, 0, sizeof(*ip1));
+ copy_ip6_address(&ip1->dst_address, &client_address);
+ u1->checksum = 0;
+ u1->src_port = clib_net_to_host_u16 (UDP_DST_PORT_dhcpv6_to_server);
+ u1->dst_port = clib_net_to_host_u16 (UDP_DST_PORT_dhcpv6_to_client);
+ u1->length = clib_host_to_net_u16 (len + sizeof(udp_header_t));
+
+ ip1->ip_version_traffic_class_and_flow_label =
+ ip0->ip_version_traffic_class_and_flow_label &
+ 0x00000fff;
+ ip1->payload_length = u1->length;
+ ip1->protocol = PROTO_UDP;
+ ip1->hop_limit = HOP_COUNT_LIMIT;
+ copy_ip6_address(&ip1->src_address, ia0);
+
+ u1->checksum = ip6_tcp_udp_icmp_compute_checksum(vm, b0, ip1,
+ &bogus_length);
+ ASSERT(bogus_length == 0);
+
+ vlib_buffer_advance (b0, -(sizeof(ethernet_header_t)));
+ si0 = vnet_get_sw_interface (vnm, original_sw_if_index);
+ if (si0->type == VNET_SW_INTERFACE_TYPE_SUB)
+ vlib_buffer_advance (b0, -4 /* space for VLAN tag */);
+
+ mac0 = vlib_buffer_get_current (b0);
+
+ hi0 = vnet_get_sup_hw_interface (vnm, original_sw_if_index);
+ ei0 = pool_elt_at_index (em->interfaces, hi0->hw_instance);
+ clib_memcpy (mac0->src_address, ei0->address, sizeof (ei0->address));
+ memset (&mac0->dst_address, 0xff, sizeof (mac0->dst_address));
+ mac0->type = (si0->type == VNET_SW_INTERFACE_TYPE_SUB) ?
+ clib_net_to_host_u16(0x8100) : clib_net_to_host_u16 (0x86dd);
+
+ if (si0->type == VNET_SW_INTERFACE_TYPE_SUB)
+ {
+ u32 * vlan_tag = (u32 *)(mac0+1);
+ u32 tmp;
+ tmp = (si0->sub.id << 16) | 0x0800;
+ *vlan_tag = clib_host_to_net_u32 (tmp);
+ }
+
+ /* $$$ consider adding a dynamic next to the graph node, for performance */
+ f0 = vlib_get_frame_to_node (vm, hi0->output_node_index);
+ to_next0 = vlib_frame_vector_args (f0);
+ to_next0[0] = bi0;
+ f0->n_vectors = 1;
+ vlib_put_frame_to_node (vm, hi0->output_node_index, f0);
+
+ do_trace:
+ if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED))
+ {
+ dhcpv6_proxy_trace_t *tr = vlib_add_trace (vm, node,
+ b0, sizeof (*tr));
+ tr->which = 1; /* to client */
+ if (ia0)
+ copy_ip6_address((ip6_address_t*)tr->packet_data, ia0);
+ tr->error = error0;
+ tr->original_sw_if_index = original_sw_if_index;
+ tr->sw_if_index = sw_if_index;
+ }
+ }
+ return from_frame->n_vectors;
+
+}
+
+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. */
+ .vector_size = sizeof (u32),
+
+ .n_errors = DHCPV6_PROXY_N_ERROR,
+ .error_strings = dhcpv6_proxy_error_strings,
+ .format_buffer = format_dhcpv6_proxy_header_with_length,
+ .format_trace = format_dhcpv6_proxy_trace,
+#if 0
+ .unformat_buffer = unformat_dhcpv6_proxy_header,
+#endif
+};
+
+static clib_error_t *
+dhcp6_proxy_init (vlib_main_t * vm)
+{
+ dhcp_proxy_main_t * dm = &dhcp_proxy_main;
+ vlib_node_t * error_drop_node;
+
+ error_drop_node = vlib_get_node_by_name (vm, (u8 *) "error-drop");
+ dm->error_drop_node_index = error_drop_node->index;
+
+ /* RFC says this is the dhcpv6 server address */
+ 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 */
+ 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 */);
+
+ udp_register_dst_port (vm, UDP_DST_PORT_dhcpv6_to_server,
+ dhcpv6_proxy_to_server_node.index, 0 /* is_ip6 */);
+
+ return 0;
+}
+
+VLIB_INIT_FUNCTION (dhcp6_proxy_init);
+
+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)
+{
+ u32 rx_fib_index = 0;
+ int rc = 0;
+
+ const mfib_prefix_t all_dhcp_servers = {
+ .fp_len = 128,
+ .fp_proto = FIB_PROTOCOL_IP6,
+ .fp_grp_addr = {
+ .ip6 = all_dhcpv6_server_relay_agent_address,
+ }
+ };
+
+ 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;
+
+ rx_fib_index = mfib_table_find_or_create_and_lock(FIB_PROTOCOL_IP6,
+ rx_table_id);
+
+ if (is_del)
+ {
+ rc = dhcp_proxy_server_del (FIB_PROTOCOL_IP6, rx_fib_index);
+
+ 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
+ {
+ 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);
+ }
+ }
+
+ mfib_table_unlock(rx_fib_index, FIB_PROTOCOL_IP6);
+
+ return (rc);
+}
+
+static clib_error_t *
+dhcpv6_proxy_set_command_fn (vlib_main_t * vm,
+ unformat_input_t * input,
+ vlib_cli_command_t * cmd)
+{
+ ip46_address_t addr, src_addr;
+ int set_server = 0, set_src_address = 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.ip6))
+ set_server = 1;
+ else if (unformat(input, "src-address %U",
+ unformat_ip6_address, &src_addr.ip6))
+ set_src_address =1;
+ else if (unformat (input, "server-fib-id %d", &server_table_id))
+ ;
+ else if (unformat (input, "rx-fib-id %d", &rx_table_id))
+ ;
+ else if (unformat (input, "delete") ||
+ unformat (input, "del"))
+ is_del = 1;
+ else
+ break;
+ }
+
+ if (is_del || (set_server && set_src_address))
+ {
+ int rv;
+
+ rv = dhcp6_proxy_set_server (&addr, &src_addr, rx_table_id,
+ server_table_id, is_del);
+
+ //TODO: Complete the errors
+ switch (rv)
+ {
+ case 0:
+ return 0;
+
+ 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);
+ }
+ }
+ else
+ return clib_error_return (0, "parse error`%U'",
+ format_unformat_error, input);
+}
+
+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> "
+ "[server-fib-id <fib-id>] [rx-fib-id <fib-id>] ",
+ .function = dhcpv6_proxy_set_command_fn,
+};
+
+static u8 *
+format_dhcp6_proxy_server (u8 * s, va_list * args)
+{
+ dhcp_server_t * server = va_arg (*args, dhcp_server_t *);
+ ip6_fib_t * rx_fib, * server_fib;
+
+ 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_fib_index);
+ rx_fib = ip6_fib_get(server->rx_fib_index);
+
+
+ s = format (s, "%=40U%=40U%=14u%=14u",
+ 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)
+{
+ vlib_cli_output (vm, "%U", format_dhcp6_proxy_server, NULL /* header line */);
+
+ dhcp_proxy_walk(FIB_PROTOCOL_IP6, dhcp6_proxy_show_walk, vm);
+
+ return (NULL);
+}
+
+VLIB_CLI_COMMAND (dhcpv6_proxy_show_command, static) = {
+ .path = "show dhcpv6 proxy",
+ .short_help = "Display dhcpv6 proxy info",
+ .function = dhcpv6_proxy_show_command_fn,
+};
+
+static clib_error_t *
+dhcpv6_vss_command_fn (vlib_main_t * vm,
+ unformat_input_t * input,
+ vlib_cli_command_t * cmd)
+{
+ int is_del = 0, got_new_vss=0;
+ u32 oui=0;
+ u32 fib_id=0, tbl_id=~0;
+
+ while (unformat_check_input(input) != UNFORMAT_END_OF_INPUT)
+ {
+ if (unformat (input, "oui %d", &oui))
+ got_new_vss = 1;
+ else if (unformat (input, "vpn-id %d", &fib_id))
+ got_new_vss = 1;
+ else if (unformat (input, "table %d", &tbl_id))
+ got_new_vss = 1;
+ else if (unformat(input, "delete") || unformat(input, "del"))
+ is_del = 1;
+ else
+ break;
+ }
+
+ if (tbl_id ==~0)
+ return clib_error_return (0, "no table ID specified.");
+
+ if (is_del || got_new_vss)
+ {
+ int rv;
+
+ rv = dhcp_proxy_set_vss(FIB_PROTOCOL_IP6, tbl_id, oui, fib_id, is_del);
+ switch (rv)
+ {
+ case 0:
+ return 0;
+
+ case VNET_API_ERROR_NO_SUCH_FIB:
+ return clib_error_return (0, "vss info (oui:%d, vpn-id:%d) not found in table %d.",
+ oui, fib_id, tbl_id);
+
+ case VNET_API_ERROR_NO_SUCH_ENTRY:
+ return clib_error_return (0, "vss for table %d not found in pool.",
+ tbl_id);
+
+ default:
+ return clib_error_return (0, "BUG: rv %d", rv);
+ }
+ }
+ else
+ return clib_error_return (0, "parse error`%U'",
+ format_unformat_error, input);
+
+}
+
+VLIB_CLI_COMMAND (dhcpv6_proxy_vss_command, static) = {
+ .path = "set dhcpv6 vss",
+ .short_help = "set dhcpv6 vss table <table-id> oui <oui> vpn-idx <vpn-idx>",
+ .function = dhcpv6_vss_command_fn,
+};
+
+static clib_error_t *
+dhcpv6_vss_show_command_fn (vlib_main_t * vm,
+ unformat_input_t * input,
+ vlib_cli_command_t * cmd)
+
+{
+ dhcp_vss_walk(FIB_PROTOCOL_IP6, dhcp_vss_show_walk, vm);
+
+ return (NULL);
+}
+
+VLIB_CLI_COMMAND (dhcpv6_proxy_vss_show_command, static) = {
+ .path = "show dhcpv6 vss",
+ .short_help = "show dhcpv6 VSS",
+ .function = dhcpv6_vss_show_command_fn,
+};
+
+static clib_error_t *
+dhcpv6_link_address_show_command_fn (vlib_main_t * vm,
+ unformat_input_t * input,
+ vlib_cli_command_t * cmd)
+
+{
+ vnet_main_t *vnm = vnet_get_main();
+ u32 sw_if_index0=0, sw_if_index;
+ 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, vnm, &sw_if_index0))
+ {
+ swif = vnet_get_sw_interface (vnm, sw_if_index0);
+ sw_if_index = (swif->flags & VNET_SW_INTERFACE_FLAG_UNNUMBERED) ?
+ swif->unnumbered_sw_if_index : sw_if_index0;
+ ia0 = ip6_interface_first_address(&ip6_main, sw_if_index);
+ if (ia0)
+ {
+ vlib_cli_output (vm, "%=20s%=48s", "interface", "link-address");
+
+ vlib_cli_output (vm, "%=20U%=48U",
+ 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, vnm, sw_if_index);
+ } else
+ break;
+ }
+
+ return 0;
+}
+
+VLIB_CLI_COMMAND (dhcpv6_proxy_address_show_command, static) = {
+ .path = "show dhcpv6 link-address interface",
+ .short_help = "show dhcpv6 link-address interface <interface>",
+ .function = dhcpv6_link_address_show_command_fn,
+};
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 */