1/*
2 * Copyright (c) 2018 Cisco and/or its affiliates.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at:
6 *
7 *     http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16#include <vnet/vnet.h>
17#include <vlibmemory/api.h>
18#include <vnet/vnet_msg_enum.h>
19#include <dhcp/dhcp6_packet.h>
20#include <dhcp/dhcp6_ia_na_client_dp.h>
21#include <vnet/ip/ip.h>
22#include <vnet/ip/ip6.h>
23#include <vnet/ip/ip6_link.h>
24#include <float.h>
25#include <math.h>
26
27typedef struct
28{
29  u32 sw_if_index;
30  ip6_address_t address;
31  u32 preferred_lt;
32  u32 valid_lt;
33  f64 due_time;
34} address_info_t;
35
36typedef struct
37{
38  u8 enabled;
39  u32 server_index;
40  u32 T1;
41  u32 T2;
42  f64 T1_due_time;
43  f64 T2_due_time;
44  u32 address_count;
45  u8 rebinding;
46} client_state_t;
47
48typedef struct
49{
50  address_info_t *address_pool;
51  client_state_t *client_state_by_sw_if_index;
52  u32 n_clients;
53  f64 max_valid_due_time;
54
55  /* convenience */
56  vlib_main_t *vlib_main;
57  vnet_main_t *vnet_main;
58  api_main_t *api_main;
59  u32 node_index;
60} dhcp6_client_cp_main_t;
61
62static dhcp6_client_cp_main_t dhcp6_client_cp_main;
63
64enum
65{
66  RD_CP_EVENT_INTERRUPT,
67  RD_CP_EVENT_DISABLE,
68};
69
70static void
71send_client_message_start_stop (u32 sw_if_index, u32 server_index,
72				u8 msg_type, address_info_t * address_list,
73				u8 start)
74{
75  dhcp6_client_cp_main_t *rm = &dhcp6_client_cp_main;
76  dhcp6_send_client_message_params_t params = { 0, };
77  dhcp6_send_client_message_params_address_t *addresses = 0, *addr;
78  u32 i;
79
80  ASSERT (sw_if_index < vec_len (rm->client_state_by_sw_if_index) &&
81	  rm->client_state_by_sw_if_index[sw_if_index].enabled);
82  client_state_t *client_state =
83    &rm->client_state_by_sw_if_index[sw_if_index];
84
85  params.sw_if_index = sw_if_index;
86  params.server_index = server_index;
87  params.msg_type = msg_type;
88  if (start)
89    {
90      if (msg_type == DHCPV6_MSG_SOLICIT)
91	{
92	  params.irt = 1;
93	  params.mrt = 120;
94	}
95      else if (msg_type == DHCPV6_MSG_REQUEST)
96	{
97	  params.irt = 1;
98	  params.mrt = 30;
99	  params.mrc = 10;
100	}
101      else if (msg_type == DHCPV6_MSG_RENEW)
102	{
103	  params.irt = 10;
104	  params.mrt = 600;
105	  f64 current_time = vlib_time_now (rm->vlib_main);
106	  i32 diff_time = client_state->T2 - current_time;
107	  if (diff_time < 0)
108	    diff_time = 0;
109	  params.mrd = diff_time;
110	}
111      else if (msg_type == DHCPV6_MSG_REBIND)
112	{
113	  params.irt = 10;
114	  params.mrt = 600;
115	  f64 current_time = vlib_time_now (rm->vlib_main);
116	  i32 diff_time = rm->max_valid_due_time - current_time;
117	  if (diff_time < 0)
118	    diff_time = 0;
119	  params.mrd = diff_time;
120	}
121      else if (msg_type == DHCPV6_MSG_RELEASE)
122	{
123	  params.mrc = 1;
124	}
125    }
126
127  params.T1 = 0;
128  params.T2 = 0;
129  if (vec_len (address_list) != 0)
130    vec_validate (addresses, vec_len (address_list) - 1);
131  for (i = 0; i < vec_len (address_list); i++)
132    {
133      address_info_t *address = &address_list[i];
134      addr = &addresses[i];
135      addr->valid_lt = address->valid_lt;
136      addr->preferred_lt = address->preferred_lt;
137      addr->address = address->address;
138    }
139  params.addresses = addresses;
140
141  dhcp6_send_client_message (rm->vlib_main, sw_if_index, !start, &params);
142
143  vec_free (params.addresses);
144}
145
146static void interrupt_process (void);
147
148static u8
149ip6_addresses_equal (ip6_address_t * address1, ip6_address_t * address2)
150{
151  if (address1->as_u64[0] != address2->as_u64[0])
152    return 0;
153  return address1->as_u64[1] == address2->as_u64[1];
154}
155
156static clib_error_t *
157dhcp6_reply_event_handler (vl_api_dhcp6_reply_event_t * mp)
158{
159  dhcp6_client_cp_main_t *rm = &dhcp6_client_cp_main;
160  vlib_main_t *vm = rm->vlib_main;
161  client_state_t *client_state;
162  ip6_address_t *address;
163  u32 sw_if_index;
164  u32 n_addresses;
165  vl_api_dhcp6_address_info_t *api_address;
166  u32 inner_status_code;
167  u32 status_code;
168  u32 server_index;
169  f64 current_time;
170  clib_error_t *error = 0;
171  u32 i;
172
173  current_time = vlib_time_now (vm);
174
175  sw_if_index = ntohl (mp->sw_if_index);
176
177  if (sw_if_index >= vec_len (rm->client_state_by_sw_if_index))
178    return 0;
179
180  client_state = &rm->client_state_by_sw_if_index[sw_if_index];
181
182  if (!client_state->enabled)
183    return 0;
184
185  server_index = ntohl (mp->server_index);
186
187  n_addresses = ntohl (mp->n_addresses);
188
189  inner_status_code = ntohs (mp->inner_status_code);
190  status_code = ntohs (mp->status_code);
191
192  if (mp->msg_type == DHCPV6_MSG_API_ADVERTISE
193      && client_state->server_index == ~0)
194    {
195      address_info_t *address_list = 0, *address_info;
196
197      if (inner_status_code == DHCPV6_STATUS_NOADDRS_AVAIL)
198	{
199	  clib_warning
200	    ("Advertise message arrived with NoAddrsAvail status code");
201	  return 0;
202	}
203
204      if (n_addresses > 0)
205	vec_validate (address_list, n_addresses - 1);
206      for (i = 0; i < n_addresses; i++)
207	{
208	  api_address = &mp->addresses[i];
209	  address = (ip6_address_t *) api_address->address;
210
211	  address_info = &address_list[i];
212	  address_info->address = *address;
213	  address_info->preferred_lt = 0;
214	  address_info->valid_lt = 0;
215	}
216
217      client_state->server_index = server_index;
218
219      send_client_message_start_stop (sw_if_index, server_index,
220				      DHCPV6_MSG_REQUEST, address_list, 1);
221      vec_free (address_list);
222    }
223
224  if (mp->msg_type != DHCPV6_MSG_API_REPLY)
225    return 0;
226
227  if (!client_state->rebinding && client_state->server_index != server_index)
228    {
229      clib_warning ("Reply message arrived with Server ID different "
230		    "from that in Request or Renew message");
231      return 0;
232    }
233
234  if (inner_status_code == DHCPV6_STATUS_NOADDRS_AVAIL)
235    {
236      clib_warning ("Reply message arrived with NoAddrsAvail status code");
237      if (n_addresses > 0)
238	{
239	  clib_warning
240	    ("Invalid Reply message arrived: It contains NoAddrsAvail "
241	     "status code but also contains addresses");
242	  return 0;
243	}
244    }
245
246  if (status_code == DHCPV6_STATUS_UNSPEC_FAIL)
247    {
248      clib_warning ("Reply message arrived with UnspecFail status code");
249      return 0;
250    }
251
252  send_client_message_start_stop (sw_if_index, server_index,
253				  mp->msg_type, 0, 0);
254
255  for (i = 0; i < n_addresses; i++)
256    {
257      address_info_t *address_info = 0;
258      u32 valid_time;
259      u32 preferred_time;
260
261      api_address = &mp->addresses[i];
262
263      address = (ip6_address_t *) api_address->address;
264
265      if (ip6_address_is_link_local_unicast (address))
266	continue;
267
268      valid_time = ntohl (api_address->valid_time);
269      preferred_time = ntohl (api_address->preferred_time);
270
271      if (preferred_time > valid_time)
272	continue;
273
274      u8 address_already_present = 0;
275      /* *INDENT-OFF* */
276      pool_foreach (address_info, rm->address_pool,
277      ({
278        if (address_info->sw_if_index != sw_if_index)
279          ;
280        else if (!ip6_addresses_equal (&address_info->address, address))
281          ;
282        else
283          {
284            address_already_present = 1;
285            goto address_pool_foreach_out;
286          }
287      }));
288      /* *INDENT-ON* */
289    address_pool_foreach_out:
290
291      if (address_already_present)
292	{
293	  address_info->preferred_lt = preferred_time;
294	  address_info->valid_lt = valid_time;
295	  address_info->due_time = current_time;
296	  /* Renew the lease at the preferred time, if non-zero */
297	  address_info->due_time += (preferred_time > 0) ?
298	    preferred_time : valid_time;
299
300	  if (address_info->due_time > rm->max_valid_due_time)
301	    rm->max_valid_due_time = address_info->due_time;
302	  continue;
303	}
304
305      if (valid_time == 0)
306	continue;
307
308      pool_get (rm->address_pool, address_info);
309      address_info->sw_if_index = sw_if_index;
310      address_info->address = *address;
311      address_info->preferred_lt = preferred_time;
312      address_info->valid_lt = valid_time;
313      address_info->due_time = current_time;
314      /* Renew the lease at the preferred time, if non-zero */
315      address_info->due_time += (preferred_time > 0) ?
316	preferred_time : valid_time;
317
318      if (address_info->due_time > rm->max_valid_due_time)
319	rm->max_valid_due_time = address_info->due_time;
320      rm->client_state_by_sw_if_index[sw_if_index].address_count++;
321
322      error = ip6_add_del_interface_address (vm, sw_if_index,
323					     &address_info->address, 64, 0);
324      if (error)
325	clib_warning ("Failed to add interface address");
326    }
327
328  client_state->server_index = server_index;
329  client_state->T1 = ntohl (mp->T1);
330  client_state->T2 = ntohl (mp->T2);
331  if (client_state->T1 != 0)
332    client_state->T1_due_time = current_time + client_state->T1;
333  if (client_state->T2 != 0)
334    client_state->T2_due_time = current_time + client_state->T2;
335  client_state->rebinding = 0;
336
337  interrupt_process ();
338
339  return error;
340}
341
342static address_info_t *
343create_address_list (u32 sw_if_index)
344{
345  dhcp6_client_cp_main_t *rm = &dhcp6_client_cp_main;
346  address_info_t *address_info, *address_list = 0;;
347
348  /* *INDENT-OFF* */
349  pool_foreach (address_info, rm->address_pool,
350  ({
351    if (address_info->sw_if_index == sw_if_index)
352      {
353        u32 pos = vec_len (address_list);
354        vec_validate (address_list, pos);
355        clib_memcpy (&address_list[pos], address_info, sizeof (*address_info));
356      }
357  }));
358  /* *INDENT-ON* */
359
360  return address_list;
361}
362
363VNET_DHCP6_REPLY_EVENT_FUNCTION (dhcp6_reply_event_handler);
364
365static uword
366dhcp6_client_cp_process (vlib_main_t * vm, vlib_node_runtime_t * rt,
367			 vlib_frame_t * f)
368{
369  dhcp6_client_cp_main_t *rm = &dhcp6_client_cp_main;
370  address_info_t *address_info;
371  client_state_t *client_state;
372  f64 sleep_time = 1e9;
373  clib_error_t *error;
374  f64 current_time;
375  f64 due_time;
376  uword event_type;
377  uword *event_data = 0;
378  int i;
379
380  while (1)
381    {
382      vlib_process_wait_for_event_or_clock (vm, sleep_time);
383      event_type = vlib_process_get_events (vm, &event_data);
384      vec_reset_length (event_data);
385
386      if (event_type == RD_CP_EVENT_DISABLE)
387	{
388	  vlib_node_set_state (vm, rm->node_index, VLIB_NODE_STATE_DISABLED);
389	  sleep_time = 1e9;
390	  continue;
391	}
392
393      current_time = vlib_time_now (vm);
394      do
395	{
396	  due_time = current_time + 1e9;
397          /* *INDENT-OFF* */
398          pool_foreach (address_info, rm->address_pool,
399          ({
400            if (address_info->due_time > current_time)
401              {
402                if (address_info->due_time < due_time)
403                  due_time = address_info->due_time;
404              }
405            else
406              {
407                u32 sw_if_index = address_info->sw_if_index;
408                error = ip6_add_del_interface_address (vm, sw_if_index,
409                                                       &address_info->address,
410                                                       64, 1);
411                if (error)
412                    clib_warning ("Failed to delete interface address");
413                pool_put (rm->address_pool, address_info);
414                /* make sure ip6 stays enabled */
415                ip6_link_enable (sw_if_index, NULL);
416                client_state = &rm->client_state_by_sw_if_index[sw_if_index];
417                if (--client_state->address_count == 0)
418                  {
419                    client_state->rebinding = 0;
420                    client_state->server_index = ~0;
421                    send_client_message_start_stop (sw_if_index, ~0,
422                                                    DHCPV6_MSG_SOLICIT,
423                                                    0, 1);
424                  }
425              }
426          }));
427          /* *INDENT-ON* */
428	  for (i = 0; i < vec_len (rm->client_state_by_sw_if_index); i++)
429	    {
430	      client_state_t *cs = &rm->client_state_by_sw_if_index[i];
431	      if (cs->enabled && cs->server_index != ~0)
432		{
433		  if (cs->T2_due_time > current_time)
434		    {
435		      if (cs->T2_due_time < due_time)
436			due_time = cs->T2_due_time;
437		      if (cs->T1_due_time > current_time)
438			{
439			  if (cs->T1_due_time < due_time)
440			    due_time = cs->T1_due_time;
441			}
442		      else
443			{
444			  cs->T1_due_time = DBL_MAX;
445			  address_info_t *address_list;
446			  address_list = create_address_list (i);
447			  cs->rebinding = 1;
448			  send_client_message_start_stop (i, cs->server_index,
449							  DHCPV6_MSG_RENEW,
450							  address_list, 1);
451			  vec_free (address_list);
452			}
453		    }
454		  else
455		    {
456		      cs->T2_due_time = DBL_MAX;
457		      address_info_t *address_list;
458		      address_list = create_address_list (i);
459		      cs->rebinding = 1;
460		      send_client_message_start_stop (i, ~0,
461						      DHCPV6_MSG_REBIND,
462						      address_list, 1);
463		      vec_free (address_list);
464		    }
465		}
466	    }
467	  current_time = vlib_time_now (vm);
468	}
469      while (due_time < current_time);
470
471      sleep_time = due_time - current_time;
472    }
473
474  return 0;
475}
476
477/* *INDENT-OFF* */
478VLIB_REGISTER_NODE (dhcp6_client_cp_process_node) = {
479    .function = dhcp6_client_cp_process,
480    .type = VLIB_NODE_TYPE_PROCESS,
481    .name = "dhcp6-client-cp-process",
482};
483/* *INDENT-ON* */
484
485static void
486interrupt_process (void)
487{
488  dhcp6_client_cp_main_t *rm = &dhcp6_client_cp_main;
489  vlib_main_t *vm = rm->vlib_main;
490
491  vlib_process_signal_event (vm, dhcp6_client_cp_process_node.index,
492			     RD_CP_EVENT_INTERRUPT, 0);
493}
494
495static void
496disable_process (void)
497{
498  dhcp6_client_cp_main_t *rm = &dhcp6_client_cp_main;
499  vlib_main_t *vm = rm->vlib_main;
500
501  vlib_process_signal_event (vm, dhcp6_client_cp_process_node.index,
502			     RD_CP_EVENT_DISABLE, 0);
503}
504
505static void
506enable_process (void)
507{
508  dhcp6_client_cp_main_t *rm = &dhcp6_client_cp_main;
509  vlib_main_t *vm = rm->vlib_main;
510  vlib_node_t *node;
511
512  node = vec_elt (vm->node_main.nodes, rm->node_index);
513
514  vlib_node_set_state (vm, rm->node_index, VLIB_NODE_STATE_POLLING);
515  vlib_start_process (vm, node->runtime_index);
516}
517
518static clib_error_t *
519dhcp6_addresses_show_command_function (vlib_main_t * vm,
520				       unformat_input_t * input,
521				       vlib_cli_command_t * cmd)
522{
523  dhcp6_client_cp_main_t *dm = &dhcp6_client_cp_main;
524  clib_error_t *error = 0;
525  address_info_t *address_info;
526  f64 current_time = vlib_time_now (vm);
527
528  /* *INDENT-OFF* */
529  pool_foreach (address_info, dm->address_pool,
530  ({
531    vlib_cli_output (vm, "address: %U, "
532                     "preferred lifetime: %u, valid lifetime: %u "
533                     "(%f remaining)",
534                     format_ip6_address, &address_info->address,
535                     address_info->preferred_lt, address_info->valid_lt,
536                     address_info->due_time - current_time);
537  }));
538  /* *INDENT-ON* */
539
540  return error;
541}
542
543/* *INDENT-OFF* */
544VLIB_CLI_COMMAND (dhcp6_addresses_show_command, static) = {
545  .path = "show dhcp6 addresses",
546  .short_help = "show dhcp6 addresses",
547  .function = dhcp6_addresses_show_command_function,
548};
549/* *INDENT-ON* */
550
551static clib_error_t *
552dhcp6_clients_show_command_function (vlib_main_t * vm,
553				     unformat_input_t * input,
554				     vlib_cli_command_t * cmd)
555{
556  dhcp6_client_cp_main_t *rm = &dhcp6_client_cp_main;
557  clib_error_t *error = 0;
558  client_state_t *cs;
559  f64 current_time = vlib_time_now (vm);
560  u8 *buf1 = 0;
561  u8 *buf2 = 0;
562  const char *rebinding;
563  u32 i;
564
565  for (i = 0; i < vec_len (rm->client_state_by_sw_if_index); i++)
566    {
567      cs = &rm->client_state_by_sw_if_index[i];
568      if (cs->enabled)
569	{
570	  vec_reset_length (buf1);
571	  vec_reset_length (buf2);
572	  if (cs->T1_due_time != DBL_MAX && cs->T1_due_time > current_time)
573	    {
574	      buf1 = format (buf1, "%u remaining",
575			     (u32) round (cs->T1_due_time - current_time));
576	    }
577	  else
578	    buf1 = format (buf1, "timeout");
579	  if (cs->T2_due_time != DBL_MAX && cs->T2_due_time > current_time)
580	    buf2 = format (buf2, "%u remaining",
581			   (u32) round (cs->T2_due_time - current_time));
582	  else
583	    buf2 = format (buf2, "timeout");
584	  if (cs->rebinding)
585	    rebinding = ", REBINDING";
586	  else
587	    rebinding = "";
588	  if (cs->T1)
589	    vlib_cli_output (vm,
590			     "sw_if_index: %u, T1: %u (%v), "
591			     "T2: %u (%v), server index: %d%s", i,
592			     cs->T1, buf1, cs->T2, buf2,
593			     cs->server_index, rebinding);
594	  else
595	    vlib_cli_output (vm, "sw_if_index: %u%s", i, rebinding);
596	}
597    }
598
599  vec_free (buf1);
600  vec_free (buf2);
601
602  return error;
603}
604
605/* *INDENT-OFF* */
606VLIB_CLI_COMMAND (dhcp6_clients_show_command, static) = {
607  .path = "show dhcp6 clients",
608  .short_help = "show dhcp6 clients",
609  .function = dhcp6_clients_show_command_function,
610};
611/* *INDENT-ON* */
612
613int
614dhcp6_client_enable_disable (u32 sw_if_index, u8 enable)
615{
616  dhcp6_client_cp_main_t *rm = &dhcp6_client_cp_main;
617  vnet_main_t *vnm = rm->vnet_main;
618  vlib_main_t *vm = rm->vlib_main;
619  client_state_t *client_state;
620  client_state_t empty_config = { 0 };
621  address_info_t *address_info;
622  clib_error_t *error;
623
624  if (!vnet_sw_interface_is_api_valid (vnm, sw_if_index))
625    {
626      clib_warning ("Invalid sw_if_index");
627      return 1;
628    }
629
630  vec_validate_init_empty (rm->client_state_by_sw_if_index, sw_if_index,
631			   empty_config);
632  client_state = &rm->client_state_by_sw_if_index[sw_if_index];
633
634  u8 old_enabled = client_state->enabled;
635  if (enable)
636    client_state->enabled = 1;
637  client_state->server_index = ~0;
638
639  if (!old_enabled && enable)
640    {
641      rm->n_clients++;
642      if (rm->n_clients == 1)
643	{
644	  enable_process ();
645	  dhcp6_clients_enable_disable (1);
646	}
647
648      ip6_link_enable (sw_if_index, NULL);
649      send_client_message_start_stop (sw_if_index, ~0, DHCPV6_MSG_SOLICIT,
650				      0, 1);
651    }
652  else if (old_enabled && !enable)
653    {
654      send_client_message_start_stop (sw_if_index, ~0, ~0, 0, 0);
655
656      rm->n_clients--;
657      if (rm->n_clients == 0)
658	{
659	  dhcp6_clients_enable_disable (0);
660	  disable_process ();
661	}
662
663      /* *INDENT-OFF* */
664      pool_foreach (address_info, rm->address_pool,
665      ({
666        if (address_info->sw_if_index == sw_if_index)
667          {
668            ASSERT (sw_if_index < vec_len (rm->client_state_by_sw_if_index) &&
669                    rm->client_state_by_sw_if_index[sw_if_index].enabled);
670            client_state_t *client_state =
671              &rm->client_state_by_sw_if_index[sw_if_index];
672            send_client_message_start_stop (sw_if_index,
673                                            client_state->server_index,
674                                            DHCPV6_MSG_RELEASE, address_info,
675                                            1);
676            error = ip6_add_del_interface_address (vm, sw_if_index,
677                                                   &address_info->address,
678                                                   64, 1);
679            if (error)
680                clib_warning ("Failed to delete interface address");
681            pool_put (rm->address_pool, address_info);
682          }
683      }));
684      /* *INDENT-ON* */
685    }
686
687  if (!enable)
688    client_state->enabled = 0;
689
690  return 0;
691}
692
693static clib_error_t *
694dhcp6_client_enable_disable_command_fn (vlib_main_t * vm,
695					unformat_input_t * input,
696					vlib_cli_command_t * cmd)
697{
698  dhcp6_client_cp_main_t *rm = &dhcp6_client_cp_main;
699  vnet_main_t *vnm = rm->vnet_main;
700  clib_error_t *error = 0;
701  u32 sw_if_index = ~0;
702  u8 enable = 1;
703  unformat_input_t _line_input, *line_input = &_line_input;
704
705  if (!unformat_user (input, unformat_line_input, line_input))
706    return 0;
707
708  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
709    {
710      if (unformat
711	  (line_input, "%U", unformat_vnet_sw_interface, vnm, &sw_if_index))
712	;
713      else if (unformat (line_input, "disable"))
714	enable = 0;
715      else
716	{
717	  error = clib_error_return (0, "unexpected input `%U'",
718				     format_unformat_error, line_input);
719	  goto done;
720	}
721    }
722
723  unformat_free (line_input);
724
725  if (sw_if_index != ~0)
726    {
727      if (dhcp6_client_enable_disable (sw_if_index, enable) != 0)
728	error = clib_error_return (0, "Invalid sw_if_index");
729    }
730  else
731    error = clib_error_return (0, "Missing sw_if_index");
732
733done:
734  return error;
735}
736
737/*?
738 * This command is used to enable/disable DHCPv6 client
739 * on particular interface.
740 *
741 * @cliexpar
742 * @parblock
743 * Example of how to enable DHCPv6 client:
744 * @cliexcmd{dhcp6 client GigabitEthernet2/0/0}
745 * Example of how to disable DHCPv6 client:
746 * @cliexcmd{dhcp6 client GigabitEthernet2/0/0 disable}
747 * @endparblock
748?*/
749/* *INDENT-OFF* */
750VLIB_CLI_COMMAND (dhcp6_client_enable_disable_command, static) = {
751  .path = "dhcp6 client",
752  .short_help = "dhcp6 client <interface> [disable]",
753  .function = dhcp6_client_enable_disable_command_fn,
754};
755/* *INDENT-ON* */
756
757static clib_error_t *
758dhcp_ia_na_client_cp_init (vlib_main_t * vm)
759{
760  dhcp6_client_cp_main_t *rm = &dhcp6_client_cp_main;
761
762  rm->vlib_main = vm;
763  rm->vnet_main = vnet_get_main ();
764  rm->api_main = vlibapi_get_main ();
765  rm->node_index = dhcp6_client_cp_process_node.index;
766
767  return NULL;
768}
769
770VLIB_INIT_FUNCTION (dhcp_ia_na_client_cp_init);
771
772/*
773 * fd.io coding-style-patch-verification: ON
774 *
775 * Local Variables:
776 * eval: (c-set-style "gnu")
777 * End:
778 */
779