FD.io VPP  v20.09-64-g4f7b92f0a
Vector Packet Processing
cdp_periodic.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2011-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 #include <cdp/cdp.h>
16 #include <vppinfra/hash.h>
17 #include <vppinfra/pcap.h>
18 #include <vnet/srp/srp.h>
19 #include <vnet/ppp/ppp.h>
20 #include <vnet/hdlc/hdlc.h>
21 #include <vnet/srp/packet.h>
22 
23 /*
24  * Generate a set of specific CDP TLVs.
25  *
26  * $$$ eventually these need to fish better data from
27  * other data structures; e.g. the hostname, software version info
28  * etc.
29  */
30 
31 static void
33 {
34  cdp_tlv_t *t = (cdp_tlv_t *) * t0p;
35 
36  t->t = htons (CDP_TLV_device_name);
37  t->l = htons (3 + sizeof (*t));
38  clib_memcpy (&t->v, "VPP", 3);
39 
40  *t0p += ntohs (t->l);
41 }
42 
43 static void
45 {
46  cdp_tlv_t *t = (cdp_tlv_t *) * t0p;
47 
48  t->t = htons (CDP_TLV_port_id);
49  t->l = htons (vec_len (hw->name) + sizeof (*t));
50  clib_memcpy (&t->v, hw->name, vec_len (hw->name));
51  *t0p += ntohs (t->l);
52 }
53 
54 static void
56 {
57  cdp_tlv_t *t = (cdp_tlv_t *) * t0p;
58 
59  t->t = htons (CDP_TLV_version);
60  t->l = htons (12 + sizeof (*t));
61  clib_memcpy (&t->v, "VPP Software", 12);
62  *t0p += ntohs (t->l);
63 }
64 
65 static void
67 {
68  cdp_tlv_t *t = (cdp_tlv_t *) * t0p;
69 
70  t->t = htons (CDP_TLV_platform);
71  t->l = htons (2 + sizeof (*t));
72  clib_memcpy (&t->v, "SW", 2);
73  *t0p += ntohs (t->l);
74 }
75 
76 static void
78 {
79  cdp_tlv_t *t = (cdp_tlv_t *) * t0p;
80  u32 capabilities;
81 
82  t->t = htons (CDP_TLV_capabilities);
83  t->l = htons (4 + sizeof (*t));
84  capabilities = CDP_ROUTER_DEVICE;
85  capabilities = htonl (capabilities);
86  clib_memcpy (&t->v, &capabilities, sizeof (capabilities));
87  *t0p += ntohs (t->l);
88 }
89 
90 static void
92 {
93  add_device_name_tlv (hw, t0p);
94  add_port_id_tlv (hw, t0p);
95  add_version_tlv (hw, t0p);
96  add_platform_tlv (hw, t0p);
97  add_capability_tlv (hw, t0p);
98 }
99 
100 /*
101  * send a cdp pkt on an ethernet interface
102  */
103 static void
105 {
106  u32 *to_next;
107  ethernet_llc_snap_and_cdp_header_t *h0;
109  u32 bi0;
110  vlib_buffer_t *b0;
111  u8 *t0;
112  u16 checksum;
113  int nbytes_to_checksum;
114  int i;
115  vlib_frame_t *f;
116  vlib_main_t *vm = cm->vlib_main;
117  vnet_main_t *vnm = cm->vnet_main;
118 
119  for (i = 0; i < count; i++)
120  {
121  /*
122  * see cdp_periodic_init() to understand what's already painted
123  * into the buffer by the packet template mechanism
124  */
126  (vm, &cm->packet_templates[n->packet_template_index], &bi0);
127 
128  if (!h0)
129  break;
130 
131  /* Add the interface's ethernet source address */
132  hw = vnet_get_sup_hw_interface (vnm, n->sw_if_index);
133 
134  clib_memcpy (h0->ethernet.src_address, hw->hw_address,
135  vec_len (hw->hw_address));
136 
137  t0 = (u8 *) & h0->cdp.data;
138 
139  /* add TLVs */
140  add_tlvs (cm, hw, &t0);
141 
142  /* add the cdp packet checksum */
143  nbytes_to_checksum = t0 - (u8 *) & h0->cdp;
144  checksum = cdp_checksum (&h0->cdp, nbytes_to_checksum);
145  h0->cdp.checksum = htons (checksum);
146 
147  /* Set the outbound packet length */
148  b0 = vlib_get_buffer (vm, bi0);
149  b0->current_length = nbytes_to_checksum + sizeof (*h0)
150  - sizeof (cdp_hdr_t);
151 
152  /* And the outbound interface */
153  vnet_buffer (b0)->sw_if_index[VLIB_TX] = hw->sw_if_index;
154 
155  /* Set the 802.3 ethernet length */
156  h0->ethernet.len = htons (b0->current_length
157  - sizeof (ethernet_802_3_header_t));
158 
159  /* And output the packet on the correct interface */
161  to_next = vlib_frame_vector_args (f);
162  to_next[0] = bi0;
163  f->n_vectors = 1;
164 
166  n->last_sent = vlib_time_now (vm);
167  }
168 }
169 
170 /*
171  * send a cdp pkt on an hdlc interface
172  */
173 static void
175 {
176  u32 *to_next;
177  hdlc_and_cdp_header_t *h0;
179  u32 bi0;
180  vlib_buffer_t *b0;
181  u8 *t0;
182  u16 checksum;
183  int nbytes_to_checksum;
184  int i;
185  vlib_frame_t *f;
186  vlib_main_t *vm = cm->vlib_main;
187  vnet_main_t *vnm = cm->vnet_main;
188 
189  for (i = 0; i < count; i++)
190  {
191  /*
192  * see cdp_periodic_init() to understand what's already painted
193  * into the buffer by the packet template mechanism
194  */
196  (vm, &cm->packet_templates[n->packet_template_index], &bi0);
197 
198  if (!h0)
199  break;
200 
201  hw = vnet_get_sup_hw_interface (vnm, n->sw_if_index);
202 
203  t0 = (u8 *) & h0->cdp.data;
204 
205  /* add TLVs */
206  add_tlvs (cm, hw, &t0);
207 
208  /* add the cdp packet checksum */
209  nbytes_to_checksum = t0 - (u8 *) & h0->cdp;
210  checksum = cdp_checksum (&h0->cdp, nbytes_to_checksum);
211  h0->cdp.checksum = htons (checksum);
212 
213  /* Set the outbound packet length */
214  b0 = vlib_get_buffer (vm, bi0);
215  b0->current_length = nbytes_to_checksum + sizeof (*h0)
216  - sizeof (cdp_hdr_t);
217 
218  /* And output the packet on the correct interface */
220  to_next = vlib_frame_vector_args (f);
221  to_next[0] = bi0;
222  f->n_vectors = 1;
223 
225  n->last_sent = vlib_time_now (vm);
226  }
227 }
228 
229 /*
230  * send a cdp pkt on an srp interface
231  */
232 static void
234 {
235  u32 *to_next;
236  srp_and_cdp_header_t *h0;
238  u32 bi0;
239  vlib_buffer_t *b0;
240  u8 *t0;
241  u16 checksum;
242  int nbytes_to_checksum;
243  int i;
244  vlib_frame_t *f;
245  vlib_main_t *vm = cm->vlib_main;
246  vnet_main_t *vnm = cm->vnet_main;
247 
248  for (i = 0; i < count; i++)
249  {
250  /*
251  * see cdp_periodic_init() to understand what's already painted
252  * into the buffer by the packet template mechanism
253  */
255  (vm, &cm->packet_templates[n->packet_template_index], &bi0);
256 
257  if (!h0)
258  break;
259 
260  hw = vnet_get_sup_hw_interface (vnm, n->sw_if_index);
261 
262  t0 = (u8 *) & h0->cdp.data;
263 
264  /* add TLVs */
265  add_tlvs (cm, hw, &t0);
266 
267  /* Add the interface's ethernet source address */
268  clib_memcpy (h0->ethernet.src_address, hw->hw_address,
269  vec_len (hw->hw_address));
270 
271  /* add the cdp packet checksum */
272  nbytes_to_checksum = t0 - (u8 *) & h0->cdp;
273  checksum = cdp_checksum (&h0->cdp, nbytes_to_checksum);
274  h0->cdp.checksum = htons (checksum);
275 
276  /* Set the outbound packet length */
277  b0 = vlib_get_buffer (vm, bi0);
278  b0->current_length = nbytes_to_checksum + sizeof (*h0)
279  - sizeof (cdp_hdr_t);
280 
281  /* And output the packet on the correct interface */
283  to_next = vlib_frame_vector_args (f);
284  to_next[0] = bi0;
285  f->n_vectors = 1;
286 
288  n->last_sent = vlib_time_now (vm);
289  }
290 }
291 
292 /*
293  * Decide which cdp packet template to use
294  */
295 static int
297 {
299 
300  return 0;
301 }
302 
303 /* Send a cdp neighbor announcement */
304 static void
306 {
307  if (n->packet_template_index == (u8) ~ 0)
308  {
309  /* If we don't know how to talk to this peer, don't try again */
310  if (pick_packet_template (cm, n))
311  {
312  n->last_sent = 1e70;
313  return;
314  }
315  }
316 
317  switch (n->packet_template_index)
318  {
320  send_ethernet_hello (cm, n, count);
321  break;
322 
324  send_hdlc_hello (cm, n, count);
325  break;
326 
328  send_srp_hello (cm, n, count);
329  break;
330 
331  default:
332  ASSERT (0);
333  }
334  n->last_sent = vlib_time_now (cm->vlib_main);
335 }
336 
337 static void
338 delete_neighbor (cdp_main_t * cm, cdp_neighbor_t * n, int want_broadcast)
339 {
341  vec_free (n->device_name);
342  vec_free (n->version);
343  vec_free (n->port_id);
344  vec_free (n->platform);
345  vec_free (n->last_rx_pkt);
346  pool_put (cm->neighbors, n);
347 }
348 
349 void
351 {
352  cdp_main_t *cm = &cdp_main;
353  cdp_neighbor_t *n;
354  f64 now = vlib_time_now (vm);
356  static u32 *delete_list = 0;
357  int i;
358  static cdp_neighbor_t **n_list = 0;
359 
360  /* *INDENT-OFF* */
361  pool_foreach (n, cm->neighbors,
362  ({
363  vec_add1 (n_list, n);
364  }));
365  /* *INDENT-ON* */
366 
367  /* Across all cdp neighbors known to the system */
368  for (i = 0; i < vec_len (n_list); i++)
369  {
370  n = n_list[i];
371 
372  /* "no cdp run" provisioned on the interface? */
373  if (n->disabled == 1)
374  continue;
375 
377 
378  /* Interface shutdown or rx timeout? */
380  || (now > (n->last_heard + (f64) n->ttl_in_seconds)))
381  /* add to list of neighbors to delete */
382  vec_add1 (delete_list, n - cm->neighbors);
383  else if (n->last_sent == 0.0)
384  /* First time, send 3 hellos */
385  send_hello (cm, n, 3 /* three to begin with */ );
386  else if (now > (n->last_sent + (((f64) n->ttl_in_seconds) / 6.0)))
387  /* Normal keepalive, send one */
388  send_hello (cm, n, 1 /* one as a keepalive */ );
389  }
390 
391  for (i = 0; i < vec_len (delete_list); i++)
392  {
393  n = vec_elt_at_index (cm->neighbors, delete_list[i]);
394  delete_neighbor (cm, n, 1);
395  }
396  if (delete_list)
397  _vec_len (delete_list) = 0;
398  if (n_list)
399  _vec_len (n_list) = 0;
400 }
401 
402 static clib_error_t *
404 {
405  cdp_main_t *cm = &cdp_main;
406 
407  /* Create the ethernet cdp hello packet template */
408  {
409  ethernet_llc_snap_and_cdp_header_t h;
410 
411  clib_memset (&h, 0, sizeof (h));
412 
413  /* Send to 01:00:0c:cc:cc */
414  h.ethernet.dst_address[0] = 0x01;
415  /* h.ethernet.dst_address[1] = 0x00; (clib_memset) */
416  h.ethernet.dst_address[2] = 0x0C;
417  h.ethernet.dst_address[3] = 0xCC;
418  h.ethernet.dst_address[4] = 0xCC;
419  h.ethernet.dst_address[5] = 0xCC;
420 
421  /* leave src address blank (fill in at send time) */
422 
423  /* leave length blank (fill in at send time) */
424 
425  /* LLC */
426  h.llc.dst_sap = h.llc.src_sap = 0xAA; /* SNAP */
427  h.llc.control = 0x03; /* UI (no extended control bytes) */
428 
429  /* SNAP */
430  /* h.snap.oui[0] = 0x00; (clib_memset) */
431  /* h.snap.oui[1] = 0x00; (clib_memset) */
432  h.snap.oui[2] = 0x0C; /* Cisco = 0x00000C */
433  h.snap.protocol = htons (0x2000); /* CDP = 0x2000 */
434 
435  /* CDP */
436  h.cdp.version = 2;
437  h.cdp.ttl = 180;
438 
441  /* data */ &h,
442  sizeof (h),
443  /* alloc chunk size */ 8,
444  "cdp-ethernet");
445  }
446 
447 #if 0 /* retain for reference */
448 
449  /* Create the hdlc cdp hello packet template */
450  {
451  hdlc_and_cdp_header_t h;
452 
453  clib_memset (&h, 0, sizeof (h));
454 
455  h.hdlc.address = 0x0f;
456  /* h.hdlc.control = 0; (clib_memset) */
457  h.hdlc.protocol = htons (0x2000); /* CDP = 0x2000 */
458 
459  /* CDP */
460  h.cdp.version = 2;
461  h.cdp.ttl = 180;
462 
465  /* data */ &h,
466  sizeof (h),
467  /* alloc chunk size */ 8,
468  "cdp-hdlc");
469  }
470 
471  /* Create the srp cdp hello packet template */
472  {
473  srp_and_cdp_header_t h;
474 
475  clib_memset (&h, 0, sizeof (h));
476 
477  /* Send to 01:00:0c:cc:cc */
478  h.ethernet.dst_address[0] = 0x01;
479  /* h.ethernet.dst_address[1] = 0x00; (clib_memset) */
480  h.ethernet.dst_address[2] = 0x0C;
481  h.ethernet.dst_address[3] = 0xCC;
482  h.ethernet.dst_address[4] = 0xCC;
483  h.ethernet.dst_address[5] = 0xCC;
484 
485  /* leave src address blank (fill in at send time) */
486 
487  /* The srp header is filled in at xmt */
488  h.srp.ttl = 1;
489  h.srp.priority = 7;
490  h.srp.mode = SRP_MODE_data;
491  srp_header_compute_parity (&h.srp);
492 
493  /* Inner ring and parity will be set at send time */
494 
495  h.ethernet.type = htons (0x2000); /* CDP = 0x2000 */
496 
497  /* CDP */
498  h.cdp.version = 2;
499  h.cdp.ttl = 180;
500 
503  /* data */ &h,
504  sizeof (h),
505  /* alloc chunk size */ 8,
506  "cdp-srp");
507  }
508 #endif
509 
510  return 0;
511 }
512 
514 
515 /*
516  * fd.io coding-style-patch-verification: ON
517  *
518  * Local Variables:
519  * eval: (c-set-style "gnu")
520  * End:
521  */
u8 count
Definition: dhcp.api:208
static void add_capability_tlv(vnet_hw_interface_t *hw, u8 **t0p)
Definition: cdp_periodic.c:77
void cdp_periodic(vlib_main_t *vm)
Definition: cdp_periodic.c:350
#define hash_unset(h, key)
Definition: hash.h:261
#define ntohs(x)
Definition: af_xdp.bpf.c:29
static vnet_hw_interface_t * vnet_get_sup_hw_interface(vnet_main_t *vnm, u32 sw_if_index)
static void delete_neighbor(cdp_main_t *cm, cdp_neighbor_t *n, int want_broadcast)
Definition: cdp_periodic.c:338
PCAP utility definitions.
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
static f64 vlib_time_now(vlib_main_t *vm)
Definition: main.h:333
cdp_main_t cdp_main
Definition: cdp_input.c:17
u16 current_length
Nbytes between current data and the end of this buffer.
Definition: buffer.h:113
f64 last_sent
Definition: cdp.h:48
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:592
static void add_tlvs(cdp_main_t *cm, vnet_hw_interface_t *hw, u8 **t0p)
Definition: cdp_periodic.c:91
u8 * version
Definition: cdp.h:65
u16 cdp_checksum(void *p, int count)
Definition: cdp_input.c:26
static vnet_sw_interface_t * vnet_get_sw_interface(vnet_main_t *vnm, u32 sw_if_index)
static void srp_header_compute_parity(srp_header_t *h)
Definition: packet.h:89
vlib_main_t * vm
Definition: in2out_ed.c:1582
u8 packet_template_index
Definition: cdp.h:57
static void send_ethernet_hello(cdp_main_t *cm, cdp_neighbor_t *n, int count)
Definition: cdp_periodic.c:104
unsigned char u8
Definition: types.h:56
uword * neighbor_by_sw_if_index
Definition: cdp.h:91
double f64
Definition: types.h:142
#define clib_memcpy(d, s, n)
Definition: string.h:180
void * vlib_packet_template_get_packet(vlib_main_t *vm, vlib_packet_template_t *t, u32 *bi_result)
Definition: buffer.c:400
#define pool_foreach(VAR, POOL, BODY)
Iterate through pool.
Definition: pool.h:513
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:173
static void add_port_id_tlv(vnet_hw_interface_t *hw, u8 **t0p)
Definition: cdp_periodic.c:44
#define vec_elt_at_index(v, i)
Get vector value at index i checking that i is in bounds.
vlib_frame_t * vlib_get_frame_to_node(vlib_main_t *vm, u32 to_node_index)
Definition: main.c:182
unsigned int u32
Definition: types.h:88
static void add_version_tlv(vnet_hw_interface_t *hw, u8 **t0p)
Definition: cdp_periodic.c:55
vnet_main_t * vnet_main
Definition: cdp.h:105
vnet_crypto_main_t * cm
Definition: quic_crypto.c:53
void vlib_packet_template_init(vlib_main_t *vm, vlib_packet_template_t *t, void *packet_data, uword n_packet_data_bytes, uword min_n_buffers_each_alloc, char *fmt,...)
Definition: buffer.c:378
unsigned short u16
Definition: types.h:57
void vlib_put_frame_to_node(vlib_main_t *vm, u32 to_node_index, vlib_frame_t *f)
Definition: main.c:216
vec_header_t h
Definition: buffer.c:322
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:302
f64 last_heard
Definition: cdp.h:47
cdp_neighbor_t * neighbors
Definition: cdp.h:82
vnet_sw_interface_flags_t flags
Definition: interface.h:738
static void send_hello(cdp_main_t *cm, cdp_neighbor_t *n, int count)
Definition: cdp_periodic.c:305
static void send_hdlc_hello(cdp_main_t *cm, cdp_neighbor_t *n, int count)
Definition: cdp_periodic.c:174
u16 n_vectors
Definition: node.h:396
sll srl srl sll sra u16x4 i
Definition: vector_sse42.h:317
#define CDP_ROUTER_DEVICE
Definition: cdp_protocol.h:148
static void send_srp_hello(cdp_main_t *cm, cdp_neighbor_t *n, int count)
Definition: cdp_periodic.c:233
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:380
u8 * last_rx_pkt
Definition: cdp.h:70
u8 * device_name
Definition: cdp.h:64
static clib_error_t * cdp_periodic_init(vlib_main_t *vm)
Definition: cdp_periodic.c:403
u8 ttl_in_seconds
Definition: cdp.h:51
#define ASSERT(truth)
vlib_main_t * vlib_main
Definition: cdp.h:104
vlib_packet_template_t packet_templates[CDP_N_PACKET_TEMPLATES]
Definition: cdp.h:101
u8 disabled
Definition: cdp.h:54
static void add_device_name_tlv(vnet_hw_interface_t *hw, u8 **t0p)
Definition: cdp_periodic.c:32
Definition: defs.h:47
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
u8 * port_id
Definition: cdp.h:66
VLIB buffer representation.
Definition: buffer.h:102
static void * vlib_frame_vector_args(vlib_frame_t *f)
Get pointer to frame vector data.
Definition: node_funcs.h:297
Definition: cdp.h:79
static int pick_packet_template(cdp_main_t *cm, cdp_neighbor_t *n)
Definition: cdp_periodic.c:296
#define vnet_buffer(b)
Definition: buffer.h:417
u8 * platform
Definition: cdp.h:67
static void add_platform_tlv(vnet_hw_interface_t *hw, u8 **t0p)
Definition: cdp_periodic.c:66
u32 sw_if_index
Definition: cdp.h:44
static vlib_buffer_t * vlib_get_buffer(vlib_main_t *vm, u32 buffer_index)
Translate buffer index into buffer pointer.
Definition: buffer_funcs.h:85