/* * Copyright (c) 2015 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 #include #include #include dhcp_client_main_t dhcp_client_main; static u8 *format_dhcp_client_state (u8 * s, va_list * va); static vlib_node_registration_t dhcp_client_process_node; #define foreach_dhcp_sent_packet_stat \ _(DISCOVER, "DHCP discover packets sent") \ _(OFFER, "DHCP offer packets sent") \ _(REQUEST, "DHCP request packets sent") \ _(ACK, "DHCP ack packets sent") #define foreach_dhcp_error_counter \ _(NOT_FOR_US, "DHCP packets for other hosts, dropped") \ _(NAK, "DHCP nak packets received") \ _(NON_OFFER_DISCOVER, "DHCP non-offer packets in discover state") \ _(ODDBALL, "DHCP non-ack, non-offer packets received") \ _(BOUND, "DHCP bind success") typedef enum { #define _(sym,str) DHCP_STAT_##sym, foreach_dhcp_sent_packet_stat foreach_dhcp_error_counter #undef _ DHCP_STAT_UNKNOWN, DHCP_STAT_N_STAT, } sample_error_t; static char *dhcp_client_process_stat_strings[] = { #define _(sym,string) string, foreach_dhcp_sent_packet_stat foreach_dhcp_error_counter #undef _ "DHCP unknown packets sent", }; static void dhcp_client_acquire_address (dhcp_client_main_t * dcm, dhcp_client_t * c) { /* * Install any/all info gleaned from dhcp, right here */ ip4_add_del_interface_address (dcm->vlib_main, c->sw_if_index, (void *) &c->leased_address, c->subnet_mask_width, 0 /*is_del */ ); } static void dhcp_client_release_address (dhcp_client_main_t * dcm, dhcp_client_t * c) { /* * Remove any/all info gleaned from dhcp, right here. Caller(s) * have not wiped out the info yet. */ ip4_add_del_interface_address (dcm->vlib_main, c->sw_if_index, (void *) &c->leased_address, c->subnet_mask_width, 1 /*is_del */ ); } static void set_l2_rewrite (dhcp_client_main_t * dcm, dhcp_client_t * c) { /* Acquire the L2 rewrite string for the indicated sw_if_index */ c->l2_rewrite = vnet_build_rewrite_for_sw_interface (dcm->vnet_main, c->sw_if_index, VNET_LINK_IP4, 0 /* broadcast */ ); } void vl_api_rpc_call_main_thread (void *fp, u8 * data, u32 data_length); static void dhcp_client_proc_callback (uword * client_index) { vlib_main_t *vm = vlib_get_main (); ASSERT (vlib_get_thread_index () == 0); vlib_process_signal_event (vm, dhcp_client_process_node.index, EVENT_DHCP_CLIENT_WAKEUP, *client_index); } static void dhcp_client_addr_callback (dhcp_client_t * c) { dhcp_client_main_t *dcm = &dhcp_client_main; /* disable the feature */ vnet_feature_enable_disable ("ip4-unicast", "ip4-dhcp-client-detect", c->sw_if_index, 0 /* disable */ , 0, 0); c->client_detect_feature_enabled = 0; /* if renewing the lease, the address and route have already been added */ if (c->state == DHCP_BOUND) return; /* add the address to the interface */ dhcp_client_acquire_address (dcm, c); /* * Configure default IP route: */ if (c->router_address.as_u32) { fib_prefix_t all_0s = { .fp_len = 0, .fp_addr.ip4.as_u32 = 0x0, .fp_proto = FIB_PROTOCOL_IP4, }; ip46_address_t nh = { .ip4 = c->router_address, }; /* *INDENT-OFF* */ fib_table_entry_path_add ( fib_table_get_index_for_sw_if_index ( FIB_PROTOCOL_IP4, c->sw_if_index), &all_0s, FIB_SOURCE_DHCP, FIB_ENTRY_FLAG_NONE, DPO_PROTO_IP4, &nh, c->sw_if_index, ~0, 1, NULL, // no label stack FIB_ROUTE_PATH_FLAG_NONE); /* *INDENT-ON* */ } /* * Call the user's event callback to report DHCP information */ if (c->event_callback) c->event_callback (c->client_index, c); } /* * dhcp_client_for_us - server-to-client callback. * Called from proxy_node.c:dhcp_proxy_to_client_input(). * This function first decides that the packet in question is * actually for the dhcp client code in case we're also acting as * a dhcp proxy. Ay caramba, what a folly! */ int dhcp_client_for_us (u32 bi, vlib_buffer_t * b, ip4_header_t * ip, udp_header_t * udp, dhcp_header_t * dhcp) { dhcp_client_main_t *dcm = &dhcp_client_main; vlib_main_t *vm = dcm->vlib_main; dhcp_client_t *c; uword *p; f64 now = vlib_time_now (dcm->vlib_main); u8 dhcp_message_type = 0; dhcp_option_t *o; /* * Doing dhcp client on this interface? * Presumably we will always receive dhcp clnt for-us pkts on * the interface that's asking for an address. */ p = hash_get (dcm->client_by_sw_if_index, vnet_buffer (b)->sw_if_index[VLIB_RX]); if (p == 0) return 0; /* no */ c = pool_elt_at_index (dcm->clients, p[0]); /* Mixing dhcp relay and dhcp proxy? DGMS... */ if (c->state == DHCP_BOUND && c->retry_count == 0) return 0; /* Packet not for us? Turf it... */ if (memcmp (dhcp->client_hardware_address, c->client_hardware_address, sizeof (c->client_hardware_address))) { vlib_node_increment_counter (vm, dhcp_client_process_node.index, DHCP_STAT_NOT_FOR_US, 1); return 0; } /* parse through the packet, learn what we can */ if (dhcp->your_ip_address.as_u32) c->leased_address.as_u32 = dhcp->your_ip_address.as_u32; c->dhcp_server.as_u32 = dhcp->server_ip_address.as_u32; o = (dhcp_option_t *) dhcp->options; while (o->option != 0xFF /* end of options */ && (u8 *) o < (b->data + b->current_data + b->current_length)) { switch (o->option) { case 53: /* dhcp message type */ dhcp_message_type = o->data[0]; break; case 51: /* lease time */ { u32 lease_time_in_seconds = clib_host_to_net_u32 (o->data_as_u32[0]); // for debug: lease_time_in_seconds = 20; /*$$$$*/ c->lease_expires = now + (f64) lease_time_in_seconds; c->lease_lifetime = lease_time_in_seconds; /* Set a sensible default, in case we don't get opt 58 */ c->lease_renewal_interval = lease_time_in_seconds / 2; } break; case 58: /* lease renew time in seconds */ { u32 lease_renew_time_in_seconds = clib_host_to_net_u32 (o->data_as_u32[0]); c->lease_renewal_interval = lease_renew_time_in_seconds; } break; case 54: /* dhcp server address */ c->dhcp_server.as_u32 = o->data_as_u32[0]; break; case 1: /* subnet mask */ { u32 subnet_mask = clib_host_to_net_u32 (o->data_as_u32[0]); c->subnet_mask_width = count_set_bits (subnet_mask); } break; case 3: /* router address */ { u32 router_address = o->data_as_u32[0]; c->router_address.as_u32 = router_address; } break; case 12: /* hostname */ { /* Replace the existing hostname if necessary */ vec_free (c->hostname); vec_validate (c->hostname, o->length - 1); clib_memcpy (c->hostname, o->data, o->length); } break; /* $$$$ Your message in this space, parse more options */ default: break; } o = (dhcp_option_t *) (((uword) o) + (o->length + 2)); } switch (c->state) { case DHCP_DISCOVER: if (dhcp_message_type != DHCP_PACKET_OFFER) { vlib_node_increment_counter (vm, dhcp_client_process_node.index, DHCP_STAT_NON_OFFER_DISCOVER, 1); c->next_transmit = now + 5.0; break; } /* Received an offer, go send a request */ c->state = DHCP_REQUEST; c->retry_count = 0; c->next_transmit = 0; /* send right now... */ /* Poke the client process, which will send the request */ uword client_id = c - dcm->clients; vl_api_rpc_call_main_thread (dhcp_client_proc_callback, (u8 *) & client_id, sizeof (uword)); break; case DHCP_BOUND: case DHCP_REQUEST: if (dhcp_message_type == DHCP_PACKET_NAK) { vlib_node_increment_counter (vm, dhcp_client_process_node.index, DHCP_STAT_NAK, 1); /* Probably never happens in bound state, but anyhow... */ if (c->state == DHCP_BOUND) { ip4_add_del_interface_address (dcm->vlib_main, c->sw_if_index, (void *) &c->leased_address, c->subnet_mask_width, 1 /*is_del */ ); vnet_feature_enable_disable ("ip4-unicast", "ip4-dhcp-client-detect", c->sw_if_index, 1 /* enable */ , 0, 0); c->client_detect_feature_enabled = 1; } /* Wipe out any memory of the address we had... */ c->state = DHCP_DISCOVER; c->next_transmit = now; c->retry_count = 0; c->leased_address.as_u32 = 0; c->subnet_mask_width = 0; c->router_address.as_u32 = 0; c->lease_renewal_interval = 0; c->dhcp_server.as_u32 = 0; break; } if (dhcp_message_type != DHCP_PACKET_ACK && dhcp_message_type != DHCP_PACKET_OFFER) { vlib_node_increment_counter (vm, dhcp_client_process_node.index, DHCP_STAT_NON_OFFER_DISCOVER, 1); clib_warning ("sw_if_index %d state %U message type %d", c->sw_if_index, format_dhcp_client_state, c->state, dhcp_message_type); c->next_transmit = now + 5.0; break; } /* OK, we own the address (etc), add to the routing table(s) */ vl_api_rpc_call_main_thread (dhcp_client_addr_callback, (u8 *) c, sizeof (*c)); c->state = DHCP_BOUND; c->retry_count = 0; c->next_transmit = now + (f64) c->lease_renewal_interval; c->lease_expires = now + (f64) c->lease_lifetime; vlib_node_increment_counter (vm, dhcp_client_process_node.index, DHCP_STAT_BOUND, 1); break; default: clib_warning ("client %d bogus state %d", c - dcm->clients, c->state); break; } /* drop the pkt, return 1 */ vlib_buffer_free (vm, &bi, 1); return 1; } static void send_dhcp_pkt (dhcp_client_main_t * dcm, dhcp_client_t * c, dhcp_packet_type_t type, int is_broadcast) { vlib_main_t *vm = dcm->vlib_main; vnet_main_t *vnm = dcm->vnet_main; vnet_hw_interface_t *hw = vnet_get_sup_hw_interface (vnm, c->sw_if_index); vnet_sw_interface_t *sup_sw = vnet_get_sup_sw_interface (vnm, c->sw_if_index); vnet_sw_interface_t *sw = vnet_get_sw_interface (vnm, c->sw_if_index); vlib_buffer_t *b; u32 bi; ip4_header_t *ip; udp_header_t *udp; dhcp_header_t *dhcp; u32 *to_next; vlib_frame_t *f; dhcp_option_t *o; u16 udp_length, ip_length; u32 counter_index; /* Interface(s) down? */ if ((hw->flags & VNET_HW_INTERFACE_FLAG_LINK_UP) == 0) return; if ((sup_sw->flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) == 0) return; if ((sw->flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) == 0) return; if (vlib_buffer_alloc (vm, &bi, 1) != 1) { clib_warning ("buffer allocation failure"); c->next_transmit = 0; return; } /* Build a dhcpv4 pkt from whole cloth */ b = vlib_get_buffer (vm, bi); ASSERT (b->current_data == 0); vnet_buffer (b)->sw_if_index[VLIB_RX] = c->sw_if_index; if (is_broadcast) { f = vlib_get_frame_to_node (vm, hw->output_node_index); vnet_buffer (b)->sw_if_index[VLIB_TX] = c->sw_if_index; clib_memcpy (b->data, c->l2_rewrite, vec_len (c->l2_rewrite)); ip = (void *) (((u8 *) vlib_buffer_get_current (b)) + vec_len (c->l2_rewrite)); } else { f = vlib_get_frame_to_node (vm, ip4_lookup_node.index); vnet_buffer (b)->sw_if_index[VLIB_TX] = ~0; /* use interface VRF */ ip = vlib_buffer_get_current (b); } /* Enqueue the packet right now */ to_next = vlib_frame_vector_args (f); to_next[0] = bi; f->n_vectors = 1; if (is_broadcast) vlib_put_frame_to_node (vm, hw->output_node_index, f); else vlib_put_frame_to_node (vm, ip4_lookup_node.index, f); udp = (udp_header_t *) (ip + 1); dhcp = (dhcp_header_t *) (udp + 1); /* $$$ optimize, maybe */ clib_memset (ip, 0, sizeof (*ip) + sizeof (*udp) + sizeof (*dhcp)); ip->ip_version_and_header_length = 0x45; ip->ttl = 128; ip->protocol = IP_PROTOCOL_UDP; if (is_broadcast) { /* src = 0.0.0.0, dst = 255.255.255.255 */ ip->dst_address.as_u32 = ~0; } else { /* Renewing an active lease, plain old ip4 src/dst */ ip->src_address.as_u32 = c->leased_address.as_u32; ip->dst_address.as_u32 = c->dhcp_server.as_u32; } udp->src_port = clib_host_to_net_u16 (UDP_DST_PORT_dhcp_to_client); udp->dst_port = clib_host_to_net_u16 (UDP_DST_PORT_dhcp_to_server); /* Send the interface MAC address */ clib_memcpy (dhcp->client_hardware_address, c->l2_rewrite + 6, 6); /* And remember it for rx-packet-for-us checking */ clib_memcpy (c->client_hardware_address, dhcp->client_hardware_address, sizeof (c->client_hardware_address)); /* Lease renewal, set up client_ip_address */ if (is_broadcast == 0) dhcp->client_ip_address.as_u32 = c->leased_address.as_u32; dhcp->opcode = 1; /* request, all we send */ dhcp->hardware_type = 1; /* ethernet */ dhcp->hardware_address_length = 6; dhcp->transaction_identifier = c->transaction_id; dhcp->flags = clib_host_to_net_u16 (is_broadcast && c->set_broadcast_flag ? DHCP_FLAG_BROADCAST : 0); dhcp->magic_cookie.as_u32 = DHCP_MAGIC; o = (dhcp_option_t *) dhcp->options; /* Send option 53, the DHCP message type */ o->option = DHCP_PACKET_OPTION_MSG_TYPE; o->length = 1; o->data[0] = type; o = (dhcp_option_t *) (((uword) o) + (o->length + 2)); /* Send option 57, max msg length */ if (0 /* not needed, apparently */ ) { o->option = 57; o->length = 2; { u16 *o2 = (u16 *) o->data; *o2 = clib_host_to_net_u16 (1152); o = (dhcp_option_t *) (((uword) o) + (o->length + 2)); } } /* * If server ip address is available with non-zero value, * option 54 (DHCP Server Identifier) is sent. */ if (c->dhcp_server.as_u32) { o->option = 54; o->length = 4; clib_memcpy (o->data, &c->dhcp_server.as_u32, 4); o = (dhcp_option_t *) (((uword) o) + (o->length + 2)); } /* send option 50, requested IP address */ if (c->leased_address.as_u32) { o->option = 50; o->length = 4; clib_memcpy (o->data, &c->leased_address.as_u32, 4); o = (dhcp_option_t *) (((uword) o) + (o->length + 2)); } /* send option 12, host name */ if (vec_len (c->hostname)) { o->option = 12; o->length = vec_len (c->hostname); clib_memcpy (o->data, c->hostname, vec_len (c->hostname)); o = (dhcp_option_t *) (((uword) o) + (o->length + 2)); } /* send option 61, client_id */ if (vec_len (c->client_identifier)) { o->option = 61; o->length = vec_len (c->client_identifier); clib_memcpy (o->data, c->client_identifier, vec_len (c->client_identifier)); o = (dhcp_option_t *) (((uword) o) + (o->length + 2)); } /* $$ maybe send the client s/w version if anyone cares */ /* * send option 55, parameter request list * The current list - see below, matches the Linux dhcp client's list * Any specific dhcp server config and/or dhcp server may or may * not yield specific options. */ o->option = 55; o->length = vec_len (c->option_55_data); clib_memcpy (o->data, c->option_55_data, vec_len (c->option_55_data)); o = (dhcp_option_t *) (((uword) o) + (o->length + 2)); /* End of list */ o->option = 0xff; o->length = 0; o++; b->current_length = ((u8 *) o) - b->data; /* fix ip length, checksum and udp length */ ip_length = vlib_buffer_length_in_chain (vm, b); if (is_broadcast) ip_length -= vec_len (c->l2_rewrite); ip->length = clib_host_to_net_u16 (ip_length); ip->checksum = ip4_header_checksum (ip); udp_length = ip_length - (sizeof (*ip)); udp->length = clib_host_to_net_u16 (udp_length); switch (type) { #define _(a,b) case DHCP_PACKET_##a: {counter_index = DHCP_STAT_##a; break;} foreach_dhcp_sent_packet_stat #undef _ default: coun
/*
 * Copyright (c) 2019 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 <vppinfra/llist.h>
#include <vlib/vlib.h>

#define LLIST_TEST_I(_cond, _comment, _args...)			\
({								\
  int _evald = (_cond);						\
  if (!(_evald)) {						\
    fformat(stderr, "FAIL:%d: " _comment "\n",			\
	    __LINE__, ##_args);					\
  } else {							\
    fformat(stderr, "PASS:%d: " _comment "\n",			\
	    __LINE__, ##_args);					\
  }								\
  _evald;							\
})

#define LLIST_TEST(_cond, _comment, _args...)			\
{								\
    if (!LLIST_TEST_I(_cond, _comment, ##_args)) {		\
	return 1;                                               \
    }								\
}

typedef struct list_elt
{
  clib_llist_anchor_t ll_test;
  clib_llist_anchor_t ll_test2;
  u32 data;
} list_elt_t;

#define list_elt_is_sane(pl,name,E,P,N)					\
 (E->name.next == (N) - pl 						\
  && E->name.prev == (P) - pl 						\
  && P->name.next == (E) - pl 						\
  && N->name.prev == (E) - pl)

#define list_test_is_sane(pl,name,h)					\
do {									\
  typeof (pl) e;							\
  int rv;								\
  clib_llist_foreach (pl, name, h, e, ({					\
    rv = list_elt_is_sane ((pl), name, (e),				\
			   clib_llist_prev (pl,name,e),			\
                           clib_llist_next (pl,name,e));			\
    if (!rv)								\
      LLIST_TEST (0, "invalid elt %u prev %u/%u next %u/%u", e - pl, 	\
                  e->name.prev, clib_llist_prev (pl,name,e) - pl,		\
                  e->name.next, clib_llist_next (pl,name,e) - pl);		\
  }));									\
} while (0)

static int
llist_test_basic (vlib_main_t * vm, unformat_input_t * input)
{
  list_elt_t *pelts = 0, *he, *he2, *he3, *e, *next, *nnext;
  int __clib_unused verbose, i, rv;
  clib_llist_index_t head, head2, head3;
  u32 old_tail;

  while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
    {
      if (unformat (input, "verbose"))
	verbose = 1;
      else
	{
	  vlib_cli_output (vm, "parse error: '%U'", format_unformat_error,
			   input);
	  return -1;
	}
    }

  head = clib_llist_make_head (pelts, ll_test);
  he = pool_elt_at_index (pelts, head);

  LLIST_TEST (he->ll_test.next == head, "head next points to itself");
  LLIST_TEST