diff options
Diffstat (limited to 'src/plugins/dhcp/dhcp_proxy.c')
| -rw-r--r-- | src/plugins/dhcp/dhcp_proxy.c | 375 |
1 files changed, 375 insertions, 0 deletions
diff --git a/src/plugins/dhcp/dhcp_proxy.c b/src/plugins/dhcp/dhcp_proxy.c new file mode 100644 index 00000000000..1890c874b61 --- /dev/null +++ b/src/plugins/dhcp/dhcp_proxy.c @@ -0,0 +1,375 @@ +/* + * 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 <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_proxy_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; + 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]; + if (~0 == vss_index) + continue; + + vss = pool_elt_at_index (dpm->vss[proto], vss_index); + + if (FIB_PROTOCOL_IP4 == proto) + { + fib = fib_table_get (i, proto); + + 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, + ip46_address_t * addr, u32 server_table_id) +{ + dhcp_proxy_main_t *dpm = &dhcp_proxy_main; + dhcp_proxy_t *proxy = 0; + + proxy = dhcp_get_proxy (dpm, rx_fib_index, proto); + + if (NULL != proxy) + { + dhcp_server_t *server; + u32 index; + + index = dhcp_proxy_server_find (proxy, proto, addr, server_table_id); + + 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); + } + } + } + + /* the proxy still exists */ + return (0); +} + +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_proxy_t *proxy = 0; + int new = 0; + + proxy = dhcp_get_proxy (dpm, rx_fib_index, proto); + + 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], proxy); + clib_memset (proxy, 0, sizeof (*proxy)); + new = 1; + + dpm->dhcp_server_index_by_rx_fib_index[proto][rx_fib_index] = + proxy - dpm->dhcp_servers[proto]; + + proxy->dhcp_src_address = *src_address; + proxy->rx_fib_index = rx_fib_index; + } + else + { + if (~0 != dhcp_proxy_server_find (proxy, proto, addr, server_table_id)) + { + return (new); + } + } + + 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); +} + +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_proxy_t * proxy, void *arg) +{ + dhcp_proxy_dump_walk_cxt_t *ctx = arg; + + dhcp_send_details (ctx->proto, ctx->opaque, ctx->context, proxy); + + 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; + + if (vss->vss_type == VSS_TYPE_VPN_ID) + { + u32 oui = ((u32) vss->vpn_id[0] << 16) + ((u32) vss->vpn_id[1] << 8) + + ((u32) vss->vpn_id[2]); + u32 fib_id = ((u32) vss->vpn_id[3] << 24) + ((u32) vss->vpn_id[4] << 16) + + ((u32) vss->vpn_id[5] << 8) + ((u32) vss->vpn_id[6]); + vlib_cli_output (vm, " fib_table: %d oui: %d vpn_index: %d", + rx_table_id, oui, fib_id); + } + else if (vss->vss_type == VSS_TYPE_ASCII) + vlib_cli_output (vm, " fib_table: %d vpn_id: %s", + rx_table_id, vss->vpn_ascii_id); + else + vlib_cli_output (vm, " fib_table: %d default global vpn", rx_table_id); + + return (1); +} + +void +update_vss (dhcp_vss_t * v, + u8 vss_type, u8 * vpn_ascii_id, u32 oui, u32 vpn_index) +{ + v->vss_type = vss_type; + if (v->vpn_ascii_id) + { + if (v->vpn_ascii_id == (u8 *) ~ 0) + v->vpn_ascii_id = 0; + else + vec_free (v->vpn_ascii_id); + } + + if (vss_type == VSS_TYPE_ASCII) + v->vpn_ascii_id = vpn_ascii_id; + else if (vss_type == VSS_TYPE_VPN_ID) + { + v->vpn_id[0] = (oui >> 16) & 0xff; + v->vpn_id[1] = (oui >> 8) & 0xff; + v->vpn_id[2] = (oui >> 0) & 0xff; + v->vpn_id[3] = (vpn_index >> 24) & 0xff; + v->vpn_id[4] = (vpn_index >> 16) & 0xff; + v->vpn_id[5] = (vpn_index >> 8) & 0xff; + v->vpn_id[6] = (vpn_index >> 0) & 0xff; + } +} + +int +dhcp_proxy_set_vss (fib_protocol_t proto, + u32 tbl_id, + u8 vss_type, + u8 * vpn_ascii_id, u32 oui, u32 vpn_index, u8 is_del) +{ + dhcp_proxy_main_t *dm = &dhcp_proxy_main; + dhcp_vss_t *v = NULL; + u32 rx_fib_index; + int rc = 0; + + 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) + { + if (is_del) + { + /* release the lock held on the table when the VSS + * info was created */ + dhcp_proxy_rx_table_unlock (proto, rx_fib_index); + + vec_free (v->vpn_ascii_id); + pool_put (dm->vss[proto], v); + dm->vss_index_by_rx_fib_index[proto][rx_fib_index] = ~0; + } + else + { + update_vss (v, vss_type, vpn_ascii_id, oui, vpn_index); + } + } + 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 */ + pool_get (dm->vss[proto], v); + update_vss (v, vss_type, vpn_ascii_id, oui, vpn_index); + 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 */ + dhcp_proxy_rx_table_unlock (proto, rx_fib_index); + + return (rc); +} + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ |