#include <vnet/dhcp/dhcp_proxy.h>
#include <vnet/fib/fib_table.h>
+#include <vnet/mfib/mfib_table.h>
/**
* @brief Shard 4/6 instance of DHCP main
*/
dhcp_proxy_main_t dhcp_proxy_main;
+static void
+dhcp_proxy_rx_table_lock (fib_protocol_t proto,
+ u32 fib_index)
+{
+ if (FIB_PROTOCOL_IP4 == proto)
+ fib_table_lock(fib_index, proto, FIB_SOURCE_DHCP);
+ else
+ mfib_table_lock(fib_index, proto, MFIB_SOURCE_DHCP);
+}
+
+static void
+dhcp_proxy_rx_table_unlock (fib_protocol_t proto,
+ u32 fib_index)
+{
+ if (FIB_PROTOCOL_IP4 == proto)
+ fib_table_unlock(fib_index, proto, FIB_SOURCE_DHCP);
+ else
+ mfib_table_unlock(fib_index, proto, MFIB_SOURCE_DHCP);
+}
+
+ u32
+dhcp_proxy_rx_table_get_table_id (fib_protocol_t proto,
+ u32 fib_index)
+{
+ if (FIB_PROTOCOL_IP4 == proto)
+ {
+ fib_table_t *fib;
+
+ fib = fib_table_get(fib_index, proto);
+
+ return (fib->ft_table_id);
+ }
+ else
+ {
+ mfib_table_t *mfib;
+
+ mfib = mfib_table_get(fib_index, proto);
+
+ return (mfib->mft_table_id);
+ }
+}
+
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;
+ dhcp_proxy_t * server;
u32 server_index, i;
vec_foreach_index (i, dpm->dhcp_server_index_by_rx_fib_index[proto])
void *ctx)
{
dhcp_proxy_main_t * dpm = &dhcp_proxy_main;
+ mfib_table_t *mfib;
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];
vss = pool_elt_at_index (dpm->vss[proto], vss_index);
- fib = fib_table_get(i, proto);
+ if (FIB_PROTOCOL_IP4 == proto)
+ {
+ fib = fib_table_get(i, proto);
- if (!fn(vss, fib->ft_table_id, ctx))
- break;
+ if (!fn(vss, fib->ft_table_id, ctx))
+ break;
+ }
+ else
+ {
+ mfib = mfib_table_get(i, proto);
+
+ if (!fn(vss, mfib->mft_table_id, ctx))
+ break;
+ }
+ }
+}
+
+static u32
+dhcp_proxy_server_find (dhcp_proxy_t *proxy,
+ fib_protocol_t proto,
+ ip46_address_t *addr,
+ u32 server_table_id)
+{
+ dhcp_server_t *server;
+ u32 ii, fib_index;
+
+ vec_foreach_index(ii, proxy->dhcp_servers)
+ {
+ server = &proxy->dhcp_servers[ii];
+ fib_index = fib_table_find(proto, server_table_id);
+
+ if (ip46_address_is_equal(&server->dhcp_server,
+ addr) &&
+ (server->server_fib_index == fib_index))
+ {
+ return (ii);
+ }
}
+ return (~0);
}
int
dhcp_proxy_server_del (fib_protocol_t proto,
- u32 rx_fib_index)
+ u32 rx_fib_index,
+ ip46_address_t *addr,
+ u32 server_table_id)
{
dhcp_proxy_main_t * dpm = &dhcp_proxy_main;
- dhcp_server_t * server = 0;
- int rc = 0;
+ dhcp_proxy_t *proxy = 0;
- server = dhcp_get_server(dpm, rx_fib_index, proto);
+ proxy = dhcp_get_proxy(dpm, rx_fib_index, proto);
- if (NULL == server)
+ if (NULL != proxy)
{
- 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;
+ dhcp_server_t *server;
+ u32 index;
- fib_table_unlock (server->server_fib_index, proto);
+ index = dhcp_proxy_server_find(proxy, proto, addr, server_table_id);
- pool_put (dpm->dhcp_servers[proto], server);
+ if (~0 != index)
+ {
+ server = &proxy->dhcp_servers[index];
+ fib_table_unlock (server->server_fib_index, proto, FIB_SOURCE_DHCP);
+
+ vec_del1(proxy->dhcp_servers, index);
+
+ if (0 == vec_len(proxy->dhcp_servers))
+ {
+ /* no servers left, delete the proxy config */
+ dpm->dhcp_server_index_by_rx_fib_index[proto][rx_fib_index] = ~0;
+ vec_free(proxy->dhcp_servers);
+ pool_put (dpm->dhcp_servers[proto], proxy);
+ return (1);
+ }
+ }
}
- return (rc);
+ /* the proxy still exists */
+ return (0);
}
int
u32 server_table_id)
{
dhcp_proxy_main_t * dpm = &dhcp_proxy_main;
- dhcp_server_t * server = 0;
+ dhcp_proxy_t * proxy = 0;
int new = 0;
- server = dhcp_get_server(dpm, rx_fib_index, proto);
+ proxy = dhcp_get_proxy(dpm, rx_fib_index, proto);
- if (NULL == server)
+ if (NULL == proxy)
{
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));
+ pool_get (dpm->dhcp_servers[proto], proxy);
+ memset (proxy, 0, sizeof (*proxy));
new = 1;
dpm->dhcp_server_index_by_rx_fib_index[proto][rx_fib_index] =
- server - dpm->dhcp_servers[proto];
+ proxy - 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);
+ proxy->dhcp_src_address = *src_address;
+ proxy->rx_fib_index = rx_fib_index;
}
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)
+ if (~0 != dhcp_proxy_server_find(proxy, proto, addr, server_table_id))
{
- 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);
+ return (new);
}
}
- server->dhcp_server = *addr;
- server->dhcp_src_address = *src_address;
+ dhcp_server_t server = {
+ .dhcp_server = *addr,
+ .server_fib_index = fib_table_find_or_create_and_lock(proto,
+ server_table_id,
+ FIB_SOURCE_DHCP),
+ };
+
+ vec_add1(proxy->dhcp_servers, server);
return (new);
}
} dhcp_proxy_dump_walk_cxt_t;
static int
-dhcp_proxy_dump_walk (dhcp_server_t *server,
+dhcp_proxy_dump_walk (dhcp_proxy_t *proxy,
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));
+ proxy);
return (1);
}
u32 rx_fib_index;
int rc = 0;
- rx_fib_index = fib_table_find_or_create_and_lock(proto, tbl_id);
+ if (proto == FIB_PROTOCOL_IP4)
+ rx_fib_index = fib_table_find_or_create_and_lock(proto, tbl_id,
+ FIB_SOURCE_DHCP);
+ else
+ rx_fib_index = mfib_table_find_or_create_and_lock(proto, tbl_id,
+ MFIB_SOURCE_DHCP);
v = dhcp_get_vss_info(dm, rx_fib_index, proto);
if (NULL != v)
{
/* release the lock held on the table when the VSS
* info was created */
- fib_table_unlock (rx_fib_index, proto);
+ dhcp_proxy_rx_table_unlock (proto, rx_fib_index);
pool_put (dm->vss[proto], v);
dm->vss_index_by_rx_fib_index[proto][rx_fib_index] = ~0;
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];
+ dhcp_proxy_rx_table_lock (proto, rx_fib_index);
}
}
/* Release the lock taken during the create_or_lock at the start */
- fib_table_unlock (rx_fib_index, proto);
-
+ dhcp_proxy_rx_table_unlock (proto, rx_fib_index);
+
return (rc);
}
Code Review / vpp.git / blobdiff