40 #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__) 58 if (ni == (
uword) ~ 0)
114 u32 dhcp_opt_len = 0;
134 if (src_addr.
as_u8[0] != 0xfe)
136 clib_warning (
"Could not find source address to send DHCPv6 packet");
153 b->
flags |= VNET_BUFFER_F_LOCALLY_ORIGINATED;
162 clib_host_to_net_u32 (0x6 << 28);
176 void *d = (
void *) dhcp->
data;
177 dhcpv6_option_t *duid;
178 dhcpv6_elapsed_t *elapsed;
179 dhcpv6_ia_header_t *ia_hdr;
180 dhcpv6_ia_opt_addr_t *opt_addr;
185 duid = (dhcpv6_option_t *) d;
186 duid->option = clib_host_to_net_u16 (DHCPV6_OPTION_CLIENTID);
196 duid = (dhcpv6_option_t *) d;
197 duid->option = clib_host_to_net_u16 (DHCPV6_OPTION_SERVERID);
198 duid->length = clib_host_to_net_u16 (se->
len);
200 d +=
sizeof (*duid) + se->
len;
203 elapsed = (dhcpv6_elapsed_t *) d;
204 elapsed->opt.option = clib_host_to_net_u16 (DHCPV6_OPTION_ELAPSED_TIME);
205 elapsed->opt.length =
206 clib_host_to_net_u16 (
sizeof (*elapsed) -
sizeof (elapsed->opt));
207 elapsed->elapsed_10ms = 0;
209 (
char *) &elapsed->elapsed_10ms -
211 d +=
sizeof (*elapsed);
213 ia_hdr = (dhcpv6_ia_header_t *) d;
214 ia_hdr->opt.option = clib_host_to_net_u16 (DHCPV6_OPTION_IA_NA);
216 ia_hdr->t1 = clib_host_to_net_u32 (client_state->
params.
T1);
217 ia_hdr->t2 = clib_host_to_net_u32 (client_state->
params.
T2);
218 d +=
sizeof (*ia_hdr);
223 clib_host_to_net_u16 (
sizeof (*ia_hdr) +
224 n_addresses *
sizeof (*opt_addr) -
225 sizeof (ia_hdr->opt));
227 for (i = 0; i < n_addresses; i++)
231 opt_addr = (dhcpv6_ia_opt_addr_t *) d;
232 opt_addr->opt.option = clib_host_to_net_u16 (DHCPV6_OPTION_IAADDR);
233 opt_addr->opt.length =
234 clib_host_to_net_u16 (
sizeof (*opt_addr) -
235 sizeof (opt_addr->opt));
236 opt_addr->addr = addr->
address;
237 opt_addr->valid = clib_host_to_net_u32 (addr->
valid_lt);
238 opt_addr->preferred = clib_host_to_net_u32 (addr->
preferred_lt);
239 d +=
sizeof (*opt_addr);
247 dhcp_opt_len = ((
u8 *) d) - dhcp->
data;
249 clib_host_to_net_u16 (
sizeof (*udp) +
sizeof (*dhcp) + dhcp_opt_len);
252 sizeof (*ip) +
sizeof (*udp) +
sizeof (*dhcp) + dhcp_opt_len;
262 f64 current_time,
f64 * due_time)
272 int bogus_length = 0;
281 params = &client_state->
params;
283 if (client_state->
due_time > current_time)
289 p0 = client_state->
buffer;
301 clib_host_to_net_u16 ((
u16)
314 if (params->
mrc != 0 && --client_state->
n_left == 0)
343 uword *event_data = 0;
344 f64 sleep_time = 1e9;
359 due_time = current_time + 1e9;
366 (vm, client_state, current_time, &dt) && (dt < due_time))
371 while (due_time < current_time);
373 sleep_time = due_time - current_time;
383 .name =
"send-dhcp6-client-message-process",
395 ASSERT (~0 != sw_if_index);
412 client_state->
params = *params;
423 if (!client_state->
buffer)
436 vl_api_dhcp6_send_client_message_reply_t *rmp;
446 REPLY_MACRO (VL_API_DHCP6_SEND_CLIENT_MESSAGE_REPLY);
453 params.
irt = ntohl (mp->
irt);
454 params.
mrt = ntohl (mp->
mrt);
455 params.
mrc = ntohl (mp->
mrc);
456 params.
mrd = ntohl (mp->
mrd);
458 params.
T1 = ntohl (mp->
T1);
459 params.
T2 = ntohl (mp->
T2);
464 for (i = 0; i < n_addresses; i++)
478 _vnet_dhcp6_reply_event_function_list_elt_t
485 error = elt->fp (data);
488 elt = elt->next_dhcp6_reply_event_function;
512 for (i = 0; i <
vec_len (events); i++)
516 vec_len (events[i].addresses) *
521 event->sw_if_index = htonl (events[i].body.sw_if_index);
522 event->server_index = htonl (events[i].body.server_index);
524 event->T1 = htonl (events[i].body.T1);
525 event->T2 = htonl (events[i].body.T2);
526 event->inner_status_code =
527 htons (events[i].body.inner_status_code);
528 event->status_code = htons (events[i].body.status_code);
531 event->n_addresses = htonl (vec_len (events[i].addresses));
533 (typeof (address)) event->addresses;
535 for (j = 0; j <
vec_len (events[i].addresses); j++)
553 vl_api_registration_t *vl_reg;
555 vl_api_client_index_to_registration (reg->client_index);
556 if (vl_reg && vl_api_can_send_msg (vl_reg))
558 vl_api_dhcp6_reply_event_t *msg =
559 vl_msg_api_alloc (event_size);
560 clib_memcpy (msg, event, event_size);
561 msg->_vl_msg_id = htons (VL_API_DHCP6_REPLY_EVENT);
562 msg->client_index = reg->client_index;
563 msg->pid = reg->client_pid;
564 vl_api_send_msg (vl_reg, (u8 *) msg);
582 .name =
"dhcp6-reply-publisher-process",
591 vl_api_want_dhcp6_reply_events_reply_t *rmp;
602 rv = VNET_API_ERROR_INVALID_REGISTRATION;
608 pool_put (am->dhcp6_reply_events_registrations, rp);
609 hash_unset (am->dhcp6_reply_events_registration_hash,
611 if (
pool_elts (am->dhcp6_reply_events_registrations) == 0)
619 rv = VNET_API_ERROR_INVALID_REGISTRATION;
622 pool_get (am->dhcp6_reply_events_registrations, rp);
626 rp - am->dhcp6_reply_events_registrations);
631 REPLY_MACRO (VL_API_WANT_DHCP6_REPLY_EVENTS_REPLY);
644 cm->
seed = 0xdeaccabe;
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
u32 flags
buffer flags: VLIB_BUFFER_FREE_LIST_INDEX_MASK: bits used to store free list index, VLIB_BUFFER_IS_TRACED: trace this buffer.
static void signal_report(address_report_t *r)
#define hash_set(h, key, value)
static vlib_buffer_t * create_buffer_for_client_message(vlib_main_t *vm, u32 sw_if_index, dhcp6_ia_na_client_state_t *client_state, u32 type)
static clib_error_t * dhcp6_client_init(vlib_main_t *vm)
static f64 vlib_process_wait_for_event_or_clock(vlib_main_t *vm, f64 dt)
Suspend a cooperative multi-tasking thread Waits for an event, or for the indicated number of seconds...
#define hash_unset(h, key)
static void vlib_buffer_free(vlib_main_t *vm, u32 *buffers, u32 n_buffers)
Free buffers Frees the entire buffer chain for each buffer.
static uword * vlib_process_wait_for_event(vlib_main_t *vm)
static void stop_sending_client_message(vlib_main_t *vm, dhcp6_ia_na_client_state_t *client_state)
vnet_main_t * vnet_get_main(void)
static vnet_hw_interface_t * vnet_get_sup_hw_interface(vnet_main_t *vnm, u32 sw_if_index)
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
static f64 vlib_time_now(vlib_main_t *vm)
_vnet_dhcp6_reply_event_function_list_elt_t * functions
void vl_api_want_dhcp6_reply_events_t_handler(vl_api_want_dhcp6_reply_events_t *mp)
u8 keep_sending_client_message
u16 current_length
Nbytes between current data and the end of this buffer.
vlib_node_registration_t dhcp6_reply_process_node
(constructor) VLIB_REGISTER_NODE (dhcp6_reply_process_node)
for(i=1;i<=collision_buckets;i++)
static vnet_sw_interface_t * vnet_get_sw_interface(vnet_main_t *vnm, u32 sw_if_index)
#define DHCPV6_CLIENT_PORT
#define pool_get(P, E)
Allocate an object E from a pool P (unspecified alignment).
static vlib_buffer_t * vlib_buffer_copy(vlib_main_t *vm, vlib_buffer_t *b)
void dhcp6_set_publisher_node(uword node_index, uword event_type)
#define vec_reset_length(v)
Reset vector length to zero NULL-pointer tolerant.
#define clib_memcpy(d, s, n)
vlib_node_registration_t ip6_rewrite_mcast_node
(constructor) VLIB_REGISTER_NODE (ip6_rewrite_mcast_node)
#define pool_foreach(VAR, POOL, BODY)
Iterate through pool.
#define VLIB_INIT_FUNCTION(x)
static uword vlib_process_get_events(vlib_main_t *vm, uword **data_vector)
Return the first event type which has occurred and a vector of per-event data of that type...
Send DHCPv6 client message of specified type.
vnet_hw_interface_flags_t flags
static vnet_sw_interface_t * vnet_get_sup_sw_interface(vnet_main_t *vnm, u32 sw_if_index)
vlib_frame_t * vlib_get_frame_to_node(vlib_main_t *vm, u32 to_node_index)
void vl_api_rpc_call_main_thread(void *fp, u8 *data, u32 data_length)
void adj_unlock(adj_index_t adj_index)
Release a reference counting lock on the adjacency.
static u32 vlib_get_buffer_index(vlib_main_t *vm, void *p)
Translate buffer pointer into buffer index.
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
dhcp6_ia_na_client_main_t dhcp6_ia_na_client_main
static void vlib_process_signal_event(vlib_main_t *vm, uword node_index, uword type_opaque, uword data)
void vlib_put_frame_to_node(vlib_main_t *vm, u32 to_node_index, vlib_frame_t *f)
static void * vlib_buffer_get_current(vlib_buffer_t *b)
Get pointer to current data to process.
#define pool_put(P, E)
Free an object E in pool P.
#define vec_dup(V)
Return copy of vector (no header, no alignment)
static void * vlib_process_signal_event_data(vlib_main_t *vm, uword node_index, uword type_opaque, uword n_data_elts, uword n_data_elt_bytes)
vnet_sw_interface_flags_t flags
dhcp6_ia_na_client_state_t * client_state_by_sw_if_index
dhcpv6_duid_ll_string_t client_duid
dhcp6_ia_na_client_public_main_t dhcp6_ia_na_client_public_main
#define CLIENT_DUID_LENGTH
#define BAD_SW_IF_INDEX_LABEL
#define VLIB_REGISTER_NODE(x,...)
#define DHCPV6_CLIENT_IAID
dhcp6_send_client_message_params_address_t * addresses
#define vec_free(V)
Free vector's memory (no header).
#define clib_warning(format, args...)
void vl_api_dhcp6_send_client_message_t_handler(vl_api_dhcp6_send_client_message_t *mp)
u16 ip6_tcp_udp_icmp_compute_checksum(vlib_main_t *vm, vlib_buffer_t *p0, ip6_header_t *ip0, int *bogus_lengthp)
Struct representing DHCPv6 address.
dhcp6_send_client_message_params_t params
static void clib_mem_free(void *p)
void dhcp6_send_client_message(vlib_main_t *vm, u32 sw_if_index, u8 stop, dhcp6_send_client_message_params_t *params)
static void * clib_mem_alloc(uword size)
static vlib_main_t * vlib_get_main(void)
dhcp6_client_common_main_t dhcp6_client_common_main
Tell client about a DHCPv6 server reply event.
ip6_address_t ip6_neighbor_get_link_local_address(u32 sw_if_index)
static void * vlib_process_get_event_data(vlib_main_t *vm, uword *return_event_type_opaque)
clib_error_t * call_dhcp6_reply_event_callbacks(void *data, _vnet_dhcp6_reply_event_function_list_elt_t *elt)
static uword dhcp6_reply_process(vlib_main_t *vm, vlib_node_runtime_t *rt, vlib_frame_t *f)
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
int dhcp6_publish_report(address_report_t *r)
VLIB buffer representation.
dhcp6_address_info_t * addresses
static void * vlib_frame_vector_args(vlib_frame_t *f)
Get pointer to frame vector data.
vl_api_dhcp6_address_info_t addresses[n_addresses]
static vlib_node_registration_t send_dhcp6_client_message_process_node
(constructor) VLIB_REGISTER_NODE (send_dhcp6_client_message_process_node)
static u8 check_send_client_message(vlib_main_t *vm, dhcp6_ia_na_client_state_t *client_state, f64 current_time, f64 *due_time)
Register for DHCPv6 reply events.
#define DHCPV6_SERVER_PORT
static uword send_dhcp6_client_message_process(vlib_main_t *vm, vlib_node_runtime_t *rt, vlib_frame_t *f0)
static u32 random_u32(u32 *seed)
32-bit random number generator
static void vlib_process_put_event_data(vlib_main_t *vm, void *event_data)
adj_index_t adj_mcast_add_or_lock(fib_protocol_t proto, vnet_link_t link_type, u32 sw_if_index)
Mcast Adjacency.
dhcp6_report_common_t body
static const ip6_address_t all_dhcp6_relay_agents_and_servers
#define vec_validate_init_empty(V, I, INIT)
Make sure vector is long enough for given index and initialize empty space (no header, unspecified alignment)
vpe_api_main_t vpe_api_main
static u32 vlib_buffer_alloc(vlib_main_t *vm, u32 *buffers, u32 n_buffers)
Allocate buffers into supplied array.
static vlib_buffer_t * vlib_get_buffer(vlib_main_t *vm, u32 buffer_index)
Translate buffer index into buffer pointer.
#define VALIDATE_SW_IF_INDEX(mp)
static_always_inline f64 random_f64_from_to(f64 from, f64 to)
static uword pool_elts(void *v)
Number of active elements in a pool.