| /* |
| * 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> |
| #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); |
| 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); |
| } |