FD.io VPP  v16.09
Vector Packet Processing
cdp_input.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2011-2016 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 <vnet/cdp/cdp_node.h>
16 
18 
19 #define DEBUG_TLV_DUMP 0 /* 1=> dump TLV's to stdout while processing them */
20 
21 /* Reliable multicast messages we use to keep peers updated */
24 
25 /*
26  * ported from an unspecified Cisco cdp implementation.
27  * Compute / return in HOST byte order. 0 => good checksum.
28  */
29 u16
30 cdp_checksum (void *p, int count)
31 {
32  u32 sum;
33  u16 i, *data;
34 
35  data = p;
36  sum = 0;
37  while (count > 1)
38  {
39  sum += ntohs (*data);
40  data++;
41  count -= 2;
42  }
43 
44  if (count > 0)
45  sum += *(char *) data;
46 
47  while (sum >> 16)
48  {
49  sum = (sum & 0xFFFF) + (sum >> 16);
50  }
51 
52  i = (i16) sum;
53  return (~i);
54 }
55 
56 /* TLV handler table */
57 typedef struct
58 {
59  char *name;
61  void *format;
62  void *process;
64 
65 static tlv_handler_t tlv_handlers[];
66 
67 /* Display a generic TLV as a set of hex bytes */
68 static u8 *
69 format_generic_tlv (u8 * s, va_list * va)
70 {
71  cdp_tlv_t *t = va_arg (*va, cdp_tlv_t *);
72  tlv_handler_t *h = &tlv_handlers[t->t];
73 
74  s = format (s, "%s(%d): %U\n", h->name,
75  t->t, format_hex_bytes, t->v, t->l - sizeof (*t));
76  return s;
77 }
78 
79 /* Ignore / skip a TLV we don't support */
80 static cdp_error_t
81 process_generic_tlv (cdp_main_t * cm, cdp_neighbor_t * n, cdp_tlv_t * t)
82 {
83 #if DEBUG_TLV_DUMP > 0
84  fformat (stdout, "%U", format_generic_tlv, t);
85 #endif
86 
87  return CDP_ERROR_NONE;
88 }
89 
90 /* print a text tlv */
91 static u8 *
92 format_text_tlv (u8 * s, va_list * va)
93 {
94  cdp_tlv_t *t = va_arg (*va, cdp_tlv_t *);
95  tlv_handler_t *h = &tlv_handlers[t->t];
96  int i;
97 
98  s = format (s, "%s(%d): ", h->name, t->t);
99 
100  for (i = 0; i < (t->l - sizeof (*t)); i++)
101  vec_add1 (s, t->v[i]);
102 
103  vec_add1 (s, '\n');
104  return s;
105 }
106 
107 #if DEBUG_TLV_DUMP == 0
108 /* gcc warning be gone */
109 CLIB_UNUSED (static cdp_error_t
111  cdp_tlv_t * t));
112 #endif
113 
114 /* process / skip a generic text TLV that we don't support */
115 static cdp_error_t
116 process_text_tlv (cdp_main_t * cm, cdp_neighbor_t * n, cdp_tlv_t * t)
117 {
118 #if DEBUG_TLV_DUMP > 0
119  fformat (stdout, "%U\n", format_text_tlv, t);
120 #endif
121 
122  return CDP_ERROR_NONE;
123 }
124 
125 /* per-TLV format function definitions */
126 #define format_unused_tlv format_generic_tlv
127 #define format_device_name_tlv format_text_tlv
128 #define format_address_tlv format_generic_tlv
129 #define format_port_id_tlv format_text_tlv
130 #define format_capabilities_tlv format_generic_tlv
131 #define format_version_tlv format_text_tlv
132 #define format_platform_tlv format_text_tlv
133 #define format_ipprefix_tlv format_generic_tlv
134 #define format_hello_tlv format_generic_tlv
135 #define format_vtp_domain_tlv format_generic_tlv
136 #define format_native_vlan_tlv format_generic_tlv
137 #define format_duplex_tlv format_generic_tlv
138 #define format_appl_vlan_tlv format_generic_tlv
139 #define format_trigger_tlv format_generic_tlv
140 #define format_power_tlv format_generic_tlv
141 #define format_mtu_tlv format_generic_tlv
142 #define format_trust_tlv format_generic_tlv
143 #define format_cos_tlv format_generic_tlv
144 #define format_sysname_tlv format_generic_tlv
145 #define format_sysobject_tlv format_generic_tlv
146 #define format_mgmt_addr_tlv format_generic_tlv
147 #define format_physical_loc_tlv format_generic_tlv
148 #define format_mgmt_addr2_tlv format_generic_tlv
149 #define format_power_requested_tlv format_generic_tlv
150 #define format_power_available_tlv format_generic_tlv
151 #define format_port_unidirectional_tlv format_generic_tlv
152 #define format_unknown_28_tlv format_generic_tlv
153 #define format_energywise_tlv format_generic_tlv
154 #define format_unknown_30_tlv format_generic_tlv
155 #define format_spare_poe_tlv format_generic_tlv
156 
157 /* tlv ID=0 is a mistake */
158 static cdp_error_t
159 process_unused_tlv (cdp_main_t * cm, cdp_neighbor_t * n, cdp_tlv_t * t)
160 {
161  return CDP_ERROR_BAD_TLV;
162 }
163 
164 /* list of text TLV's that we snapshoot */
165 #define foreach_text_to_struct_tlv \
166 _(device_name,DEBUG_TLV_DUMP) \
167 _(version,DEBUG_TLV_DUMP) \
168 _(platform,DEBUG_TLV_DUMP) \
169 _(port_id,DEBUG_TLV_DUMP)
170 
171 #define _(z,dbg) \
172 static \
173 cdp_error_t process_##z##_tlv (cdp_main_t *cm, cdp_neighbor_t *n, \
174  cdp_tlv_t *t) \
175 { \
176  int i; \
177  if (dbg) \
178  fformat(stdout, "%U\n", format_text_tlv, t); \
179  \
180  if (n->z) \
181  _vec_len(n->z) = 0; \
182  \
183  for (i = 0; i < (t->l - sizeof (*t)); i++) \
184  vec_add1(n->z, t->v[i]); \
185  \
186  vec_add1(n->z, 0); \
187  \
188  return CDP_ERROR_NONE; \
189 }
190 
192 #undef _
193 #define process_address_tlv process_generic_tlv
194 #define process_capabilities_tlv process_generic_tlv
195 #define process_ipprefix_tlv process_generic_tlv
196 #define process_hello_tlv process_generic_tlv
197 #define process_vtp_domain_tlv process_generic_tlv
198 #define process_native_vlan_tlv process_generic_tlv
199 #define process_duplex_tlv process_generic_tlv
200 #define process_appl_vlan_tlv process_generic_tlv
201 #define process_trigger_tlv process_generic_tlv
202 #define process_power_tlv process_generic_tlv
203 #define process_mtu_tlv process_generic_tlv
204 #define process_trust_tlv process_generic_tlv
205 #define process_cos_tlv process_generic_tlv
206 #define process_sysname_tlv process_generic_tlv
207 #define process_sysobject_tlv process_generic_tlv
208 #define process_mgmt_addr_tlv process_generic_tlv
209 #define process_physical_loc_tlv process_generic_tlv
210 #define process_mgmt_addr2_tlv process_generic_tlv
211 #define process_power_requested_tlv process_generic_tlv
212 #define process_power_available_tlv process_generic_tlv
213 #define process_port_unidirectional_tlv process_generic_tlv
214 #define process_unknown_28_tlv process_generic_tlv
215 #define process_energywise_tlv process_generic_tlv
216 #define process_unknown_30_tlv process_generic_tlv
217 #define process_spare_poe_tlv process_generic_tlv
218 static tlv_handler_t tlv_handlers[] = {
219 #define _(a) {#a, CDP_TLV_##a, format_##a##_tlv, process_##a##_tlv},
221 #undef _
222 };
223 
224 #if DEBUG_TLV_DUMP == 0
225 CLIB_UNUSED (static u8 * format_cdp_hdr (u8 * s, va_list * va));
226 #endif
227 
228 static u8 *
229 format_cdp_hdr (u8 * s, va_list * va)
230 {
231  cdp_hdr_t *h = va_arg (*va, cdp_hdr_t *);
232 
233  s = format (s, "version %d, ttl %d(secs), cksum 0x%04x\n",
234  h->version, h->ttl, h->checksum);
235  return s;
236 }
237 
238 static cdp_error_t
239 process_cdp_hdr (cdp_main_t * cm, cdp_neighbor_t * n, cdp_hdr_t * h)
240 {
241 #if DEBUG_TLV_DUMP > 0
242  fformat (stdout, "%U", format_cdp_hdr, h);
243 #endif
244 
245  if (h->version != 1 && h->version != 2)
246  return CDP_ERROR_PROTOCOL_VERSION;
247 
248  n->ttl_in_seconds = h->ttl;
249 
250  return CDP_ERROR_NONE;
251 }
252 
253 /* scan a cdp packet; header, then tlv's */
254 static int
256 {
257  u8 *cur = n->last_rx_pkt;
258  cdp_hdr_t *h;
259  cdp_tlv_t *tlv;
260  cdp_error_t e = CDP_ERROR_NONE;
261  tlv_handler_t *handler;
262  cdp_error_t (*fp) (cdp_main_t *, cdp_neighbor_t *, cdp_tlv_t *);
263  u16 computed_checksum;
264 
265  computed_checksum = cdp_checksum (cur, vec_len (cur));
266 
267  if (computed_checksum)
268  return CDP_ERROR_CHECKSUM;
269 
270  h = (cdp_hdr_t *) cur;
271 
272  e = process_cdp_hdr (cm, n, h);
273  if (e)
274  return e;
275 
276  cur = (u8 *) (h + 1);
277 
278  while (cur < n->last_rx_pkt + vec_len (n->last_rx_pkt) - 1)
279  {
280  tlv = (cdp_tlv_t *) cur;
281  tlv->t = ntohs (tlv->t);
282  tlv->l = ntohs (tlv->l);
283  if (tlv->t >= ARRAY_LEN (tlv_handlers))
284  return CDP_ERROR_BAD_TLV;
285  handler = &tlv_handlers[tlv->t];
286  fp = handler->process;
287  e = (*fp) (cm, n, tlv);
288  if (e)
289  return e;
290  /* tlv length includes (t, l) */
291  cur += tlv->l;
292  }
293 
294  return CDP_ERROR_NONE;
295 }
296 
297 /*
298  * cdp input routine
299  */
302 {
303  cdp_main_t *cm = &cdp_main;
304  cdp_neighbor_t *n;
305  uword *p, nbytes;
306  cdp_error_t e;
307  uword last_packet_signature;
308 
309  /* find or create a neighbor pool entry for the (sw) interface
310  upon which we received this pkt */
312  vnet_buffer (b0)->sw_if_index[VLIB_RX]);
313 
314  if (p == 0)
315  {
316  pool_get (cm->neighbors, n);
317  memset (n, 0, sizeof (*n));
318  n->sw_if_index = vnet_buffer (b0)->sw_if_index[VLIB_RX];
319  n->packet_template_index = (u8) ~ 0;
321  n - cm->neighbors);
322  }
323  else
324  {
325  n = pool_elt_at_index (cm->neighbors, p[0]);
326  }
327 
328  /*
329  * typical clib idiom. Don't repeatedly allocate and free
330  * the per-neighbor rx buffer. Reset its apparent length to zero
331  * and reuse it.
332  */
333 
334  if (n->last_rx_pkt)
335  _vec_len (n->last_rx_pkt) = 0;
336 
337  /* cdp disabled on this interface, we're done */
338  if (n->disabled)
339  return CDP_ERROR_DISABLED;
340 
341  /*
342  * Make sure the per-neighbor rx buffer is big enough to hold
343  * the data we're about to copy
344  */
346 
347  /*
348  * Coalesce / copy e the buffer chain into the per-neighbor
349  * rx buffer
350  */
351  nbytes = vlib_buffer_contents (vm, bi0, n->last_rx_pkt);
352  ASSERT (nbytes <= vec_len (n->last_rx_pkt));
353 
354  /*
355  * Compute Jenkins hash of the new packet, decide if we need to
356  * actually parse through the TLV's. CDP packets are all identical,
357  * so unless we time out the peer, we don't need to process the packet.
358  */
359  last_packet_signature =
360  hash_memory (n->last_rx_pkt, vec_len (n->last_rx_pkt), 0xd00b);
361 
363  n->last_packet_signature == last_packet_signature)
364  {
365  e = CDP_ERROR_CACHE_HIT;
366  }
367  else
368  {
369  /* Actually scan the packet */
370  e = cdp_packet_scan (cm, n);
372  n->last_packet_signature = last_packet_signature;
373  }
374 
375  if (e == CDP_ERROR_NONE)
376  {
377  n->last_heard = vlib_time_now (vm);
378  }
379 
380  return e;
381 }
382 
383 /*
384  * setup neighbor hash table
385  */
386 static clib_error_t *
388 {
389  clib_error_t *error;
390  cdp_main_t *cm = &cdp_main;
391  void vnet_cdp_node_reference (void);
392 
394 
395  if ((error = vlib_call_init_function (vm, cdp_periodic_init)))
396  return error;
397 
398  cm->vlib_main = vm;
399  cm->vnet_main = vnet_get_main ();
400  cm->neighbor_by_sw_if_index = hash_create (0, sizeof (uword));
401 
402  return 0;
403 }
404 
406 
407 
408 static u8 *
409 format_cdp_neighbors (u8 * s, va_list * va)
410 {
411  CLIB_UNUSED (vlib_main_t * vm) = va_arg (*va, vlib_main_t *);
412  cdp_main_t *cm = va_arg (*va, cdp_main_t *);
413  vnet_main_t *vnm = &vnet_main;
414  cdp_neighbor_t *n;
416 
417  s = format (s,
418  "%=25s %=15s %=25s %=10s\n",
419  "Our Port", "Peer System", "Peer Port", "Last Heard");
420 
421  /* *INDENT-OFF* */
422  pool_foreach (n, cm->neighbors,
423  ({
424  hw = vnet_get_sup_hw_interface (vnm, n->sw_if_index);
425 
426  if (n->disabled == 0)
427  s = format (s, "%=25s %=15s %=25s %=10.1f\n",
428  hw->name, n->device_name, n->port_id,
429  n->last_heard);
430  }));
431  /* *INDENT-ON* */
432  return s;
433 }
434 
435 
436 static clib_error_t *
438  unformat_input_t * input, vlib_cli_command_t * cmd)
439 {
440  cdp_main_t *cm = &cdp_main;
441 
442  vlib_cli_output (vm, "%U\n", format_cdp_neighbors, vm, cm);
443 
444  return 0;
445 }
446 
447 /* *INDENT-OFF* */
448 VLIB_CLI_COMMAND (show_cdp_command, static) = {
449  .path = "show cdp",
450  .short_help = "Show cdp command",
451  .function = show_cdp,
452 };
453 /* *INDENT-ON* */
454 
455 
456 /*
457  * packet trace format function, very similar to
458  * cdp_packet_scan except that we call the per TLV format
459  * functions instead of the per TLV processing functions
460  */
461 u8 *
462 cdp_input_format_trace (u8 * s, va_list * args)
463 {
464  CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
465  CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
466  cdp_input_trace_t *t = va_arg (*args, cdp_input_trace_t *);
467  u8 *cur;
468  cdp_hdr_t *h;
469  cdp_tlv_t *tlv;
470  tlv_handler_t *handler;
471  u8 *(*fp) (cdp_tlv_t *);
472 
473  cur = t->data;
474 
475  h = (cdp_hdr_t *) cur;
476  s = format (s, "%U", format_cdp_hdr, h);
477 
478  cur = (u8 *) (h + 1);
479 
480  while (cur < t->data + t->len)
481  {
482  tlv = (cdp_tlv_t *) cur;
483  tlv->t = ntohs (tlv->t);
484  tlv->l = ntohs (tlv->l);
485  if (tlv->t >= ARRAY_LEN (tlv_handlers))
486  {
487  s = format (s, "BAD_TLV\n");
488  break;
489  }
490  handler = &tlv_handlers[tlv->t];
491  fp = handler->format;
492  s = format (s, " %U", fp, tlv);
493  /* tlv length includes (t, l) */
494  cur += tlv->l;
495  }
496 
497  return s;
498 }
499 
500 /*
501  * fd.io coding-style-patch-verification: ON
502  *
503  * Local Variables:
504  * eval: (c-set-style "gnu")
505  * End:
506  */
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
Definition: vec.h:396
char * name
Definition: cdp_input.c:59
#define hash_set(h, key, value)
Definition: hash.h:254
mc_serialize_msg_t serialize_cdp_keepalive_msg
Definition: cdp_input.c:23
sll srl srl sll sra u16x4 i
Definition: vector_sse2.h:343
static cdp_error_t process_unused_tlv(cdp_main_t *cm, cdp_neighbor_t *n, cdp_tlv_t *t)
Definition: cdp_input.c:159
u16 cdp_checksum(void *p, int count)
Definition: cdp_input.c:30
static f64 vlib_time_now(vlib_main_t *vm)
Definition: main.h:182
static clib_error_t * cdp_init(vlib_main_t *vm)
Definition: cdp_input.c:387
cdp_error_t
Definition: cdp_node.h:109
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:482
static u8 * format_cdp_neighbors(u8 *s, va_list *va)
Definition: cdp_input.c:409
u8 packet_template_index
Definition: cdp_node.h:54
void * process
Definition: cdp_input.c:62
cdp_main_t cdp_main
Definition: cdp_input.c:17
static uword vlib_buffer_length_in_chain(vlib_main_t *vm, vlib_buffer_t *b)
Get length in bytes of the buffer chain.
Definition: buffer_funcs.h:112
#define pool_get(P, E)
Allocate an object E from a pool P (unspecified alignment).
Definition: pool.h:200
uword * neighbor_by_sw_if_index
Definition: cdp_node.h:85
static u8 * format_cdp_hdr(u8 *s, va_list *va)
Definition: cdp_input.c:229
vnet_main_t * vnet_get_main(void)
Definition: misc.c:45
#define pool_foreach(VAR, POOL, BODY)
Iterate through pool.
Definition: pool.h:348
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:111
u8 * format_hex_bytes(u8 *s, va_list *va)
Definition: std-formats.c:84
u8 last_packet_signature_valid
Definition: cdp_node.h:57
#define vlib_call_init_function(vm, x)
Definition: init.h:161
cdp_error_t cdp_input(vlib_main_t *vm, vlib_buffer_t *b0, u32 bi0)
Definition: cdp_input.c:301
vnet_main_t * vnet_main
Definition: cdp_node.h:95
CLIB_UNUSED(static cdp_error_t process_text_tlv(cdp_main_t *cm, cdp_neighbor_t *n, cdp_tlv_t *t))
#define hash_get(h, key)
Definition: hash.h:248
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:369
f64 last_heard
Definition: cdp_node.h:44
cdp_neighbor_t * neighbors
Definition: cdp_node.h:79
vnet_main_t vnet_main
Definition: misc.c:42
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:575
uword last_packet_signature
Definition: cdp_node.h:58
static uword vlib_buffer_contents(vlib_main_t *vm, u32 buffer_index, u8 *contents)
Copy buffer contents to memory.
Definition: buffer_funcs.h:143
void vnet_cdp_node_reference(void)
Definition: cdp_node.c:198
u8 * last_rx_pkt
Definition: cdp_node.h:67
static int cdp_packet_scan(cdp_main_t *cm, cdp_neighbor_t *n)
Definition: cdp_input.c:255
static clib_error_t * cdp_periodic_init(vlib_main_t *vm)
Definition: cdp_periodic.c:394
u8 ttl_in_seconds
Definition: cdp_node.h:48
static cdp_error_t process_text_tlv(cdp_main_t *cm, cdp_neighbor_t *n, cdp_tlv_t *t)
Definition: cdp_input.c:116
static cdp_error_t process_generic_tlv(cdp_main_t *cm, cdp_neighbor_t *n, cdp_tlv_t *t)
Definition: cdp_input.c:81
#define ARRAY_LEN(x)
Definition: clib.h:59
#define hash_create(elts, value_bytes)
Definition: hash.h:647
#define ASSERT(truth)
static clib_error_t * show_cdp(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: cdp_input.c:437
unsigned int u32
Definition: types.h:88
#define vnet_buffer(b)
Definition: buffer.h:335
u8 * format(u8 *s, char *fmt,...)
Definition: format.c:418
uword hash_memory(void *p, word n_bytes, uword state)
Definition: hash.c:214
vlib_main_t * vlib_main
Definition: cdp_node.h:94
static u8 * format_generic_tlv(u8 *s, va_list *va)
Definition: cdp_input.c:69
void * format
Definition: cdp_input.c:61
u64 uword
Definition: types.h:112
unsigned short u16
Definition: types.h:57
VLIB_CLI_COMMAND(set_interface_ip_source_and_port_range_check_command, static)
#define foreach_text_to_struct_tlv
Definition: cdp_input.c:165
struct _mc_serialize_msg mc_serialize_msg_t
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
unsigned char u8
Definition: types.h:56
word fformat(FILE *f, char *fmt,...)
Definition: format.c:452
short i16
Definition: types.h:46
u8 * cdp_input_format_trace(u8 *s, va_list *args)
Definition: cdp_input.c:462
mc_serialize_msg_t serialize_cdp_neighbor_msg
Definition: cdp_input.c:22
struct _unformat_input_t unformat_input_t
static cdp_error_t process_cdp_hdr(cdp_main_t *cm, cdp_neighbor_t *n, cdp_hdr_t *h)
Definition: cdp_input.c:239
u32 sw_if_index
Definition: cdp_node.h:41
static u8 * format_text_tlv(u8 *s, va_list *va)
Definition: cdp_input.c:92
Definition: defs.h:46